gdb: add infrun_debug_printf macro

Introduce this macro to print debug statements in the infrun.c file,
same idea as what was done in 9327494e0eeb ("gdb: add
linux_nat_debug_printf macro").

Although in this case, there are places outside infrun.c that print
debug statements if debug_infrun is set.  So the macro has to be
declared in the header file, so that it can be used in these other
files.

Note one special case.  In stop_all_threads, I've used an explicit

    if (debug_infrun)
      infrun_debug_printf_1 ("stop_all_threads", "done");

for the message in the SCOPE_EXIT.  Otherwise, the message appears like
this:

  [infrun] operator(): done

Until we find a better solution for extracting a meaningful function
name for lambda functions, I think it's fine to handle these special
cases manually, they are quite rare.

Some tests need to be updated, because they rely on some infrun debug
statements.

gdb/ChangeLog:

	* infrun.h (infrun_debug_printf_1): New function declaration.
	(infrun_debug_printf): New macro.
	* infrun.c (infrun_debug_printf_1): Use infrun_debug_printf
	throughout.
	(infrun_debug_printf): New function.
	* breakpoint.c (should_be_inserted): Use infrun_debug_printf.
	(handle_jit_event): Likewise.

gdb/testsuite/ChangeLog:

	* gdb.base/gdb-sigterm.exp (do_test): Update expected regexp.
	* gdb.threads/signal-while-stepping-over-bp-other-thread.exp:
	Likewise.
	* gdb.threads/stepi-random-signal.exp: Likewise.

Change-Id: I66433c8a9caa64c8525ab57c593022b9d1956d5c

1 files changed, 260 insertions, 512 deletions

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 66f5020..0f2a1bc 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -104,16 +104,28 @@ static int infrun_is_async = -1;
 /* See infrun.h.  */
 
 void
+infrun_debug_printf_1 (const char *func_name, const char *fmt, ...)
+{
+  debug_printf ("[infrun] %s: ", func_name);
+
+  va_list ap;
+  va_start (ap, fmt);
+  debug_vprintf (fmt, ap);
+  va_end (ap);
+
+  debug_printf ("\n");
+}
+
+/* See infrun.h.  */
+
+void
 infrun_async (int enable)
 {
   if (infrun_is_async != enable)
     {
       infrun_is_async = enable;
 
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: infrun_async(%d)\n",
-			    enable);
+      infrun_debug_printf ("enable=%d", enable);
 
       if (enable)
 	mark_async_event_handler (infrun_async_inferior_event_token);
@@ -904,10 +916,8 @@ proceed_after_vfork_done (struct thread_info *thread,
       && !thread->stop_requested
       && thread->suspend.stop_signal == GDB_SIGNAL_0)
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: resuming vfork parent thread %s\n",
-			    target_pid_to_str (thread->ptid).c_str ());
+      infrun_debug_printf ("resuming vfork parent thread %s",
+			   target_pid_to_str (thread->ptid).c_str ());
 
       switch_to_thread (thread);
       clear_proceed_status (0);
@@ -1042,10 +1052,8 @@ handle_vfork_child_exec_or_exit (int exec)
 	     free now.  */
 	  scoped_restore_current_thread restore_thread;
 
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: resuming vfork parent process %d\n",
-				resume_parent);
+	  infrun_debug_printf ("resuming vfork parent process %d",
+			       resume_parent);
 
 	  iterate_over_threads (proceed_after_vfork_done, &resume_parent);
 	}
@@ -1336,9 +1344,7 @@ set_step_over_info (const address_space *aspace, CORE_ADDR address,
 static void
 clear_step_over_info (void)
 {
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: clear_step_over_info\n");
+  infrun_debug_printf ("clearing step over info");
   step_over_info.aspace = NULL;
   step_over_info.address = 0;
   step_over_info.nonsteppable_watchpoint_p = 0;
@@ -1808,12 +1814,8 @@ displaced_step_prepare (thread_info *thread)
 	  && ex.error != NOT_SUPPORTED_ERROR)
 	throw;
 
-      if (debug_infrun)
-	{
-	  fprintf_unfiltered (gdb_stdlog,
-			      "infrun: disabling displaced stepping: %s\n",
-			      ex.what ());
-	}
+      infrun_debug_printf ("caught exception, disabling displaced stepping: %s",
+			   ex.what ());
 
       /* Be verbose if "set displaced-stepping" is "on", silent if
 	 "auto".  */
@@ -1997,11 +1999,7 @@ start_step_over (void)
       thread_step_over_chain_remove (tp);
 
       if (step_over_queue_head == NULL)
-	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: step-over queue now empty\n");
-	}
+	infrun_debug_printf ("step-over queue now empty");
 
       if (tp->control.trap_expected
 	  || tp->resumed
@@ -2016,10 +2014,8 @@ start_step_over (void)
 			  tp->executing);
 	}
 
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: resuming [%s] for step-over\n",
-			    target_pid_to_str (tp->ptid).c_str ());
+      infrun_debug_printf ("resuming [%s] for step-over",
+			   target_pid_to_str (tp->ptid).c_str ());
 
       /* keep_going_pass_signal skips the step-over if the breakpoint
 	 is no longer inserted.  In all-stop, we want to keep looking
@@ -2284,18 +2280,12 @@ resume_1 (enum gdb_signal sig)
 
   if (tp->suspend.waitstatus_pending_p)
     {
-      if (debug_infrun)
-	{
-	  std::string statstr
-	    = target_waitstatus_to_string (&tp->suspend.waitstatus);
-
-	  fprintf_unfiltered (gdb_stdlog,
-			      "infrun: resume: thread %s has pending wait "
-			      "status %s (currently_stepping=%d).\n",
-			      target_pid_to_str (tp->ptid).c_str (),
-			      statstr.c_str (),
-			      currently_stepping (tp));
-	}
+      infrun_debug_printf
+	("thread %s has pending wait "
+	 "status %s (currently_stepping=%d).",
+	 target_pid_to_str (tp->ptid).c_str (),
+	 target_waitstatus_to_string (&tp->suspend.waitstatus).c_str (),
+	 currently_stepping (tp));
 
       tp->inf->process_target ()->threads_executing = true;
       tp->resumed = true;
@@ -2339,22 +2329,18 @@ resume_1 (enum gdb_signal sig)
 	 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
 	 the parent, and tell it to `keep_going', which automatically
 	 re-sets it stepping.  */
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: resume : clear step\n");
+      infrun_debug_printf ("resume : clear step");
       step = 0;
     }
 
   CORE_ADDR pc = regcache_read_pc (regcache);
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: resume (step=%d, signal=%s), "
-			"trap_expected=%d, current thread [%s] at %s\n",
-			step, gdb_signal_to_symbol_string (sig),
-			tp->control.trap_expected,
-			target_pid_to_str (inferior_ptid).c_str (),
-			paddress (gdbarch, pc));
+  infrun_debug_printf ("step=%d, signal=%s, trap_expected=%d, "
+		       "current thread [%s] at %s",
+		       step, gdb_signal_to_symbol_string (sig),
+		       tp->control.trap_expected,
+		       target_pid_to_str (inferior_ptid).c_str (),
+		       paddress (gdbarch, pc));
 
   /* Normally, by the time we reach `resume', the breakpoints are either
      removed or inserted, as appropriate.  The exception is if we're sitting
@@ -2378,10 +2364,8 @@ resume_1 (enum gdb_signal sig)
 	     signal handler (or hit some other event).  We'll delete
 	     the step-resume breakpoint then.  */
 
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: resume: skipping permanent breakpoint, "
-				"deliver signal first\n");
+	  infrun_debug_printf ("resume: skipping permanent breakpoint, "
+			       "deliver signal first");
 
 	  clear_step_over_info ();
 	  tp->control.trap_expected = 0;
