From c058728c31684d08da396f1bf50fabaa196dc9d9 Mon Sep 17 00:00:00 2001
From: Simon Marchi <simon.marchi@polymtl.ca>
Date: Sun, 16 Jan 2022 21:27:58 -0500
Subject: [PATCH] gdbserver: introduce threads_debug_printf,
 THREADS_SCOPED_DEBUG_ENTER_EXIT

Add the threads_debug_printf and THREADS_SCOPED_DEBUG_ENTER_EXIT, which
use the logging infrastructure from gdbsupport/common-debug.h.  Replace
all debug_print uses that are predicated by debug_threads with
threads_dethreads_debug_printf.  Replace uses of the debug_enter and
debug_exit macros with THREADS_SCOPED_DEBUG_ENTER_EXIT, which serves
essentially the same purpose, but allows showing what comes between the
enter and the exit in an indented form.

Note that "threads" debug is currently used for a bit of everything in
GDBserver, not only threads related stuff.  It should ideally be cleaned
up and separated logically as is done in GDB, but that's out of the
scope of this patch.

Change-Id: I2d4546464462cb4c16f7f1168c5cec5a89f2289a
---
 gdbserver/ax.cc                |   2 +-
 gdbserver/debug.cc             |  24 -
 gdbserver/debug.h              |  31 +-
 gdbserver/fork-child.cc        |   6 +-
 gdbserver/linux-aarch64-low.cc |   5 +-
 gdbserver/linux-low.cc         | 965 +++++++++++++--------------------
 gdbserver/linux-s390-low.cc    |   5 +-
 gdbserver/linux-x86-low.cc     |   5 +-
 gdbserver/mem-break.cc         | 128 ++---
 gdbserver/remote-utils.cc      |   8 +-
 gdbserver/server.cc            |  32 +-
 gdbserver/thread-db.cc         |  44 +-
 gdbserver/tracepoint.cc        |  26 +-
 13 files changed, 483 insertions(+), 798 deletions(-)

diff --git a/gdbserver/ax.cc b/gdbserver/ax.cc
index 4f36bc50cab..365bd2195b2 100644
--- a/gdbserver/ax.cc
+++ b/gdbserver/ax.cc
@@ -39,7 +39,7 @@ ax_vdebug (const char *fmt, ...)
 #ifdef IN_PROCESS_AGENT
   fprintf (stderr, PROG "/ax: %s\n", buf);
 #else
-  debug_printf (PROG "/ax: %s\n", buf);
+  threads_debug_printf (PROG "/ax: %s", buf);
 #endif
   va_end (ap);
 }
diff --git a/gdbserver/debug.cc b/gdbserver/debug.cc
index 372b5577958..8b3e95e65cd 100644
--- a/gdbserver/debug.cc
+++ b/gdbserver/debug.cc
@@ -110,30 +110,6 @@ debug_flush (void)
   fflush (debug_file);
 }
 
-/* Notify the user that the code is entering FUNCTION_NAME.
-   FUNCTION_NAME is the name of the calling function, or NULL if unknown.
-
-   This is intended to be called via the debug_enter macro.  */
-
-void
-do_debug_enter (const char *function_name)
-{
-  if (function_name != NULL)
-    debug_printf (">>>> entering %s\n", function_name);
-}
-
-/* Notify the user that the code is exiting FUNCTION_NAME.
-   FUNCTION_NAME is the name of the calling function, or NULL if unknown.
-
-   This is intended to be called via the debug_exit macro.  */
-
-void
-do_debug_exit (const char *function_name)
-{
-  if (function_name != NULL)
-    debug_printf ("<<<< exiting %s\n", function_name);
-}
-
 /* See debug.h.  */
 
 ssize_t
diff --git a/gdbserver/debug.h b/gdbserver/debug.h
index 20cb4e733f2..4220246de79 100644
--- a/gdbserver/debug.h
+++ b/gdbserver/debug.h
@@ -35,31 +35,22 @@ extern int using_threads;
 
 extern bool debug_threads;
 
+/* Print a "threads" debug statement.  */
+
+#define threads_debug_printf(fmt, ...) \
+  debug_prefixed_printf_cond (debug_threads, \
+			      "threads", fmt, ##__VA_ARGS__)
+
+/* Print "threads" enter/exit debug statements.  */
+
+#define THREADS_SCOPED_DEBUG_ENTER_EXIT \
+  scoped_debug_enter_exit (debug_threads, "threads")
+
 extern int debug_timestamp;
 
 void debug_flush (void);
-void do_debug_enter (const char *function_name);
-void do_debug_exit (const char *function_name);
 
 /* Async signal safe debug output function that calls write directly.  */
 ssize_t debug_write (const void *buf, size_t nbyte);
 
-/* These macros are for use in major functions that produce a lot of
-   debugging output.  They help identify in the mass of debugging output
-   when these functions enter and exit.  debug_enter is intended to be
-   called at the start of a function, before any other debugging output.
-   debug_exit is intended to be called at the end of the same function,
-   after all debugging output.  */
-#ifdef FUNCTION_NAME
-#define debug_enter() \
-  do { do_debug_enter (FUNCTION_NAME); } while (0)
-#define debug_exit() \
-  do { do_debug_exit (FUNCTION_NAME); } while (0)
-#else
-#define debug_enter() \
-  do { } while (0)
-#define debug_exit() \
-  do { } while (0)
-#endif
-
 #endif /* GDBSERVER_DEBUG_H */
diff --git a/gdbserver/fork-child.cc b/gdbserver/fork-child.cc
index c991ce3a9d3..96dd4d009ab 100644
--- a/gdbserver/fork-child.cc
+++ b/gdbserver/fork-child.cc
@@ -45,11 +45,7 @@ void
 prefork_hook (const char *args)
 {
   client_state &cs = get_client_state ();
-  if (debug_threads)
-    {
-      debug_printf ("args: %s\n", args);
-      debug_flush ();
-    }
+  threads_debug_printf ("args: %s", args);
 
 #ifdef SIGTTOU
   signal (SIGTTOU, SIG_DFL);
diff --git a/gdbserver/linux-aarch64-low.cc b/gdbserver/linux-aarch64-low.cc
index 10aab52c228..aef69b34525 100644
--- a/gdbserver/linux-aarch64-low.cc
+++ b/gdbserver/linux-aarch64-low.cc
@@ -2467,9 +2467,8 @@ emit_ops_insns (const uint32_t *start, int len)
 {
   CORE_ADDR buildaddr = current_insn_ptr;
 
-  if (debug_threads)
-    debug_printf ("Adding %d instrucions at %s\n",
-		  len, paddress (buildaddr));
+  threads_debug_printf ("Adding %d instrucions at %s",
+			len, paddress (buildaddr));
 
   append_insns (&buildaddr, len, start);
   current_insn_ptr = buildaddr;
diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc
index d7c7336ff1f..9e571a4d771 100644
--- a/gdbserver/linux-low.cc
+++ b/gdbserver/linux-low.cc
@@ -376,8 +376,7 @@ linux_process_target::delete_lwp (lwp_info *lwp)
 {
   struct thread_info *thr = get_lwp_thread (lwp);
 
-  if (debug_threads)
-    debug_printf ("deleting %ld\n", lwpid_of (thr));
+  threads_debug_printf ("deleting %ld", lwpid_of (thr));
 
   remove_thread (thr);
 
@@ -489,13 +488,10 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
 
 	  ptid = ptid_t (new_pid, new_pid);
 
-	  if (debug_threads)
-	    {
-	      debug_printf ("HEW: Got fork event from LWP %ld, "
-			    "new child is %d\n",
-			    ptid_of (event_thr).lwp (),
-			    ptid.pid ());
-	    }
+	  threads_debug_printf ("Got fork event from LWP %ld, "
+				"new child is %d",
+				ptid_of (event_thr).lwp (),
+				ptid.pid ());
 
 	  /* Add the new process to the tables and clone the breakpoint
 	     lists of the parent.  We need to do this even if the new process
@@ -520,8 +516,7 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
 	  if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS
 	      || event_lwp->bp_reinsert != 0)
 	    {
-	      if (debug_threads)
-		debug_printf ("HEW: leaving child suspended\n");
+	      threads_debug_printf ("leaving child suspended");
 	      child_lwp->suspended = 1;
 	    }
 
@@ -586,10 +581,9 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
 	  return 0;
 	}
 
-      if (debug_threads)
-	debug_printf ("HEW: Got clone event "
-		      "from LWP %ld, new child is LWP %ld\n",
-		      lwpid_of (event_thr), new_pid);
+      threads_debug_printf
+	("Got clone event from LWP %ld, new child is LWP %ld",
+	 lwpid_of (event_thr), new_pid);
 
       ptid = ptid_t (pid_of (event_thr), new_pid);
       new_lwp = add_lwp (ptid);
@@ -652,11 +646,8 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
       ptid_t event_ptid;
       pid_t event_pid;
 
-      if (debug_threads)
-	{
-	  debug_printf ("HEW: Got exec event from LWP %ld\n",
-			lwpid_of (event_thr));
-	}
+      threads_debug_printf ("Got exec event from LWP %ld",
+			    lwpid_of (event_thr));
 
       /* Get the event ptid.  */
       event_ptid = ptid_of (event_thr);
@@ -720,8 +711,7 @@ linux_process_target::get_pc (lwp_info *lwp)
   regcache = get_thread_regcache (current_thread, 1);
   pc = low_get_pc (regcache);
 
-  if (debug_threads)
-    debug_printf ("pc is 0x%lx\n", (long) pc);
+  threads_debug_printf ("pc is 0x%lx", (long) pc);
 
   return pc;
 }
@@ -737,8 +727,7 @@ linux_process_target::get_syscall_trapinfo (lwp_info *lwp, int *sysno)
   regcache = get_thread_regcache (current_thread, 1);
   low_get_syscall_trapinfo (regcache, sysno);
 
-  if (debug_threads)
-    debug_printf ("get_syscall_trapinfo sysno %d\n", *sysno);
+  threads_debug_printf ("get_syscall_trapinfo sysno %d", *sysno);
 }
 
 void
@@ -827,13 +816,9 @@ linux_process_target::save_stop_reason (lwp_info *lwp)
 
   if (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
     {
-      if (debug_threads)
-	{
-	  struct thread_info *thr = get_lwp_thread (lwp);
-
-	  debug_printf ("CSBB: %s stopped by software breakpoint\n",
-			target_pid_to_str (ptid_of (thr)).c_str ());
-	}
+      threads_debug_printf
+	("%s stopped by software breakpoint",
+	 target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
 
       /* Back up the PC if necessary.  */
       if (pc != sw_breakpoint_pc)
@@ -847,35 +832,17 @@ linux_process_target::save_stop_reason (lwp_info *lwp)
       pc = sw_breakpoint_pc;
     }
   else if (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
-    {
-      if (debug_threads)
-	{
-	  struct thread_info *thr = get_lwp_thread (lwp);
-
-	  debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
-			target_pid_to_str (ptid_of (thr)).c_str ());
-	}
-    }
+    threads_debug_printf
+      ("%s stopped by hardware breakpoint",
+       target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
   else if (lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
-    {
-      if (debug_threads)
-	{
-	  struct thread_info *thr = get_lwp_thread (lwp);
-
-	  debug_printf ("CSBB: %s stopped by hardware watchpoint\n",
-			target_pid_to_str (ptid_of (thr)).c_str ());
-	}
-    }
+    threads_debug_printf
+      ("%s stopped by hardware watchpoint",
+       target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
   else if (lwp->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
-    {
-      if (debug_threads)
-	{
-	  struct thread_info *thr = get_lwp_thread (lwp);
-
-	  debug_printf ("CSBB: %s stopped by trace\n",
-			target_pid_to_str (ptid_of (thr)).c_str ());
-	}
-    }
+    threads_debug_printf
+      ("%s stopped by trace",
+       target_pid_to_str (ptid_of (get_lwp_thread (lwp))).c_str ());
 
   lwp->stop_pc = pc;
   return true;
@@ -1003,8 +970,7 @@ linux_process_target::attach_lwp (ptid_t ptid)
 
   if (linux_proc_pid_is_stopped (lwpid))
     {
-      if (debug_threads)
-	debug_printf ("Attached to a stopped process\n");
+      threads_debug_printf ("Attached to a stopped process");
 
       /* The process is definitely stopped.  It is in a job control
 	 stop, unless the kernel predates the TASK_STOPPED /
@@ -1080,8 +1046,7 @@ attach_proc_task_lwp_callback (ptid_t ptid)
       int lwpid = ptid.lwp ();
       int err;
 
-      if (debug_threads)
-	debug_printf ("Found new lwp %d\n", lwpid);
+      threads_debug_printf ("Found new lwp %d", lwpid);
 
       err = the_linux_target->attach_lwp (ptid);
 
@@ -1091,14 +1056,9 @@ attach_proc_task_lwp_callback (ptid_t ptid)
 	 case, confirm the status in /proc/PID/status.  */
       if (err == ESRCH
 	  || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
-	{
-	  if (debug_threads)
-	    {
-	      debug_printf ("Cannot attach to lwp %d: "
-			    "thread is gone (%d: %s)\n",
-			    lwpid, err, safe_strerror (err));
-	    }
-	}
+	threads_debug_printf
+	  ("Cannot attach to lwp %d: thread is gone (%d: %s)",
+	   lwpid, err, safe_strerror (err));
       else if (err != 0)
 	{
 	  std::string reason
@@ -1237,9 +1197,9 @@ linux_kill_one_lwp (struct lwp_info *lwp)
     {
       int save_errno = errno;
 
-      debug_printf ("LKL:  kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
-		    target_pid_to_str (ptid_of (thr)).c_str (),
-		    save_errno ? safe_strerror (save_errno) : "OK");
+      threads_debug_printf ("kill_lwp (SIGKILL) %s, 0, 0 (%s)",
+			    target_pid_to_str (ptid_of (thr)).c_str (),
+			    save_errno ? safe_strerror (save_errno) : "OK");
     }
 
   errno = 0;
@@ -1248,9 +1208,9 @@ linux_kill_one_lwp (struct lwp_info *lwp)
     {
       int save_errno = errno;
 
-      debug_printf ("LKL:  PTRACE_KILL %s, 0, 0 (%s)\n",
-		    target_pid_to_str (ptid_of (thr)).c_str (),
-		    save_errno ? safe_strerror (save_errno) : "OK");
+      threads_debug_printf ("PTRACE_KILL %s, 0, 0 (%s)",
+			    target_pid_to_str (ptid_of (thr)).c_str (),
+			    save_errno ? safe_strerror (save_errno) : "OK");
     }
 }
 
@@ -1265,8 +1225,7 @@ kill_wait_lwp (struct lwp_info *lwp)
   int wstat;
   int res;
 
-  if (debug_threads)
-    debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid, pid);
+  threads_debug_printf ("killing lwp %d, for pid: %d", lwpid, pid);
 
   do
     {
@@ -1312,9 +1271,8 @@ kill_one_lwp_callback (thread_info *thread, int pid)
 
   if (lwpid_of (thread) == pid)
     {
-      if (debug_threads)
-	debug_printf ("lkop: is last of process %s\n",
-		      target_pid_to_str (thread->id).c_str ());
+      threads_debug_printf ("is last of process %s",
+			    target_pid_to_str (thread->id).c_str ());
       return;
     }
 
@@ -1340,11 +1298,7 @@ linux_process_target::kill (process_info *process)
   lwp_info *lwp = find_lwp_pid (ptid_t (pid));
 
   if (lwp == NULL)
-    {
-      if (debug_threads)
-	debug_printf ("lk_1: cannot find lwp for pid: %d\n",
-		      pid);
-    }
+    threads_debug_printf ("cannot find lwp for pid: %d", pid);
   else
     kill_wait_lwp (lwp);
 
@@ -1386,19 +1340,17 @@ get_detach_signal (struct thread_info *thread)
 
   if (!WIFSTOPPED (status))
     {
-      if (debug_threads)
-	debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
-		      target_pid_to_str (ptid_of (thread)).c_str ());
+      threads_debug_printf ("lwp %s hasn't stopped: no pending signal",
+			    target_pid_to_str (ptid_of (thread)).c_str ());
       return 0;
     }
 
   /* Extended wait statuses aren't real SIGTRAPs.  */
   if (WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status))
     {
-      if (debug_threads)
-	debug_printf ("GPS: lwp %s had stopped with extended "
-		      "status: no pending signal\n",
-		      target_pid_to_str (ptid_of (thread)).c_str ());
+      threads_debug_printf ("lwp %s had stopped with extended "
+			    "status: no pending signal",
+			    target_pid_to_str (ptid_of (thread)).c_str ());
       return 0;
     }
 
@@ -1406,10 +1358,9 @@ get_detach_signal (struct thread_info *thread)
 
   if (cs.program_signals_p && !cs.program_signals[signo])
     {
-      if (debug_threads)
-	debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
-		      target_pid_to_str (ptid_of (thread)).c_str (),
-		      gdb_signal_to_string (signo));
+      threads_debug_printf ("lwp %s had signal %s, but it is in nopass state",
+			    target_pid_to_str (ptid_of (thread)).c_str (),
+			    gdb_signal_to_string (signo));
       return 0;
     }
   else if (!cs.program_signals_p
@@ -1418,20 +1369,18 @@ get_detach_signal (struct thread_info *thread)
 	      SIGTRAP/SIGINT, which is GDB's default.  */
 	   && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
     {
-      if (debug_threads)
-	debug_printf ("GPS: lwp %s had signal %s, "
-		      "but we don't know if we should pass it. "
-		      "Default to not.\n",
-		      target_pid_to_str (ptid_of (thread)).c_str (),
-		      gdb_signal_to_string (signo));
+      threads_debug_printf ("lwp %s had signal %s, "
+			    "but we don't know if we should pass it. "
+			    "Default to not.",
+			    target_pid_to_str (ptid_of (thread)).c_str (),
+			    gdb_signal_to_string (signo));
       return 0;
     }
   else
     {
-      if (debug_threads)
-	debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
-		      target_pid_to_str (ptid_of (thread)).c_str (),
-		      gdb_signal_to_string (signo));
+      threads_debug_printf ("lwp %s has pending signal %s: delivering it",
+			    target_pid_to_str (ptid_of (thread)).c_str (),
+			    gdb_signal_to_string (signo));
 
       return WSTOPSIG (status);
     }
@@ -1447,9 +1396,8 @@ linux_process_target::detach_one_lwp (lwp_info *lwp)
   /* If there is a pending SIGSTOP, get rid of it.  */
   if (lwp->stop_expected)
     {
-      if (debug_threads)
-	debug_printf ("Sending SIGCONT to %s\n",
-		      target_pid_to_str (ptid_of (thread)).c_str ());
+      threads_debug_printf ("Sending SIGCONT to %s",
+			    target_pid_to_str (ptid_of (thread)).c_str ());
 
       kill_lwp (lwpid_of (thread), SIGCONT);
       lwp->stop_expected = 0;
@@ -1509,12 +1457,10 @@ linux_process_target::detach_one_lwp (lwp_info *lwp)
 		 safe_strerror (save_errno));
 	}
     }
-  else if (debug_threads)
-    {
-      debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)\n",
-		    target_pid_to_str (ptid_of (thread)).c_str (),
-		    strsignal (sig));
-    }
+  else
+    threads_debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)",
+			  target_pid_to_str (ptid_of (thread)).c_str (),
+			  strsignal (sig));
 
   delete_lwp (lwp);
 }
