Unify gdb printf functions

Now that filtered and unfiltered output can be treated identically, we
can unify the printf family of functions.  This is done under the name
"gdb_printf".  Most of this patch was written by script.

1 files changed, 177 insertions, 177 deletions

diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index c45a9611abd..a347745164c 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -367,9 +367,9 @@ trace_variable_command (const char *args, int from_tty)
 	  tsv->initial_value = initval;
 	  gdb::observers::tsv_modified.notify (tsv);
 	}
-      printf_filtered (_("Trace state variable $%s "
-			 "now has initial value %s.\n"),
-		       tsv->name.c_str (), plongest (tsv->initial_value));
+      gdb_printf (_("Trace state variable $%s "
+		    "now has initial value %s.\n"),
+		  tsv->name.c_str (), plongest (tsv->initial_value));
       return;
     }
 
@@ -379,9 +379,9 @@ trace_variable_command (const char *args, int from_tty)
 
   gdb::observers::tsv_created.notify (tsv);
 
-  printf_filtered (_("Trace state variable $%s "
-		     "created, with initial value %s.\n"),
-		   tsv->name.c_str (), plongest (tsv->initial_value));
+  gdb_printf (_("Trace state variable $%s "
+		"created, with initial value %s.\n"),
+	      tsv->name.c_str (), plongest (tsv->initial_value));
 }
 
 static void
@@ -482,10 +482,10 @@ save_trace_state_variables (struct ui_file *fp)
 {
   for (const trace_state_variable &tsv : tvariables)
     {
-      fprintf_unfiltered (fp, "tvariable $%s", tsv.name.c_str ());
+      gdb_printf (fp, "tvariable $%s", tsv.name.c_str ());
       if (tsv.initial_value)
-	fprintf_unfiltered (fp, " = %s", plongest (tsv.initial_value));
-      fprintf_unfiltered (fp, "\n");
+	gdb_printf (fp, " = %s", plongest (tsv.initial_value));
+      gdb_printf (fp, "\n");
     }
 }
 
@@ -827,7 +827,7 @@ void
 collection_list::add_remote_register (unsigned int regno)
 {
   if (info_verbose)
-    printf_filtered ("collect register %d\n", regno);
+    gdb_printf ("collect register %d\n", regno);
 
   m_regs_mask.at (regno / 8) |= 1 << (regno % 8);
 }