@@ -2403,9 +2387,7 @@ resume_1 (enum gdb_signal sig)
 	{
 	  /* There's no signal to pass, we can go ahead and skip the
 	     permanent breakpoint manually.  */
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: resume: skipping permanent breakpoint\n");
+	  infrun_debug_printf ("skipping permanent breakpoint");
 	  gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
 	  /* Update pc to reflect the new address from which we will
 	     execute instructions.  */
@@ -2460,9 +2442,7 @@ resume_1 (enum gdb_signal sig)
 
       if (prepared == 0)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"Got placed in step-over queue\n");
+	  infrun_debug_printf ("Got placed in step-over queue");
 
 	  tp->control.trap_expected = 0;
 	  return;
@@ -2599,10 +2579,8 @@ resume_1 (enum gdb_signal sig)
 	 gdb.threads/non-stop-fair-events.exp, on targets that don't
 	 do displaced stepping.  */
 
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: resume: [%s] stepped breakpoint\n",
-			    target_pid_to_str (tp->ptid).c_str ());
+      infrun_debug_printf ("resume: [%s] stepped breakpoint",
+			   target_pid_to_str (tp->ptid).c_str ());
 
       tp->stepped_breakpoint = 1;
 
@@ -2703,10 +2681,7 @@ new_stop_id (void)
 static void
 clear_proceed_status_thread (struct thread_info *tp)
 {
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: clear_proceed_status_thread (%s)\n",
-			target_pid_to_str (tp->ptid).c_str ());
+  infrun_debug_printf ("%s", target_pid_to_str (tp->ptid).c_str ());
 
   /* If we're starting a new sequence, then the previous finished
      single-step is no longer relevant.  */
@@ -2714,28 +2689,20 @@ clear_proceed_status_thread (struct thread_info *tp)
     {
       if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: clear_proceed_status: pending "
-				"event of %s was a finished step. "
-				"Discarding.\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("pending event of %s was a finished step. "
+			       "Discarding.",
+			       target_pid_to_str (tp->ptid).c_str ());
 
 	  tp->suspend.waitstatus_pending_p = 0;
 	  tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
 	}
-      else if (debug_infrun)
+      else
 	{
-	  std::string statstr
-	    = target_waitstatus_to_string (&tp->suspend.waitstatus);
-
-	  fprintf_unfiltered (gdb_stdlog,
-			      "infrun: clear_proceed_status_thread: thread %s "
-			      "has pending wait status %s "
-			      "(currently_stepping=%d).\n",
-			      target_pid_to_str (tp->ptid).c_str (),
-			      statstr.c_str (),
-			      currently_stepping (tp));
+	  infrun_debug_printf
+	    ("thread %s has pending wait status %s (currently_stepping=%d).",
+	     target_pid_to_str (tp->ptid).c_str (),
+	     target_waitstatus_to_string (&tp->suspend.waitstatus).c_str (),
+	     currently_stepping (tp));
 	}
     }
 
@@ -3043,11 +3010,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
   if (!cur_thr->control.in_infcall)
     set_running (resume_target, resume_ptid, true);
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: proceed (addr=%s, signal=%s)\n",
-			paddress (gdbarch, addr),
-			gdb_signal_to_symbol_string (siggnal));
+  infrun_debug_printf ("addr=%s, signal=%s", paddress (gdbarch, addr),
+		       gdb_signal_to_symbol_string (siggnal));
 
   annotate_starting ();
 
@@ -3091,10 +3055,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
 
 	  gdb_assert (!thread_is_in_step_over_chain (tp));
 
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: need to step-over [%s] first\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("need to step-over [%s] first",
+			       target_pid_to_str (tp->ptid).c_str ());
 
 	  thread_step_over_chain_enqueue (tp);
 	}
@@ -3141,37 +3103,28 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
 
 	    if (!tp->inf->has_execution ())
 	      {
-		if (debug_infrun)
-		  fprintf_unfiltered (gdb_stdlog,
-				      "infrun: proceed: [%s] target has "
-				      "no execution\n",
-				      target_pid_to_str (tp->ptid).c_str ());
+		infrun_debug_printf ("[%s] target has no execution",
+				     target_pid_to_str (tp->ptid).c_str ());
 		continue;
 	      }
 
 	    if (tp->resumed)
 	      {
-		if (debug_infrun)
-		  fprintf_unfiltered (gdb_stdlog,
-				      "infrun: proceed: [%s] resumed\n",
-				      target_pid_to_str (tp->ptid).c_str ());
+		infrun_debug_printf ("[%s] resumed",
+				     target_pid_to_str (tp->ptid).c_str ());
 		gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
 		continue;
 	      }
 
 	    if (thread_is_in_step_over_chain (tp))
 	      {
-		if (debug_infrun)
-		  fprintf_unfiltered (gdb_stdlog,
-				      "infrun: proceed: [%s] needs step-over\n",
-				      target_pid_to_str (tp->ptid).c_str ());
+		infrun_debug_printf ("[%s] needs step-over",
+				     target_pid_to_str (tp->ptid).c_str ());
 		continue;
 	      }
 
-	    if (debug_infrun)
-	      fprintf_unfiltered (gdb_stdlog,
-				  "infrun: proceed: resuming %s\n",
-				  target_pid_to_str (tp->ptid).c_str ());
+	    infrun_debug_printf ("resuming %s",
+			         target_pid_to_str (tp->ptid).c_str ());
 
 	    reset_ecs (ecs, tp);
 	    switch_to_thread (tp);
@@ -3406,19 +3359,19 @@ print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
      output as a unit; we want only one timestamp printed if debug_timestamp
      is set.  */
 
