* [PATCH 0/3] Improvements to GDBserver logging
@ 2022-01-17 21:27 Simon Marchi
2022-01-17 21:27 ` [PATCH 2/3] gdbserver: introduce threads_debug_printf, THREADS_SCOPED_DEBUG_ENTER_EXIT Simon Marchi
` (2 more replies)
0 siblings, 3 replies; 9+ messages in thread
From: Simon Marchi @ 2022-01-17 21:27 UTC (permalink / raw)
To: gdb-patches
This series starts making GDBserver use the same logging helpers as GDB,
which automatically includes function names and produces indented
output. I think it helps read long logs. The indentation in
particular helps spots beginning and end of operations, which helps
understand the context, and allows to skips long sections you are not
interested in. A lot could be improved still, but this is just to get
the ball rolling.
Simon Marchi (3):
gdbserver: turn debug_threads into a boolean
gdbserver: introduce threads_debug_printf,
THREADS_SCOPED_DEBUG_ENTER_EXIT
gdbserver: introduce remote_debug_printf
gdbserver/ax.cc | 9 +-
gdbserver/debug.cc | 28 +-
gdbserver/debug.h | 41 +-
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/notif.cc | 10 +-
gdbserver/remote-utils.cc | 63 +--
gdbserver/server.cc | 108 ++--
gdbserver/thread-db.cc | 44 +-
gdbserver/tracepoint.cc | 35 +-
14 files changed, 541 insertions(+), 911 deletions(-)
base-commit: 6c037fdbf0a1cf32582285993e13307dd3272a9e
--
2.34.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 2/3] gdbserver: introduce threads_debug_printf, THREADS_SCOPED_DEBUG_ENTER_EXIT
2022-01-17 21:27 [PATCH 0/3] Improvements to GDBserver logging Simon Marchi
@ 2022-01-17 21:27 ` Simon Marchi
2022-01-17 21:27 ` [PATCH 3/3] gdbserver: introduce remote_debug_printf Simon Marchi
2022-01-18 11:14 ` [PATCH 0/3] Improvements to GDBserver logging Hannes Domani
2 siblings, 0 replies; 9+ messages in thread
From: Simon Marchi @ 2022-01-17 21:27 UTC (permalink / raw)
To: gdb-patches
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 4f36bc50cab6..365bd2195b22 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 372b5577958d..8b3e95e65cd1 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 20cb4e733f26..4220246de793 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 c991ce3a9d31..96dd4d009ab8 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 10aab52c2282..aef69b345259 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 d7c7336ff1f5..9e571a4d771f 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 c1a8c18f13b8..5adc28070574 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 171f21c79976..d2b55f6f0d2b 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 87d025c9b5c1..5f5cdb18797e 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 0faf5a91f2b1..8cd8f5271053 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 021c7adc3085..02b09e50da7f 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 62ce23ce0374..6e0e2228a5f9 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 0136f6e23473..5459dc34cbb5 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.34.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 3/3] gdbserver: introduce remote_debug_printf
2022-01-17 21:27 [PATCH 0/3] Improvements to GDBserver logging Simon Marchi
2022-01-17 21:27 ` [PATCH 2/3] gdbserver: introduce threads_debug_printf, THREADS_SCOPED_DEBUG_ENTER_EXIT Simon Marchi
@ 2022-01-17 21:27 ` Simon Marchi
2022-01-18 11:14 ` [PATCH 0/3] Improvements to GDBserver logging Hannes Domani
2 siblings, 0 replies; 9+ messages in thread
From: Simon Marchi @ 2022-01-17 21:27 UTC (permalink / raw)
To: gdb-patches
Add remote_debug_printf, and use it for all debug messages controlled by
remote_debug.
Change remote_debug to be a bool, which is trivial in this case.
Change-Id: I90de13cb892faec3830047b571661822b126d6e8
---
gdbserver/debug.cc | 2 +-
gdbserver/debug.h | 8 ++++-
gdbserver/notif.cc | 10 +++---
gdbserver/remote-utils.cc | 55 ++++++++----------------------
gdbserver/server.cc | 70 +++++++++++++--------------------------
5 files changed, 48 insertions(+), 97 deletions(-)
diff --git a/gdbserver/debug.cc b/gdbserver/debug.cc
index 8b3e95e65cd1..195c7e9a6838 100644
--- a/gdbserver/debug.cc
+++ b/gdbserver/debug.cc
@@ -20,7 +20,7 @@
#include <chrono>
#if !defined (IN_PROCESS_AGENT)
-int remote_debug = 0;
+bool remote_debug = false;
#endif
/* Output file for debugging. Default to standard error. */
diff --git a/gdbserver/debug.h b/gdbserver/debug.h
index 4220246de793..d92427521099 100644
--- a/gdbserver/debug.h
+++ b/gdbserver/debug.h
@@ -20,7 +20,13 @@
#define GDBSERVER_DEBUG_H
#if !defined (IN_PROCESS_AGENT)
-extern int remote_debug;
+extern bool remote_debug;
+
+/* Print a "remote" debug statement. */
+
+#define remote_debug_printf(fmt, ...) \
+ debug_prefixed_printf_cond (remote_debug, \
+ "remote", fmt, ##__VA_ARGS__)
/* Switch all debug output to DEBUG_FILE. If DEBUG_FILE is nullptr or an
empty string, or if the file cannot be opened, then debug output is sent to
diff --git a/gdbserver/notif.cc b/gdbserver/notif.cc
index 9176a7111d02..3be733f76f93 100644
--- a/gdbserver/notif.cc
+++ b/gdbserver/notif.cc
@@ -102,9 +102,8 @@ handle_notif_ack (char *own_buf, int packet_len)
struct notif_event *head = np->queue.front ();
np->queue.pop_front ();
- if (remote_debug)
- debug_printf ("%s: acking %d\n", np->ack_name,
- (int) np->queue.size ());
+ remote_debug_printf ("%s: acking %d", np->ack_name,
+ (int) np->queue.size ());
delete head;
}
@@ -122,9 +121,8 @@ notif_event_enque (struct notif_server *notif,
{
notif->queue.push_back (event);
- if (remote_debug)
- debug_printf ("pending events: %s %d\n", notif->notif_name,
- (int) notif->queue.size ());
+ remote_debug_printf ("pending events: %s %d", notif->notif_name,
+ (int) notif->queue.size ());
}
diff --git a/gdbserver/remote-utils.cc b/gdbserver/remote-utils.cc
index 8cd8f5271053..3004130fb25b 100644
--- a/gdbserver/remote-utils.cc
+++ b/gdbserver/remote-utils.cc
@@ -670,22 +670,15 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
if (cs.noack_mode || is_notif)
{
/* Don't expect an ack then. */
- if (remote_debug)
- {
- if (is_notif)
- debug_printf ("putpkt (\"%s\"); [notif]\n", buf2);
- else
- debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2);
- debug_flush ();
- }
+ if (is_notif)
+ remote_debug_printf ("putpkt (\"%s\"); [notif]", buf2);
+ else
+ remote_debug_printf ("putpkt (\"%s\"); [noack mode]", buf2);
+
break;
}
- if (remote_debug)
- {
- debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2);
- debug_flush ();
- }
+ remote_debug_printf ("putpkt (\"%s\"); [looking for ack]", buf2);
cc = readchar ();
@@ -695,11 +688,7 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
return -1;
}
- if (remote_debug)
- {
- debug_printf ("[received '%c' (0x%x)]\n", cc, cc);
- debug_flush ();
- }
+ remote_debug_printf ("[received '%c' (0x%x)]", cc, cc);
/* Check for an input interrupt while we're here. */
if (cc == '\003' && current_thread != NULL)
@@ -868,8 +857,7 @@ readchar (void)
{
if (readchar_bufcnt == 0)
{
- if (remote_debug)
- debug_printf ("readchar: Got EOF\n");
+ remote_debug_printf ("readchar: Got EOF");
}
else
perror ("readchar");
@@ -950,11 +938,8 @@ getpkt (char *buf)
if (c == '$')
break;
- if (remote_debug)
- {
- debug_printf ("[getpkt: discarding char '%c']\n", c);
- debug_flush ();
- }
+
+ remote_debug_printf ("[getpkt: discarding char '%c']", c);
if (c < 0)
return -1;
@@ -997,29 +982,15 @@ getpkt (char *buf)
if (!cs.noack_mode)
{
- if (remote_debug)
- {
- debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf);
- debug_flush ();
- }
+ remote_debug_printf ("getpkt (\"%s\"); [sending ack]", buf);
if (write_prim ("+", 1) != 1)
return -1;
- if (remote_debug)
- {
- debug_printf ("[sent ack]\n");
- debug_flush ();
- }
+ remote_debug_printf ("[sent ack]");
}
else
- {
- if (remote_debug)
- {
- debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf);
- debug_flush ();
- }
- }
+ remote_debug_printf ("getpkt (\"%s\"); [no ack sent]", buf);
/* The readchar above may have already read a '\003' out of the socket
and moved it to the local buffer. For example, when GDB sends
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 02b09e50da7f..4177239f4a62 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -736,13 +736,9 @@ handle_general_set (char *own_buf)
std::string final_var = hex2str (p);
std::string var_name, var_value;
- if (remote_debug)
- {
- debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p);
- debug_printf (_("[Environment variable to be set: '%s']\n"),
- final_var.c_str ());
- debug_flush ();
- }
+ remote_debug_printf ("[QEnvironmentHexEncoded received '%s']", p);
+ remote_debug_printf ("[Environment variable to be set: '%s']",
+ final_var.c_str ());
size_t pos = final_var.find ('=');
if (pos == std::string::npos)
@@ -767,13 +763,9 @@ handle_general_set (char *own_buf)
const char *p = own_buf + sizeof ("QEnvironmentUnset:") - 1;
std::string varname = hex2str (p);
- if (remote_debug)
- {
- debug_printf (_("[QEnvironmentUnset received '%s']\n"), p);
- debug_printf (_("[Environment variable to be unset: '%s']\n"),
- varname.c_str ());
- debug_flush ();
- }
+ remote_debug_printf ("[QEnvironmentUnset received '%s']", p);
+ remote_debug_printf ("[Environment variable to be unset: '%s']",
+ varname.c_str ());
our_environ.unset (varname.c_str ());
@@ -783,11 +775,7 @@ handle_general_set (char *own_buf)
if (strcmp (own_buf, "QStartNoAckMode") == 0)
{
- if (remote_debug)
- {
- debug_printf ("[noack mode enabled]\n");
- debug_flush ();
- }
+ remote_debug_printf ("[noack mode enabled]");
cs.noack_mode = 1;
write_ok (own_buf);
@@ -824,8 +812,7 @@ handle_general_set (char *own_buf)
non_stop = (req != 0);
- if (remote_debug)
- debug_printf ("[%s mode enabled]\n", req_str);
+ remote_debug_printf ("[%s mode enabled]", req_str);
write_ok (own_buf);
return;
@@ -839,12 +826,9 @@ handle_general_set (char *own_buf)
unpack_varlen_hex (packet, &setting);
cs.disable_randomization = setting;
- if (remote_debug)
- {
- debug_printf (cs.disable_randomization
- ? "[address space randomization disabled]\n"
- : "[address space randomization enabled]\n");
- }
+ remote_debug_printf (cs.disable_randomization
+ ? "[address space randomization disabled]"
+ : "[address space randomization enabled]");
write_ok (own_buf);
return;
@@ -872,8 +856,7 @@ handle_general_set (char *own_buf)
/* Update the flag. */
use_agent = req;
- if (remote_debug)
- debug_printf ("[%s agent]\n", req ? "Enable" : "Disable");
+ remote_debug_printf ("[%s agent]", req ? "Enable" : "Disable");
write_ok (own_buf);
return;
}
@@ -905,12 +888,8 @@ handle_general_set (char *own_buf)
cs.report_thread_events = (req == TRIBOOL_TRUE);
- if (remote_debug)
- {
- const char *req_str = cs.report_thread_events ? "enabled" : "disabled";
-
- debug_printf ("[thread events are now %s]\n", req_str);
- }
+ remote_debug_printf ("[thread events are now %s]\n",
+ cs.report_thread_events ? "enabled" : "disabled");
write_ok (own_buf);
return;
@@ -933,9 +912,8 @@ handle_general_set (char *own_buf)
return;
}
- if (remote_debug)
- debug_printf (_("[Inferior will %s started with shell]"),
- startup_with_shell ? "be" : "not be");
+ remote_debug_printf ("[Inferior will %s started with shell]",
+ startup_with_shell ? "be" : "not be");
write_ok (own_buf);
return;
@@ -949,9 +927,8 @@ handle_general_set (char *own_buf)
{
std::string path = hex2str (p);
- if (remote_debug)
- debug_printf (_("[Set the inferior's current directory to %s]\n"),
- path.c_str ());
+ remote_debug_printf ("[Set the inferior's current directory to %s]",
+ path.c_str ());
set_inferior_cwd (std::move (path));
}
@@ -961,9 +938,8 @@ handle_general_set (char *own_buf)
previously set cwd for the inferior. */
set_inferior_cwd ("");
- if (remote_debug)
- debug_printf (_("\
-[Unset the inferior's current directory; will use gdbserver's cwd]\n"));
+ remote_debug_printf ("[Unset the inferior's current directory; will "
+ "use gdbserver's cwd]");
}
write_ok (own_buf);
@@ -1399,12 +1375,12 @@ handle_monitor_command (char *mon, char *own_buf)
}
else if (strcmp (mon, "set remote-debug 1") == 0)
{
- remote_debug = 1;
+ remote_debug = true;
monitor_output ("Protocol debug output enabled.\n");
}
else if (strcmp (mon, "set remote-debug 0") == 0)
{
- remote_debug = 0;
+ remote_debug = false;
monitor_output ("Protocol debug output disabled.\n");
}
else if (strcmp (mon, "set event-loop-debug 1") == 0)
@@ -3827,7 +3803,7 @@ captured_main (int argc, char *argv[])
}
}
else if (strcmp (*next_arg, "--remote-debug") == 0)
- remote_debug = 1;
+ remote_debug = true;
else if (strcmp (*next_arg, "--event-loop-debug") == 0)
debug_event_loop = debug_event_loop_kind::ALL;
else if (startswith (*next_arg, "--debug-file="))
--
2.34.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 0/3] Improvements to GDBserver logging
2022-01-17 21:27 [PATCH 0/3] Improvements to GDBserver logging Simon Marchi
2022-01-17 21:27 ` [PATCH 2/3] gdbserver: introduce threads_debug_printf, THREADS_SCOPED_DEBUG_ENTER_EXIT Simon Marchi
2022-01-17 21:27 ` [PATCH 3/3] gdbserver: introduce remote_debug_printf Simon Marchi
@ 2022-01-18 11:14 ` Hannes Domani
2022-01-18 16:30 ` Simon Marchi
2 siblings, 1 reply; 9+ messages in thread
From: Hannes Domani @ 2022-01-18 11:14 UTC (permalink / raw)
To: gdb-patches, Simon Marchi
Am Montag, 17. Januar 2022, 22:29:18 MEZ hat Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> Folgendes geschrieben:
> This series starts making GDBserver use the same logging helpers as GDB,
> which automatically includes function names and produces indented
> output. I think it helps read long logs. The indentation in
> particular helps spots beginning and end of operations, which helps
> understand the context, and allows to skips long sections you are not
> interested in. A lot could be improved still, but this is just to get
> the ball rolling.
>
>
> Simon Marchi (3):
> gdbserver: turn debug_threads into a boolean
> gdbserver: introduce threads_debug_printf,
> THREADS_SCOPED_DEBUG_ENTER_EXIT
> gdbserver: introduce remote_debug_printf
Where is patch 1/3?
Hannes
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 0/3] Improvements to GDBserver logging
2022-01-18 11:14 ` [PATCH 0/3] Improvements to GDBserver logging Hannes Domani
@ 2022-01-18 16:30 ` Simon Marchi
2022-01-18 17:16 ` Tom Tromey
0 siblings, 1 reply; 9+ messages in thread
From: Simon Marchi @ 2022-01-18 16:30 UTC (permalink / raw)
To: Hannes Domani, gdb-patches
On 2022-01-18 06:14, Hannes Domani wrote:
> Am Montag, 17. Januar 2022, 22:29:18 MEZ hat Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> Folgendes geschrieben:
>
>> This series starts making GDBserver use the same logging helpers as GDB,
>> which automatically includes function names and produces indented
>> output. I think it helps read long logs. The indentation in
>> particular helps spots beginning and end of operations, which helps
>> understand the context, and allows to skips long sections you are not
>> interested in. A lot could be improved still, but this is just to get
>> the ball rolling.
>>
>>
>> Simon Marchi (3):
>> gdbserver: turn debug_threads into a boolean
>> gdbserver: introduce threads_debug_printf,
>> THREADS_SCOPED_DEBUG_ENTER_EXIT
>> gdbserver: introduce remote_debug_printf
>
> Where is patch 1/3?
>
>
> Hannes
Looks like it failed to go through? I'll re-send it.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 0/3] Improvements to GDBserver logging
2022-01-18 16:30 ` Simon Marchi
@ 2022-01-18 17:16 ` Tom Tromey
2022-01-18 17:45 ` [PATCH RESEND ...5? 1/3] gdbserver: turn debug_threads into a boolean Simon Marchi
0 siblings, 1 reply; 9+ messages in thread
From: Tom Tromey @ 2022-01-18 17:16 UTC (permalink / raw)
To: Simon Marchi via Gdb-patches
Simon> Looks like it failed to go through? I'll re-send it.
FWIW patches 2 and 3 looked good to me.
I still haven't seen patch 1 though.
Tom
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH RESEND ...5? 1/3] gdbserver: turn debug_threads into a boolean
2022-01-18 17:16 ` Tom Tromey
@ 2022-01-18 17:45 ` Simon Marchi
2022-01-18 18:13 ` Tom Tromey
0 siblings, 1 reply; 9+ messages in thread
From: Simon Marchi @ 2022-01-18 17:45 UTC (permalink / raw)
To: Tom Tromey, Simon Marchi via Gdb-patches
Here is patch 1, I tried to send it again using git-send-email, no luck.
Hopefully this will reach the list.
From 7b0cc62bc54da15c4f1829e53c19d2dfa15953e2 Mon Sep 17 00:00:00 2001
From: Simon Marchi <simon.marchi@polymtl.ca>
Date: Sun, 16 Jan 2022 21:21:24 -0500
Subject: [PATCH] gdbserver: turn debug_threads into a boolean
debug_threads is always used as a boolean. Except in ax.cc and
tracepoint.cc. These files have their own macros that use
debug_threads, and have a concept of verbosity level. But they both
have a single level, so it's just a boolean in the end.
Remove this concept of level. If we ever want to re-introduce it, I
think it will be better implemented in a more common location.
Change debug_threads to bool and adjust some users that were treating it
as an int.
Change-Id: I137f596eaf763a08c977dd74417969cedfee9ecf
---
gdbserver/ax.cc | 7 ++-----
gdbserver/debug.cc | 2 +-
gdbserver/debug.h | 2 +-
gdbserver/server.cc | 6 +++---
gdbserver/tracepoint.cc | 11 ++++-------
5 files changed, 11 insertions(+), 17 deletions(-)
diff --git a/gdbserver/ax.cc b/gdbserver/ax.cc
index d2d003377e0d..4f36bc50cab6 100644
--- a/gdbserver/ax.cc
+++ b/gdbserver/ax.cc
@@ -44,15 +44,12 @@ ax_vdebug (const char *fmt, ...)
va_end (ap);
}
-#define ax_debug_1(level, fmt, args...) \
+#define ax_debug(fmt, args...) \
do { \
- if (level <= debug_threads) \
+ if (debug_threads) \
ax_vdebug ((fmt), ##args); \
} while (0)
-#define ax_debug(FMT, args...) \
- ax_debug_1 (1, FMT, ##args)
-
/* This enum must exactly match what is documented in
gdb/doc/agentexpr.texi, including all the numerical values. */
diff --git a/gdbserver/debug.cc b/gdbserver/debug.cc
index 202d315ab679..372b5577958d 100644
--- a/gdbserver/debug.cc
+++ b/gdbserver/debug.cc
@@ -27,7 +27,7 @@ int remote_debug = 0;
static FILE *debug_file = stderr;
/* See debug.h. */
-int debug_threads;
+bool debug_threads;
/* Include timestamps in debugging output. */
int debug_timestamp;
diff --git a/gdbserver/debug.h b/gdbserver/debug.h
index 6c5f997d09ee..20cb4e733f26 100644
--- a/gdbserver/debug.h
+++ b/gdbserver/debug.h
@@ -33,7 +33,7 @@ extern int using_threads;
/* Enable miscellaneous debugging output. The name is historical - it
was originally used to debug LinuxThreads support. */
-extern int debug_threads;
+extern bool debug_threads;
extern int debug_timestamp;
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 07f119dc6a11..021c7adc3085 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -1380,12 +1380,12 @@ handle_monitor_command (char *mon, char *own_buf)
{
if (strcmp (mon, "set debug 1") == 0)
{
- debug_threads = 1;
+ debug_threads = true;
monitor_output ("Debug output enabled.\n");
}
else if (strcmp (mon, "set debug 0") == 0)
{
- debug_threads = 0;
+ debug_threads = false;
monitor_output ("Debug output disabled.\n");
}
else if (strcmp (mon, "set debug-hw-points 1") == 0)
@@ -3814,7 +3814,7 @@ captured_main (int argc, char *argv[])
*next_arg = NULL;
}
else if (strcmp (*next_arg, "--debug") == 0)
- debug_threads = 1;
+ debug_threads = true;
else if (startswith (*next_arg, "--debug-format="))
{
std::string error_msg
diff --git a/gdbserver/tracepoint.cc b/gdbserver/tracepoint.cc
index 8ccdf491b996..0136f6e23473 100644
--- a/gdbserver/tracepoint.cc
+++ b/gdbserver/tracepoint.cc
@@ -77,17 +77,17 @@ trace_vdebug (const char *fmt, ...)
va_end (ap);
}
-#define trace_debug_1(level, fmt, args...) \
+#define trace_debug(fmt, args...) \
do { \
- if (level <= debug_threads) \
+ if (debug_threads) \
trace_vdebug ((fmt), ##args); \
} while (0)
#else
-#define trace_debug_1(level, fmt, args...) \
+#define trace_debug(fmt, args...) \
do { \
- if (level <= debug_threads) \
+ if (debug_threads) \
{ \
debug_printf ((fmt), ##args); \
debug_printf ("\n"); \
@@ -96,9 +96,6 @@ trace_vdebug (const char *fmt, ...)
#endif
-#define trace_debug(FMT, args...) \
- trace_debug_1 (1, FMT, ##args)
-
/* Prefix exported symbols, for good citizenship. All the symbols
that need exporting are defined in this module. Note that all
these symbols must be tagged with IP_AGENT_EXPORT_*. */
base-commit: e53c95d40b128a1e794b27ec8b166ae1445356eb
--
2.34.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH RESEND ...5? 1/3] gdbserver: turn debug_threads into a boolean
2022-01-18 17:45 ` [PATCH RESEND ...5? 1/3] gdbserver: turn debug_threads into a boolean Simon Marchi
@ 2022-01-18 18:13 ` Tom Tromey
2022-01-18 18:45 ` Simon Marchi
0 siblings, 1 reply; 9+ messages in thread
From: Tom Tromey @ 2022-01-18 18:13 UTC (permalink / raw)
To: Simon Marchi via Gdb-patches; +Cc: Tom Tromey, Simon Marchi
>>>>> "Simon" == Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> writes:
Simon> Here is patch 1, I tried to send it again using git-send-email, no luck.
Simon> Hopefully this will reach the list.
It did. I wonder what prevented it earlier.
Simon> Subject: [PATCH] gdbserver: turn debug_threads into a boolean
Seems reasonable to me.
Tom
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH RESEND ...5? 1/3] gdbserver: turn debug_threads into a boolean
2022-01-18 18:13 ` Tom Tromey
@ 2022-01-18 18:45 ` Simon Marchi
0 siblings, 0 replies; 9+ messages in thread
From: Simon Marchi @ 2022-01-18 18:45 UTC (permalink / raw)
To: Tom Tromey, Simon Marchi via Gdb-patches
On 2022-01-18 13:13, Tom Tromey wrote:
>>>>>> "Simon" == Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> writes:
>
> Simon> Here is patch 1, I tried to send it again using git-send-email, no luck.
> Simon> Hopefully this will reach the list.
>
> It did. I wonder what prevented it earlier.
>
> Simon> Subject: [PATCH] gdbserver: turn debug_threads into a boolean
>
> Seems reasonable to me.
>
> Tom
Thanks, I pushed the series.
Simon
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2022-01-18 22:20 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-01-17 21:27 [PATCH 0/3] Improvements to GDBserver logging Simon Marchi
2022-01-17 21:27 ` [PATCH 2/3] gdbserver: introduce threads_debug_printf, THREADS_SCOPED_DEBUG_ENTER_EXIT Simon Marchi
2022-01-17 21:27 ` [PATCH 3/3] gdbserver: introduce remote_debug_printf Simon Marchi
2022-01-18 11:14 ` [PATCH 0/3] Improvements to GDBserver logging Hannes Domani
2022-01-18 16:30 ` Simon Marchi
2022-01-18 17:16 ` Tom Tromey
2022-01-18 17:45 ` [PATCH RESEND ...5? 1/3] gdbserver: turn debug_threads into a boolean Simon Marchi
2022-01-18 18:13 ` Tom Tromey
2022-01-18 18:45 ` Simon Marchi
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).