@@ -902,7 +902,7 @@ collection_list::add_memrange (struct gdbarch *gdbarch,
 			       unsigned long len, CORE_ADDR scope)
 {
   if (info_verbose)
-    printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
+    gdb_printf ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
 
   /* type: memrange_absolute == memory, other n == basereg */
   /* base: addr if memory, offset if reg relative.  */
@@ -931,20 +931,20 @@ collection_list::collect_symbol (struct symbol *sym,
   switch (sym->aclass ())
     {
     default:
-      printf_filtered ("%s: don't know symbol class %d\n",
-		       sym->print_name (), sym->aclass ());
+      gdb_printf ("%s: don't know symbol class %d\n",
+		  sym->print_name (), sym->aclass ());
       break;
     case LOC_CONST:
-      printf_filtered ("constant %s (value %s) will not be collected.\n",
-		       sym->print_name (), plongest (SYMBOL_VALUE (sym)));
+      gdb_printf ("constant %s (value %s) will not be collected.\n",
+		  sym->print_name (), plongest (SYMBOL_VALUE (sym)));
       break;
     case LOC_STATIC:
       offset = SYMBOL_VALUE_ADDRESS (sym);
       if (info_verbose)
 	{
-	  printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
-			   sym->print_name (), len,
-			   paddress (gdbarch, offset));
+	  gdb_printf ("LOC_STATIC %s: collect %ld bytes at %s.\n",
+		      sym->print_name (), len,
+		      paddress (gdbarch, offset));
 	}
       /* A struct may be a C++ class with static fields, go to general
 	 expression handling.  */
@@ -956,7 +956,7 @@ collection_list::collect_symbol (struct symbol *sym,
     case LOC_REGISTER:
       reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
       if (info_verbose)
-	printf_filtered ("LOC_REG[parm] %s: ", sym->print_name ());
+	gdb_printf ("LOC_REG[parm] %s: ", sym->print_name ());
       add_local_register (gdbarch, reg, scope);
       /* Check for doubles stored in two registers.  */
       /* FIXME: how about larger types stored in 3 or more regs?  */
@@ -965,17 +965,17 @@ collection_list::collect_symbol (struct symbol *sym,
 	add_local_register (gdbarch, reg + 1, scope);
       break;
     case LOC_REF_ARG:
-      printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
-      printf_filtered ("       (will not collect %s)\n", sym->print_name ());
+      gdb_printf ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
+      gdb_printf ("       (will not collect %s)\n", sym->print_name ());
       break;
     case LOC_ARG:
       reg = frame_regno;
       offset = frame_offset + SYMBOL_VALUE (sym);
       if (info_verbose)
 	{
-	  printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
-			   " from frame ptr reg %d\n", sym->print_name (), len,
-			   paddress (gdbarch, offset), reg);
+	  gdb_printf ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
+		      " from frame ptr reg %d\n", sym->print_name (), len,
+		      paddress (gdbarch, offset), reg);
 	}
       add_memrange (gdbarch, reg, offset, len, scope);
       break;
@@ -984,9 +984,9 @@ collection_list::collect_symbol (struct symbol *sym,
       offset = 0;
       if (info_verbose)
 	{
-	  printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
-			   " from reg %d\n", sym->print_name (), len,
-			   paddress (gdbarch, offset), reg);
+	  gdb_printf ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
+		      " from reg %d\n", sym->print_name (), len,
+		      paddress (gdbarch, offset), reg);
 	}
       add_memrange (gdbarch, reg, offset, len, scope);
       break;
@@ -995,9 +995,9 @@ collection_list::collect_symbol (struct symbol *sym,
       offset = frame_offset + SYMBOL_VALUE (sym);
       if (info_verbose)
 	{
-	  printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
-			   " from frame ptr reg %d\n", sym->print_name (), len,
-			   paddress (gdbarch, offset), reg);
+	  gdb_printf ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
+		      " from frame ptr reg %d\n", sym->print_name (), len,
+		      paddress (gdbarch, offset), reg);
 	}
       add_memrange (gdbarch, reg, offset, len, scope);
       break;