-  stb.printf ("infrun: target_wait (%d.%ld.%ld",
+  stb.printf ("[infrun] target_wait (%d.%ld.%ld",
 	      waiton_ptid.pid (),
 	      waiton_ptid.lwp (),
 	      waiton_ptid.tid ());
   if (waiton_ptid.pid () != -1)
     stb.printf (" [%s]", target_pid_to_str (waiton_ptid).c_str ());
   stb.printf (", status) =\n");
-  stb.printf ("infrun:   %d.%ld.%ld [%s],\n",
+  stb.printf ("[infrun]   %d.%ld.%ld [%s],\n",
 	      result_ptid.pid (),
 	      result_ptid.lwp (),
 	      result_ptid.tid (),
 	      target_pid_to_str (result_ptid).c_str ());
-  stb.printf ("infrun:   %s\n", status_string.c_str ());
+  stb.printf ("[infrun]   %s\n", status_string.c_str ());
 
   /* This uses %s in part to handle %'s in the text, but also to avoid
      a gcc error: the format attribute requires a string literal.  */
@@ -3453,10 +3406,9 @@ random_pending_event_thread (inferior *inf, ptid_t waiton_ptid)
   int random_selector = (int) ((num_events * (double) rand ())
 			       / (RAND_MAX + 1.0));
 
-  if (debug_infrun && num_events > 1)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: Found %d events, selecting #%d\n",
-			num_events, random_selector);
+  if (num_events > 1)
+    infrun_debug_printf ("Found %d events, selecting #%d",
+			 num_events, random_selector);
 
   /* Select the Nth thread that has had an event.  */
   for (thread_info *tp : inf->non_exited_threads ())
@@ -3493,10 +3445,8 @@ do_target_wait_1 (inferior *inf, ptid_t ptid,
     }
   else
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: Waiting for specific thread %s.\n",
-			    target_pid_to_str (ptid).c_str ());
+      infrun_debug_printf ("Waiting for specific thread %s.",
+			   target_pid_to_str (ptid).c_str ());
 
       /* We have a specific thread to check.  */
       tp = find_thread_ptid (inf, ptid);
@@ -3518,31 +3468,25 @@ do_target_wait_1 (inferior *inf, ptid_t ptid,
 
       if (pc != tp->suspend.stop_pc)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: PC of %s changed.  was=%s, now=%s\n",
-				target_pid_to_str (tp->ptid).c_str (),
-				paddress (gdbarch, tp->suspend.stop_pc),
-				paddress (gdbarch, pc));
+	  infrun_debug_printf ("PC of %s changed.  was=%s, now=%s",
+			       target_pid_to_str (tp->ptid).c_str (),
+			       paddress (gdbarch, tp->suspend.stop_pc),
+			       paddress (gdbarch, pc));
 	  discard = 1;
 	}
       else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: previous breakpoint of %s, at %s gone\n",
-				target_pid_to_str (tp->ptid).c_str (),
-				paddress (gdbarch, pc));
+	  infrun_debug_printf ("previous breakpoint of %s, at %s gone",
+			       target_pid_to_str (tp->ptid).c_str (),
+			       paddress (gdbarch, pc));
 
 	  discard = 1;
 	}
 
       if (discard)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: pending event of %s cancelled.\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("pending event of %s cancelled.",
+			       target_pid_to_str (tp->ptid).c_str ());
 
 	  tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
 	  tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