@@ -1645,9 +1591,8 @@ linux_process_target::thread_still_has_status_pending (thread_info *thread)
 
       if (pc != lp->stop_pc)
 	{
-	  if (debug_threads)
-	    debug_printf ("PC of %ld changed\n",
-			  lwpid_of (thread));
+	  threads_debug_printf ("PC of %ld changed",
+				lwpid_of (thread));
 	  discard = 1;
 	}
 
@@ -1655,25 +1600,22 @@ linux_process_target::thread_still_has_status_pending (thread_info *thread)
       else if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
 	       && !low_breakpoint_at (pc))
 	{
-	  if (debug_threads)
-	    debug_printf ("previous SW breakpoint of %ld gone\n",
-			  lwpid_of (thread));
+	  threads_debug_printf ("previous SW breakpoint of %ld gone",
+				lwpid_of (thread));
 	  discard = 1;
 	}
       else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT
 	       && !hardware_breakpoint_inserted_here (pc))
 	{
-	  if (debug_threads)
-	    debug_printf ("previous HW breakpoint of %ld gone\n",
-			  lwpid_of (thread));
+	  threads_debug_printf ("previous HW breakpoint of %ld gone",
+				lwpid_of (thread));
 	  discard = 1;
 	}
 #endif
 
       if (discard)
 	{
-	  if (debug_threads)
-	    debug_printf ("discarding pending breakpoint status\n");
+	  threads_debug_printf ("discarding pending breakpoint status");
 	  lp->status_pending_p = 0;
 	  return 0;
 	}
@@ -1784,11 +1726,10 @@ linux_process_target::check_zombie_leaders ()
 
     leader_lp = find_lwp_pid (ptid_t (leader_pid));
 
-    if (debug_threads)
-      debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
-		    "num_lwps=%d, zombie=%d\n",
-		    leader_pid, leader_lp!= NULL, num_lwps (leader_pid),
-		    linux_proc_pid_is_zombie (leader_pid));
+    threads_debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
+			  "num_lwps=%d, zombie=%d",
+			  leader_pid, leader_lp!= NULL, num_lwps (leader_pid),
+			  linux_proc_pid_is_zombie (leader_pid));
 
     if (leader_lp != NULL && !leader_lp->stopped
 	/* Check if there are other threads in the group, as we may
@@ -1824,10 +1765,9 @@ linux_process_target::check_zombie_leaders ()
 	   previous leader did exit voluntarily before some other
 	   thread execs).  */
 
-	if (debug_threads)
-	  debug_printf ("CZL: Thread group leader %d zombie "
-			"(it exited, or another thread execd).\n",
-			leader_pid);
+	threads_debug_printf ("Thread group leader %d zombie "
+			      "(it exited, or another thread execd).",
+			      leader_pid);
 
 	delete_lwp (leader_lp);
       }
@@ -1855,13 +1795,10 @@ lwp_suspended_inc (struct lwp_info *lwp)
 {
   lwp->suspended++;
 
-  if (debug_threads && lwp->suspended > 4)
-    {
-      struct thread_info *thread = get_lwp_thread (lwp);
-
-      debug_printf ("LWP %ld has a suspiciously high suspend count,"
-		    " suspended=%d\n", lwpid_of (thread), lwp->suspended);
-    }
+  if (lwp->suspended > 4)
+    threads_debug_printf
+      ("LWP %ld has a suspiciously high suspend count, suspended=%d",
+       lwpid_of (get_lwp_thread (lwp)), lwp->suspended);
 }
 
 /* Decrement LWP's suspend count.  */
@@ -1923,8 +1860,7 @@ handle_tracepoints (struct lwp_info *lwp)
 
   if (tpoint_related_event)
     {
-      if (debug_threads)
-	debug_printf ("got a tracepoint event\n");
+      threads_debug_printf ("got a tracepoint event");
       return 1;
     }
 
@@ -1967,10 +1903,9 @@ linux_process_target::maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat)
     {
       struct fast_tpoint_collect_status status;
 
-      if (debug_threads)
-	debug_printf ("Checking whether LWP %ld needs to move out of the "
-		      "jump pad.\n",
-		      lwpid_of (current_thread));
+      threads_debug_printf
+	("Checking whether LWP %ld needs to move out of the jump pad.",
+	 lwpid_of (current_thread));
 
       fast_tpoint_collect_result r
 	= linux_fast_tracepoint_collecting (lwp, &status);
@@ -1995,10 +1930,9 @@ linux_process_target::maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat)
 		    = set_breakpoint_at (status.adjusted_insn_addr, NULL);
 		}
 
-	      if (debug_threads)
-		debug_printf ("Checking whether LWP %ld needs to move out of "
-			      "the jump pad...it does\n",
-			      lwpid_of (current_thread));
+	      threads_debug_printf
+		("Checking whether LWP %ld needs to move out of the jump pad..."
+		 " it does", lwpid_of (current_thread));
 
 	      return true;
 	    }
@@ -2050,9 +1984,9 @@ linux_process_target::maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat)
 
 	  if (lwp->exit_jump_pad_bkpt != NULL)
 	    {
-	      if (debug_threads)
-		debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
-			      "stopping all threads momentarily.\n");
+	      threads_debug_printf
+		("Cancelling fast exit-jump-pad: removing bkpt."
+		 "stopping all threads momentarily.");
 
 	      stop_all_lwps (1, lwp);
 