@@ -1007,8 +1007,8 @@ collection_list::collect_symbol (struct symbol *sym,
       break;
 
     case LOC_OPTIMIZED_OUT:
-      printf_filtered ("%s has been optimized out of existence.\n",
-		       sym->print_name ());
+      gdb_printf ("%s has been optimized out of existence.\n",
+		  sym->print_name ());
       break;
 
     case LOC_COMPUTED:
@@ -1027,8 +1027,8 @@ collection_list::collect_symbol (struct symbol *sym,
 	 have a location expression.  */
       if (!aexpr)
 	{
-	  printf_filtered ("%s has been optimized out of existence.\n",
-			   sym->print_name ());
+	  gdb_printf ("%s has been optimized out of existence.\n",
+		      sym->print_name ());
 	  return;
 	}
 
@@ -1100,7 +1100,7 @@ void
 collection_list::add_static_trace_data ()
 {
   if (info_verbose)
-    printf_filtered ("collect static trace data\n");
+    gdb_printf ("collect static trace data\n");
   m_strace_data = true;
 }
 
@@ -1138,7 +1138,7 @@ collection_list::stringify ()
   if (m_strace_data)
     {
       if (info_verbose)
-	printf_filtered ("\nCollecting static trace data\n");
+	gdb_printf ("\nCollecting static trace data\n");
       end = temp_buf.data ();
       *end++ = 'L';
       str_list.emplace_back (temp_buf.data (), end - temp_buf.data ());
@@ -1150,7 +1150,7 @@ collection_list::stringify ()
   if (m_regs_mask[i] != 0)	/* Prepare to send regs_mask to the stub.  */
     {
       if (info_verbose)
-	printf_filtered ("\nCollecting registers (mask): 0x");
+	gdb_printf ("\nCollecting registers (mask): 0x");
 
       /* One char for 'R', one for the null terminator and two per
 	 mask byte.  */
@@ -1164,7 +1164,7 @@ collection_list::stringify ()
 	{
 	  QUIT;			/* Allow user to bail out with ^C.  */
 	  if (info_verbose)
-	    printf_filtered ("%02X", m_regs_mask[i]);
+	    gdb_printf ("%02X", m_regs_mask[i]);
 
 	  end = pack_hex_byte (end, m_regs_mask[i]);
 	}
@@ -1173,21 +1173,21 @@ collection_list::stringify ()
       str_list.emplace_back (temp_buf.data ());
     }
   if (info_verbose)
-    printf_filtered ("\n");
+    gdb_printf ("\n");
   if (!m_memranges.empty () && info_verbose)
-    printf_filtered ("Collecting memranges: \n");
+    gdb_printf ("Collecting memranges: \n");
   for (i = 0, count = 0, end = temp_buf.data ();
        i < m_memranges.size (); i++)
     {
       QUIT;			/* Allow user to bail out with ^C.  */
       if (info_verbose)
 	{
-	  printf_filtered ("(%d, %s, %ld)\n", 
-			   m_memranges[i].type,
-			   paddress (target_gdbarch (),
-				     m_memranges[i].start),
-			   (long) (m_memranges[i].end
-				   - m_memranges[i].start));
+	  gdb_printf ("(%d, %s, %ld)\n", 
+		      m_memranges[i].type,
+		      paddress (target_gdbarch (),
+				m_memranges[i].start),
+		      (long) (m_memranges[i].end
+			      - m_memranges[i].start));
 	}
       if (count + 27 > MAX_AGENT_EXPR_LEN)
 	{
@@ -1373,7 +1373,7 @@ encode_actions_1 (struct command_line *action,
 					  _("Register $%s not available"),
 					  name);
 			if (info_verbose)
-			  printf_filtered ("OP_REGISTER: ");
+			  gdb_printf ("OP_REGISTER: ");
 			collect->add_local_register (target_gdbarch (),
 						     i, tloc->address);
 			break;
@@ -1760,61 +1760,61 @@ tstatus_command (const char *args, int from_tty)
   if (status == -1)
     {
       if (ts->filename != NULL)
-	printf_filtered (_("Using a trace file.\n"));
+	gdb_printf (_("Using a trace file.\n"));
       else
 	{
-	  printf_filtered (_("Trace can not be run on this target.\n"));
+	  gdb_printf (_("Trace can not be run on this target.\n"));
 	  return;
 	}
     }
 
   if (!ts->running_known)
     {
-      printf_filtered (_("Run/stop status is unknown.\n"));
+      gdb_printf (_("Run/stop status is unknown.\n"));
     }
   else if (ts->running)
     {
-      printf_filtered (_("Trace is running on the target.\n"));
+      gdb_printf (_("Trace is running on the target.\n"));
     }
   else
     {
       switch (ts->stop_reason)
 	{
 	case trace_never_run:
-	  printf_filtered (_("No trace has been run on the target.\n"));
+	  gdb_printf (_("No trace has been run on the target.\n"));
 	  break;
 	case trace_stop_command:
 	  if (ts->stop_desc)
-	    printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
-			     ts->stop_desc);
+	    gdb_printf (_("Trace stopped by a tstop command (%s).\n"),
+			ts->stop_desc);
 	  else
-	    printf_filtered (_("Trace stopped by a tstop command.\n"));
+	    gdb_printf (_("Trace stopped by a tstop command.\n"));
 	  break;
 	case trace_buffer_full:
-	  printf_filtered (_("Trace stopped because the buffer was full.\n"));
+	  gdb_printf (_("Trace stopped because the buffer was full.\n"));
 	  break;
 	case trace_disconnected:
-	  printf_filtered (_("Trace stopped because of disconnection.\n"));
+	  gdb_printf (_("Trace stopped because of disconnection.\n"));
 	  break;
 	case tracepoint_passcount:
-	  printf_filtered (_("Trace stopped by tracepoint %d.\n"),
-			   ts->stopping_tracepoint);
+	  gdb_printf (_("Trace stopped by tracepoint %d.\n"),
+		      ts->stopping_tracepoint);
 	  break;
 	case tracepoint_error:
 	  if (ts->stopping_tracepoint)
-	    printf_filtered (_("Trace stopped by an "
-			       "error (%s, tracepoint %d).\n"),
-			     ts->stop_desc, ts->stopping_tracepoint);
+	    gdb_printf (_("Trace stopped by an "
+			  "error (%s, tracepoint %d).\n"),
+			ts->stop_desc, ts->stopping_tracepoint);
 	  else
-	    printf_filtered (_("Trace stopped by an error (%s).\n"),
-			     ts->stop_desc);
+	    gdb_printf (_("Trace stopped by an error (%s).\n"),
+			ts->stop_desc);
 	  break;
 	case trace_stop_reason_unknown:
-	  printf_filtered (_("Trace stopped for an unknown reason.\n"));
+	  gdb_printf (_("Trace stopped for an unknown reason.\n"));
 	  break;
 	default:
-	  printf_filtered (_("Trace stopped for some other reason (%d).\n"),
-			   ts->stop_reason);
+	  gdb_printf (_("Trace stopped for some other reason (%d).\n"),
+		      ts->stop_reason);
 	  break;
 	}
     }
@@ -1822,54 +1822,54 @@ tstatus_command (const char *args, int from_tty)
   if (ts->traceframes_created >= 0
       && ts->traceframe_count != ts->traceframes_created)
     {
-      printf_filtered (_("Buffer contains %d trace "
-			 "frames (of %d created total).\n"),
-		       ts->traceframe_count, ts->traceframes_created);
+      gdb_printf (_("Buffer contains %d trace "
+		    "frames (of %d created total).\n"),
+		  ts->traceframe_count, ts->traceframes_created);
     }
   else if (ts->traceframe_count >= 0)
     {
-      printf_filtered (_("Collected %d trace frames.\n"),
-		       ts->traceframe_count);
+      gdb_printf (_("Collected %d trace frames.\n"),
+		  ts->traceframe_count);
     }
 
   if (ts->buffer_free >= 0)
     {
       if (ts->buffer_size >= 0)
 	{
-	  printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
-			   ts->buffer_free, ts->buffer_size);
+	  gdb_printf (_("Trace buffer has %d bytes of %d bytes free"),
+		      ts->buffer_free, ts->buffer_size);
 	  if (ts->buffer_size > 0)
-	    printf_filtered (_(" (%d%% full)"),
-			     ((int) ((((long long) (ts->buffer_size
-						    - ts->buffer_free)) * 100)
-				     / ts->buffer_size)));
-	  printf_filtered (_(".\n"));
+	    gdb_printf (_(" (%d%% full)"),
+			((int) ((((long long) (ts->buffer_size
+					       - ts->buffer_free)) * 100)
+				/ ts->buffer_size)));
+	  gdb_printf (_(".\n"));
 	}
       else
-	printf_filtered (_("Trace buffer has %d bytes free.\n"),
-			 ts->buffer_free);
+	gdb_printf (_("Trace buffer has %d bytes free.\n"),
+		    ts->buffer_free);
     }
 
   if (ts->disconnected_tracing)
-    printf_filtered (_("Trace will continue if GDB disconnects.\n"));
+    gdb_printf (_("Trace will continue if GDB disconnects.\n"));
   else
-    printf_filtered (_("Trace will stop if GDB disconnects.\n"));
+    gdb_printf (_("Trace will stop if GDB disconnects.\n"));
 
   if (ts->circular_buffer)
-    printf_filtered (_("Trace buffer is circular.\n"));
+    gdb_printf (_("Trace buffer is circular.\n"));
 
   if (ts->user_name && strlen (ts->user_name) > 0)
-    printf_filtered (_("Trace user is %s.\n"), ts->user_name);
+    gdb_printf (_("Trace user is %s.\n"), ts->user_name);
 
   if (ts->notes && strlen (ts->notes) > 0)
-    printf_filtered (_("Trace notes: %s.\n"), ts->notes);
+    gdb_printf (_("Trace notes: %s.\n"), ts->notes);
 
   /* Now report on what we're doing with tfind.  */
   if (traceframe_number >= 0)
-    printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
-		     traceframe_number, tracepoint_number);
+    gdb_printf (_("Looking at trace frame %d, tracepoint %d.\n"),
+		traceframe_number, tracepoint_number);
   else
-    printf_filtered (_("Not looking at any trace frame.\n"));
+    gdb_printf (_("Not looking at any trace frame.\n"));
 
   /* Report start/stop times if supplied.  */
   if (ts->start_time)
@@ -1879,21 +1879,21 @@ tstatus_command (const char *args, int from_tty)
 	  LONGEST run_time = ts->stop_time - ts->start_time;
 
 	  /* Reporting a run time is more readable than two long numbers.  */
-	  printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
-			   (long int) (ts->start_time / 1000000),
-			   (long int) (ts->start_time % 1000000),
-			   (long int) (run_time / 1000000),
-			   (long int) (run_time % 1000000));
+	  gdb_printf (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
+		      (long int) (ts->start_time / 1000000),
+		      (long int) (ts->start_time % 1000000),
+		      (long int) (run_time / 1000000),
+		      (long int) (run_time % 1000000));
 	}
       else