@@ -3551,16 +3495,10 @@ do_target_wait_1 (inferior *inf, ptid_t ptid,
 
   if (tp != NULL)
     {
-      if (debug_infrun)
-	{
-	  std::string statstr
-	    = target_waitstatus_to_string (&tp->suspend.waitstatus);
-
-	  fprintf_unfiltered (gdb_stdlog,
-			      "infrun: Using pending wait status %s for %s.\n",
-			      statstr.c_str (),
-			      target_pid_to_str (tp->ptid).c_str ());
-	}
+      infrun_debug_printf ("Using pending wait status %s for %s.",
+			   target_waitstatus_to_string
+			     (&tp->suspend.waitstatus).c_str (),
+			   target_pid_to_str (tp->ptid).c_str ());
 
       /* Now that we've selected our final event LWP, un-adjust its PC
 	 if it was a software breakpoint (and the target doesn't
@@ -3642,10 +3580,9 @@ do_target_wait (ptid_t wait_ptid, execution_control_state *ecs, int options)
   random_selector = (int)
     ((num_inferiors * (double) rand ()) / (RAND_MAX + 1.0));
 
-  if (debug_infrun && num_inferiors > 1)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: Found %d inferiors, starting at #%d\n",
-			num_inferiors, random_selector);
+  if (num_inferiors > 1)
+    infrun_debug_printf ("Found %d inferiors, starting at #%d",
+			 num_inferiors, random_selector);
 
   /* Select the Nth inferior that matched.  */
 
@@ -3709,9 +3646,7 @@ prepare_for_detach (void)
   if (displaced->step_thread == nullptr)
     return;
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"displaced-stepping in-process while detaching");
+  infrun_debug_printf ("displaced-stepping in-process while detaching");
 
   scoped_restore restore_detaching = make_scoped_restore (&inf->detaching, true);
 
@@ -3770,9 +3705,7 @@ prepare_for_detach (void)
 static void
 wait_for_inferior (inferior *inf)
 {
-  if (debug_infrun)
-    fprintf_unfiltered
-      (gdb_stdlog, "infrun: wait_for_inferior ()\n");
+  infrun_debug_printf ("wait_for_inferior ()");
 
   SCOPE_EXIT { delete_just_stopped_threads_infrun_breakpoints (); };
 
@@ -4148,15 +4081,13 @@ nullify_last_target_wait_ptid (void)
 static void
 context_switch (execution_control_state *ecs)
 {
-  if (debug_infrun
-      && ecs->ptid != inferior_ptid
+  if (ecs->ptid != inferior_ptid
       && (inferior_ptid == null_ptid
 	  || ecs->event_thread != inferior_thread ()))
     {
-      fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
-			  target_pid_to_str (inferior_ptid).c_str ());
-      fprintf_unfiltered (gdb_stdlog, "to %s\n",
-			  target_pid_to_str (ecs->ptid).c_str ());
+      infrun_debug_printf ("Switching context from %s to %s",
+			   target_pid_to_str (inferior_ptid).c_str (),
+			   target_pid_to_str (ecs->ptid).c_str ());
     }
 
   switch_to_thread (ecs->event_thread);
@@ -4401,9 +4332,7 @@ handle_syscall_event (struct execution_control_state *ecs)
   if (catch_syscall_enabled () > 0
       && catching_syscall_number (syscall_number) > 0)
     {
-      if (debug_infrun)
-        fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
-                            syscall_number);
+      infrun_debug_printf ("syscall number=%d", syscall_number);
 
       ecs->event_thread->control.stop_bpstat
 	= bpstat_stop_status (regcache->aspace (),
@@ -4599,17 +4528,11 @@ wait_one ()
 static void
 save_waitstatus (struct thread_info *tp, const target_waitstatus *ws)
 {
-  if (debug_infrun)
-    {
-      std::string statstr = target_waitstatus_to_string (ws);
-
-      fprintf_unfiltered (gdb_stdlog,
-			  "infrun: saving status %s for %d.%ld.%ld\n",
-			  statstr.c_str (),
-			  tp->ptid.pid (),
-			  tp->ptid.lwp (),
-			  tp->ptid.tid ());
-    }
+  infrun_debug_printf ("saving status %s for %d.%ld.%ld",
+		       target_waitstatus_to_string (ws).c_str (),
+		       tp->ptid.pid (),
+		       tp->ptid.lwp (),
+		       tp->ptid.tid ());
 
   /* Record for later.  */
   tp->suspend.waitstatus = *ws;
@@ -4720,8 +4643,7 @@ stop_all_threads (void)
 
   gdb_assert (exists_non_stop_target ());
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
+  infrun_debug_printf ("starting");
 
   scoped_restore_current_thread restore_thread;
 
@@ -4741,8 +4663,10 @@ stop_all_threads (void)
 	  target_thread_events (false);
 	}
 
+      /* Use infrun_debug_printf_1 directly to get a meaningful function
+         name.  */
       if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
+	infrun_debug_printf_1 ("stop_all_threads", "done");
     };
 
   /* Request threads to stop, and then wait for the stops.  Because
@@ -4752,10 +4676,7 @@ stop_all_threads (void)
      until two passes find no threads that need to be stopped.  */
   for (pass = 0; pass < 2; pass++, iterations++)
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: stop_all_threads, pass=%d, "
-			    "iterations=%d\n", pass, iterations);
+      infrun_debug_printf ("pass=%d, iterations=%d", pass, iterations);
       while (1)
 	{
 	  int waits_needed = 0;
@@ -4787,21 +4708,15 @@ stop_all_threads (void)
 		     We just haven't seen the notification yet.  */
 		  if (!t->stop_requested)
 		    {
-		      if (debug_infrun)
-			fprintf_unfiltered (gdb_stdlog,
-					    "infrun:   %s executing, "
-					    "need stop\n",
-					    target_pid_to_str (t->ptid).c_str ());
+		      infrun_debug_printf ("  %s executing, need stop",
+					   target_pid_to_str (t->ptid).c_str ());
 		      target_stop (t->ptid);
 		      t->stop_requested = 1;
 		    }
 		  else
 		    {
-		      if (debug_infrun)
-			fprintf_unfiltered (gdb_stdlog,
-					    "infrun:   %s executing, "
-					    "already stopping\n",
-					    target_pid_to_str (t->ptid).c_str ());
+		      infrun_debug_printf ("  %s executing, already stopping",
+					   target_pid_to_str (t->ptid).c_str ());
 		    }
 
 		  if (t->stop_requested)
@@ -4809,10 +4724,8 @@ stop_all_threads (void)
 		}
 	      else
 		{
-		  if (debug_infrun)
-		    fprintf_unfiltered (gdb_stdlog,
-					"infrun:   %s not executing\n",
-					target_pid_to_str (t->ptid).c_str ());
+		  infrun_debug_printf ("  %s not executing",
+				       target_pid_to_str (t->ptid).c_str ());
 
 		  /* The thread may be not executing, but still be
 		     resumed with a pending status to process.  */
@@ -4833,13 +4746,9 @@ stop_all_threads (void)
 	    {
 	      wait_one_event event = wait_one ();
 
-	      if (debug_infrun)
-		{
-		  fprintf_unfiltered (gdb_stdlog,
-				      "infrun: stop_all_threads %s %s\n",
-				      target_waitstatus_to_string (&event.ws).c_str (),
-				      target_pid_to_str (event.ptid).c_str ());
-		}
+	      infrun_debug_printf
+		("%s %s", target_waitstatus_to_string (&event.ws).c_str (),
+		 target_pid_to_str (event.ptid).c_str ());
 
 	      if (event.ws.kind == TARGET_WAITKIND_NO_RESUMED)
 		{
@@ -4874,10 +4783,8 @@ stop_all_threads (void)
 			 of going into an infinite loop.  */
 		      gdb_assert (t != nullptr);
 
-		      if (debug_infrun)
-			fprintf_unfiltered (gdb_stdlog,
-					    "infrun: stop_all_threads, using %s\n",
-					    target_pid_to_str (t->ptid).c_str ());
+		      infrun_debug_printf
+			("using %s", target_pid_to_str (t->ptid).c_str ());
 		    }
 		  else
 		    {
@@ -4931,14 +4838,11 @@ stop_all_threads (void)
 		      if (displaced_step_fixup (t, GDB_SIGNAL_0) < 0)
 			{
 			  /* Add it back to the step-over queue.  */
-			  if (debug_infrun)
-			    {
-			      fprintf_unfiltered (gdb_stdlog,
-						  "infrun: displaced-step of %s "
-						  "canceled: adding back to the "
-						  "step-over queue\n",
-						  target_pid_to_str (t->ptid).c_str ());
-			    }
+			  infrun_debug_printf
+			    ("displaced-step of %s canceled: adding back to "
+			     "the step-over queue",
+			      target_pid_to_str (t->ptid).c_str ());
+
 			  t->control.trap_expected = 0;
 			  thread_step_over_chain_enqueue (t);
 			}
@@ -4948,18 +4852,10 @@ stop_all_threads (void)
 		      enum gdb_signal sig;
 		      struct regcache *regcache;
 
-		      if (debug_infrun)
-			{
-			  std::string statstr = target_waitstatus_to_string (&event.ws);
-
-			  fprintf_unfiltered (gdb_stdlog,
-					      "infrun: target_wait %s, saving "
-					      "status for %d.%ld.%ld\n",
-					      statstr.c_str (),
-					      t->ptid.pid (),
-					      t->ptid.lwp (),
-					      t->ptid.tid ());
-			}
+		      infrun_debug_printf
+			("target_wait %s, saving status for %d.%ld.%ld",
+			 target_waitstatus_to_string (&event.ws).c_str (),
+			 t->ptid.pid (), t->ptid.lwp (), t->ptid.tid ());
 
 		      /* Record for later.  */
 		      save_waitstatus (t, &event.ws);
@@ -4977,16 +4873,12 @@ stop_all_threads (void)
 		      regcache = get_thread_regcache (t);
 		      t->suspend.stop_pc = regcache_read_pc (regcache);
 
-		      if (debug_infrun)
-			{
-			  fprintf_unfiltered (gdb_stdlog,
-					      "infrun: saved stop_pc=%s for %s "
-					      "(currently_stepping=%d)\n",
-					      paddress (target_gdbarch (),
-							t->suspend.stop_pc),
-					      target_pid_to_str (t->ptid).c_str (),
-					      currently_stepping (t));
-			}
+		      infrun_debug_printf ("saved stop_pc=%s for %s "
+					   "(currently_stepping=%d)",
+					   paddress (target_gdbarch (),
+						     t->suspend.stop_pc),
+					   target_pid_to_str (t->ptid).c_str (),
+					   currently_stepping (t));
 		    }
 		}
 	    }
@@ -5017,10 +4909,7 @@ handle_no_resumed (struct execution_control_state *ecs)
 	     we're not synchronously waiting for events either.  Just
 	     ignore.  */
 
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: TARGET_WAITKIND_NO_RESUMED "
-				"(ignoring: bg)\n");
+	  infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED (ignoring: bg)");
 	  prepare_to_wait (ecs);
 	  return 1;
 	}
@@ -5111,10 +5000,8 @@ handle_no_resumed (struct execution_control_state *ecs)
 	     target at some point, but there are now, or some target
 	     other than the eventing one has unwaited-for children
 	     left.  Just ignore.  */
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: TARGET_WAITKIND_NO_RESUMED "
-				"(ignoring: found resumed)\n");
+	  infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED "
+			       "(ignoring: found resumed)");
 
 	  ignore_event = true;
 	}