@@ -2066,10 +2000,9 @@ linux_process_target::maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat)
 	}
     }
 
-  if (debug_threads)
-    debug_printf ("Checking whether LWP %ld needs to move out of the "
-		  "jump pad...no\n",
-		  lwpid_of (current_thread));
+  threads_debug_printf
+    ("Checking whether LWP %ld needs to move out of the jump pad... no",
+     lwpid_of (current_thread));
 
   return false;
 }
@@ -2082,17 +2015,15 @@ enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
 {
   struct thread_info *thread = get_lwp_thread (lwp);
 
-  if (debug_threads)
-    debug_printf ("Deferring signal %d for LWP %ld.\n",
-		  WSTOPSIG (*wstat), lwpid_of (thread));
+  threads_debug_printf ("Deferring signal %d for LWP %ld.",
+			WSTOPSIG (*wstat), lwpid_of (thread));
 
   if (debug_threads)
     {
       for (const auto &sig : lwp->pending_signals_to_report)
-	debug_printf ("   Already queued %d\n",
-		      sig.signal);
+	threads_debug_printf ("   Already queued %d", sig.signal);
 
-      debug_printf ("   (no more currently queued signals)\n");
+      threads_debug_printf ("   (no more currently queued signals)");
     }
 
   /* Don't enqueue non-RT signals if they are already in the deferred
@@ -2104,11 +2035,9 @@ enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
 	{
 	  if (sig.signal == WSTOPSIG (*wstat))
 	    {
-	      if (debug_threads)
-		debug_printf ("Not requeuing already queued non-RT signal %d"
-			      " for LWP %ld\n",
-			      sig.signal,
-			      lwpid_of (thread));
+	      threads_debug_printf
+		("Not requeuing already queued non-RT signal %d for LWP %ld",
+		 sig.signal, lwpid_of (thread));
 	      return;
 	    }
 	}
@@ -2139,17 +2068,15 @@ dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
 
       lwp->pending_signals_to_report.pop_front ();
 
-      if (debug_threads)
-	debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
-		      WSTOPSIG (*wstat), lwpid_of (thread));
+      threads_debug_printf ("Reporting deferred signal %d for LWP %ld.",
+			    WSTOPSIG (*wstat), lwpid_of (thread));
 
       if (debug_threads)
 	{
 	  for (const auto &sig : lwp->pending_signals_to_report)
-	    debug_printf ("   Still queued %d\n",
-			  sig.signal);
+	    threads_debug_printf ("   Still queued %d", sig.signal);
 
-	  debug_printf ("   (no more queued signals)\n");
+	  threads_debug_printf ("   (no more queued signals)");
 	}
 
       return 1;
@@ -2240,11 +2167,8 @@ linux_process_target::filter_event (int lwpid, int wstat)
       ptid_t child_ptid;
 
       /* A multi-thread exec after we had seen the leader exiting.  */
-      if (debug_threads)
-	{
-	  debug_printf ("LLW: Re-adding thread group leader LWP %d"
-			"after exec.\n", lwpid);
-	}
+      threads_debug_printf ("Re-adding thread group leader LWP %d after exec.",
+			    lwpid);
 
       child_ptid = ptid_t (lwpid, lwpid);
       child = add_lwp (child_ptid);
@@ -2273,8 +2197,7 @@ linux_process_target::filter_event (int lwpid, int wstat)
   /* Check if the thread has exited.  */
   if ((WIFEXITED (wstat) || WIFSIGNALED (wstat)))
     {
-      if (debug_threads)
-	debug_printf ("LLFE: %d exited.\n", lwpid);
+      threads_debug_printf ("%d exited", lwpid);
 
       if (finish_step_over (child))
 	{
@@ -2380,33 +2303,29 @@ linux_process_target::filter_event (int lwpid, int wstat)
   if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGSTOP
       && child->stop_expected)
     {
-      if (debug_threads)
-	debug_printf ("Expected stop.\n");
+      threads_debug_printf ("Expected stop.");
+
       child->stop_expected = 0;
 
       if (thread->last_resume_kind == resume_stop)
 	{
 	  /* We want to report the stop to the core.  Treat the
 	     SIGSTOP as a normal event.  */
-	  if (debug_threads)
-	    debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
-			  target_pid_to_str (ptid_of (thread)).c_str ());
+	  threads_debug_printf ("resume_stop SIGSTOP caught for %s.",
+				target_pid_to_str (ptid_of (thread)).c_str ());
 	}
       else if (stopping_threads != NOT_STOPPING_THREADS)
 	{
 	  /* Stopping threads.  We don't want this SIGSTOP to end up
 	     pending.  */
-	  if (debug_threads)
-	    debug_printf ("LLW: SIGSTOP caught for %s "
-			  "while stopping threads.\n",
-			  target_pid_to_str (ptid_of (thread)).c_str ());
+	  threads_debug_printf ("SIGSTOP caught for %s while stopping threads.",
+				target_pid_to_str (ptid_of (thread)).c_str ());
 	  return;
 	}
       else
 	{
 	  /* This is a delayed SIGSTOP.  Filter out the event.  */
-	  if (debug_threads)
-	    debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
+	  threads_debug_printf ("%s %s, 0, 0 (discard delayed SIGSTOP)",
 			  child->stepping ? "step" : "continue",
 			  target_pid_to_str (ptid_of (thread)).c_str ());
 
@@ -2449,11 +2368,9 @@ linux_process_target::resume_stopped_resumed_lwps (thread_info *thread)
       if (thread->last_resume_kind == resume_step)
 	step = maybe_hw_step (thread);
 
-      if (debug_threads)
-	debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
-		      target_pid_to_str (ptid_of (thread)).c_str (),
-		      paddress (lp->stop_pc),
-		      step);
+      threads_debug_printf ("resuming stopped-resumed LWP %s at %s: step=%d",
+			    target_pid_to_str (ptid_of (thread)).c_str (),
+			    paddress (lp->stop_pc), step);
 
       resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
     }
@@ -2485,9 +2402,10 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
 	});
 
       if (event_thread != NULL)
-	event_child = get_thread_lwp (event_thread);
-      if (debug_threads && event_thread)
-	debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread));
+	{
+	  event_child = get_thread_lwp (event_thread);
+	  threads_debug_printf ("Got a pending child %ld", lwpid_of (event_thread));
+	}
     }
   else if (filter_ptid != null_ptid)
     {
@@ -2522,9 +2440,10 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
 
   if (event_child != NULL)
     {
-      if (debug_threads)
-	debug_printf ("Got an event from pending child %ld (%04x)\n",
-		      lwpid_of (event_thread), event_child->status_pending);
+      threads_debug_printf ("Got an event from pending child %ld (%04x)",
+			    lwpid_of (event_thread),
+			    event_child->status_pending);
+
       *wstatp = event_child->status_pending;
       event_child->status_pending_p = 0;
       event_child->status_pending = 0;
@@ -2566,17 +2485,13 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
       errno = 0;
       ret = my_waitpid (-1, wstatp, options | WNOHANG);
 
-      if (debug_threads)
-	debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
-		      ret, errno ? safe_strerror (errno) : "ERRNO-OK");
+      threads_debug_printf ("waitpid(-1, ...) returned %d, %s",
+			    ret, errno ? safe_strerror (errno) : "ERRNO-OK");
 
       if (ret > 0)
 	{
-	  if (debug_threads)
-	    {
-	      debug_printf ("LLW: waitpid %ld received %s\n",
-			    (long) ret, status_to_str (*wstatp).c_str ());
-	    }
+	  threads_debug_printf ("waitpid %ld received %s",
+				(long) ret, status_to_str (*wstatp).c_str ());
 
 	  /* Filter all events.  IOW, leave all events pending.  We'll
 	     randomly select an event LWP out of all that have events
@@ -2629,8 +2544,8 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
 	 over 0 (below), as it is more detailed.  */
       if (find_thread (not_stopped) == NULL)
 	{
-	  if (debug_threads)
-	    debug_printf ("LLW: exit (no unwaited-for LWP)\n");
+	  threads_debug_printf ("exit (no unwaited-for LWP)");
+
 	  gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
 	  return -1;
 	}
@@ -2638,16 +2553,14 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
       /* No interesting event to report to the caller.  */
       if ((options & WNOHANG))
 	{
-	  if (debug_threads)
-	    debug_printf ("WNOHANG set, no event found\n");
+	  threads_debug_printf ("WNOHANG set, no event found");
 
 	  gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
 	  return 0;
 	}
 
       /* Block until we get an event reported with SIGCHLD.  */
-      if (debug_threads)
-	debug_printf ("sigsuspend'ing\n");
+      threads_debug_printf ("sigsuspend'ing");
 
       sigsuspend (&prev_mask);
       gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
@@ -2694,11 +2607,9 @@ select_event_lwp (struct lwp_info **orig_lp)
 	});
 
       if (event_thread != NULL)
-	{
-	  if (debug_threads)
-	    debug_printf ("SEL: Select single-step %s\n",
-			  target_pid_to_str (ptid_of (event_thread)).c_str ());
-	}
+	threads_debug_printf
+	  ("Select single-step %s",
+	   target_pid_to_str (ptid_of (event_thread)).c_str ());
     }
   if (event_thread == NULL)
     {
@@ -2781,9 +2692,8 @@ linux_process_target::stabilize_threads ()
 
   if (thread_stuck != NULL)
     {
-      if (debug_threads)
-	debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
-		      lwpid_of (thread_stuck));
+      threads_debug_printf ("can't stabilize, LWP %ld is stuck in jump pad",
+			    lwpid_of (thread_stuck));
       return;
     }
 
@@ -2837,8 +2747,9 @@ linux_process_target::stabilize_threads ()
 		       });
 
       if (thread_stuck != NULL)
-	debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
-		      lwpid_of (thread_stuck));
+	threads_debug_printf
+	  ("couldn't stabilize, LWP %ld got stuck in jump pad",
+	   lwpid_of (thread_stuck));
     }
 }
 
@@ -2914,6 +2825,8 @@ ptid_t
 linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 			      target_wait_flags target_options)
 {
+  THREADS_SCOPED_DEBUG_ENTER_EXIT;
+
   client_state &cs = get_client_state ();
   int w;
   struct lwp_info *event_child;
@@ -2927,11 +2840,7 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
   int in_step_range;
   int any_resumed;
 
-  if (debug_threads)
-    {
-      debug_enter ();
-      debug_printf ("wait_1: [%s]\n", target_pid_to_str (ptid).c_str ());
-    }
+  threads_debug_printf ("[%s]", target_pid_to_str (ptid).c_str ());
 
   /* Translate generic target options into linux options.  */
   options = __WALL;
@@ -2965,9 +2874,8 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
     pid = wait_for_event (ptid, &w, options);
   else
     {
-      if (debug_threads)
-	debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
-		      target_pid_to_str (step_over_bkpt).c_str ());
+      threads_debug_printf ("step_over_bkpt set [%s], doing a blocking wait",
+			    target_pid_to_str (step_over_bkpt).c_str ());
       pid = wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
     }
 