-	printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
-			 (long int) (ts->start_time / 1000000),
-			 (long int) (ts->start_time % 1000000));
+	gdb_printf (_("Trace started at %ld.%06ld secs.\n"),
+		    (long int) (ts->start_time / 1000000),
+		    (long int) (ts->start_time % 1000000));
     }
   else if (ts->stop_time)
-    printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
-		     (long int) (ts->stop_time / 1000000),
-		     (long int) (ts->stop_time % 1000000));
+    gdb_printf (_("Trace stopped at %ld.%06ld secs.\n"),
+		(long int) (ts->stop_time / 1000000),
+		(long int) (ts->stop_time % 1000000));
 
   /* Now report any per-tracepoint status available.  */
   for (breakpoint *t : all_tracepoints ())
@@ -2129,7 +2129,7 @@ tfind_1 (enum trace_find_type type, int num,
       else
 	{
 	  if (info_verbose)
-	    printf_filtered ("End of trace buffer.\n");
+	    gdb_printf ("End of trace buffer.\n");
 #if 0 /* dubious now?  */
 	  /* The following will not recurse, since it's
 	     special-cased.  */
@@ -2167,8 +2167,8 @@ tfind_1 (enum trace_find_type type, int num,
 	}
       else
 	{
-	  printf_filtered (_("Found trace frame %d, tracepoint %d\n"),
-			   traceframe_number, tracepoint_number);
+	  gdb_printf (_("Found trace frame %d, tracepoint %d\n"),
+		      traceframe_number, tracepoint_number);
 	}
     }
   else
@@ -2176,9 +2176,9 @@ tfind_1 (enum trace_find_type type, int num,
       if (uiout->is_mi_like_p ())
 	uiout->field_string ("found", "0");
       else if (type == tfind_number && num == -1)
-	printf_filtered (_("No longer looking at any trace frame\n"));
+	gdb_printf (_("No longer looking at any trace frame\n"));
       else /* This case may never occur, check.  */
-	printf_filtered (_("No trace frame found\n"));
+	gdb_printf (_("No trace frame found\n"));
     }
 
   /* If we're in nonstop mode and getting out of looking at trace
@@ -2363,20 +2363,20 @@ tfind_line_command (const char *args, int from_tty)
     {
       if (start_pc == end_pc)
 	{
-	  printf_filtered ("Line %d of \"%s\"",
-			   sal.line,
-			   symtab_to_filename_for_display (sal.symtab));
+	  gdb_printf ("Line %d of \"%s\"",
+		      sal.line,
+		      symtab_to_filename_for_display (sal.symtab));
 	  gdb_stdout->wrap_here (2);
-	  printf_filtered (" is at address ");
+	  gdb_printf (" is at address ");
 	  print_address (get_current_arch (), start_pc, gdb_stdout);
 	  gdb_stdout->wrap_here (2);
-	  printf_filtered (" but contains no code.\n");
+	  gdb_printf (" but contains no code.\n");
 	  sal = find_pc_line (start_pc, 0);
 	  if (sal.line > 0
 	      && find_line_pc_range (sal, &start_pc, &end_pc)
 	      && start_pc != end_pc)
-	    printf_filtered ("Attempting to find line %d instead.\n",
-			     sal.line);
+	    gdb_printf ("Attempting to find line %d instead.\n",
+			sal.line);
 	  else
 	    error (_("Cannot find a good line."));
 	}
@@ -2408,7 +2408,7 @@ tfind_range_command (const char *args, int from_tty)
 
   if (args == 0 || *args == 0)
     { /* XXX FIXME: what should default behavior be?  */
-      printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n");
+      gdb_printf ("Usage: tfind range STARTADDR, ENDADDR\n");
       return;
     }
 
