along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "displaced-stepping.h"
+#include "gdbsupport/common-defs.h"
+#include "gdbsupport/common-utils.h"
#include "infrun.h"
#include <ctype.h>
#include "symtab.h"
#include "top.h"
#include "inf-loop.h"
#include "regcache.h"
+#include "utils.h"
#include "value.h"
#include "observable.h"
#include "language.h"
Starts off as -1, indicating "never enabled/disabled". */
static int infrun_is_async = -1;
+#define infrun_log_debug(fmt, args...) \
+ infrun_log_debug_1 (__LINE__, __func__, fmt, ##args)
+
+static void ATTRIBUTE_PRINTF(3, 4)
+infrun_log_debug_1 (int line, const char *func,
+ const char *fmt, ...)
+{
+ if (debug_infrun)
+ {
+ va_list args;
+ va_start (args, fmt);
+ std::string msg = string_vprintf (fmt, args);
+ va_end (args);
+
+ fprintf_unfiltered (gdb_stdout, "infrun: %s: %s\n", func, msg.c_str ());
+ }
+}
+
/* See infrun.h. */
void
{
infrun_is_async = enable;
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "infrun: infrun_async(%d)\n",
- enable);
+ infrun_log_debug ("enable=%d", enable);
if (enable)
mark_async_event_handler (infrun_async_inferior_event_token);
struct breakpoint *exception_resume_breakpoint = NULL;
CORE_ADDR step_range_start = 0;
CORE_ADDR step_range_end = 0;
+ int current_line = 0;
+ symtab *current_symtab = NULL;
struct frame_id step_frame_id = { 0 };
struct thread_fsm *thread_fsm = NULL;
(tp->control.step_resume_breakpoint);
step_range_start = tp->control.step_range_start;
step_range_end = tp->control.step_range_end;
+ current_line = tp->current_line;
+ current_symtab = tp->current_symtab;
step_frame_id = tp->control.step_frame_id;
exception_resume_breakpoint
= clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
= step_resume_breakpoint;
tp->control.step_range_start = step_range_start;
tp->control.step_range_end = step_range_end;
+ tp->current_line = current_line;
+ tp->current_symtab = current_symtab;
tp->control.step_frame_id = step_frame_id;
tp->control.exception_resume_breakpoint
= exception_resume_breakpoint;
&& !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_log_debug ("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_log_debug ("resuming vfork parent process %d",
+ resume_parent);
iterate_over_threads (proceed_after_vfork_done, &resume_parent);
}
to avoid starvation, otherwise, we could e.g., find ourselves
constantly stepping the same couple threads past their breakpoints
over and over, if the single-step finish fast enough. */
-struct thread_info *step_over_queue_head;
+struct thread_info *global_thread_step_over_chain_head;
/* Bit flags indicating what the thread needs to step over. */
static void
clear_step_over_info (void)
{
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "infrun: clear_step_over_info\n");
+ infrun_log_debug ("clearing step over info");
step_over_info.aspace = NULL;
step_over_info.address = 0;
step_over_info.nonsteppable_watchpoint_p = 0;
displaced step operation on it. See displaced_step_prepare and
displaced_step_fixup for details. */
-/* Default destructor for displaced_step_closure. */
-
-displaced_step_closure::~displaced_step_closure () = default;
-
-/* Get the displaced stepping state of process PID. */
+/* Get the displaced stepping state of inferior INF. */
static displaced_step_inferior_state *
get_displaced_stepping_state (inferior *inf)
return &inf->displaced_step_state;
}
-/* Returns true if any inferior has a thread doing a displaced
- step. */
+/* Get the displaced stepping state of thread THREAD. */
-static bool
-displaced_step_in_progress_any_inferior ()
+static displaced_step_thread_state *
+get_displaced_stepping_state (thread_info *thread)
{
- for (inferior *i : all_inferiors ())
- {
- if (i->displaced_step_state.step_thread != nullptr)
- return true;
- }
-
- return false;
+ return &thread->displaced_step_state;
}
-/* Return true if thread represented by PTID is doing a displaced
- step. */
+/* Return true if the given thread is doing a displaced step. */
-static int
-displaced_step_in_progress_thread (thread_info *thread)
+static bool
+displaced_step_in_progress (thread_info *thread)
{
gdb_assert (thread != NULL);
- return get_displaced_stepping_state (thread->inf)->step_thread == thread;
+ return get_displaced_stepping_state (thread)->in_progress ();
}
-/* Return true if process PID has a thread doing a displaced step. */
+/* Return true if any thread of this inferior is doing a displaced step. */
-static int
+static bool
displaced_step_in_progress (inferior *inf)
{
- return get_displaced_stepping_state (inf)->step_thread != nullptr;
+ for (thread_info *thread : inf->non_exited_threads ())
+ {
+ if (displaced_step_in_progress (thread))
+ return true;
+ }
+
+ return false;
}
-/* If inferior is in displaced stepping, and ADDR equals to starting address
- of copy area, return corresponding displaced_step_closure. Otherwise,
- return NULL. */
+/* Return true if any thread is doing a displaced step. */
-struct displaced_step_closure*
-get_displaced_step_closure_by_addr (CORE_ADDR addr)
+static bool
+displaced_step_in_progress_any_thread ()
{
- displaced_step_inferior_state *displaced
- = get_displaced_stepping_state (current_inferior ());
+ for (thread_info *thread : all_non_exited_threads ())
+ {
+ if (displaced_step_in_progress (thread))
+ return true;
+ }
- /* If checking the mode of displaced instruction in copy area. */
- if (displaced->step_thread != nullptr
- && displaced->step_copy == addr)
- return displaced->step_closure.get ();
+ return false;
+}
+
+/* If inferior is in displaced stepping, and ADDR equals to starting address
+ of copy area, return corresponding displaced_step_copy_insn_closure. Otherwise,
+ return NULL. */
+struct displaced_step_copy_insn_closure *
+get_displaced_step_copy_insn_closure_by_addr (CORE_ADDR addr)
+{
+// FIXME: implement me (only needed on ARM).
+// displaced_step_inferior_state *displaced
+// = get_displaced_stepping_state (current_inferior ());
+//
+// /* If checking the mode of displaced instruction in copy area. */
+// if (displaced->step_thread != nullptr
+// && displaced->step_copy == addr)
+// return displaced->step_closure.get ();
+//
return NULL;
}
static bool
gdbarch_supports_displaced_stepping (gdbarch *arch)
{
- /* Only check for the presence of step_copy_insn. Other required methods
- are checked by the gdbarch validation. */
+ /* Only check for the presence of copy_insn. Other required methods
+ are checked by the gdbarch validation to be provided if copy_insn is
+ provided. */
return gdbarch_displaced_step_copy_insn_p (arch);
}
return true;
}
-/* Simple function wrapper around displaced_step_inferior_state::reset. */
+/* Simple function wrapper around displaced_step_thread_state::reset. */
static void
-displaced_step_reset (displaced_step_inferior_state *displaced)
+displaced_step_reset (displaced_step_thread_state *displaced)
{
displaced->reset ();
}
stepped now; 0 if displaced stepping this thread got queued; or -1
if this instruction can't be displaced stepped. */
-static int
+static displaced_step_prepare_status
displaced_step_prepare_throw (thread_info *tp)
{
regcache *regcache = get_thread_regcache (tp);
struct gdbarch *gdbarch = regcache->arch ();
- const address_space *aspace = regcache->aspace ();
- CORE_ADDR original, copy;
- ULONGEST len;
- int status;
+ displaced_step_thread_state *thread_disp_step_state
+ = get_displaced_stepping_state (tp);
/* We should never reach this function if the architecture does not
support displaced stepping. */
jump/branch). */
tp->control.may_range_step = 0;
- /* We have to displaced step one thread at a time, as we only have
- access to a single scratch space per inferior. */
-
- displaced_step_inferior_state *displaced
- = get_displaced_stepping_state (tp->inf);
-
- if (displaced->step_thread != nullptr)
- {
- /* Already waiting for a displaced step to finish. Defer this
- request and place in queue. */
-
- if (debug_displaced)
- fprintf_unfiltered (gdb_stdlog,
- "displaced: deferring step of %s\n",
- target_pid_to_str (tp->ptid).c_str ());
-
- thread_step_over_chain_enqueue (tp);
- return 0;
- }
- else
- {
- if (debug_displaced)
- fprintf_unfiltered (gdb_stdlog,
- "displaced: stepping %s now\n",
- target_pid_to_str (tp->ptid).c_str ());
- }
-
- displaced_step_reset (displaced);
+ /* We are about to start a displaced step for this thread, if one is already
+ in progress, we goofed up somewhere. */
+ gdb_assert (!thread_disp_step_state->in_progress ());
scoped_restore_current_thread restore_thread;
switch_to_thread (tp);
- original = regcache_read_pc (regcache);
+ CORE_ADDR original_pc = regcache_read_pc (regcache);
- copy = gdbarch_displaced_step_location (gdbarch);
- len = gdbarch_max_insn_length (gdbarch);
+ displaced_step_prepare_status status =
+ gdbarch_displaced_step_prepare (gdbarch, tp);
- if (breakpoint_in_range_p (aspace, copy, len))
+ if (status == DISPLACED_STEP_PREPARE_STATUS_ERROR)
{
- /* There's a breakpoint set in the scratch pad location range
- (which is usually around the entry point). We'd either
- install it before resuming, which would overwrite/corrupt the
- scratch pad, or if it was already inserted, this displaced
- step would overwrite it. The latter is OK in the sense that
- we already assume that no thread is going to execute the code
- in the scratch pad range (after initial startup) anyway, but
- the former is unacceptable. Simply punt and fallback to
- stepping over this breakpoint in-line. */
if (debug_displaced)
- {
- fprintf_unfiltered (gdb_stdlog,
- "displaced: breakpoint set in scratch pad. "
- "Stepping over breakpoint in-line instead.\n");
- }
+ fprintf_unfiltered (gdb_stdlog,
+ "displaced: failed to prepare (%s)",
+ target_pid_to_str (tp->ptid).c_str ());
- return -1;
+ return DISPLACED_STEP_PREPARE_STATUS_ERROR;
}
-
- /* Save the original contents of the copy area. */
- displaced->step_saved_copy.resize (len);
- status = target_read_memory (copy, displaced->step_saved_copy.data (), len);
- if (status != 0)
- throw_error (MEMORY_ERROR,
- _("Error accessing memory address %s (%s) for "
- "displaced-stepping scratch space."),
- paddress (gdbarch, copy), safe_strerror (status));
- if (debug_displaced)
+ else if (status == DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE)
{
- fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
- paddress (gdbarch, copy));
- displaced_step_dump_bytes (gdb_stdlog,
- displaced->step_saved_copy.data (),
- len);
- };
+ /* Not enough displaced stepping resources available, defer this
+ request by placing it the queue. */
- displaced->step_closure
- = gdbarch_displaced_step_copy_insn (gdbarch, original, copy, regcache);
- if (displaced->step_closure == NULL)
- {
- /* The architecture doesn't know how or want to displaced step
- this instruction or instruction sequence. Fallback to
- stepping over the breakpoint in-line. */
- return -1;
- }
+ if (debug_displaced)
+ fprintf_unfiltered (gdb_stdlog,
+ "displaced: not enough resources available, "
+ "deferring step of %s\n",
+ target_pid_to_str (tp->ptid).c_str ());
+
+ global_thread_step_over_chain_enqueue (tp);
+ tp->inf->displaced_step_state.unavailable = true;
+
+ return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE;
+ }
+
+ gdb_assert (status == DISPLACED_STEP_PREPARE_STATUS_OK);
+
+// FIXME: Should probably replicated in the arch implementation now.
+//
+// if (breakpoint_in_range_p (aspace, copy, len))
+// {
+// /* There's a breakpoint set in the scratch pad location range
+// (which is usually around the entry point). We'd either
+// install it before resuming, which would overwrite/corrupt the
+// scratch pad, or if it was already inserted, this displaced
+// step would overwrite it. The latter is OK in the sense that
+// we already assume that no thread is going to execute the code
+// in the scratch pad range (after initial startup) anyway, but
+// the former is unacceptable. Simply punt and fallback to
+// stepping over this breakpoint in-line. */
+// if (debug_displaced)
+// {
+// fprintf_unfiltered (gdb_stdlog,
+// "displaced: breakpoint set in scratch pad. "
+// "Stepping over breakpoint in-line instead.\n");
+// }
+//
+// gdb_assert (false);
+// gdbarch_displaced_step_release_location (gdbarch, copy);
+//
+// return -1;
+// }
/* Save the information we need to fix things up if the step
succeeds. */
- displaced->step_thread = tp;
- displaced->step_gdbarch = gdbarch;
- displaced->step_original = original;
- displaced->step_copy = copy;
-
- {
- displaced_step_reset_cleanup cleanup (displaced);
+ thread_disp_step_state->set (gdbarch);
- /* Resume execution at the copy. */
- regcache_write_pc (regcache, copy);
-
- cleanup.release ();
- }
+ // FIXME: get it from _prepare?
+ CORE_ADDR displaced_pc = 0;
if (debug_displaced)
- fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
- paddress (gdbarch, copy));
+ fprintf_unfiltered (gdb_stdlog,
+ "displaced: prepared successfully thread=%s, "
+ "original_pc=%s, displaced_pc=%s\n",
+ target_pid_to_str (tp->ptid).c_str (),
+ paddress (gdbarch, original_pc),
+ paddress (gdbarch, displaced_pc));
- return 1;
+ return DISPLACED_STEP_PREPARE_STATUS_OK;
}
/* Wrapper for displaced_step_prepare_throw that disabled further
attempts at displaced stepping if we get a memory error. */
-static int
+static displaced_step_prepare_status
displaced_step_prepare (thread_info *thread)
{
- int prepared = -1;
+ displaced_step_prepare_status status
+ = DISPLACED_STEP_PREPARE_STATUS_ERROR;
try
{
- prepared = displaced_step_prepare_throw (thread);
+ status = displaced_step_prepare_throw (thread);
}
catch (const gdb_exception_error &ex)
{
&& ex.error != NOT_SUPPORTED_ERROR)
throw;
- if (debug_infrun)
- {
- fprintf_unfiltered (gdb_stdlog,
- "infrun: disabling displaced stepping: %s\n",
- ex.what ());
- }
+ infrun_log_debug ("caught exception, disabling displaced stepping: %s",
+ ex.what ());
/* Be verbose if "set displaced-stepping" is "on", silent if
"auto". */
displaced_state->failed_before = 1;
}
- return prepared;
-}
-
-static void
-write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
- const gdb_byte *myaddr, int len)
-{
- scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
-
- inferior_ptid = ptid;
- write_memory (memaddr, myaddr, len);
-}
-
-/* Restore the contents of the copy area for thread PTID. */
-
-static void
-displaced_step_restore (struct displaced_step_inferior_state *displaced,
- ptid_t ptid)
-{
- ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
-
- write_memory_ptid (ptid, displaced->step_copy,
- displaced->step_saved_copy.data (), len);
- if (debug_displaced)
- fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
- target_pid_to_str (ptid).c_str (),
- paddress (displaced->step_gdbarch,
- displaced->step_copy));
+ return status;
}
/* If we displaced stepped an instruction successfully, adjust
-1. If the thread wasn't displaced stepping, return 0. */
static int
-displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal)
+displaced_step_finish (thread_info *event_thread, enum gdb_signal signal)
{
- struct displaced_step_inferior_state *displaced
- = get_displaced_stepping_state (event_thread->inf);
- int ret;
+ displaced_step_thread_state *displaced
+ = get_displaced_stepping_state (event_thread);
- /* Was this event for the thread we displaced? */
- if (displaced->step_thread != event_thread)
+ /* Was this thread performing a displaced step? */
+ if (!displaced->in_progress ())
return 0;
+ displaced_step_reset_cleanup cleanup (displaced);
+
/* Fixup may need to read memory/registers. Switch to the thread
that we're fixing up. Also, target_stopped_by_watchpoint checks
the current thread, and displaced_step_restore performs ptid-dependent
memory accesses using current_inferior() and current_top_target(). */
switch_to_thread (event_thread);
- displaced_step_reset_cleanup cleanup (displaced);
-
- displaced_step_restore (displaced, displaced->step_thread->ptid);
+ /* Do the fixup, and release the resources acquired to do the displaced
+ step. */
+ displaced_step_finish_status finish_status =
+ gdbarch_displaced_step_finish (displaced->get_original_gdbarch (),
+ event_thread, signal);
- /* Did the instruction complete successfully? */
- if (signal == GDB_SIGNAL_TRAP
- && !(target_stopped_by_watchpoint ()
- && (gdbarch_have_nonsteppable_watchpoint (displaced->step_gdbarch)
- || target_have_steppable_watchpoint)))
- {
- /* Fix up the resulting state. */
- gdbarch_displaced_step_fixup (displaced->step_gdbarch,
- displaced->step_closure.get (),
- displaced->step_original,
- displaced->step_copy,
- get_thread_regcache (displaced->step_thread));
- ret = 1;
- }
+ if (finish_status == DISPLACED_STEP_FINISH_STATUS_OK)
+ return 1;
else
- {
- /* Since the instruction didn't complete, all we can do is
- relocate the PC. */
- struct regcache *regcache = get_thread_regcache (event_thread);
- CORE_ADDR pc = regcache_read_pc (regcache);
-
- pc = displaced->step_original + (pc - displaced->step_copy);
- regcache_write_pc (regcache, pc);
- ret = -1;
- }
-
- return ret;
+ return -1;
}
/* Data to be passed around while handling an event. This data is
start_step_over (void)
{
struct thread_info *tp, *next;
+ int started = 0;
/* Don't start a new step-over if we already have an in-line
step-over operation ongoing. */
if (step_over_info_valid_p ())
- return 0;
+ return started;
- for (tp = step_over_queue_head; tp != NULL; tp = next)
+ /* Steal the global thread step over chain. */
+ thread_info *threads_to_step = global_thread_step_over_chain_head;
+ global_thread_step_over_chain_head = NULL;
+
+ if (debug_infrun)
+ fprintf_unfiltered (gdb_stdlog,
+ "infrun: stealing list of %d threads to step from global queue\n",
+ thread_step_over_chain_length (threads_to_step));
+
+ for (inferior *inf : all_inferiors ())
+ inf->displaced_step_state.unavailable = false;
+
+ for (tp = threads_to_step; tp != NULL; tp = next)
{
struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss;
gdb_assert (!tp->stop_requested);
- next = thread_step_over_chain_next (tp);
-
- /* If this inferior already has a displaced step in process,
- don't start a new one. */
- if (displaced_step_in_progress (tp->inf))
- continue;
+ next = thread_step_over_chain_next (threads_to_step, tp);
step_what = thread_still_needs_step_over (tp);
must_be_in_line = ((step_what & STEP_OVER_WATCHPOINT)
/* We currently stop all threads of all processes to step-over
in-line. If we need to start a new in-line step-over, let
any pending displaced steps finish first. */
- if (must_be_in_line && displaced_step_in_progress_any_inferior ())
- return 0;
-
- thread_step_over_chain_remove (tp);
+ if (must_be_in_line && displaced_step_in_progress_any_thread ())
+ continue;
- if (step_over_queue_head == NULL)
- {
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "infrun: step-over queue now empty\n");
- }
+ thread_step_over_chain_remove (&threads_to_step, tp);
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_log_debug ("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 (!target_is_non_stop_p () && !step_what)
continue;
+ if (tp->inf->displaced_step_state.unavailable)
+ {
+ global_thread_step_over_chain_enqueue (tp);
+ continue;
+ }
+
switch_to_thread (tp);
reset_ecs (ecs, tp);
keep_going_pass_signal (ecs);
if (!ecs->wait_some_more)
error (_("Command aborted."));
- gdb_assert (tp->resumed);
+ /* If the thread's step over could not be initiated, it was re-added
+ to the global step over chain. */
+ if (tp->resumed)
+ {
+ infrun_log_debug ("start_step_over: [%s] was resumed.\n",
+ target_pid_to_str (tp->ptid).c_str ());
+ gdb_assert (!thread_is_in_step_over_chain (tp));
+ }
+ else
+ {
+ infrun_log_debug ("infrun: start_step_over: [%s] was NOT resumed.\n",
+ target_pid_to_str (tp->ptid).c_str ());
+ gdb_assert (thread_is_in_step_over_chain (tp));
+
+ }
/* If we started a new in-line step-over, we're done. */
if (step_over_info_valid_p ())
{
gdb_assert (tp->control.trap_expected);
- return 1;
+ started = 1;
+ break;
}
if (!target_is_non_stop_p ())
/* With remote targets (at least), in all-stop, we can't
issue any further remote commands until the program stops
again. */
- return 1;
+ started = 1;
+ break;
}
/* Either the thread no longer needed a step-over, or a new
displaced step on a thread of other process. */
}
- return 0;
+ /* If there are threads left in the THREADS_TO_STEP list, but we have
+ detected that we can't start anything more, put back these threads
+ in the global list. */
+ if (threads_to_step == NULL)
+ {
+ if (debug_infrun)
+ fprintf_unfiltered (gdb_stdlog,
+ "infrun: step-over queue now empty\n");
+ }
+ else
+ {
+ if (debug_infrun)
+ fprintf_unfiltered (gdb_stdlog,
+ "infrun: putting back %d threads to step in global queue\n",
+ thread_step_over_chain_length (threads_to_step));
+ while (threads_to_step != nullptr)
+ {
+ thread_info *thread = threads_to_step;
+
+ /* Remove from that list. */
+ thread_step_over_chain_remove (&threads_to_step, thread);
+
+ /* Add to global list. */
+ global_thread_step_over_chain_enqueue (thread);
+
+ }
+ }
+
+ return started;
}
/* Update global variables holding ptids to hold NEW_PTID if they were
struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = regcache->arch ();
struct thread_info *tp = inferior_thread ();
- CORE_ADDR pc = regcache_read_pc (regcache);
const address_space *aspace = regcache->aspace ();
ptid_t resume_ptid;
/* This represents the user's step vs continue request. When
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_log_debug
+ ("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_log_debug ("resume : clear step");
step = 0;
}
- 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));
+ CORE_ADDR pc = regcache_read_pc (regcache);
+
+ infrun_log_debug ("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_log_debug ("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_log_debug ("skipping permanent breakpoint");
gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
/* Update pc to reflect the new address from which we will
execute instructions. */
&& sig == GDB_SIGNAL_0
&& !current_inferior ()->waiting_for_vfork_done)
{
- int prepared = displaced_step_prepare (tp);
+ displaced_step_prepare_status prepare_status
+ = displaced_step_prepare (tp);
- if (prepared == 0)
+ if (prepare_status == DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE)
{
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "Got placed in step-over queue\n");
+ infrun_log_debug ("Got placed in step-over queue");
tp->control.trap_expected = 0;
return;
}
- else if (prepared < 0)
+ else if (prepare_status == DISPLACED_STEP_PREPARE_STATUS_ERROR)
{
/* Fallback to stepping over the breakpoint in-line. */
insert_breakpoints ();
}
- else if (prepared > 0)
+ else if (prepare_status == DISPLACED_STEP_PREPARE_STATUS_OK)
{
- struct displaced_step_inferior_state *displaced;
-
- /* Update pc to reflect the new address from which we will
- execute instructions due to displaced stepping. */
- pc = regcache_read_pc (get_thread_regcache (tp));
-
- displaced = get_displaced_stepping_state (tp->inf);
- step = gdbarch_displaced_step_hw_singlestep
- (gdbarch, displaced->step_closure.get ());
+ step = gdbarch_displaced_step_hw_singlestep (gdbarch, NULL);
}
+ else
+ gdb_assert_not_reached ("invalid displaced_step_prepare_status value");
}
/* Do we need to do it the hard way, w/temp breakpoints? */
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_log_debug ("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_log_debug ("%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_log_debug ("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_log_debug
+ ("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));
}
}
gdbarch = regcache->arch ();
const address_space *aspace = regcache->aspace ();
- pc = regcache_read_pc (regcache);
+ pc = regcache_read_pc_protected (regcache);
+
thread_info *cur_thr = inferior_thread ();
/* Fill in with reasonable starting values. */
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_log_debug ("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_log_debug ("need to step-over [%s] first",
+ target_pid_to_str (tp->ptid).c_str ());
- thread_step_over_chain_enqueue (tp);
+ global_thread_step_over_chain_enqueue (tp);
}
switch_to_thread (cur_thr);
/* Enqueue the current thread last, so that we move all other
threads over their breakpoints first. */
if (cur_thr->stepping_over_breakpoint)
- thread_step_over_chain_enqueue (cur_thr);
+ global_thread_step_over_chain_enqueue (cur_thr);
/* If the thread isn't started, we'll still need to set its prev_pc,
so that switch_back_to_stepped_thread knows the thread hasn't
advanced. Must do this before resuming any thread, as in
all-stop/remote, once we resume we can't send any other packet
until the target stops again. */
- cur_thr->prev_pc = regcache_read_pc (regcache);
+ cur_thr->prev_pc = regcache_read_pc_protected (regcache);
{
scoped_restore save_defer_tc = make_scoped_defer_target_commit_resume ();
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_log_debug ("[%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_log_debug ("[%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_log_debug ("[%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_log_debug ("resuming %s",
+ target_pid_to_str (tp->ptid).c_str ());
reset_ecs (ecs, tp);
switch_to_thread (tp);
start_step_over doesn't try to resume them
automatically. */
if (thread_is_in_step_over_chain (tp))
- thread_step_over_chain_remove (tp);
+ global_thread_step_over_chain_remove (tp);
/* If the thread is stopped, but the user/frontend doesn't
know about that yet, queue a pending event, as if the
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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("Found %d inferiors, starting at #%d",
+ num_inferiors, random_selector);
/* Select the Nth inferior that was resumed. */
struct inferior *inf = current_inferior ();
ptid_t pid_ptid = ptid_t (inf->pid);
- displaced_step_inferior_state *displaced = get_displaced_stepping_state (inf);
+ // displaced_step_inferior_state *displaced = get_displaced_stepping_state (inf);
/* Is any thread of this process displaced stepping? If not,
there's nothing else to do. */
- if (displaced->step_thread == nullptr)
+ if (displaced_step_in_progress (inf))
return;
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "displaced-stepping in-process while detaching");
+ infrun_log_debug ("displaced-stepping in-process while detaching");
scoped_restore restore_detaching = make_scoped_restore (&inf->detaching, true);
- while (displaced->step_thread != nullptr)
+ // FIXME
+ while (false)
{
struct execution_control_state ecss;
struct execution_control_state *ecs;
static void
wait_for_inferior (inferior *inf)
{
- if (debug_infrun)
- fprintf_unfiltered
- (gdb_stdlog, "infrun: wait_for_inferior ()\n");
+ infrun_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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;
}
}
+/* Mark the non-executing threads accordingly. In all-stop, all
+ threads of all processes are stopped when we get any event
+ reported. In non-stop mode, only the event thread stops. */
+
+static void
+mark_non_executing_threads (process_stratum_target *target,
+ ptid_t event_ptid,
+ struct target_waitstatus ws)
+{
+ ptid_t mark_ptid;
+
+ if (!target_is_non_stop_p ())
+ mark_ptid = minus_one_ptid;
+ else if (ws.kind == TARGET_WAITKIND_SIGNALLED
+ || ws.kind == TARGET_WAITKIND_EXITED)
+ {
+ /* If we're handling a process exit in non-stop mode, even
+ though threads haven't been deleted yet, one would think
+ that there is nothing to do, as threads of the dead process
+ will be soon deleted, and threads of any other process were
+ left running. However, on some targets, threads survive a
+ process exit event. E.g., for the "checkpoint" command,
+ when the current checkpoint/fork exits, linux-fork.c
+ automatically switches to another fork from within
+ target_mourn_inferior, by associating the same
+ inferior/thread to another fork. We haven't mourned yet at
+ this point, but we must mark any threads left in the
+ process as not-executing so that finish_thread_state marks
+ them stopped (in the user's perspective) if/when we present
+ the stop to the user. */
+ mark_ptid = ptid_t (event_ptid.pid ());
+ }
+ else
+ mark_ptid = event_ptid;
+
+ set_executing (target, mark_ptid, false);
+
+ /* Likewise the resumed flag. */
+ set_resumed (target, mark_ptid, false);
+}
+
/* See infrun.h. */
void
gdb_assert (exists_non_stop_target ());
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
+ infrun_log_debug ("stop_all_threads");
scoped_restore_current_thread restore_thread;
- target_thread_events (1);
- SCOPE_EXIT { target_thread_events (0); };
+ /* Enable thread events of all targets. */
+ for (auto *target : all_non_exited_process_targets ())
+ {
+ switch_to_target_no_thread (target);
+ target_thread_events (true);
+ }
+
+ SCOPE_EXIT
+ {
+ /* Disable thread events of all targets. */
+ for (auto *target : all_non_exited_process_targets ())
+ {
+ switch_to_target_no_thread (target);
+ target_thread_events (false);
+ }
+
+
+ infrun_log_debug ("stop_all_threads done");
+ };
/* Request threads to stop, and then wait for the stops. Because
threads we already know about can spawn more threads while we're
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_log_debug ("stop_all_threads, pass=%d, iterations=%d",
+ pass, iterations);
while (1)
{
- int need_wait = 0;
+ int waits_needed = 0;
- update_thread_list ();
+ for (auto *target : all_non_exited_process_targets ())
+ {
+ switch_to_target_no_thread (target);
+ update_thread_list ();
+ }
/* Go through all threads looking for threads that we need
to tell the target to stop. */
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_log_debug (" %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_log_debug (" %s executing, already stopping",
+ target_pid_to_str (t->ptid).c_str ());
}
if (t->stop_requested)
- need_wait = 1;
+ waits_needed++;
}
else
{
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "infrun: %s not executing\n",
- target_pid_to_str (t->ptid).c_str ());
+ infrun_log_debug (" %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. */
}
}
- if (!need_wait)
+ if (waits_needed == 0)
break;
/* If we find new threads on the second iteration, restart
if (pass > 0)
pass = -1;
- wait_one_event event = wait_one ();
-
- if (debug_infrun)
+ for (int i = 0; i < waits_needed; i++)
{
- 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 ());
- }
+ wait_one_event event = wait_one ();
- if (event.ws.kind == TARGET_WAITKIND_NO_RESUMED
- || event.ws.kind == TARGET_WAITKIND_THREAD_EXITED
- || event.ws.kind == TARGET_WAITKIND_EXITED
- || event.ws.kind == TARGET_WAITKIND_SIGNALLED)
- {
- /* All resumed threads exited
- or one thread/process exited/signalled. */
- }
- else
- {
- thread_info *t = find_thread_ptid (event.target, event.ptid);
- if (t == NULL)
- t = add_thread (event.target, event.ptid);
-
- t->stop_requested = 0;
- t->executing = 0;
- t->resumed = false;
- t->control.may_range_step = 0;
-
- /* This may be the first time we see the inferior report
- a stop. */
- inferior *inf = find_inferior_ptid (event.target, event.ptid);
- if (inf->needs_setup)
+ infrun_log_debug ("%s %s\n",
+ target_waitstatus_to_string (&event.ws).c_str (),
+ target_pid_to_str (event.ptid).c_str ());
+
+ if (event.ws.kind == TARGET_WAITKIND_NO_RESUMED)
{
- switch_to_thread_no_regs (t);
- setup_inferior (0);
+ /* All resumed threads exited. */
+ break;
}
-
- if (event.ws.kind == TARGET_WAITKIND_STOPPED
- && event.ws.value.sig == GDB_SIGNAL_0)
+ else if (event.ws.kind == TARGET_WAITKIND_THREAD_EXITED
+ || event.ws.kind == TARGET_WAITKIND_EXITED
+ || event.ws.kind == TARGET_WAITKIND_SIGNALLED)
{
- /* We caught the event that we intended to catch, so
- there's no event pending. */
- t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
- t->suspend.waitstatus_pending_p = 0;
+ /* One thread/process exited/signalled. */
+
+ thread_info *t = nullptr;
- if (displaced_step_fixup (t, GDB_SIGNAL_0) < 0)
+ /* The target may have reported just a pid. If so, try
+ the first non-exited thread. */
+ if (event.ptid.is_pid ())
{
- /* Add it back to the step-over queue. */
- if (debug_infrun)
+ int pid = event.ptid.pid ();
+ inferior *inf = find_inferior_pid (event.target, pid);
+ for (thread_info *tp : inf->non_exited_threads ())
{
- 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 ());
+ t = tp;
+ break;
}
- t->control.trap_expected = 0;
- thread_step_over_chain_enqueue (t);
+
+ /* If there is no available thread, the event would
+ have to be appended to a per-inferior event list,
+ which does not exist (and if it did, we'd have
+ to adjust run control command to be able to
+ resume such an inferior). We assert here instead
+ of going into an infinite loop. */
+ gdb_assert (t != nullptr);
+
+ infrun_log_debug ("using %s\n",
+ target_pid_to_str (t->ptid).c_str ());
+ }
+ else
+ {
+ t = find_thread_ptid (event.target, event.ptid);
+ /* Check if this is the first time we see this thread.
+ Don't bother adding if it individually exited. */
+ if (t == nullptr
+ && event.ws.kind != TARGET_WAITKIND_THREAD_EXITED)
+ t = add_thread (event.target, event.ptid);
+ }
+
+ if (t != nullptr)
+ {
+ /* Set the threads as non-executing to avoid
+ another stop attempt on them. */
+ switch_to_thread_no_regs (t);
+ mark_non_executing_threads (event.target, event.ptid,
+ event.ws);
+ save_waitstatus (t, &event.ws);
+ t->stop_requested = false;
}
}
else
{
- enum gdb_signal sig;
- struct regcache *regcache;
+ thread_info *t = find_thread_ptid (event.target, event.ptid);
+ if (t == NULL)
+ t = add_thread (event.target, event.ptid);
- if (debug_infrun)
+ t->stop_requested = 0;
+ t->executing = 0;
+ t->resumed = false;
+ t->control.may_range_step = 0;
+
+ /* This may be the first time we see the inferior report
+ a stop. */
+ inferior *inf = find_inferior_ptid (event.target, event.ptid);
+ if (inf->needs_setup)
{
- 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 ());
+ switch_to_thread_no_regs (t);
+ setup_inferior (0);
}
- /* Record for later. */
- save_waitstatus (t, &event.ws);
+ if (event.ws.kind == TARGET_WAITKIND_STOPPED
+ && event.ws.value.sig == GDB_SIGNAL_0)
+ {
+ /* We caught the event that we intended to catch, so
+ there's no event pending. */
+ t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
+ t->suspend.waitstatus_pending_p = 0;
- sig = (event.ws.kind == TARGET_WAITKIND_STOPPED
- ? event.ws.value.sig : GDB_SIGNAL_0);
+ if (displaced_step_finish (t, GDB_SIGNAL_0) < 0)
+ {
+ /* Add it back to the step-over queue. */
+ infrun_log_debug ("displaced-step of %s "
+ "canceled: adding back to the "
+ "step-over queue\n",
+ target_pid_to_str (t->ptid).c_str ());
- if (displaced_step_fixup (t, sig) < 0)
- {
- /* Add it back to the step-over queue. */
- t->control.trap_expected = 0;
- thread_step_over_chain_enqueue (t);
+ t->control.trap_expected = 0;
+ global_thread_step_over_chain_enqueue (t);
+ }
}
+ else
+ {
+ enum gdb_signal sig;
+ struct regcache *regcache;
- regcache = get_thread_regcache (t);
- t->suspend.stop_pc = regcache_read_pc (regcache);
+ if (debug_infrun)
+ {
+ std::string statstr = target_waitstatus_to_string (&event.ws);
+
+ infrun_log_debug ("target_wait %s, saving "
+ "status for %d.%ld.%ld\n",
+ statstr.c_str (),
+ t->ptid.pid (),
+ t->ptid.lwp (),
+ t->ptid.tid ());
+ }
- 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));
+ /* Record for later. */
+ save_waitstatus (t, &event.ws);
+
+ sig = (event.ws.kind == TARGET_WAITKIND_STOPPED
+ ? event.ws.value.sig : GDB_SIGNAL_0);
+
+ if (displaced_step_finish (t, sig) < 0)
+ {
+ /* Add it back to the step-over queue. */
+ t->control.trap_expected = 0;
+ global_thread_step_over_chain_enqueue (t);
+ }
+
+ regcache = get_thread_regcache (t);
+ t->suspend.stop_pc = regcache_read_pc (regcache);
+
+ infrun_log_debug ("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));
}
}
}
}
}
-
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
}
/* Handle a TARGET_WAITKIND_NO_RESUMED event. */
{
if (target_can_async_p ())
{
- struct ui *ui;
int any_sync = 0;
- ALL_UIS (ui)
+ for (ui *ui : all_uis ())
{
if (ui->prompt_state == PROMPT_BLOCKED)
{
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_log_debug ("TARGET_WAITKIND_NO_RESUMED (ignoring: bg)");
prepare_to_wait (ecs);
return 1;
}
{
/* There were no unwaited-for children left in the target at
some point, but there are now. Just ignore. */
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "infrun: TARGET_WAITKIND_NO_RESUMED "
- "(ignoring: found resumed)\n");
- prepare_to_wait (ecs);
- return 1;
- }
- }
-
- /* Note however that we may find no resumed thread because the whole
- process exited meanwhile (thus updating the thread list results
- in an empty thread list). In this case we know we'll be getting
- a process exit event shortly. */
- for (inferior *inf : all_non_exited_inferiors (ecs->target))
- {
- thread_info *thread = any_live_thread_of_inferior (inf);
- if (thread == NULL)
- {
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog,
- "infrun: TARGET_WAITKIND_NO_RESUMED "
- "(expect process exit)\n");
+ infrun_log_debug ("TARGET_WAITKIND_NO_RESUMED "
+ "(ignoring: found resumed)");
prepare_to_wait (ecs);
return 1;
}
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_log_debug ("%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_log_debug ("Treating signal as SIGTRAP");
ecs->ws.value.sig = GDB_SIGNAL_TRAP;
}
}
- /* Mark the non-executing threads accordingly. In all-stop, all
- threads of all processes are stopped when we get any event
- reported. In non-stop mode, only the event thread stops. */
- {
- ptid_t mark_ptid;
-
- if (!target_is_non_stop_p ())
- mark_ptid = minus_one_ptid;
- else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
- || ecs->ws.kind == TARGET_WAITKIND_EXITED)
- {
- /* If we're handling a process exit in non-stop mode, even
- though threads haven't been deleted yet, one would think
- that there is nothing to do, as threads of the dead process
- will be soon deleted, and threads of any other process were
- left running. However, on some targets, threads survive a
- process exit event. E.g., for the "checkpoint" command,
- when the current checkpoint/fork exits, linux-fork.c
- automatically switches to another fork from within
- target_mourn_inferior, by associating the same
- inferior/thread to another fork. We haven't mourned yet at
- this point, but we must mark any threads left in the
- process as not-executing so that finish_thread_state marks
- them stopped (in the user's perspective) if/when we present
- the stop to the user. */
- mark_ptid = ptid_t (ecs->ptid.pid ());
- }
- else
- mark_ptid = ecs->ptid;
-
- set_executing (ecs->target, mark_ptid, false);
-
- /* Likewise the resumed flag. */
- set_resumed (ecs->target, mark_ptid, false);
- }
+ mark_non_executing_threads (ecs->target, ecs->ptid, ecs->ws);
switch (ecs->ws.kind)
{
if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
|| stop_soon == STOP_QUIETLY_REMOTE)
{
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
+ infrun_log_debug ("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_log_debug ("Cannot fill $_exitsignal with the correct "
+ "signal number.");
}
gdb::observers::signal_exited.notify (ecs->ws.value.sig);
/* If checking displaced stepping is supported, and thread
ecs->ptid is displaced stepping. */
- if (displaced_step_in_progress_thread (ecs->event_thread))
+ if (displaced_step_in_progress (ecs->event_thread))
{
struct inferior *parent_inf
= find_inferior_ptid (ecs->target, ecs->ptid);
if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
{
- struct displaced_step_inferior_state *displaced
- = get_displaced_stepping_state (parent_inf);
+ // struct displaced_step_inferior_state *displaced
+ // = get_displaced_stepping_state (parent_inf);
/* Restore scratch pad for child process. */
- displaced_step_restore (displaced, ecs->ws.value.related_pid);
+ //displaced_step_restore (displaced, ecs->ws.value.related_pid);
+ // FIXME: we should restore all the buffers that were currently in use
}
/* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
has been done. Perform cleanup for parent process here. Note
that this operation also cleans up the child process for vfork,
because their pages are shared. */
- displaced_step_fixup (ecs->event_thread, GDB_SIGNAL_TRAP);
+ displaced_step_finish (ecs->event_thread, GDB_SIGNAL_TRAP);
/* Start a new step-over in another thread if there's one
that needs it. */
start_step_over ();
/* Switch to the stopped thread. */
context_switch (ecs);
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
+ infrun_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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);
{
int had_step_over_info;
- displaced_step_fixup (ecs->event_thread,
- ecs->event_thread->suspend.stop_signal);
+ displaced_step_finish (ecs->event_thread,
+ ecs->event_thread->suspend.stop_signal);
had_step_over_info = step_over_info_valid_p ();
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_log_debug ("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_log_debug ("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));
/* 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_log_debug ("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_log_debug ("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_log_debug ("stopped data address=%s",
+ paddress (reg_gdbarch, addr));
else
- fprintf_unfiltered (gdb_stdlog,
- "infrun: (no data address available)\n");
+ infrun_log_debug ("(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_log_debug ("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_log_debug ("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_log_debug ("[%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_log_debug ("[%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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("BPSTAT_WHAT_STOP_NOISY");
stop_print_frame = 1;
/* Assume the thread stopped for a breapoint. We'll still check
return;
case BPSTAT_WHAT_STOP_SILENT:
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
+ infrun_log_debug ("BPSTAT_WHAT_STOP_SILENT");
stop_print_frame = 0;
/* Assume the thread stopped for a breapoint. 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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug
+ ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("infrun: stepped to a different line\n");
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_log_debug ("infrun: stepped to a different line, but "
+ "it's not the start of a statement\n");
}
}
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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug
+ ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("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_log_debug ("stop_waiting");
/* Let callers know we don't want to wait for the inferior anymore. */
ecs->wait_some_more = 0;
/* Save the pc before execution, to compare with pc after stop. */
ecs->event_thread->prev_pc
- = regcache_read_pc (get_thread_regcache (ecs->event_thread));
+ = regcache_read_pc_protected (get_thread_regcache (ecs->event_thread));
if (ecs->event_thread->control.trap_expected)
{
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_log_debug ("%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 ());
- thread_step_over_chain_enqueue (tp);
+ infrun_log_debug ("step-over already in progress: "
+ "step-over for %s deferred",
+ target_pid_to_str (tp->ptid).c_str ());
+ global_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_log_debug ("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_log_debug ("prepare_to_wait");
ecs->wait_some_more = 1;
projects / deliverable / binutils-gdb.git / blobdiff