@@ -2975,24 +2883,14 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
     {
       gdb_assert (target_options & TARGET_WNOHANG);
 
-      if (debug_threads)
-	{
-	  debug_printf ("wait_1 ret = null_ptid, "
-			"TARGET_WAITKIND_IGNORE\n");
-	  debug_exit ();
-	}
+      threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_IGNORE");
 
       ourstatus->set_ignore ();
       return null_ptid;
     }
   else if (pid == -1)
     {
-      if (debug_threads)
-	{
-	  debug_printf ("wait_1 ret = null_ptid, "
-			"TARGET_WAITKIND_NO_RESUMED\n");
-	  debug_exit ();
-	}
+      threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_NO_RESUMED");
 
       ourstatus->set_no_resumed ();
       return null_ptid;
@@ -3008,27 +2906,19 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 	{
 	  ourstatus->set_exited (WEXITSTATUS (w));
 
-	  if (debug_threads)
-	    {
-	      debug_printf ("wait_1 ret = %s, exited with "
-			    "retcode %d\n",
-			    target_pid_to_str (ptid_of (current_thread)).c_str (),
-			    WEXITSTATUS (w));
-	      debug_exit ();
-	    }
+	  threads_debug_printf
+	    ("ret = %s, exited with retcode %d",
+	     target_pid_to_str (ptid_of (current_thread)).c_str (),
+	     WEXITSTATUS (w));
 	}
       else
 	{
 	  ourstatus->set_signalled (gdb_signal_from_host (WTERMSIG (w)));
 
-	  if (debug_threads)
-	    {
-	      debug_printf ("wait_1 ret = %s, terminated with "
-			    "signal %d\n",
-			    target_pid_to_str (ptid_of (current_thread)).c_str (),
-			    WTERMSIG (w));
-	      debug_exit ();
-	    }
+	  threads_debug_printf
+	    ("ret = %s, terminated with signal %d",
+	     target_pid_to_str (ptid_of (current_thread)).c_str (),
+	     WTERMSIG (w));
 	}
 
       if (ourstatus->kind () == TARGET_WAITKIND_EXITED)
@@ -3060,11 +2950,9 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
       breakpoint_kind = breakpoint_kind_from_current_state (&stop_pc);
       sw_breakpoint_from_kind (breakpoint_kind, &increment_pc);
 
-      if (debug_threads)
-	{
-	  debug_printf ("step-over for %s executed software breakpoint\n",
-			target_pid_to_str (ptid_of (current_thread)).c_str ());
-	}
+      threads_debug_printf
+	("step-over for %s executed software breakpoint",
+	 target_pid_to_str (ptid_of (current_thread)).c_str ());
 
       if (increment_pc != 0)
 	{
@@ -3117,10 +3005,7 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
       trace_event = handle_tracepoints (event_child);
 
       if (bp_explains_trap)
-	{
-	  if (debug_threads)
-	    debug_printf ("Hit a gdbserver breakpoint.\n");
-	}
+	threads_debug_printf ("Hit a gdbserver breakpoint.");
     }
   else
     {
@@ -3141,10 +3026,9 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
       && supports_fast_tracepoints ()
       && agent_loaded_p ())
     {
-      if (debug_threads)
-	debug_printf ("Got signal %d for LWP %ld.  Check if we need "
-		      "to defer or adjust it.\n",
-		      WSTOPSIG (w), lwpid_of (current_thread));
+      threads_debug_printf ("Got signal %d for LWP %ld.  Check if we need "
+			    "to defer or adjust it.",
+			    WSTOPSIG (w), lwpid_of (current_thread));
 
       /* Allow debugging the jump pad itself.  */
       if (current_thread->last_resume_kind != resume_step
@@ -3152,14 +3036,11 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 	{
 	  enqueue_one_deferred_signal (event_child, &w);
 
-	  if (debug_threads)
-	    debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
-			  WSTOPSIG (w), lwpid_of (current_thread));
+	  threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad)",
+				WSTOPSIG (w), lwpid_of (current_thread));
 
 	  resume_one_lwp (event_child, 0, 0, NULL);
 
-	  if (debug_threads)
-	    debug_exit ();
 	  return ignore_event (ourstatus);
 	}
     }
@@ -3167,11 +3048,11 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
   if (event_child->collecting_fast_tracepoint
       != fast_tpoint_collect_result::not_collecting)
     {
-      if (debug_threads)
-	debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
-		      "Check if we're already there.\n",
-		      lwpid_of (current_thread),
-		      (int) event_child->collecting_fast_tracepoint);
+      threads_debug_printf
+	("LWP %ld was trying to move out of the jump pad (%d). "
+	 "Check if we're already there.",
+	 lwpid_of (current_thread),
+	 (int) event_child->collecting_fast_tracepoint);
 
       trace_event = 1;
 
@@ -3184,9 +3065,9 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 	  /* No longer need this breakpoint.  */
 	  if (event_child->exit_jump_pad_bkpt != NULL)
 	    {
-	      if (debug_threads)
-		debug_printf ("No longer need exit-jump-pad bkpt; removing it."
-			      "stopping all threads momentarily.\n");
+	      threads_debug_printf
+		("No longer need exit-jump-pad bkpt; removing it."
+		 "stopping all threads momentarily.");
 
 	      /* Other running threads could hit this breakpoint.
 		 We don't handle moribund locations like GDB does,
@@ -3209,33 +3090,23 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
       if (event_child->collecting_fast_tracepoint
 	  == fast_tpoint_collect_result::not_collecting)
 	{
-	  if (debug_threads)
-	    debug_printf ("fast tracepoint finished "
-			  "collecting successfully.\n");
+	  threads_debug_printf
+	    ("fast tracepoint finished collecting successfully.");
 
 	  /* We may have a deferred signal to report.  */
 	  if (dequeue_one_deferred_signal (event_child, &w))
-	    {
-	      if (debug_threads)
-		debug_printf ("dequeued one signal.\n");
-	    }
+	    threads_debug_printf ("dequeued one signal.");
 	  else
 	    {
-	      if (debug_threads)
-		debug_printf ("no deferred signals.\n");
+	      threads_debug_printf ("no deferred signals.");
 
 	      if (stabilizing_threads)
 		{
 		  ourstatus->set_stopped (GDB_SIGNAL_0);
 
-		  if (debug_threads)
-		    {
-		      debug_printf ("wait_1 ret = %s, stopped "
-				    "while stabilizing threads\n",
-				    target_pid_to_str
-				      (ptid_of (current_thread)).c_str ());
-		      debug_exit ();
-		    }
+		  threads_debug_printf
+		    ("ret = %s, stopped while stabilizing threads",
+		     target_pid_to_str (ptid_of (current_thread)).c_str ());
 
 		  return ptid_of (current_thread);
 		}
@@ -3250,16 +3121,11 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
       && WSTOPSIG (w) == SYSCALL_SIGTRAP
       && !gdb_catch_this_syscall (event_child))
     {
-      if (debug_threads)
-	{
-	  debug_printf ("Ignored syscall for LWP %ld.\n",
-			lwpid_of (current_thread));
-	}
+      threads_debug_printf ("Ignored syscall for LWP %ld.",
+			    lwpid_of (current_thread));
 
       resume_one_lwp (event_child, event_child->stepping, 0, NULL);
 
-      if (debug_threads)
-	debug_exit ();
       return ignore_event (ourstatus);
     }
 
@@ -3287,9 +3153,8 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
     {
       siginfo_t info, *info_p;
 
-      if (debug_threads)
-	debug_printf ("Ignored signal %d for LWP %ld.\n",
-		      WSTOPSIG (w), lwpid_of (current_thread));
+      threads_debug_printf ("Ignored signal %d for LWP %ld.",
+			    WSTOPSIG (w), lwpid_of (current_thread));
 
       if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
 		  (PTRACE_TYPE_ARG3) 0, &info) == 0)
@@ -3316,9 +3181,6 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 			  WSTOPSIG (w), info_p);
 	}
 
-      if (debug_threads)
-	debug_exit ();
-
       return ignore_event (ourstatus);
     }
 
@@ -3361,20 +3223,20 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
      shouldn't know about.  */
   if (!report_to_gdb)
     {
-      if (debug_threads)
-	{
-	  if (bp_explains_trap)
-	    debug_printf ("Hit a gdbserver breakpoint.\n");
-	  if (step_over_finished)
-	    debug_printf ("Step-over finished.\n");
-	  if (trace_event)
-	    debug_printf ("Tracepoint event.\n");
-	  if (lwp_in_step_range (event_child))
-	    debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
-			  paddress (event_child->stop_pc),
-			  paddress (event_child->step_range_start),
-			  paddress (event_child->step_range_end));
-	}
+      if (bp_explains_trap)
+	threads_debug_printf ("Hit a gdbserver breakpoint.");
+
+      if (step_over_finished)
+	threads_debug_printf ("Step-over finished.");
+
+      if (trace_event)
+	threads_debug_printf ("Tracepoint event.");
+
+      if (lwp_in_step_range (event_child))
+	threads_debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).",
+			      paddress (event_child->stop_pc),
+			      paddress (event_child->step_range_start),
+			      paddress (event_child->step_range_end));
 
       /* We're not reporting this breakpoint to GDB, so apply the
 	 decr_pc_after_break adjustment to the inferior's regcache
@@ -3410,36 +3272,36 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 	    }
 	}
 
-      if (debug_threads)
-	debug_printf ("proceeding all threads.\n");
-      proceed_all_lwps ();
+      threads_debug_printf ("proceeding all threads.");
 
-      if (debug_threads)
-	debug_exit ();
+      proceed_all_lwps ();
 
       return ignore_event (ourstatus);
     }
 
-  if (debug_threads)
-    {
-      if (event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE)
-	debug_printf ("LWP %ld: extended event with waitstatus %s\n",
-		      lwpid_of (get_lwp_thread (event_child)),
-		      event_child->waitstatus.to_string ().c_str ());
-      if (current_thread->last_resume_kind == resume_step)
-	{
-	  if (event_child->step_range_start == event_child->step_range_end)
-	    debug_printf ("GDB wanted to single-step, reporting event.\n");
-	  else if (!lwp_in_step_range (event_child))
-	    debug_printf ("Out of step range, reporting event.\n");
-	}
-      if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
-	debug_printf ("Stopped by watchpoint.\n");
-      else if (gdb_breakpoint_here (event_child->stop_pc))
-	debug_printf ("Stopped by GDB breakpoint.\n");
-      if (debug_threads)
-	debug_printf ("Hit a non-gdbserver trap event.\n");
-    }
+    if (debug_threads)
+      {
+	if (event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE)
+	  threads_debug_printf ("LWP %ld: extended event with waitstatus %s",
+				lwpid_of (get_lwp_thread (event_child)),
+				event_child->waitstatus.to_string ().c_str ());
+
+	if (current_thread->last_resume_kind == resume_step)
+	  {
+	    if (event_child->step_range_start == event_child->step_range_end)
+	      threads_debug_printf
+		("GDB wanted to single-step, reporting event.");
+	    else if (!lwp_in_step_range (event_child))
+	      threads_debug_printf ("Out of step range, reporting event.");
+	  }
+
+	if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
+	  threads_debug_printf ("Stopped by watchpoint.");
+	else if (gdb_breakpoint_here (event_child->stop_pc))
+	  threads_debug_printf ("Stopped by GDB breakpoint.");
+      }
+
+    threads_debug_printf ("Hit a non-gdbserver trap event.");
 
   /* Alright, we're going to report a stop.  */
 
@@ -3630,13 +3492,9 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 
   gdb_assert (step_over_bkpt == null_ptid);
 
-  if (debug_threads)
-    {
-      debug_printf ("wait_1 ret = %s, %d, %d\n",
-		    target_pid_to_str (ptid_of (current_thread)).c_str (),
-		    ourstatus->kind (), ourstatus->sig ());
-      debug_exit ();
-    }
+  threads_debug_printf ("ret = %s, %d, %d",
+			target_pid_to_str (ptid_of (current_thread)).c_str (),
+			ourstatus->kind (), ourstatus->sig ());
 
   if (ourstatus->kind () == TARGET_WAITKIND_EXITED)
     return filter_exit_event (event_child, ourstatus);
@@ -3736,14 +3594,12 @@ send_sigstop (struct lwp_info *lwp)
      send another.  */
   if (lwp->stop_expected)
     {
-      if (debug_threads)
-	debug_printf ("Have pending sigstop for lwp %d\n", pid);
+      threads_debug_printf ("Have pending sigstop for lwp %d", pid);
 
       return;
     }
 
-  if (debug_threads)
-    debug_printf ("Sending sigstop to lwp %d\n", pid);
+  threads_debug_printf ("Sending sigstop to lwp %d", pid);
 
   lwp->stop_expected = 1;
   kill_lwp (pid, SIGSTOP);
@@ -3828,8 +3684,7 @@ linux_process_target::wait_for_sigstop ()
 
   scoped_restore_current_thread restore_thread;
 
