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