@@ -2442,7 +2442,7 @@ tfind_outside_command (const char *args, int from_tty)
 
   if (args == 0 || *args == 0)
     { /* XXX FIXME: what should default behavior be?  */
-      printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
+      gdb_printf ("Usage: tfind outside STARTADDR, ENDADDR\n");
       return;
     }
 
@@ -2504,7 +2504,7 @@ info_scope_command (const char *args_in, int from_tty)
 	{
 	  QUIT;			/* Allow user to bail out with ^C.  */
 	  if (count == 0)
-	    printf_filtered ("Scope for %s:\n", save_args);
+	    gdb_printf ("Scope for %s:\n", save_args);
 	  count++;
 
 	  symname = sym->print_name ();
@@ -2513,7 +2513,7 @@ info_scope_command (const char *args_in, int from_tty)
 
 	  gdbarch = symbol_arch (sym);
 
-	  printf_filtered ("Symbol %s is ", symname);
+	  gdb_printf ("Symbol %s is ", symname);
 
 	  if (SYMBOL_COMPUTED_OPS (sym) != NULL)
 	    SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
@@ -2525,26 +2525,26 @@ info_scope_command (const char *args_in, int from_tty)
 		{
 		default:
 		case LOC_UNDEF:	/* Messed up symbol?  */
-		  printf_filtered ("a bogus symbol, class %d.\n",
-				   sym->aclass ());
+		  gdb_printf ("a bogus symbol, class %d.\n",
+			      sym->aclass ());
 		  count--;		/* Don't count this one.  */
 		  continue;
 		case LOC_CONST:
-		  printf_filtered ("a constant with value %s (%s)",
-				   plongest (SYMBOL_VALUE (sym)),
-				   hex_string (SYMBOL_VALUE (sym)));
+		  gdb_printf ("a constant with value %s (%s)",
+			      plongest (SYMBOL_VALUE (sym)),
+			      hex_string (SYMBOL_VALUE (sym)));
 		  break;
 		case LOC_CONST_BYTES:
-		  printf_filtered ("constant bytes: ");
+		  gdb_printf ("constant bytes: ");
 		  if (sym->type ())
 		    for (j = 0; j < TYPE_LENGTH (sym->type ()); j++)
-		      printf_filtered (" %02x",
-				       (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
+		      gdb_printf (" %02x",
+				  (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
 		  break;
 		case LOC_STATIC:
-		  printf_filtered ("in static storage at address ");
-		  printf_filtered ("%s", paddress (gdbarch,
-						   SYMBOL_VALUE_ADDRESS (sym)));
+		  gdb_printf ("in static storage at address ");
+		  gdb_printf ("%s", paddress (gdbarch,
+					      SYMBOL_VALUE_ADDRESS (sym)));
 		  break;
 		case LOC_REGISTER:
 		  /* GDBARCH is the architecture associated with the objfile
@@ -2558,59 +2558,59 @@ info_scope_command (const char *args_in, int from_tty)
 								      gdbarch);
 
 		  if (sym->is_argument ())
-		    printf_filtered ("an argument in register $%s",
-				     gdbarch_register_name (gdbarch, regno));
+		    gdb_printf ("an argument in register $%s",
+				gdbarch_register_name (gdbarch, regno));
 		  else
-		    printf_filtered ("a local variable in register $%s",
-				     gdbarch_register_name (gdbarch, regno));
+		    gdb_printf ("a local variable in register $%s",
+				gdbarch_register_name (gdbarch, regno));
 		  break;
 		case LOC_ARG:
-		  printf_filtered ("an argument at stack/frame offset %s",
-				   plongest (SYMBOL_VALUE (sym)));
+		  gdb_printf ("an argument at stack/frame offset %s",
+			      plongest (SYMBOL_VALUE (sym)));
 		  break;
 		case LOC_LOCAL:
-		  printf_filtered ("a local variable at frame offset %s",
-				   plongest (SYMBOL_VALUE (sym)));
+		  gdb_printf ("a local variable at frame offset %s",
+			      plongest (SYMBOL_VALUE (sym)));
 		  break;
 		case LOC_REF_ARG:
-		  printf_filtered ("a reference argument at offset %s",
-				   plongest (SYMBOL_VALUE (sym)));
+		  gdb_printf ("a reference argument at offset %s",
+			      plongest (SYMBOL_VALUE (sym)));
 		  break;
 		case LOC_REGPARM_ADDR:
 		  /* Note comment at LOC_REGISTER.  */
 		  regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
 								      gdbarch);
-		  printf_filtered ("the address of an argument, in register $%s",
-				   gdbarch_register_name (gdbarch, regno));
+		  gdb_printf ("the address of an argument, in register $%s",
+			      gdbarch_register_name (gdbarch, regno));
 		  break;
 		case LOC_TYPEDEF:
-		  printf_filtered ("a typedef.\n");
+		  gdb_printf ("a typedef.\n");
 		  continue;
 		case LOC_LABEL:
-		  printf_filtered ("a label at address ");
-		  printf_filtered ("%s", paddress (gdbarch,
-						   SYMBOL_VALUE_ADDRESS (sym)));
+		  gdb_printf ("a label at address ");
+		  gdb_printf ("%s", paddress (gdbarch,
+					      SYMBOL_VALUE_ADDRESS (sym)));
 		  break;
 		case LOC_BLOCK:
-		  printf_filtered ("a function at address ");
-		  printf_filtered ("%s",
-				   paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))));
+		  gdb_printf ("a function at address ");
+		  gdb_printf ("%s",
+			      paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))));
 		  break;
 		case LOC_UNRESOLVED:
 		  msym = lookup_minimal_symbol (sym->linkage_name (),
 						NULL, NULL);
 		  if (msym.minsym == NULL)