-  if (debug_threads)
-    debug_printf ("wait_for_sigstop: pulling events\n");
+  threads_debug_printf ("pulling events");
 
   /* Passing NULL_PTID as filter indicates we want all events to be
      left pending.  Eventually this returns when there are no
@@ -3841,8 +3696,7 @@ linux_process_target::wait_for_sigstop ()
     return;
   else
     {
-      if (debug_threads)
-	debug_printf ("Previously current thread died.\n");
+      threads_debug_printf ("Previously current thread died.");
 
       /* We can't change the current inferior behind GDB's back,
 	 otherwise, a subsequent command may apply to the wrong
@@ -3901,19 +3755,16 @@ linux_process_target::move_out_of_jump_pad (thread_info *thread)
       && thread->last_resume_kind != resume_step
       && maybe_move_out_of_jump_pad (lwp, wstat))
     {
-      if (debug_threads)
-	debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("LWP %ld needs stabilizing (in jump pad)",
+			    lwpid_of (thread));
 
       if (wstat)
 	{
 	  lwp->status_pending_p = 0;
 	  enqueue_one_deferred_signal (lwp, wstat);
 
-	  if (debug_threads)
-	    debug_printf ("Signal %d for LWP %ld deferred "
-			  "(in jump pad)\n",
-			  WSTOPSIG (*wstat), lwpid_of (thread));
+	  threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad",
+				WSTOPSIG (*wstat), lwpid_of (thread));
 	}
 
       resume_one_lwp (lwp, 0, 0, NULL);
@@ -3939,16 +3790,13 @@ linux_process_target::stop_all_lwps (int suspend, lwp_info *except)
   /* Should not be called recursively.  */
   gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
 
-  if (debug_threads)
-    {
-      debug_enter ();
-      debug_printf ("stop_all_lwps (%s, except=%s)\n",
-		    suspend ? "stop-and-suspend" : "stop",
-		    (except != NULL
-		     ? target_pid_to_str
-			 (ptid_of (get_lwp_thread (except))).c_str ()
-		     : "none"));
-    }
+  THREADS_SCOPED_DEBUG_ENTER_EXIT;
+
+  threads_debug_printf
+    ("%s, except=%s", suspend ? "stop-and-suspend" : "stop",
+     (except != NULL
+      ? target_pid_to_str (ptid_of (get_lwp_thread (except))).c_str ()
+      : "none"));
 
   stopping_threads = (suspend
 		      ? STOPPING_AND_SUSPENDING_THREADS
@@ -3968,12 +3816,7 @@ linux_process_target::stop_all_lwps (int suspend, lwp_info *except)
   wait_for_sigstop ();
   stopping_threads = NOT_STOPPING_THREADS;
 
-  if (debug_threads)
-    {
-      debug_printf ("stop_all_lwps done, setting stopping_threads "
-		    "back to !stopping\n");
-      debug_exit ();
-    }
+  threads_debug_printf ("setting stopping_threads back to !stopping");
 }
 
 /* Enqueue one signal in the chain of signals which need to be
@@ -4019,10 +3862,7 @@ linux_process_target::single_step (lwp_info* lwp)
       step = 0;
     }
   else
-    {
-      if (debug_threads)
-	debug_printf ("stepping is not implemented on this target");
-    }
+    threads_debug_printf ("stepping is not implemented on this target");
 
   return step;
 }
@@ -4092,11 +3932,10 @@ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
 
   if (lwp->status_pending_p)
     {
-      if (debug_threads)
-	debug_printf ("Not resuming lwp %ld (%s, stop %s);"
-		      " has pending status\n",
-		      lwpid_of (thread), step ? "step" : "continue",
-		      lwp->stop_expected ? "expected" : "not expected");
+      threads_debug_printf
+	("Not resuming lwp %ld (%s, stop %s); has pending status",
+	 lwpid_of (thread), step ? "step" : "continue",
+	 lwp->stop_expected ? "expected" : "not expected");
       return;
     }
 
@@ -4115,9 +3954,8 @@ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
      worthwhile just to solve this one, however.  */
   if (lwp->bp_reinsert != 0)
     {
-      if (debug_threads)
-	debug_printf ("  pending reinsert at 0x%s\n",
-		      paddress (lwp->bp_reinsert));
+      threads_debug_printf ("  pending reinsert at 0x%s",
+			    paddress (lwp->bp_reinsert));
 
       if (supports_hardware_single_step ())
 	{
@@ -4135,18 +3973,15 @@ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
     }
 
   if (fast_tp_collecting == fast_tpoint_collect_result::before_insn)
-    {
-      if (debug_threads)
-	debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
-		      " (exit-jump-pad-bkpt)\n",
-		      lwpid_of (thread));
-    }
+    threads_debug_printf
+      ("lwp %ld wants to get out of fast tracepoint jump pad "
+       "(exit-jump-pad-bkpt)", lwpid_of (thread));
+
   else if (fast_tp_collecting == fast_tpoint_collect_result::at_insn)
     {
-      if (debug_threads)
-	debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
-		      " single-stepping\n",
-		      lwpid_of (thread));
+      threads_debug_printf
+	("lwp %ld wants to get out of fast tracepoint jump pad single-stepping",
+	 lwpid_of (thread));
 
       if (supports_hardware_single_step ())
 	step = 1;
@@ -4168,9 +4003,9 @@ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
      enhancement.  */
   if (thread->while_stepping != NULL)
     {
-      if (debug_threads)
-	debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
-		      lwpid_of (thread));
+      threads_debug_printf
+	("lwp %ld has a while-stepping action -> forcing step.",
+	 lwpid_of (thread));
 
       step = single_step (lwp);
     }
@@ -4181,11 +4016,8 @@ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
 
       lwp->stop_pc = low_get_pc (regcache);
 
-      if (debug_threads)
-	{
-	  debug_printf ("  %s from pc 0x%lx\n", step ? "step" : "continue",
-			(long) lwp->stop_pc);
-	}
+      threads_debug_printf ("  %s from pc 0x%lx", step ? "step" : "continue",
+			    (long) lwp->stop_pc);
     }
 
   /* If we have pending signals, consume one if it can be delivered to
@@ -4202,10 +4034,9 @@ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
       lwp->pending_signals.pop_front ();
     }
 
-  if (debug_threads)
-    debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
-		  lwpid_of (thread), step ? "step" : "continue", signal,
-		  lwp->stop_expected ? "expected" : "not expected");
+  threads_debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)",
+			lwpid_of (thread), step ? "step" : "continue", signal,
+			lwp->stop_expected ? "expected" : "not expected");
 
   low_prepare_to_resume (lwp);
 
@@ -4319,13 +4150,11 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
 	  if (resume[ndx].kind == resume_stop
 	      && thread->last_resume_kind == resume_stop)
 	    {
-	      if (debug_threads)
-		debug_printf ("already %s LWP %ld at GDB's request\n",
-			      (thread->last_status.kind ()
-			       == TARGET_WAITKIND_STOPPED)
-			      ? "stopped"
-			      : "stopping",
-			      lwpid_of (thread));
+	      threads_debug_printf
+		("already %s LWP %ld at GDB's request",
+		 (thread->last_status.kind () == TARGET_WAITKIND_STOPPED
+		  ? "stopped" : "stopping"),
+		  lwpid_of (thread));
 
 	      continue;
 	    }
@@ -4335,13 +4164,11 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
 	  if (resume[ndx].kind != resume_stop
 	      && thread->last_resume_kind != resume_stop)
 	    {
-	      if (debug_threads)
-		debug_printf ("already %s LWP %ld at GDB's request\n",
-			      (thread->last_resume_kind
-			       == resume_step)
-			      ? "stepping"
-			      : "continuing",
-			      lwpid_of (thread));
+	      threads_debug_printf
+		("already %s LWP %ld at GDB's request",
+		 (thread->last_resume_kind == resume_step
+		  ? "stepping" : "continuing"),
+		 lwpid_of (thread));
 	      continue;
 	    }
 
@@ -4355,9 +4182,9 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
 		  && (rel->waitstatus.kind () == TARGET_WAITKIND_FORKED
 		      || rel->waitstatus.kind () == TARGET_WAITKIND_VFORKED))
 		{
-		  if (debug_threads)
-		    debug_printf ("not resuming LWP %ld: has queued stop reply\n",
-				  lwpid_of (thread));
+		  threads_debug_printf
+		    ("not resuming LWP %ld: has queued stop reply",
+		     lwpid_of (thread));
 		  continue;
 		}
 	    }
@@ -4368,9 +4195,9 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
 	     (wildcard) resume request.  */
 	  if (in_queued_stop_replies (thread->id))
 	    {
-	      if (debug_threads)
-		debug_printf ("not resuming LWP %ld: has queued stop reply\n",
-			      lwpid_of (thread));
+	      threads_debug_printf
+		("not resuming LWP %ld: has queued stop reply",
+		 lwpid_of (thread));
 	      continue;
 	    }
 
@@ -4389,11 +4216,11 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
 	    {
 	      lwp->status_pending_p = 1;
 
-	      if (debug_threads)
-		debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
-			      "leaving status pending.\n",
-			      WSTOPSIG (lwp->status_pending),
-			      lwpid_of (thread));
+	      threads_debug_printf
+		("Dequeueing deferred signal %d for LWP %ld, "
+		 "leaving status pending.",
+		 WSTOPSIG (lwp->status_pending),
+		 lwpid_of (thread));
 	    }
 
 	  return;
@@ -4434,18 +4261,16 @@ linux_process_target::thread_needs_step_over (thread_info *thread)
 
   if (!lwp->stopped)
     {
-      if (debug_threads)
-	debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped",
+			    lwpid_of (thread));
       return false;
     }
 
   if (thread->last_resume_kind == resume_stop)
     {
-      if (debug_threads)
-	debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
-		      " stopped\n",
-		      lwpid_of (thread));
+      threads_debug_printf
+	("Need step over [LWP %ld]? Ignoring, should remain stopped",
+	 lwpid_of (thread));
       return false;
     }
 
@@ -4453,18 +4278,16 @@ linux_process_target::thread_needs_step_over (thread_info *thread)
 
   if (lwp->suspended)
     {
-      if (debug_threads)
-	debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("Need step over [LWP %ld]? Ignoring, suspended",
+			    lwpid_of (thread));
       return false;
     }
 
   if (lwp->status_pending_p)
     {
-      if (debug_threads)
-	debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
-		      " status.\n",
-		      lwpid_of (thread));
+      threads_debug_printf
+	("Need step over [LWP %ld]? Ignoring, has pending status.",
+	 lwpid_of (thread));
       return false;
     }
 
@@ -4479,11 +4302,10 @@ linux_process_target::thread_needs_step_over (thread_info *thread)
      command, or poked thread's registers herself.  */
   if (pc != lwp->stop_pc)
     {
-      if (debug_threads)
-	debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
-		      "Old stop_pc was 0x%s, PC is now 0x%s\n",
-		      lwpid_of (thread),
-		      paddress (lwp->stop_pc), paddress (pc));
+      threads_debug_printf
+	("Need step over [LWP %ld]? Cancelling, PC was changed. "
+	 "Old stop_pc was 0x%s, PC is now 0x%s", lwpid_of (thread),
+	 paddress (lwp->stop_pc), paddress (pc));
       return false;
     }
 
@@ -4493,10 +4315,9 @@ linux_process_target::thread_needs_step_over (thread_info *thread)
       && !lwp->pending_signals.empty ()
       && lwp_signal_can_be_delivered (lwp))
     {
-      if (debug_threads)
-	debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
-		      " signals.\n",
-		      lwpid_of (thread));
+      threads_debug_printf
+	("Need step over [LWP %ld]? Ignoring, has pending signals.",
+	 lwpid_of (thread));
 
       return false;
     }
@@ -4514,19 +4335,17 @@ linux_process_target::thread_needs_step_over (thread_info *thread)
 	  && gdb_condition_true_at_breakpoint (pc)
 	  && gdb_no_commands_at_breakpoint (pc))
 	{
-	  if (debug_threads)
-	    debug_printf ("Need step over [LWP %ld]? yes, but found"
-			  " GDB breakpoint at 0x%s; skipping step over\n",
-			  lwpid_of (thread), paddress (pc));
+	  threads_debug_printf ("Need step over [LWP %ld]? yes, but found"
+				" GDB breakpoint at 0x%s; skipping step over",
+				lwpid_of (thread), paddress (pc));
 
 	  return false;
 	}
       else
 	{
-	  if (debug_threads)
-	    debug_printf ("Need step over [LWP %ld]? yes, "
-			  "found breakpoint at 0x%s\n",
-			  lwpid_of (thread), paddress (pc));
+	  threads_debug_printf ("Need step over [LWP %ld]? yes, "
+				"found breakpoint at 0x%s",
+				lwpid_of (thread), paddress (pc));
 
 	  /* We've found an lwp that needs stepping over --- return 1 so
 	     that find_thread stops looking.  */
@@ -4534,10 +4353,9 @@ linux_process_target::thread_needs_step_over (thread_info *thread)
 	}
     }
 