@@ -5157,9 +5044,7 @@ handle_inferior_event (struct execution_control_state *ecs)
 
   enum stop_kind stop_soon;
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog, "infrun: handle_inferior_event %s\n",
-			target_waitstatus_to_string (&ecs->ws).c_str ());
+  infrun_debug_printf ("%s", target_waitstatus_to_string (&ecs->ws).c_str ());
 
   if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
     {
@@ -5242,9 +5127,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       if (breakpoint_inserted_here_p (regcache->aspace (),
 				      regcache_read_pc (regcache)))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: Treating signal as SIGTRAP\n");
+	  infrun_debug_printf ("Treating signal as SIGTRAP");
 	  ecs->ws.value.sig = GDB_SIGNAL_TRAP;
 	}
     }
@@ -5321,8 +5204,7 @@ handle_inferior_event (struct execution_control_state *ecs)
       if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
 	  || stop_soon == STOP_QUIETLY_REMOTE)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
+	  infrun_debug_printf ("quietly stopped");
 	  stop_waiting (ecs);
 	  return;
 	}
@@ -5406,9 +5288,8 @@ handle_inferior_event (struct execution_control_state *ecs)
 		 information to the user.  It's better to just warn
 		 her about it (if infrun debugging is enabled), and
 		 give up.  */
-	      if (debug_infrun)
-		fprintf_filtered (gdb_stdlog, _("\
-Cannot fill $_exitsignal with the correct signal number.\n"));
+	      infrun_debug_printf ("Cannot fill $_exitsignal with the correct "
+				   "signal number.");
 	    }
 
 	  gdb::observers::signal_exited.notify (ecs->ws.value.sig);
@@ -5674,8 +5555,7 @@ Cannot fill $_exitsignal with the correct signal number.\n"));
 
       /* Switch to the stopped thread.  */
       context_switch (ecs);
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
+      infrun_debug_printf ("stopped");
 
       delete_just_stopped_threads_single_step_breakpoints ();
       ecs->event_thread->suspend.stop_pc
@@ -5706,41 +5586,30 @@ restart_threads (struct thread_info *event_thread)
 
       if (tp == event_thread)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: "
-				"[%s] is event thread\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] is event thread",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  continue;
 	}
 
       if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: "
-				"[%s] not meant to be running\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] not meant to be running",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  continue;
 	}
 
       if (tp->resumed)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: [%s] resumed\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] resumed",
+			      target_pid_to_str (tp->ptid).c_str ());
 	  gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
 	  continue;
 	}
 
       if (thread_is_in_step_over_chain (tp))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: "
-				"[%s] needs step-over\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] needs step-over",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  gdb_assert (!tp->resumed);
 	  continue;
 	}
@@ -5748,11 +5617,8 @@ restart_threads (struct thread_info *event_thread)
 
       if (tp->suspend.waitstatus_pending_p)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: "
-				"[%s] has pending status\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] has pending status",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  tp->resumed = true;
 	  continue;
 	}
@@ -5772,10 +5638,8 @@ restart_threads (struct thread_info *event_thread)
 
       if (currently_stepping (tp))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: [%s] was stepping\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] was stepping",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  keep_going_stepped_thread (tp);
 	}
       else
@@ -5783,10 +5647,8 @@ restart_threads (struct thread_info *event_thread)
 	  struct execution_control_state ecss;
 	  struct execution_control_state *ecs = &ecss;
 
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: restart threads: [%s] continuing\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("restart threads: [%s] continuing",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  reset_ecs (ecs, tp);
 	  switch_to_thread (tp);
 	  keep_going_pass_signal (ecs);
@@ -5879,12 +5741,8 @@ finish_step_over (struct execution_control_state *ecs)
 	  struct thread_info *tp = ecs->event_thread;
 	  struct regcache *regcache;
 
-	  if (debug_infrun)
-	    {
-	      fprintf_unfiltered (gdb_stdlog,
-				  "infrun: found resumed threads with "
-				  "pending events, saving status\n");
-	    }
+	  infrun_debug_printf ("found resumed threads with "
+			       "pending events, saving status");
 
 	  gdb_assert (pending != tp);
 
@@ -5900,16 +5758,12 @@ finish_step_over (struct execution_control_state *ecs)
 	  regcache = get_thread_regcache (tp);
 	  tp->suspend.stop_pc = regcache_read_pc (regcache);
 
-	  if (debug_infrun)
-	    {
-	      fprintf_unfiltered (gdb_stdlog,
-				  "infrun: saved stop_pc=%s for %s "
-				  "(currently_stepping=%d)\n",
-				  paddress (target_gdbarch (),
-					    tp->suspend.stop_pc),
-				  target_pid_to_str (tp->ptid).c_str (),
-				  currently_stepping (tp));
-	    }
+	  infrun_debug_printf ("saved stop_pc=%s for %s "
+			       "(currently_stepping=%d)",
+			       paddress (target_gdbarch (),
+				         tp->suspend.stop_pc),
+			       target_pid_to_str (tp->ptid).c_str (),
+			       currently_stepping (tp));
 
 	  /* This in-line step-over finished; clear this so we won't
 	     start a new one.  This is what handle_signal_stop would
@@ -5965,22 +5819,20 @@ handle_signal_stop (struct execution_control_state *ecs)
 
       switch_to_thread (ecs->event_thread);
 
-      fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
-			  paddress (reg_gdbarch,
-				    ecs->event_thread->suspend.stop_pc));
+      infrun_debug_printf ("stop_pc=%s",
+			   paddress (reg_gdbarch,
+				     ecs->event_thread->suspend.stop_pc));
       if (target_stopped_by_watchpoint ())
 	{
           CORE_ADDR addr;
 
-	  fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
+	  infrun_debug_printf ("stopped by watchpoint");
 
 	  if (target_stopped_data_address (current_top_target (), &addr))
-            fprintf_unfiltered (gdb_stdlog,
-                                "infrun: stopped data address = %s\n",
-                                paddress (reg_gdbarch, addr));
+	    infrun_debug_printf ("stopped data address=%s",
+			         paddress (reg_gdbarch, addr));
           else
-            fprintf_unfiltered (gdb_stdlog,
-                                "infrun: (no data address available)\n");
+	    infrun_debug_printf ("(no data address available)");
 	}
     }
 
@@ -5990,8 +5842,7 @@ handle_signal_stop (struct execution_control_state *ecs)
   if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
     {
       context_switch (ecs);
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
+      infrun_debug_printf ("quietly stopped");
       stop_print_frame = 1;
       stop_waiting (ecs);
       return;
@@ -6032,8 +5883,7 @@ handle_signal_stop (struct execution_control_state *ecs)
      so, then switch to that thread.  */
   if (ecs->ptid != inferior_ptid)
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
+      infrun_debug_printf ("context switch");
 
       context_switch (ecs);
 
@@ -6064,25 +5914,16 @@ handle_signal_stop (struct execution_control_state *ecs)
 	{
 	  if (single_step_breakpoint_inserted_here_p (aspace, pc))
 	    {
-	      if (debug_infrun)
-		{
-		  fprintf_unfiltered (gdb_stdlog,
-				      "infrun: [%s] hit another thread's "
-				      "single-step breakpoint\n",
-				      target_pid_to_str (ecs->ptid).c_str ());
-		}
+	      infrun_debug_printf ("[%s] hit another thread's single-step "
+				   "breakpoint",
+				   target_pid_to_str (ecs->ptid).c_str ());
 	      ecs->hit_singlestep_breakpoint = 1;
 	    }
 	}
       else
 	{
-	  if (debug_infrun)
-	    {
-	      fprintf_unfiltered (gdb_stdlog,
-				  "infrun: [%s] hit its "
-				  "single-step breakpoint\n",
-				  target_pid_to_str (ecs->ptid).c_str ());
-	    }
+	  infrun_debug_printf ("[%s] hit its single-step breakpoint",
+			       target_pid_to_str (ecs->ptid).c_str ());
 	}
     }
   delete_just_stopped_threads_single_step_breakpoints ();