-		    printf_filtered ("Unresolved Static");
+		    gdb_printf ("Unresolved Static");
 		  else
 		    {
-		      printf_filtered ("static storage at address ");
-		      printf_filtered ("%s",
-				       paddress (gdbarch,
-						 BMSYMBOL_VALUE_ADDRESS (msym)));
+		      gdb_printf ("static storage at address ");
+		      gdb_printf ("%s",
+				  paddress (gdbarch,
+					    BMSYMBOL_VALUE_ADDRESS (msym)));
 		    }
 		  break;
 		case LOC_OPTIMIZED_OUT:
-		  printf_filtered ("optimized out.\n");
+		  gdb_printf ("optimized out.\n");
 		  continue;
 		case LOC_COMPUTED:
 		  gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
@@ -2620,7 +2620,7 @@ info_scope_command (const char *args_in, int from_tty)
 	    {
 	      struct type *t = check_typedef (sym->type ());
 
-	      printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t)));
+	      gdb_printf (", length %s.\n", pulongest (TYPE_LENGTH (t)));
 	    }
 	}
       if (BLOCK_FUNCTION (block))
@@ -2629,8 +2629,8 @@ info_scope_command (const char *args_in, int from_tty)
 	block = BLOCK_SUPERBLOCK (block);
     }
   if (count <= 0)