-  if (debug_threads)
-    debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
-		  " at 0x%s\n",
-		  lwpid_of (thread), paddress (pc));
+  threads_debug_printf
+    ("Need step over [LWP %ld]? No, no breakpoint found at 0x%s",
+     lwpid_of (thread), paddress (pc));
 
   return false;
 }
@@ -4548,9 +4366,8 @@ linux_process_target::start_step_over (lwp_info *lwp)
   struct thread_info *thread = get_lwp_thread (lwp);
   CORE_ADDR pc;
 
-  if (debug_threads)
-    debug_printf ("Starting step-over on LWP %ld.  Stopping all threads\n",
-		  lwpid_of (thread));
+  threads_debug_printf ("Starting step-over on LWP %ld.  Stopping all threads",
+			lwpid_of (thread));
 
   stop_all_lwps (1, lwp);
 
@@ -4561,8 +4378,7 @@ linux_process_target::start_step_over (lwp_info *lwp)
 		      lwp->suspended);
     }
 
-  if (debug_threads)
-    debug_printf ("Done stopping all threads for step-over.\n");
+  threads_debug_printf ("Done stopping all threads for step-over.");
 
   /* Note, we should always reach here with an already adjusted PC,
      either by GDB (if we're resuming due to GDB's request), or by our
@@ -4595,8 +4411,7 @@ linux_process_target::finish_step_over (lwp_info *lwp)
     {
       scoped_restore_current_thread restore_thread;
 
-      if (debug_threads)
-	debug_printf ("Finished step over.\n");
+      threads_debug_printf ("Finished step over.");
 
       switch_to_thread (get_lwp_thread (lwp));
 
@@ -4634,8 +4449,7 @@ linux_process_target::complete_ongoing_step_over ()
       int wstat;
       int ret;
 
-      if (debug_threads)
-	debug_printf ("detach: step over in progress, finish it first\n");
+      threads_debug_printf ("detach: step over in progress, finish it first");
 
       /* Passing NULL_PTID as filter indicates we want all events to
 	 be left pending.  Eventually this returns when there are no
@@ -4659,19 +4473,15 @@ linux_process_target::complete_ongoing_step_over ()
 	      thread_info *thread = get_lwp_thread (lwp);
 	      if (thread->last_resume_kind != resume_step)
 		{
-		  if (debug_threads)
-		    debug_printf ("detach: discard step-over SIGTRAP\n");
+		  threads_debug_printf ("detach: discard step-over SIGTRAP");
 
 		  lwp->status_pending_p = 0;
 		  lwp->status_pending = 0;
 		  resume_one_lwp (lwp, lwp->stepping, 0, NULL);
 		}
 	      else
-		{
-		  if (debug_threads)
-		    debug_printf ("detach: resume_step, "
-				  "not discarding step-over SIGTRAP\n");
-		}
+		threads_debug_printf
+		  ("detach: resume_step, not discarding step-over SIGTRAP");
 	    }
 	}
       step_over_bkpt = null_ptid;
@@ -4691,13 +4501,12 @@ linux_process_target::resume_one_thread (thread_info *thread,
 
   if (lwp->resume->kind == resume_stop)
     {
-      if (debug_threads)
-	debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread));
+      threads_debug_printf ("resume_stop request for LWP %ld",
+			    lwpid_of (thread));
 
       if (!lwp->stopped)
 	{
-	  if (debug_threads)
-	    debug_printf ("stopping LWP %ld\n", lwpid_of (thread));
+	  threads_debug_printf ("stopping LWP %ld", lwpid_of (thread));
 
 	  /* Stop the thread, and wait for the event asynchronously,
 	     through the event loop.  */
@@ -4705,9 +4514,7 @@ linux_process_target::resume_one_thread (thread_info *thread,
 	}
       else
 	{
-	  if (debug_threads)
-	    debug_printf ("already stopped LWP %ld\n",
-			  lwpid_of (thread));
+	  threads_debug_printf ("already stopped LWP %ld", lwpid_of (thread));
 
 	  /* The LWP may have been stopped in an internal event that
 	     was not meant to be notified back to GDB (e.g., gdbserver
@@ -4769,16 +4576,12 @@ linux_process_target::resume_one_thread (thread_info *thread,
 
   if (!leave_pending)
     {
-      if (debug_threads)
-	debug_printf ("resuming LWP %ld\n", lwpid_of (thread));
+      threads_debug_printf ("resuming LWP %ld", lwpid_of (thread));
 
       proceed_one_lwp (thread, NULL);
     }
   else
-    {
-      if (debug_threads)
-	debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread));
-    }
+    threads_debug_printf ("leaving LWP %ld stopped", lwpid_of (thread));
 
   thread->last_status.set_ignore ();
   lwp->resume = NULL;
@@ -4789,11 +4592,7 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
 {
   struct thread_info *need_step_over = NULL;
 
-  if (debug_threads)
-    {
-      debug_enter ();
-      debug_printf ("linux_resume:\n");
-    }
+ THREADS_SCOPED_DEBUG_ENTER_EXIT;
 
   for_each_thread ([&] (thread_info *thread)
     {
@@ -4827,16 +4626,13 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
 
   bool leave_all_stopped = (need_step_over != NULL || any_pending);
 
-  if (debug_threads)
-    {
-      if (need_step_over != NULL)
-	debug_printf ("Not resuming all, need step over\n");
-      else if (any_pending)
-	debug_printf ("Not resuming, all-stop and found "
-		      "an LWP with pending status\n");
-      else
-	debug_printf ("Resuming, no pending status or step over needed\n");
-    }
+  if (need_step_over != NULL)
+    threads_debug_printf ("Not resuming all, need step over");
+  else if (any_pending)
+    threads_debug_printf ("Not resuming, all-stop and found "
+			  "an LWP with pending status");
+  else
+    threads_debug_printf ("Resuming, no pending status or step over needed");
 
   /* Even if we're leaving threads stopped, queue all signals we'd
      otherwise deliver.  */
@@ -4848,12 +4644,6 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
   if (need_step_over)
     start_step_over (get_thread_lwp (need_step_over));
 
-  if (debug_threads)
-    {
-      debug_printf ("linux_resume done\n");
-      debug_exit ();
-    }
-
   /* We may have events that were pending that can/should be sent to
      the client now.  Trigger a linux_wait call.  */
   if (target_is_async_p ())
@@ -4869,30 +4659,26 @@ linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
   if (lwp == except)
     return;
 
-  if (debug_threads)
-    debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread));
+  threads_debug_printf ("lwp %ld", lwpid_of (thread));
 
   if (!lwp->stopped)
     {
-      if (debug_threads)
-	debug_printf ("   LWP %ld already running\n", lwpid_of (thread));
+      threads_debug_printf ("   LWP %ld already running", lwpid_of (thread));
       return;
     }
 
   if (thread->last_resume_kind == resume_stop
       && thread->last_status.kind () != TARGET_WAITKIND_IGNORE)
     {
-      if (debug_threads)
-	debug_printf ("   client wants LWP to remain %ld stopped\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("   client wants LWP to remain %ld stopped",
+			    lwpid_of (thread));
       return;
     }
 
   if (lwp->status_pending_p)
     {
-      if (debug_threads)
-	debug_printf ("   LWP %ld has pending status, leaving stopped\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("   LWP %ld has pending status, leaving stopped",
+			    lwpid_of (thread));
       return;
     }
 
@@ -4900,8 +4686,7 @@ linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
 
   if (lwp->suspended)
     {
-      if (debug_threads)
-	debug_printf ("   LWP %ld is suspended\n", lwpid_of (thread));
+      threads_debug_printf ("   LWP %ld is suspended", lwpid_of (thread));
       return;
     }
 
@@ -4920,19 +4705,17 @@ linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
 	 another one here.  Note that if the LWP already has a SIGSTOP
 	 pending, this is a no-op.  */
 
