/* 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)
{
{
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);
&& !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);
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);
}
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;
&& 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". */
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
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
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;
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
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;
{
/* 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. */
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;
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;
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. */
{
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));
}
}
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 ();
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);
}
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);
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. */
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 ())
}
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);
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;
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
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. */
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);
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 (); };
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);
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 (),
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;
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;
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
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;
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)
}
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. */
{
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)
{
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
{
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);
}
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);
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));
}
}
}
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;
}
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;
}
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)
{
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;
}
}
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;
}
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);
/* 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
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;
}
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;
}
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
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);
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);
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
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)");
}
}
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;
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);
{
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 ();
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)
{
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
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;
}
}
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;
}
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
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;
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;
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);
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);
}
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;
|| !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;
}
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);
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
break;
case BPSTAT_WHAT_STOP_NOISY:
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
+ infrun_debug_printf ("BPSTAT_WHAT_STOP_NOISY");
stop_print_frame = 1;
/* Assume the thread stopped for a breakpoint. We'll still check
return;
case BPSTAT_WHAT_STOP_SILENT:
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
+ infrun_debug_printf ("BPSTAT_WHAT_STOP_SILENT");
stop_print_frame = 0;
/* Assume the thread stopped for a breakpoint. We'll still check
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)
&& 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;
}
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
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;
|| 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
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)
{
&& 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;
}
|| 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
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)
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)
{
&& 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
{
/* 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;
}
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;
}
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 ());
&& 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))
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;
}
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");
}
}
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);
}
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;
}
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;
}
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;
}
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))
{
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);
{
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
}
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);
}
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 ();
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 ();
{
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,
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 ();
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;
{
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
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
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;
projects / binutils-gdb.git / commitdiff