-    printf_filtered ("Scope for %s contains no locals or arguments.\n",
-		     save_args);
+    gdb_printf ("Scope for %s contains no locals or arguments.\n",
+		save_args);
 }
 
 /* Helper for trace_dump_command.  Dump the action list starting at
@@ -2713,9 +2713,9 @@ trace_dump_actions (struct command_line *action,
 			  exp = contents.c_str ();
 			}
 
-		      printf_filtered ("%s = ", exp);
+		      gdb_printf ("%s = ", exp);
 		      output_command (exp, from_tty);
-		      printf_filtered ("\n");
+		      gdb_printf ("\n");
 		    }
 		  action_exp = next_comma;
 		}
@@ -2803,8 +2803,8 @@ tdump_command (const char *args, int from_tty)
   /* This throws an error is not inspecting a trace frame.  */
   loc = get_traceframe_location (&stepping_frame);
 
-  printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
-		   tracepoint_number, traceframe_number);
+  gdb_printf ("Data collected at tracepoint %d, trace frame %d:\n",
+	      tracepoint_number, traceframe_number);
 
   /* This command only makes sense for the current frame, not the
      selected frame.  */
@@ -3107,10 +3107,10 @@ merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
 	  /* Mark this location as already inserted.  */
 	  loc->inserted = 1;
 	  t = (struct tracepoint *) loc->owner;