-      if (debug_threads)
-	debug_printf ("Client wants LWP %ld to stop. "
-		      "Making sure it has a SIGSTOP pending\n",
-		      lwpid_of (thread));
+      threads_debug_printf
+	("Client wants LWP %ld to stop.  Making sure it has a SIGSTOP pending",
+	 lwpid_of (thread));
 
       send_sigstop (lwp);
     }
 
   if (thread->last_resume_kind == resume_step)
     {
-      if (debug_threads)
-	debug_printf ("   stepping LWP %ld, client wants it stepping\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("   stepping LWP %ld, client wants it stepping",
+			    lwpid_of (thread));
 
       /* If resume_step is requested by GDB, install single-step
 	 breakpoints when the thread is about to be actually resumed if
@@ -4945,9 +4728,8 @@ linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
     }
   else if (lwp->bp_reinsert != 0)
     {
-      if (debug_threads)
-	debug_printf ("   stepping LWP %ld, reinsert set\n",
-		      lwpid_of (thread));
+      threads_debug_printf ("   stepping LWP %ld, reinsert set",
+			    lwpid_of (thread));
 
       step = maybe_hw_step (thread);
     }
@@ -4990,18 +4772,15 @@ linux_process_target::proceed_all_lwps ()
 
       if (need_step_over != NULL)
 	{
-	  if (debug_threads)
-	    debug_printf ("proceed_all_lwps: found "
-			  "thread %ld needing a step-over\n",
-			  lwpid_of (need_step_over));
+	  threads_debug_printf ("found thread %ld needing a step-over",
+				lwpid_of (need_step_over));
 
 	  start_step_over (get_thread_lwp (need_step_over));
 	  return;
 	}
     }
 
-  if (debug_threads)
-    debug_printf ("Proceeding, no step-over needed\n");
+  threads_debug_printf ("Proceeding, no step-over needed");
 
   for_each_thread ([this] (thread_info *thread)
     {
@@ -5012,15 +4791,13 @@ linux_process_target::proceed_all_lwps ()
 void
 linux_process_target::unstop_all_lwps (int unsuspend, lwp_info *except)
 {
-  if (debug_threads)
-    {
-      debug_enter ();
-      if (except)
-	debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
-		      lwpid_of (get_lwp_thread (except)));
-      else
-	debug_printf ("unstopping all lwps\n");
-    }
+  THREADS_SCOPED_DEBUG_ENTER_EXIT;
+
+  if (except)
+    threads_debug_printf ("except=(LWP %ld)",
+		  lwpid_of (get_lwp_thread (except)));
+  else
+    threads_debug_printf ("except=nullptr");
 
   if (unsuspend)
     for_each_thread ([&] (thread_info *thread)
@@ -5032,12 +4809,6 @@ linux_process_target::unstop_all_lwps (int unsuspend, lwp_info *except)
       {
 	proceed_one_lwp (thread, except);
       });
-
-  if (debug_threads)
-    {
-      debug_printf ("unstop_all_lwps done\n");
-      debug_exit ();
-    }
 }
 
 
@@ -5622,8 +5393,8 @@ linux_process_target::write_memory (CORE_ADDR memaddr,
 	}
       *p = '\0';
 
-      debug_printf ("Writing %s to 0x%08lx in process %d\n",
-		    str, (long) memaddr, pid);
+      threads_debug_printf ("Writing %s to 0x%08lx in process %d",
+			    str, (long) memaddr, pid);
     }
 
   /* Fill start and end extra bytes of buffer with existing memory data.  */
@@ -5967,10 +5738,9 @@ linux_process_target::qxfer_siginfo (const char *annex,
 
   pid = lwpid_of (current_thread);
 
-  if (debug_threads)
-    debug_printf ("%s siginfo for lwp %d.\n",
-		  readbuf != NULL ? "Reading" : "Writing",
-		  pid);
+  threads_debug_printf ("%s siginfo for lwp %d.",
+			readbuf != NULL ? "Reading" : "Writing",
+			pid);
 
   if (offset >= sizeof (siginfo))
     return -1;
@@ -6040,9 +5810,8 @@ linux_process_target::async (bool enable)
 {
   bool previous = target_is_async_p ();
 
-  if (debug_threads)
-    debug_printf ("linux_async (%d), previous=%d\n",
-		  enable, previous);
+  threads_debug_printf ("async (%d), previous=%d",
+			enable, previous);
 
   if (previous != enable)
     {
@@ -7129,8 +6898,7 @@ linux_get_pc_32bit (struct regcache *regcache)
   uint32_t pc;
 
   collect_register_by_name (regcache, "pc", &pc);
-  if (debug_threads)
-    debug_printf ("stop pc is 0x%" PRIx32 "\n", pc);
+  threads_debug_printf ("stop pc is 0x%" PRIx32, pc);
   return pc;
 }
 
@@ -7154,8 +6922,7 @@ linux_get_pc_64bit (struct regcache *regcache)
   uint64_t pc;
 
   collect_register_by_name (regcache, "pc", &pc);
-  if (debug_threads)
-    debug_printf ("stop pc is 0x%" PRIx64 "\n", pc);
+  threads_debug_printf ("stop pc is 0x%" PRIx64, pc);
   return pc;
 }
 
diff --git a/gdbserver/linux-s390-low.cc b/gdbserver/linux-s390-low.cc
index c1a8c18f13b..5adc2807057 100644
--- a/gdbserver/linux-s390-low.cc
+++ b/gdbserver/linux-s390-low.cc
@@ -1503,9 +1503,8 @@ add_insns (const unsigned char *start, int len)
 {
   CORE_ADDR buildaddr = current_insn_ptr;
 
-  if (debug_threads)
-    debug_printf ("Adding %d bytes of insn at %s\n",
-		  len, paddress (buildaddr));
+  threads_debug_printf ("Adding %d bytes of insn at %s",
+			len, paddress (buildaddr));
 
   append_insns (&buildaddr, len, start);
   current_insn_ptr = buildaddr;
diff --git a/gdbserver/linux-x86-low.cc b/gdbserver/linux-x86-low.cc
index 171f21c7997..d2b55f6f0d2 100644
--- a/gdbserver/linux-x86-low.cc
+++ b/gdbserver/linux-x86-low.cc
@@ -1628,9 +1628,8 @@ add_insns (unsigned char *start, int len)
 {
   CORE_ADDR buildaddr = current_insn_ptr;
 
-  if (debug_threads)
-    debug_printf ("Adding %d bytes of insn at %s\n",
-		  len, paddress (buildaddr));
+  threads_debug_printf ("Adding %d bytes of insn at %s",
+			len, paddress (buildaddr));
 
   append_insns (&buildaddr, len, start);
   current_insn_ptr = buildaddr;
diff --git a/gdbserver/mem-break.cc b/gdbserver/mem-break.cc
index 87d025c9b5c..5f5cdb18797 100644
--- a/gdbserver/mem-break.cc
+++ b/gdbserver/mem-break.cc
@@ -371,10 +371,9 @@ insert_memory_breakpoint (struct raw_breakpoint *bp)
   err = read_inferior_memory (bp->pc, buf, bp_size (bp));
   if (err != 0)
     {
-      if (debug_threads)
-	debug_printf ("Failed to read shadow memory of"
-		      " breakpoint at 0x%s (%s).\n",
-		      paddress (bp->pc), safe_strerror (err));
+      threads_debug_printf ("Failed to read shadow memory of"
+			    " breakpoint at 0x%s (%s).",
+			    paddress (bp->pc), safe_strerror (err));
     }
   else
     {
@@ -383,11 +382,8 @@ insert_memory_breakpoint (struct raw_breakpoint *bp)
       err = the_target->write_memory (bp->pc, bp_opcode (bp),
 				      bp_size (bp));
       if (err != 0)
-	{
-	  if (debug_threads)
-	    debug_printf ("Failed to insert breakpoint at 0x%s (%s).\n",
-			  paddress (bp->pc), safe_strerror (err));
-	}
+	threads_debug_printf ("Failed to insert breakpoint at 0x%s (%s).",
+			      paddress (bp->pc), safe_strerror (err));
     }
   return err != 0 ? -1 : 0;
 }
@@ -411,12 +407,10 @@ remove_memory_breakpoint (struct raw_breakpoint *bp)
   memcpy (buf, bp->old_data, bp_size (bp));
   err = target_write_memory (bp->pc, buf, bp_size (bp));
   if (err != 0)
-    {
-      if (debug_threads)
-	debug_printf ("Failed to uninsert raw breakpoint "
-		      "at 0x%s (%s) while deleting it.\n",
-		      paddress (bp->pc), safe_strerror (err));
-    }
+      threads_debug_printf ("Failed to uninsert raw breakpoint "
+			    "at 0x%s (%s) while deleting it.",
+			    paddress (bp->pc), safe_strerror (err));
+
   return err != 0 ? -1 : 0;
 }
 
@@ -438,9 +432,9 @@ set_raw_breakpoint_at (enum raw_bkpt_type type, CORE_ADDR where, int kind,
 	{
 	  /* A different kind than previously seen.  The previous
 	     breakpoint must be gone then.  */
-	  if (debug_threads)
-	    debug_printf ("Inconsistent breakpoint kind?  Was %d, now %d.\n",
-			  bp->kind, kind);
+	  threads_debug_printf
+	    ("Inconsistent breakpoint kind?  Was %d, now %d.",
+	     bp->kind, kind);
 	  bp->inserted = -1;
 	  bp = NULL;
 	}
@@ -463,9 +457,8 @@ set_raw_breakpoint_at (enum raw_bkpt_type type, CORE_ADDR where, int kind,
       *err = the_target->insert_point (bp->raw_type, bp->pc, bp->kind, bp);
       if (*err != 0)
 	{
-	  if (debug_threads)
-	    debug_printf ("Failed to insert breakpoint at 0x%s (%d).\n",
-			  paddress (where), *err);
+	  threads_debug_printf ("Failed to insert breakpoint at 0x%s (%d).",
+				paddress (where), *err);
 
 	  return NULL;
 	}
@@ -594,10 +587,10 @@ delete_fast_tracepoint_jump (struct fast_tracepoint_jump *todel)
 		  /* Something went wrong, relink the jump.  */
 		  *bp_link = prev_bp_link;
 
-		  if (debug_threads)
-		    debug_printf ("Failed to uninsert fast tracepoint jump "
-				  "at 0x%s (%s) while deleting it.\n",
-				  paddress (bp->pc), safe_strerror (ret));
+		  threads_debug_printf
+		    ("Failed to uninsert fast tracepoint jump "
+		     "at 0x%s (%s) while deleting it.",
+		     paddress (bp->pc), safe_strerror (ret));
 		  return ret;
 		}
 
@@ -657,10 +650,9 @@ set_fast_tracepoint_jump (CORE_ADDR where,
   err = read_inferior_memory (where, buf, length);
   if (err != 0)
     {
-      if (debug_threads)
-	debug_printf ("Failed to read shadow memory of"
-		      " fast tracepoint at 0x%s (%s).\n",
-		      paddress (where), safe_strerror (err));
+      threads_debug_printf ("Failed to read shadow memory of"
+			    " fast tracepoint at 0x%s (%s).",
+			    paddress (where), safe_strerror (err));
       free (jp);
       return NULL;
     }
@@ -682,9 +674,9 @@ set_fast_tracepoint_jump (CORE_ADDR where,
   err = target_write_memory (where, buf, length);
   if (err != 0)
     {
-      if (debug_threads)
-	debug_printf ("Failed to insert fast tracepoint jump at 0x%s (%s).\n",
-		      paddress (where), safe_strerror (err));
+      threads_debug_printf
+	("Failed to insert fast tracepoint jump at 0x%s (%s).",
+	 paddress (where), safe_strerror (err));
 
       /* Unlink it.  */
       proc->fast_tracepoint_jumps = jp->next;
@@ -707,10 +699,9 @@ uninsert_fast_tracepoint_jumps_at (CORE_ADDR pc)
     {
       /* This can happen when we remove all breakpoints while handling
 	 a step-over.  */
-      if (debug_threads)
-	debug_printf ("Could not find fast tracepoint jump at 0x%s "
-		      "in list (uninserting).\n",
-		      paddress (pc));
+      threads_debug_printf ("Could not find fast tracepoint jump at 0x%s "
+			    "in list (uninserting).",
+			    paddress (pc));
       return;
     }
 
@@ -736,10 +727,9 @@ uninsert_fast_tracepoint_jumps_at (CORE_ADDR pc)
 	{
 	  jp->inserted = 1;
 
-	  if (debug_threads)
-	    debug_printf ("Failed to uninsert fast tracepoint jump at"
-			  " 0x%s (%s).\n",
-			  paddress (pc), safe_strerror (err));
+	  threads_debug_printf ("Failed to uninsert fast tracepoint jump at"
+				" 0x%s (%s).",
+				paddress (pc), safe_strerror (err));
 	}
     }
 }
@@ -756,10 +746,9 @@ reinsert_fast_tracepoint_jumps_at (CORE_ADDR where)
     {
       /* This can happen when we remove breakpoints when a tracepoint
 	 hit causes a tracing stop, while handling a step-over.  */
-      if (debug_threads)
-	debug_printf ("Could not find fast tracepoint jump at 0x%s "
-		      "in list (reinserting).\n",
-		      paddress (where));
+      threads_debug_printf ("Could not find fast tracepoint jump at 0x%s "
+			    "in list (reinserting).",
+			    paddress (where));
       return;
     }
 
@@ -783,10 +772,9 @@ reinsert_fast_tracepoint_jumps_at (CORE_ADDR where)
     {
       jp->inserted = 0;
 
-      if (debug_threads)
-	debug_printf ("Failed to reinsert fast tracepoint jump at"
-		      " 0x%s (%s).\n",
-		      paddress (where), safe_strerror (err));
+      threads_debug_printf ("Failed to reinsert fast tracepoint jump at"
+			    " 0x%s (%s).",
+			    paddress (where), safe_strerror (err));
     }
 }
 
@@ -897,10 +885,9 @@ delete_raw_breakpoint (struct process_info *proc, struct raw_breakpoint *todel)
 		  /* Something went wrong, relink the breakpoint.  */
 		  *bp_link = prev_bp_link;
 
-		  if (debug_threads)
-		    debug_printf ("Failed to uninsert raw breakpoint "
-				  "at 0x%s while deleting it.\n",
-				  paddress (bp->pc));
+		  threads_debug_printf ("Failed to uninsert raw breakpoint "
+					"at 0x%s while deleting it.",
+					paddress (bp->pc));
 		  return ret;
 		}
 	    }
@@ -1404,10 +1391,9 @@ gdb_no_commands_at_breakpoint_z_type (char z_type, CORE_ADDR addr)
   if (bp == NULL)
     return 1;
 
-  if (debug_threads)
-    debug_printf ("at 0x%s, type Z%c, bp command_list is 0x%s\n",
-		  paddress (addr), z_type,
-		  phex_nz ((uintptr_t) bp->command_list, 0));
+  threads_debug_printf ("at 0x%s, type Z%c, bp command_list is 0x%s",
+			paddress (addr), z_type,
+			phex_nz ((uintptr_t) bp->command_list, 0));
   return (bp->command_list == NULL);
 }
 
@@ -1521,9 +1507,8 @@ uninsert_raw_breakpoint (struct raw_breakpoint *bp)
 {
   if (bp->inserted < 0)
     {
-      if (debug_threads)
-	debug_printf ("Breakpoint at %s is marked insert-disabled.\n",
-		      paddress (bp->pc));
+      threads_debug_printf ("Breakpoint at %s is marked insert-disabled.",
+			    paddress (bp->pc));
     }
   else if (bp->inserted > 0)
     {
@@ -1536,9 +1521,8 @@ uninsert_raw_breakpoint (struct raw_breakpoint *bp)
 	{
 	  bp->inserted = 1;
 
-	  if (debug_threads)
-	    debug_printf ("Failed to uninsert raw breakpoint at 0x%s.\n",
-			  paddress (bp->pc));
+	  threads_debug_printf ("Failed to uninsert raw breakpoint at 0x%s.",
+				paddress (bp->pc));
 	}
     }
 }
@@ -1565,10 +1549,9 @@ uninsert_breakpoints_at (CORE_ADDR pc)
     {
       /* This can happen when we remove all breakpoints while handling
 	 a step-over.  */
-      if (debug_threads)
-	debug_printf ("Could not find breakpoint at 0x%s "
-		      "in list (uninserting).\n",
-		      paddress (pc));
+      threads_debug_printf ("Could not find breakpoint at 0x%s "
+			    "in list (uninserting).",
+			    paddress (pc));
     }
 }
 