@@ -6197,8 +6038,9 @@ handle_signal_stop (struct execution_control_state *ecs)
       int step_through_delay
 	= gdbarch_single_step_through_delay (gdbarch, frame);
 
-      if (debug_infrun && step_through_delay)
-	fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
+      if (step_through_delay)
+	infrun_debug_printf ("step through delay");
+
       if (ecs->event_thread->control.step_range_end == 0
 	  && step_through_delay)
 	{
@@ -6239,14 +6081,14 @@ handle_signal_stop (struct execution_control_state *ecs)
      simply make sure to ignore it if `stopped_by_watchpoint' is
      set.  */
 
-  if (debug_infrun
-      && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
+  if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
       && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
 				  GDB_SIGNAL_TRAP)
       && stopped_by_watchpoint)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: no user watchpoint explains "
-			"watchpoint SIGTRAP, ignoring\n");
+    {
+      infrun_debug_printf ("no user watchpoint explains watchpoint SIGTRAP, "
+			   "ignoring");
+    }
 
   /* NOTE: cagney/2003-03-29: These checks for a random signal
      at one stage in the past included checks for an inferior
@@ -6303,10 +6145,7 @@ handle_signal_stop (struct execution_control_state *ecs)
       else
 	{
 	  /* A delayed software breakpoint event.  Ignore the trap.  */
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: delayed software breakpoint "
-				"trap, ignoring\n");
+	  infrun_debug_printf ("delayed software breakpoint trap, ignoring");
 	  random_signal = 0;
 	}
     }
@@ -6316,10 +6155,8 @@ handle_signal_stop (struct execution_control_state *ecs)
   if (random_signal && target_stopped_by_hw_breakpoint ())
     {
       /* A delayed hardware breakpoint event.  Ignore the trap.  */
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: delayed hardware breakpoint/watchpoint "
-			    "trap, ignoring\n");
+      infrun_debug_printf ("delayed hardware breakpoint/watchpoint "
+			   "trap, ignoring");
       random_signal = 0;
     }
 
@@ -6343,8 +6180,7 @@ handle_signal_stop (struct execution_control_state *ecs)
   if (ecs->event_thread->stop_requested)
     {
       random_signal = 1;
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: user-requested stop\n");
+      infrun_debug_printf ("user-requested stop");
     }
 
   /* For the program's own signals, act according to
@@ -6356,9 +6192,8 @@ handle_signal_stop (struct execution_control_state *ecs)
       struct inferior *inf = find_inferior_ptid (ecs->target, ecs->ptid);
       enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
 
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
-			     gdb_signal_to_symbol_string (stop_signal));
+      infrun_debug_printf ("random signal (%s)",
+			   gdb_signal_to_symbol_string (stop_signal));
 
       stopped_by_random_signal = 1;
 
@@ -6403,10 +6238,7 @@ handle_signal_stop (struct execution_control_state *ecs)
 	     code paths as single-step - set a breakpoint at the
 	     signal return address and then, once hit, step off that
 	     breakpoint.  */
-          if (debug_infrun)
-            fprintf_unfiltered (gdb_stdlog,
-                                "infrun: signal arrived while stepping over "
-                                "breakpoint\n");
+	  infrun_debug_printf ("signal arrived while stepping over breakpoint");
 
 	  insert_hp_step_resume_breakpoint_at_frame (frame);
 	  ecs->event_thread->step_after_step_resume_breakpoint = 1;
@@ -6437,10 +6269,7 @@ handle_signal_stop (struct execution_control_state *ecs)
 	     Note that this is only needed for a signal delivered
 	     while in the single-step range.  Nested signals aren't a
 	     problem as they eventually all return.  */
-          if (debug_infrun)
-            fprintf_unfiltered (gdb_stdlog,
-                                "infrun: signal may take us out of "
-                                "single-step range\n");
+	  infrun_debug_printf ("signal may take us out of single-step range");
 
 	  clear_step_over_info ();
 	  insert_hp_step_resume_breakpoint_at_frame (frame);
@@ -6460,9 +6289,7 @@ handle_signal_stop (struct execution_control_state *ecs)
 
       if (!switch_back_to_stepped_thread (ecs))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: random signal, keep going\n");
+	  infrun_debug_printf ("random signal, keep going");
 
 	  keep_going (ecs);
 	}
@@ -6516,9 +6343,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 	 install a momentary breakpoint at the target of the
 	 jmp_buf.  */
 
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
+      infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME");
 
       ecs->event_thread->stepping_over_breakpoint = 1;
 
@@ -6539,10 +6364,8 @@ process_event_stop_test (struct execution_control_state *ecs)
 		   || !gdbarch_get_longjmp_target (gdbarch,
 						   frame, &jmp_buf_pc))
 	    {
-	      if (debug_infrun)
-		fprintf_unfiltered (gdb_stdlog,
-				    "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
-				    "(!gdbarch_get_longjmp_target)\n");
+	      infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME "
+				   "(!gdbarch_get_longjmp_target)");
 	      keep_going (ecs);
 	      return;
 	    }
@@ -6577,9 +6400,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 	   against stale dummy frames and user is not interested in
 	   stopping around longjmps.  */
 
-	if (debug_infrun)
-	  fprintf_unfiltered (gdb_stdlog,
-			      "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
+	infrun_debug_printf ("BPSTAT_WHAT_CLEAR_LONGJMP_RESUME");
 
 	gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
 		    != NULL);
@@ -6625,16 +6446,14 @@ process_event_stop_test (struct execution_control_state *ecs)
       return;
 
     case BPSTAT_WHAT_SINGLE:
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
+      infrun_debug_printf ("BPSTAT_WHAT_SINGLE");
       ecs->event_thread->stepping_over_breakpoint = 1;
       /* Still need to check other stuff, at least the case where we
 	 are stepping and step out of the right range.  */
       break;
 
     case BPSTAT_WHAT_STEP_RESUME:
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
+      infrun_debug_printf ("BPSTAT_WHAT_STEP_RESUME");
 
       delete_step_resume_breakpoint (ecs->event_thread);
       if (ecs->event_thread->control.proceed_to_finish
@@ -6666,8 +6485,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       break;
 
     case BPSTAT_WHAT_STOP_NOISY:
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
+      infrun_debug_printf ("BPSTAT_WHAT_STOP_NOISY");
       stop_print_frame = 1;
 
       /* Assume the thread stopped for a breakpoint.  We'll still check
@@ -6679,8 +6497,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       return;
 
     case BPSTAT_WHAT_STOP_SILENT:
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
+      infrun_debug_printf ("BPSTAT_WHAT_STOP_SILENT");
       stop_print_frame = 0;
 
       /* Assume the thread stopped for a breakpoint.  We'll still check
@@ -6691,8 +6508,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       return;
 
     case BPSTAT_WHAT_HP_STEP_RESUME:
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
+      infrun_debug_printf ("BPSTAT_WHAT_HP_STEP_RESUME");
 
       delete_step_resume_breakpoint (ecs->event_thread);
       if (ecs->event_thread->step_after_step_resume_breakpoint)
@@ -6727,10 +6543,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 	  && sr_bp->type == bp_hp_step_resume
 	  && sr_bp->loc->address == ecs->event_thread->prev_pc)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: stepped permanent breakpoint, stopped in "
-				"handler\n");
+	  infrun_debug_printf ("stepped permanent breakpoint, stopped in handler");
 	  delete_step_resume_breakpoint (ecs->event_thread);
 	  ecs->event_thread->step_after_step_resume_breakpoint = 0;
 	}
@@ -6748,9 +6561,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 
   if (ecs->event_thread->control.step_resume_breakpoint)
     {
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog,
-			     "infrun: step-resume breakpoint is inserted\n");
+      infrun_debug_printf ("step-resume breakpoint is inserted");
 
       /* Having a step-resume breakpoint overrides anything
          else having to do with stepping commands until
@@ -6761,8 +6572,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 
   if (ecs->event_thread->control.step_range_end == 0)
     {
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
+      infrun_debug_printf ("no stepping, continue");
       /* Likewise if we aren't even stepping.  */
       keep_going (ecs);
       return;
@@ -6791,11 +6601,10 @@ process_event_stop_test (struct execution_control_state *ecs)
 	  || frame_id_eq (get_frame_id (frame),
 			  ecs->event_thread->control.step_frame_id)))
     {
-      if (debug_infrun)
-	fprintf_unfiltered
-	  (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
-	   paddress (gdbarch, ecs->event_thread->control.step_range_start),
-	   paddress (gdbarch, ecs->event_thread->control.step_range_end));
+      infrun_debug_printf
+	("stepping inside range [%s-%s]",
+	 paddress (gdbarch, ecs->event_thread->control.step_range_start),
+	 paddress (gdbarch, ecs->event_thread->control.step_range_end));
 
       /* Tentatively re-enable range stepping; `resume' disables it if
 	 necessary (e.g., if we're stepping over a breakpoint or we
@@ -6838,9 +6647,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 	gdbarch_skip_solib_resolver (gdbarch,
 				     ecs->event_thread->suspend.stop_pc);
 
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog,
-			     "infrun: stepped into dynsym resolve code\n");
+      infrun_debug_printf ("stepped into dynsym resolve code");
 
       if (pc_after_resolver)
 	{
@@ -6863,9 +6670,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       && gdbarch_in_indirect_branch_thunk (gdbarch,
 					   ecs->event_thread->suspend.stop_pc))
     {
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog,
-			     "infrun: stepped into indirect branch thunk\n");
+      infrun_debug_printf ("stepped into indirect branch thunk");
       keep_going (ecs);
       return;
     }