-	  printf_filtered (_("Assuming tracepoint %d is same "
-			     "as target's tracepoint %d at %s.\n"),
-			   loc->owner->number, utp->number,
-			   paddress (loc->gdbarch, utp->addr));
+	  gdb_printf (_("Assuming tracepoint %d is same "
+			"as target's tracepoint %d at %s.\n"),
+		      loc->owner->number, utp->number,
+		      paddress (loc->gdbarch, utp->addr));
 
 	  /* The tracepoint LOC->owner was modified (the location LOC
 	     was marked as inserted in the target).  Save it in
@@ -3130,15 +3130,15 @@ merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
 	{
 	  t = create_tracepoint_from_upload (utp);
 	  if (t)
-	    printf_filtered (_("Created tracepoint %d for "
-			       "target's tracepoint %d at %s.\n"),
-			     t->number, utp->number,
-			     paddress (get_current_arch (), utp->addr));
+	    gdb_printf (_("Created tracepoint %d for "
+			  "target's tracepoint %d at %s.\n"),
+			t->number, utp->number,
+			paddress (get_current_arch (), utp->addr));
 	  else
-	    printf_filtered (_("Failed to create tracepoint for target's "
-			       "tracepoint %d at %s, skipping it.\n"),
-			     utp->number,
-			     paddress (get_current_arch (), utp->addr));
+	    gdb_printf (_("Failed to create tracepoint for target's "
+			  "tracepoint %d at %s, skipping it.\n"),
+			utp->number,
+			paddress (get_current_arch (), utp->addr));
 	}
       /* Whether found or created, record the number used by the
 	 target, to help with mapping target tracepoints back to their
@@ -3221,17 +3221,17 @@ merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
       if (tsv)
 	{
 	  if (info_verbose)
-	    printf_filtered (_("Assuming trace state variable $%s "
-			       "is same as target's variable %d.\n"),
-			     tsv->name.c_str (), utsv->number);
+	    gdb_printf (_("Assuming trace state variable $%s "
+			  "is same as target's variable %d.\n"),
+			tsv->name.c_str (), utsv->number);
 	}
       else
 	{
 	  tsv = create_tsv_from_upload (utsv);
 	  if (info_verbose)
-	    printf_filtered (_("Created trace state variable "
-			       "$%s for target's variable %d.\n"),
-			     tsv->name.c_str (), utsv->number);
+	    gdb_printf (_("Created trace state variable "
+			  "$%s for target's variable %d.\n"),
+			tsv->name.c_str (), utsv->number);
 	}
       /* Give precedence to numberings that come from the target.  */
       if (tsv)