@@ -1622,9 +1605,9 @@ reinsert_raw_breakpoint (struct raw_breakpoint *bp)
   err = the_target->insert_point (bp->raw_type, bp->pc, bp->kind, bp);
   if (err == 0)
     bp->inserted = 1;
-  else if (debug_threads)
-    debug_printf ("Failed to reinsert breakpoint at 0x%s (%d).\n",
-		  paddress (bp->pc), err);
+  else
+    threads_debug_printf ("Failed to reinsert breakpoint at 0x%s (%d).",
+			  paddress (bp->pc), err);
 }
 
 void
@@ -1648,10 +1631,9 @@ reinsert_breakpoints_at (CORE_ADDR pc)
     {
       /* This can happen when we remove all breakpoints while handling
 	 a step-over.  */
-      if (debug_threads)
-	debug_printf ("Could not find raw breakpoint at 0x%s "
-		      "in list (reinserting).\n",
-		      paddress (pc));
+      threads_debug_printf ("Could not find raw breakpoint at 0x%s "
+			    "in list (reinserting).",
+			    paddress (pc));
     }
 }
 
diff --git a/gdbserver/remote-utils.cc b/gdbserver/remote-utils.cc
index 0faf5a91f2b..8cd8f527105 100644
--- a/gdbserver/remote-utils.cc
+++ b/gdbserver/remote-utils.cc
@@ -144,8 +144,7 @@ handle_accept_event (int err, gdb_client_data client_data)
   struct sockaddr_storage sockaddr;
   socklen_t len = sizeof (sockaddr);
 
-  if (debug_threads)
-    debug_printf ("handling possible accept event\n");
+  threads_debug_printf ("handling possible accept event");
 
   remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &len);
   if (remote_desc == -1)
@@ -1084,9 +1083,8 @@ void
 prepare_resume_reply (char *buf, ptid_t ptid, const target_waitstatus &status)
 {
   client_state &cs = get_client_state ();
-  if (debug_threads)
-    debug_printf ("Writing resume reply for %s:%d\n",
-		  target_pid_to_str (ptid).c_str (), status.kind ());
+  threads_debug_printf ("Writing resume reply for %s:%d",
+			target_pid_to_str (ptid).c_str (), status.kind ());
 
   switch (status.kind ())
     {
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 021c7adc308..02b09e50da7 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -1228,8 +1228,7 @@ handle_detach (char *own_buf)
 	 pass signals down without informing GDB.  */
       if (!non_stop)
 	{
-	  if (debug_threads)
-	    debug_printf ("Forcing non-stop mode\n");
+	  threads_debug_printf ("Forcing non-stop mode");
 
 	  non_stop = true;
 	  the_target->start_non_stop (true);
@@ -3336,10 +3335,10 @@ queue_stop_reply_callback (thread_info *thread)
     {
       if (target_thread_stopped (thread))
 	{
-	  if (debug_threads)
-	    debug_printf ("Reporting thread %s as already stopped with %s\n",
-			  target_pid_to_str (thread->id).c_str (),
-			  thread->last_status.to_string ().c_str ());
+	  threads_debug_printf
+	    ("Reporting thread %s as already stopped with %s",
+	     target_pid_to_str (thread->id).c_str (),
+	     thread->last_status.to_string ().c_str ());
 
 	  gdb_assert (thread->last_status.kind () != TARGET_WAITKIND_IGNORE);
 
@@ -4183,16 +4182,14 @@ process_point_options (struct gdb_breakpoint *bp, const char **packet)
       if (*dataptr == 'X')
 	{
 	  /* Conditional expression.  */
-	  if (debug_threads)
-	    debug_printf ("Found breakpoint condition.\n");
+	  threads_debug_printf ("Found breakpoint condition.");
 	  if (!add_breakpoint_condition (bp, &dataptr))
 	    dataptr = strchrnul (dataptr, ';');
 	}
       else if (startswith (dataptr, "cmds:"))
 	{
 	  dataptr += strlen ("cmds:");
-	  if (debug_threads)
-	    debug_printf ("Found breakpoint commands %s.\n", dataptr);
+	  threads_debug_printf ("Found breakpoint commands %s.", dataptr);
 	  persist = (*dataptr == '1');
 	  dataptr += 2;
 	  if (add_breakpoint_commands (bp, &dataptr, persist))
@@ -4576,8 +4573,7 @@ process_serial_event (void)
 void
 handle_serial_event (int err, gdb_client_data client_data)
 {
-  if (debug_threads)
-    debug_printf ("handling possible serial event\n");
+  threads_debug_printf ("handling possible serial event");
 
   /* Really handle it.  */
   if (process_serial_event () < 0)
@@ -4610,8 +4606,7 @@ void
 handle_target_event (int err, gdb_client_data client_data)
 {
   client_state &cs = get_client_state ();
-  if (debug_threads)
-    debug_printf ("handling possible target event\n");
+  threads_debug_printf ("handling possible target event");
 
   cs.last_ptid = mywait (minus_one_ptid, &cs.last_status,
 		      TARGET_WNOHANG, 1);
@@ -4663,11 +4658,10 @@ handle_target_event (int err, gdb_client_data client_data)
 		 inferior, as if it wasn't being traced.  */
 	      enum gdb_signal signal;
 
-	      if (debug_threads)
-		debug_printf ("GDB not connected; forwarding event %d for"
-			      " [%s]\n",
-			      (int) cs.last_status.kind (),
-			      target_pid_to_str (cs.last_ptid).c_str ());
+	      threads_debug_printf ("GDB not connected; forwarding event %d for"
+				    " [%s]",
+				    (int) cs.last_status.kind (),
+				    target_pid_to_str (cs.last_ptid).c_str ());
 
 	      if (cs.last_status.kind () == TARGET_WAITKIND_STOPPED)
 		signal = cs.last_status.sig ();
diff --git a/gdbserver/thread-db.cc b/gdbserver/thread-db.cc
index 62ce23ce037..6e0e2228a5f 100644
--- a/gdbserver/thread-db.cc
+++ b/gdbserver/thread-db.cc
@@ -184,9 +184,8 @@ find_one_thread (ptid_t ptid)
     error ("Cannot get thread info for LWP %d: %s",
 	   lwpid, thread_db_err_str (err));
 
-  if (debug_threads)
-    debug_printf ("Found thread %ld (LWP %d)\n",
-		  (unsigned long) ti.ti_tid, ti.ti_lid);
+  threads_debug_printf ("Found thread %ld (LWP %d)",
+			(unsigned long) ti.ti_tid, ti.ti_lid);
 
   if (lwpid != ti.ti_lid)
     {
@@ -218,9 +217,8 @@ attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
   struct lwp_info *lwp;
   int err;
 
-  if (debug_threads)
-    debug_printf ("Attaching to thread %ld (LWP %d)\n",
-		  (unsigned long) ti_p->ti_tid, ti_p->ti_lid);
+  threads_debug_printf ("Attaching to thread %ld (LWP %d)",
+			(unsigned long) ti_p->ti_tid, ti_p->ti_lid);
   err = the_linux_target->attach_lwp (ptid);
   if (err != 0)
     {
@@ -283,10 +281,9 @@ find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 	 thread that previously exited and was joined.  (glibc marks
 	 terminated and joined threads with kernel thread ID -1.  See
 	 glibc PR17707.  */
-      if (debug_threads)
-	debug_printf ("thread_db: skipping exited and "
-		      "joined thread (0x%lx)\n",
-		      (unsigned long) ti.ti_tid);
+      threads_debug_printf ("thread_db: skipping exited and "
+			    "joined thread (0x%lx)",
+			    (unsigned long) ti.ti_tid);
       return 0;
     }
 
@@ -333,9 +330,8 @@ thread_db_find_new_threads (void)
 					 TD_THR_ANY_STATE,
 					 TD_THR_LOWEST_PRIORITY,
 					 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
-      if (debug_threads)
-	debug_printf ("Found %d threads in iteration %d.\n",
-		      new_thread_count, iteration);
+      threads_debug_printf ("Found %d threads in iteration %d.",
+			    new_thread_count, iteration);
 
       if (new_thread_count != 0)
 	{
@@ -492,8 +488,7 @@ thread_db_load_search (void)
   err = tdb->td_ta_new_p (&tdb->proc_handle, &tdb->thread_agent);
   if (err != TD_OK)
     {
-      if (debug_threads)
-	debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err));
+      threads_debug_printf ("td_ta_new(): %s", thread_db_err_str (err));
       free (tdb);
       proc->priv->thread_db = NULL;
       return 0;
@@ -535,8 +530,7 @@ try_thread_db_load_1 (void *handle)
     {								\
       if ((a) == NULL)						\
 	{							\
-	  if (debug_threads)					\
-	    debug_printf ("dlsym: %s\n", dlerror ());		\
+	  threads_debug_printf ("dlsym: %s", dlerror ());	\
 	  if (required)						\
 	    {							\
 	      free (tdb);					\
@@ -556,8 +550,7 @@ try_thread_db_load_1 (void *handle)
   err = tdb->td_ta_new_p (&tdb->proc_handle, &tdb->thread_agent);
   if (err != TD_OK)
     {
-      if (debug_threads)
-	debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err));
+      threads_debug_printf ("td_ta_new(): %s", thread_db_err_str (err));
       free (tdb);
       proc->priv->thread_db = NULL;
       return 0;
@@ -601,14 +594,12 @@ try_thread_db_load (const char *library)
 {
   void *handle;
 
-  if (debug_threads)
-    debug_printf ("Trying host libthread_db library: %s.\n",
-		  library);
+  threads_debug_printf ("Trying host libthread_db library: %s.",
+			library);
   handle = dlopen (library, RTLD_NOW);
   if (handle == NULL)
     {
-      if (debug_threads)
-	debug_printf ("dlopen failed: %s.\n", dlerror ());
+      threads_debug_printf ("dlopen failed: %s.", dlerror ());
       return 0;
     }
 
@@ -623,7 +614,7 @@ try_thread_db_load (const char *library)
 	  const char *const libpath = dladdr_to_soname (td_init);
 
 	  if (libpath != NULL)
-	    debug_printf ("Host %s resolved to: %s.\n", library, libpath);
+	    threads_debug_printf ("Host %s resolved to: %s.", library, libpath);
 	}
     }
 #endif
@@ -722,8 +713,7 @@ thread_db_load_search (void)
 	}
     }
 
-  if (debug_threads)
-    debug_printf ("thread_db_load_search returning %d\n", rc);
+  threads_debug_printf ("thread_db_load_search returning %d", rc);
   return rc;
 }
 
diff --git a/gdbserver/tracepoint.cc b/gdbserver/tracepoint.cc
index 0136f6e2347..5459dc34cbb 100644
--- a/gdbserver/tracepoint.cc
+++ b/gdbserver/tracepoint.cc
@@ -87,11 +87,7 @@ trace_vdebug (const char *fmt, ...)
 
 #define trace_debug(fmt, args...)	\
   do {						\
-    if (debug_threads)				\
-      {						\
-	debug_printf ((fmt), ##args);		\
-	debug_printf ("\n");			\
-      }						\
+      threads_debug_printf ((fmt), ##args);	\
   } while (0)
 
 #endif
@@ -324,8 +320,7 @@ tracepoint_look_up_symbols (void)
 
       if (look_up_one_symbol (symbol_list[i].name, addrp, 1) == 0)
 	{
-	  if (debug_threads)
-	    debug_printf ("symbol `%s' not found\n", symbol_list[i].name);
+	  threads_debug_printf ("symbol `%s' not found", symbol_list[i].name);
 	  return;
 	}
     }
@@ -4519,15 +4514,14 @@ handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc)
 		   ipa_expr_eval_result,
 		   paddress (ipa_error_tracepoint));
 
-      if (debug_threads)
-	{
-	  if (ipa_trace_buffer_is_full)
-	    trace_debug ("lib stopped due to full buffer.");
-	  if (ipa_stopping_tracepoint)
-	    trace_debug ("lib stopped due to tpoint");
-	  if (ipa_error_tracepoint)
-	    trace_debug ("lib stopped due to error");
-	}
+      if (ipa_trace_buffer_is_full)
+	trace_debug ("lib stopped due to full buffer.");
+
+      if (ipa_stopping_tracepoint)
+	trace_debug ("lib stopped due to tpoint");
+
+      if (ipa_error_tracepoint)
+	trace_debug ("lib stopped due to error");
 
       if (ipa_stopping_tracepoint != 0)
 	{
-- 
2.30.2