@@ -6875,9 +6680,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 	  || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
       && get_frame_type (frame) == SIGTRAMP_FRAME)
     {
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog,
-			     "infrun: stepped into signal trampoline\n");
+      infrun_debug_printf ("stepped into signal trampoline");
       /* The inferior, while doing a "step" or "next", has ended up in
          a signal trampoline (either by a signal being delivered or by
          the signal handler returning).  Just single-step until the
@@ -6902,9 +6705,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       CORE_ADDR real_stop_pc
 	= gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
 
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog,
-			     "infrun: stepped into solib return tramp\n");
+      infrun_debug_printf ("stepped into solib return tramp");
 
       /* Only proceed through if we know where it's going.  */
       if (real_stop_pc)
@@ -6957,8 +6758,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
       CORE_ADDR real_stop_pc;
 
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
+      infrun_debug_printf ("stepped into subroutine");
 
       if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
 	{
@@ -7155,9 +6955,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       && ecs->stop_func_name == NULL
       && stop_pc_sal.line == 0)
     {
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog,
-			     "infrun: stepped into undebuggable function\n");
+      infrun_debug_printf ("stepped into undebuggable function");
 
       /* The inferior just stepped into, or returned to, an
          undebuggable function (where there is no debugging information
@@ -7190,8 +6988,7 @@ process_event_stop_test (struct execution_control_state *ecs)
     {
       /* It is stepi or nexti.  We always want to stop stepping after
          one instruction.  */
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
+      infrun_debug_printf ("stepi/nexti");
       end_stepping_range (ecs);
       return;
     }
@@ -7202,8 +6999,7 @@ process_event_stop_test (struct execution_control_state *ecs)
          stepping (does this always happen right after one instruction,
          when we do "s" in a function with no line numbers,
          or can this happen as a result of a return or longjmp?).  */
-      if (debug_infrun)
-	 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
+      infrun_debug_printf ("line number info");
       end_stepping_range (ecs);
       return;
     }
@@ -7216,9 +7012,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 		   ecs->event_thread->control.step_frame_id)
       && inline_skipped_frames (ecs->event_thread))
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: stepped into inlined function\n");
+      infrun_debug_printf ("stepped into inlined function");
 
       symtab_and_line call_sal = find_frame_sal (get_current_frame ());
 
@@ -7268,9 +7062,7 @@ process_event_stop_test (struct execution_control_state *ecs)
       && stepped_in_from (get_current_frame (),
 			  ecs->event_thread->control.step_frame_id))
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: stepping through inlined function\n");
+      infrun_debug_printf ("stepping through inlined function");
 
       if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL
 	  || inline_frame_is_marked_for_skip (false, ecs->event_thread))
@@ -7291,9 +7083,7 @@ process_event_stop_test (struct execution_control_state *ecs)
 	     we don't stop if we step into the middle of a different line.
 	     That is said to make things like for (;;) statements work
 	     better.  */
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: stepped to a different line\n");
+	  infrun_debug_printf ("stepped to a different line");
 	  end_stepping_range (ecs);
 	  return;
 	}
@@ -7305,10 +7095,8 @@ process_event_stop_test (struct execution_control_state *ecs)
 	     ignore this line table entry, and continue stepping forward,
 	     looking for a better place to stop.  */
 	  refresh_step_info = false;
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: stepped to a different line, but "
-				"it's not the start of a statement\n");
+	  infrun_debug_printf ("stepped to a different line, but "
+			       "it's not the start of a statement");
 	}
     }
 
@@ -7332,8 +7120,7 @@ process_event_stop_test (struct execution_control_state *ecs)
   if (refresh_step_info)
     set_step_info (ecs->event_thread, frame, stop_pc_sal);
 
-  if (debug_infrun)
-     fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
+  infrun_debug_printf ("keep going");
   keep_going (ecs);
 }
 
@@ -7365,12 +7152,9 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
       if (ecs->event_thread->control.trap_expected
 	  && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
 	{
-	  if (debug_infrun)
-	    {
-	      fprintf_unfiltered (gdb_stdlog,
-				  "infrun: need to finish step-over of [%s]\n",
-				  target_pid_to_str (ecs->event_thread->ptid).c_str ());
-	    }
+	  infrun_debug_printf
+	    ("need to finish step-over of [%s]",
+	     target_pid_to_str (ecs->event_thread->ptid).c_str ());
 	  keep_going (ecs);
 	  return 1;
 	}
@@ -7379,13 +7163,8 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
 	 breakpoint of another thread.  */
       if (ecs->hit_singlestep_breakpoint)
        {
-	 if (debug_infrun)
-	   {
-	     fprintf_unfiltered (gdb_stdlog,
-				 "infrun: need to step [%s] over single-step "
-				 "breakpoint\n",
-				 target_pid_to_str (ecs->ptid).c_str ());
-	   }
+	 infrun_debug_printf ("need to step [%s] over single-step breakpoint",
+			      target_pid_to_str (ecs->ptid).c_str ());
 	 keep_going (ecs);
 	 return 1;
        }
@@ -7395,12 +7174,9 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
 	 another thread.  */
       if (thread_still_needs_step_over (ecs->event_thread))
 	{
-	  if (debug_infrun)
-	    {
-	      fprintf_unfiltered (gdb_stdlog,
-				  "infrun: thread [%s] still needs step-over\n",
-				  target_pid_to_str (ecs->event_thread->ptid).c_str ());
-	    }
+	  infrun_debug_printf
+	    ("thread [%s] still needs step-over",
+	     target_pid_to_str (ecs->event_thread->ptid).c_str ());
 	  keep_going (ecs);
 	  return 1;
 	}
@@ -7479,9 +7255,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs)
 
       if (stepping_thread != NULL)
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: switching back to stepped thread\n");
+	  infrun_debug_printf ("switching back to stepped thread");
 
 	  if (keep_going_stepped_thread (stepping_thread))
 	    {
@@ -7527,18 +7301,14 @@ keep_going_stepped_thread (struct thread_info *tp)
 
   if (tp->state == THREAD_EXITED || !target_thread_alive (tp->ptid))
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: not resuming previously  "
-			    "stepped thread, it has vanished\n");
+      infrun_debug_printf ("not resuming previously stepped thread, it has "
+			   "vanished");
 
       delete_thread (tp);
       return 0;
     }
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: resuming previously stepped thread\n");
+  infrun_debug_printf ("resuming previously stepped thread");
 
   reset_ecs (ecs, tp);
   switch_to_thread (tp);
@@ -7563,11 +7333,9 @@ keep_going_stepped_thread (struct thread_info *tp)
     {
       ptid_t resume_ptid;
 
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: expected thread advanced also (%s -> %s)\n",
-			    paddress (target_gdbarch (), tp->prev_pc),
-			    paddress (target_gdbarch (), tp->suspend.stop_pc));
+      infrun_debug_printf ("expected thread advanced also (%s -> %s)",
+			   paddress (target_gdbarch (), tp->prev_pc),
+			   paddress (target_gdbarch (), tp->suspend.stop_pc));
 
       /* Clear the info of the previous step-over, as it's no longer
 	 valid (if the thread was trying to step over a breakpoint, it
@@ -7589,9 +7357,7 @@ keep_going_stepped_thread (struct thread_info *tp)
     }
   else
     {
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: expected thread still hasn't advanced\n");
+      infrun_debug_printf ("expected thread still hasn't advanced");
 
       keep_going_pass_signal (ecs);
     }
@@ -7742,10 +7508,8 @@ insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
   gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
   gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: inserting step-resume breakpoint at %s\n",
-			paddress (gdbarch, sr_sal.pc));
+  infrun_debug_printf ("inserting step-resume breakpoint at %s",
+		       paddress (gdbarch, sr_sal.pc));
 
   inferior_thread ()->control.step_resume_breakpoint
     = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type).release ();
@@ -7831,10 +7595,8 @@ insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
      longjmp_resume_breakpoint when one is already active.  */
   gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: inserting longjmp-resume breakpoint at %s\n",
-			paddress (gdbarch, pc));
+  infrun_debug_printf ("inserting longjmp-resume breakpoint at %s",
+		       paddress (gdbarch, pc));
 
   inferior_thread ()->control.exception_resume_breakpoint =
     set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume).release ();
@@ -7867,10 +7629,8 @@ insert_exception_resume_breakpoint (struct thread_info *tp,
 	{
 	  handler = value_as_address (value);
 
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: exception resume at %lx\n",
-				(unsigned long) handler);
+	  infrun_debug_printf ("exception resume at %lx",
+			       (unsigned long) handler);
 
 	  bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
 					       handler,
@@ -7907,11 +7667,8 @@ insert_exception_resume_from_probe (struct thread_info *tp,
 
   handler = value_as_address (arg_value);
 
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog,
-			"infrun: exception resume at %s\n",
-			paddress (probe->objfile->arch (),
-				  handler));
+  infrun_debug_printf ("exception resume at %s",
+		       paddress (probe->objfile->arch (), handler));
 
   bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
 				       handler, bp_exception_resume).release ();
@@ -7990,8 +7747,7 @@ check_exception_resume (struct execution_control_state *ecs,
 static void
 stop_waiting (struct execution_control_state *ecs)
 {
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
+  infrun_debug_printf ("stop_waiting");
 
   /* Let callers know we don't want to wait for the inferior anymore.  */
   ecs->wait_some_more = 0;
@@ -8019,11 +7775,9 @@ keep_going_pass_signal (struct execution_control_state *ecs)
     {
       struct thread_info *tp = ecs->event_thread;
 
-      if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog,
-			    "infrun: %s has trap_expected set, "
-			    "resuming to collect trap\n",
-			    target_pid_to_str (tp->ptid).c_str ());
+      infrun_debug_printf ("%s has trap_expected set, "
+			   "resuming to collect trap",
+			   target_pid_to_str (tp->ptid).c_str ());
 
       /* We haven't yet gotten our trap, and either: intercepted a
 	 non-signal event (e.g., a fork); or took a signal which we
@@ -8041,20 +7795,15 @@ keep_going_pass_signal (struct execution_control_state *ecs)
       if (ecs->hit_singlestep_breakpoint
 	  || thread_still_needs_step_over (tp))
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: step-over already in progress: "
-				"step-over for %s deferred\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("step-over already in progress: "
+			       "step-over for %s deferred",
+			       target_pid_to_str (tp->ptid).c_str ());
 	  thread_step_over_chain_enqueue (tp);
 	}
       else
 	{
-	  if (debug_infrun)
-	    fprintf_unfiltered (gdb_stdlog,
-				"infrun: step-over in progress: "
-				"resume of %s deferred\n",
-				target_pid_to_str (tp->ptid).c_str ());
+	  infrun_debug_printf ("step-over in progress: resume of %s deferred",
+			       target_pid_to_str (tp->ptid).c_str ());
 	}
     }
   else
@@ -8154,8 +7903,7 @@ keep_going (struct execution_control_state *ecs)
 static void
 prepare_to_wait (struct execution_control_state *ecs)
 {
-  if (debug_infrun)
-    fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
+  infrun_debug_printf ("prepare_to_wait");
 
   ecs->wait_some_more = 1;