#include "gdb_assert.h"
#include "mi/mi-common.h"
+#include "event-top.h"
/* Prototypes for local functions */
static void set_schedlock_func (char *args, int from_tty,
struct cmd_list_element *c);
-struct execution_control_state;
-
-static int currently_stepping (struct execution_control_state *ecs);
+static int currently_stepping (struct thread_info *tp);
static void xdb_handle_command (char *args, int from_tty);
past the dynamic linker, as if we were using "next" to step over a
function call.
- IN_SOLIB_DYNSYM_RESOLVE_CODE says whether we're in the dynamic
+ in_solib_dynsym_resolve_code() says whether we're in the dynamic
linker code or not. Normally, this means we single-step. However,
if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an
address where we can place a step-resume breakpoint to get past the
linker's symbol resolution function.
- IN_SOLIB_DYNSYM_RESOLVE_CODE can generally be implemented in a
+ in_solib_dynsym_resolve_code() can generally be implemented in a
pretty portable way, by comparing the PC against the address ranges
of the dynamic linker's sections.
static struct symbol *step_start_function;
-/* Nonzero if we are presently stepping over a breakpoint.
-
- If we hit a breakpoint or watchpoint, and then continue,
- we need to single step the current thread with breakpoints
- disabled, to avoid hitting the same breakpoint or
- watchpoint again. And we should step just a single
- thread and keep other threads stopped, so that
- other threads don't miss breakpoints while they are removed.
-
- So, this variable simultaneously means that we need to single
- step the current thread, keep other threads stopped, and that
- breakpoints should be removed while we step.
-
- This variable is set either:
- - in proceed, when we resume inferior on user's explicit request
- - in keep_going, if handle_inferior_event decides we need to
- step over breakpoint.
-
- The variable is cleared in clear_proceed_status, called every
- time before we call proceed. The proceed calls wait_for_inferior,
- which calls handle_inferior_event in a loop, and until
- wait_for_inferior exits, this variable is changed only by keep_going. */
-
-static int stepping_over_breakpoint;
-
/* Nonzero if we want to give control to the user when we're notified
of shared library events by the dynamic linker. */
static int stop_on_solib_events;
enum stop_kind stop_soon;
-/* Nonzero if proceed is being used for a "finish" command or a similar
- situation when stop_registers should be saved. */
-
-int proceed_to_finish;
-
/* Save register contents here when about to pop a stack dummy frame,
if-and-only-if proceed_to_finish is set.
Thus this contains the return value from the called function (assuming
static int stop_print_frame;
-/* Step-resume or longjmp-resume breakpoint. */
-static struct breakpoint *step_resume_breakpoint = NULL;
-
/* This is a cached copy of the pid/waitstatus of the last event
returned by target_wait()/deprecated_target_wait_hook(). This
information is returned by get_last_target_status(). */
static ptid_t target_last_wait_ptid;
static struct target_waitstatus target_last_waitstatus;
-struct execution_control_state ecss;
+static void context_switch (ptid_t ptid);
+
+void init_thread_stepping_state (struct thread_info *tss);
+
+void init_infwait_state (void);
/* This is used to remember when a fork, vfork or exec event
was caught by a catchpoint, and thus the event is to be
void
follow_inferior_reset_breakpoints (void)
{
+ struct thread_info *tp = inferior_thread ();
+
/* Was there a step_resume breakpoint? (There was if the user
did a "next" at the fork() call.) If so, explicitly reset its
thread number.
"threads". We must update the bp's notion of which thread
it is for, or it'll be ignored when it triggers. */
- if (step_resume_breakpoint)
- breakpoint_re_set_thread (step_resume_breakpoint);
+ if (tp->step_resume_breakpoint)
+ breakpoint_re_set_thread (tp->step_resume_breakpoint);
/* Reinsert all breakpoints in the child. The user may have set
breakpoints after catching the fork, in which case those
{
ptid_t saved_pid = pid;
struct target_ops *tgt;
+ struct thread_info *th = inferior_thread ();
/* This is an exec event that we actually wish to pay attention to.
Refresh our symbol table to the newly exec'd program, remove any
/* If there was one, it's gone now. We cannot truly step-to-next
statement through an exec(). */
- step_resume_breakpoint = NULL;
- step_range_start = 0;
- step_range_end = 0;
+ th->step_resume_breakpoint = NULL;
+ th->step_range_start = 0;
+ th->step_range_end = 0;
/* What is this a.out's name? */
printf_unfiltered (_("Executing new program: %s\n"), execd_pathname);
}
}
+/* Update global variables holding ptids to hold NEW_PTID if they were
+ holding OLD_PTID. */
+static void
+infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
+{
+ struct displaced_step_request *it;
+
+ if (ptid_equal (inferior_ptid, old_ptid))
+ inferior_ptid = new_ptid;
+
+ if (ptid_equal (singlestep_ptid, old_ptid))
+ singlestep_ptid = new_ptid;
+
+ if (ptid_equal (displaced_step_ptid, old_ptid))
+ displaced_step_ptid = new_ptid;
+
+ if (ptid_equal (deferred_step_ptid, old_ptid))
+ deferred_step_ptid = new_ptid;
+
+ for (it = displaced_step_request_queue; it; it = it->next)
+ if (ptid_equal (it->ptid, old_ptid))
+ it->ptid = new_ptid;
+}
+
\f
/* Resuming. */
struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct thread_info *tp = inferior_thread ();
CORE_ADDR pc = regcache_read_pc (regcache);
QUIT;
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog,
"infrun: resume (step=%d, signal=%d), "
- "stepping_over_breakpoint=%d\n",
- step, sig, stepping_over_breakpoint);
+ "trap_expected=%d\n",
+ step, sig, tp->trap_expected);
/* Some targets (e.g. Solaris x86) have a kernel bug when stepping
over an instruction that causes a page fault without triggering
comments in the handle_inferior event for dealing with 'random
signals' explain what we do instead. */
if (use_displaced_stepping (gdbarch)
- && stepping_over_breakpoint
+ && tp->trap_expected
&& sig == TARGET_SIGNAL_0)
{
if (!displaced_step_prepare (inferior_ptid))
- /* Got placed in displaced stepping queue. Will be resumed
- later when all the currently queued displaced stepping
- requests finish. */
- return;
+ {
+ /* Got placed in displaced stepping queue. Will be resumed
+ later when all the currently queued displaced stepping
+ requests finish. The thread is not executing at this point,
+ and the call to set_executing will be made later. But we
+ need to call set_running here, since from frontend point of view,
+ the thread is running. */
+ set_running (inferior_ptid, 1);
+ discard_cleanups (old_cleanups);
+ return;
+ }
}
if (step && gdbarch_software_single_step_p (gdbarch))
}
if ((step || singlestep_breakpoints_inserted_p)
- && stepping_over_breakpoint)
+ && tp->trap_expected)
{
/* We're allowing a thread to run past a breakpoint it has
hit, by single-stepping the thread with the breakpoint
resume_ptid = inferior_ptid;
}
- if ((scheduler_mode == schedlock_on)
- || (scheduler_mode == schedlock_step
- && (step || singlestep_breakpoints_inserted_p)))
+ if (non_stop)
+ {
+ /* With non-stop mode on, threads are always handled
+ individually. */
+ resume_ptid = inferior_ptid;
+ }
+ else if ((scheduler_mode == schedlock_on)
+ || (scheduler_mode == schedlock_step
+ && (step || singlestep_breakpoints_inserted_p)))
{
/* User-settable 'scheduler' mode requires solo thread resume. */
resume_ptid = inferior_ptid;
if (debug_displaced
&& use_displaced_stepping (gdbarch)
- && stepping_over_breakpoint)
+ && tp->trap_expected)
{
struct regcache *resume_regcache = get_thread_regcache (resume_ptid);
CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
}
target_resume (resume_ptid, step, sig);
+
+ /* Avoid confusing the next resume, if the next stop/resume
+ happens to apply to another thread. */
+ tp->stop_signal = TARGET_SIGNAL_0;
}
discard_cleanups (old_cleanups);
void
clear_proceed_status (void)
{
- stepping_over_breakpoint = 0;
- step_range_start = 0;
- step_range_end = 0;
- step_frame_id = null_frame_id;
- step_over_calls = STEP_OVER_UNDEBUGGABLE;
+ if (!ptid_equal (inferior_ptid, null_ptid))
+ {
+ struct thread_info *tp = inferior_thread ();
+
+ tp->trap_expected = 0;
+ tp->step_range_start = 0;
+ tp->step_range_end = 0;
+ tp->step_frame_id = null_frame_id;
+ tp->step_over_calls = STEP_OVER_UNDEBUGGABLE;
+
+ tp->stop_step = 0;
+
+ tp->proceed_to_finish = 0;
+
+ /* Discard any remaining commands or status from previous
+ stop. */
+ bpstat_clear (&tp->stop_bpstat);
+ }
+
stop_after_trap = 0;
stop_soon = NO_STOP_QUIETLY;
- proceed_to_finish = 0;
breakpoint_proceeded = 1; /* We're about to proceed... */
if (stop_registers)
regcache_xfree (stop_registers);
stop_registers = NULL;
}
-
- /* Discard any remaining commands or status from previous stop. */
- bpstat_clear (&stop_bpstat);
}
/* This should be suitable for any targets that support threads. */
return 0;
}
-/* Record the pc of the program the last time it stopped. This is
- just used internally by wait_for_inferior, but need to be preserved
- over calls to it and cleared when the inferior is started. */
-static CORE_ADDR prev_pc;
-
/* Basic routine for continuing the program in various fashions.
ADDR is the address to resume at, or -1 for resume where stopped.
{
struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct thread_info *tp;
CORE_ADDR pc = regcache_read_pc (regcache);
int oneproc = 0;
+ enum target_signal stop_signal;
if (step > 0)
step_start_function = find_pc_function (pc);
"infrun: proceed (addr=0x%s, signal=%d, step=%d)\n",
paddr_nz (addr), siggnal, step);
- /* In a multi-threaded task we may select another thread
- and then continue or step.
-
- But if the old thread was stopped at a breakpoint, it
- will immediately cause another breakpoint stop without
- any execution (i.e. it will report a breakpoint hit
- incorrectly). So we must step over it first.
+ if (non_stop)
+ /* In non-stop, each thread is handled individually. The context
+ must already be set to the right thread here. */
+ ;
+ else
+ {
+ /* In a multi-threaded task we may select another thread and
+ then continue or step.
+
+ But if the old thread was stopped at a breakpoint, it will
+ immediately cause another breakpoint stop without any
+ execution (i.e. it will report a breakpoint hit incorrectly).
+ So we must step over it first.
+
+ prepare_to_proceed checks the current thread against the
+ thread that reported the most recent event. If a step-over
+ is required it returns TRUE and sets the current thread to
+ the old thread. */
+ if (prepare_to_proceed (step))
+ oneproc = 1;
+ }
- prepare_to_proceed checks the current thread against the thread
- that reported the most recent event. If a step-over is required
- it returns TRUE and sets the current thread to the old thread. */
- if (prepare_to_proceed (step))
- oneproc = 1;
+ /* prepare_to_proceed may change the current thread. */
+ tp = inferior_thread ();
if (oneproc)
{
- stepping_over_breakpoint = 1;
+ tp->trap_expected = 1;
/* If displaced stepping is enabled, we can step over the
breakpoint without hitting it, so leave all breakpoints
inserted. Otherwise we need to disable all breakpoints, step
/* We can insert breakpoints if we're not trying to step over one,
or if we are stepping over one but we're using displaced stepping
to do so. */
- if (! stepping_over_breakpoint || use_displaced_stepping (gdbarch))
+ if (! tp->trap_expected || use_displaced_stepping (gdbarch))
insert_breakpoints ();
+ if (!non_stop)
+ {
+ /* Pass the last stop signal to the thread we're resuming,
+ irrespective of whether the current thread is the thread that
+ got the last event or not. This was historically GDB's
+ behaviour before keeping a stop_signal per thread. */
+
+ struct thread_info *last_thread;
+ ptid_t last_ptid;
+ struct target_waitstatus last_status;
+
+ get_last_target_status (&last_ptid, &last_status);
+ if (!ptid_equal (inferior_ptid, last_ptid)
+ && !ptid_equal (last_ptid, null_ptid)
+ && !ptid_equal (last_ptid, minus_one_ptid))
+ {
+ last_thread = find_thread_pid (last_ptid);
+ if (last_thread)
+ {
+ tp->stop_signal = last_thread->stop_signal;
+ last_thread->stop_signal = TARGET_SIGNAL_0;
+ }
+ }
+ }
+
if (siggnal != TARGET_SIGNAL_DEFAULT)
- stop_signal = siggnal;
+ tp->stop_signal = siggnal;
/* If this signal should not be seen by program,
give it zero. Used for debugging signals. */
- else if (!signal_program[stop_signal])
- stop_signal = TARGET_SIGNAL_0;
+ else if (!signal_program[tp->stop_signal])
+ tp->stop_signal = TARGET_SIGNAL_0;
annotate_starting ();
are not guaranteed the inferior is stopped and so the regcache_read_pc ()
call can fail. Setting the prev_pc value here ensures the value is
updated correctly when the inferior is stopped. */
- prev_pc = regcache_read_pc (get_current_regcache ());
+ tp->prev_pc = regcache_read_pc (get_current_regcache ());
+
+ /* Fill in with reasonable starting values. */
+ init_thread_stepping_state (tp);
+
+ /* Reset to normal state. */
+ init_infwait_state ();
/* Resume inferior. */
- resume (oneproc || step || bpstat_should_step (), stop_signal);
+ resume (oneproc || step || bpstat_should_step (), tp->stop_signal);
/* Wait for it to stop (if not standalone)
and in any case decode why it stopped, and act accordingly. */
{
init_wait_for_inferior ();
stop_soon = STOP_QUIETLY_REMOTE;
- stepping_over_breakpoint = 0;
/* Always go on waiting for the target, regardless of the mode. */
/* FIXME: cagney/1999-09-23: At present it isn't possible to
init_wait_for_inferior (void)
{
/* These are meaningless until the first time through wait_for_inferior. */
- prev_pc = 0;
breakpoint_init_inferior (inf_starting);
- /* Don't confuse first call to proceed(). */
- stop_signal = TARGET_SIGNAL_0;
-
/* The first resume is not following a fork/vfork/exec. */
pending_follow.kind = TARGET_WAITKIND_SPURIOUS; /* I.e., none. */
target_last_wait_ptid = minus_one_ptid;
+ previous_inferior_ptid = null_ptid;
+ init_infwait_state ();
+
displaced_step_clear ();
}
SIGNAL_RECEIVED
};
-/* This structure contains what used to be local variables in
- wait_for_inferior. Probably many of them can return to being
- locals in handle_inferior_event. */
+/* The PTID we'll do a target_wait on.*/
+ptid_t waiton_ptid;
+
+/* Current inferior wait state. */
+enum infwait_states infwait_state;
+/* Data to be passed around while handling an event. This data is
+ discarded between events. */
struct execution_control_state
{
+ ptid_t ptid;
+ /* The thread that got the event, if this was a thread event; NULL
+ otherwise. */
+ struct thread_info *event_thread;
+
struct target_waitstatus ws;
- struct target_waitstatus *wp;
- /* Should we step over breakpoint next time keep_going
- is called? */
- int stepping_over_breakpoint;
int random_signal;
CORE_ADDR stop_func_start;
CORE_ADDR stop_func_end;
char *stop_func_name;
- struct symtab_and_line sal;
- int current_line;
- struct symtab *current_symtab;
- ptid_t ptid;
- ptid_t saved_inferior_ptid;
- int step_after_step_resume_breakpoint;
- int stepping_through_solib_after_catch;
- bpstat stepping_through_solib_catchpoints;
int new_thread_event;
- struct target_waitstatus tmpstatus;
- enum infwait_states infwait_state;
- ptid_t waiton_ptid;
int wait_some_more;
};
static void print_stop_reason (enum inferior_stop_reason stop_reason,
int stop_info);
+/* Callback for iterate_over_threads. */
+
+static int
+delete_step_resume_breakpoint_callback (struct thread_info *info, void *data)
+{
+ if (is_exited (info->ptid))
+ return 0;
+
+ delete_step_resume_breakpoint (info);
+ return 0;
+}
+
+/* In all-stop, delete the step resume breakpoint of any thread that
+ had one. In non-stop, delete the step resume breakpoint of the
+ thread that just stopped. */
+
+static void
+delete_step_thread_step_resume_breakpoint (void)
+{
+ if (!target_has_execution
+ || ptid_equal (inferior_ptid, null_ptid))
+ /* If the inferior has exited, we have already deleted the step
+ resume breakpoints out of GDB's lists. */
+ return;
+
+ if (non_stop)
+ {
+ /* If in non-stop mode, only delete the step-resume or
+ longjmp-resume breakpoint of the thread that just stopped
+ stepping. */
+ struct thread_info *tp = inferior_thread ();
+ delete_step_resume_breakpoint (tp);
+ }
+ else
+ /* In all-stop mode, delete all step-resume and longjmp-resume
+ breakpoints of any thread that had them. */
+ iterate_over_threads (delete_step_resume_breakpoint_callback, NULL);
+}
+
+/* A cleanup wrapper. */
+
+static void
+delete_step_thread_step_resume_breakpoint_cleanup (void *arg)
+{
+ delete_step_thread_step_resume_breakpoint ();
+}
+
/* Wait for control to return from inferior to debugger.
If TREAT_EXEC_AS_SIGTRAP is non-zero, then handle EXEC signals
wait_for_inferior (int treat_exec_as_sigtrap)
{
struct cleanup *old_cleanups;
+ struct execution_control_state ecss;
struct execution_control_state *ecs;
if (debug_infrun)
(gdb_stdlog, "infrun: wait_for_inferior (treat_exec_as_sigtrap=%d)\n",
treat_exec_as_sigtrap);
- old_cleanups = make_cleanup (delete_step_resume_breakpoint,
- &step_resume_breakpoint);
+ old_cleanups =
+ make_cleanup (delete_step_thread_step_resume_breakpoint_cleanup, NULL);
ecs = &ecss;
+ memset (ecs, 0, sizeof (*ecs));
- /* Fill in with reasonable starting values. */
- init_execution_control_state (ecs);
+ overlay_cache_invalid = 1;
- /* We'll update this if & when we switch to a new thread. */
+ /* We'll update this if & when we switch to a new thread. */
previous_inferior_ptid = inferior_ptid;
- overlay_cache_invalid = 1;
-
/* We have to invalidate the registers BEFORE calling target_wait
because they can be loaded from the target while in target_wait.
This makes remote debugging a bit more efficient for those
while (1)
{
if (deprecated_target_wait_hook)
- ecs->ptid = deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp);
+ ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
else
- ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp);
+ ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
if (treat_exec_as_sigtrap && ecs->ws.kind == TARGET_WAITKIND_EXECD)
{
if (!ecs->wait_some_more)
break;
}
+
do_cleanups (old_cleanups);
}
void
fetch_inferior_event (void *client_data)
{
+ struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
+ int was_sync = sync_execution;
- if (!ecs->wait_some_more)
- {
- /* Fill in with reasonable starting values. */
- init_execution_control_state (ecs);
+ memset (ecs, 0, sizeof (*ecs));
- /* We'll update this if & when we switch to a new thread. */
- previous_inferior_ptid = inferior_ptid;
+ overlay_cache_invalid = 1;
- overlay_cache_invalid = 1;
+ /* We can only rely on wait_for_more being correct before handling
+ the event in all-stop, but previous_inferior_ptid isn't used in
+ non-stop. */
+ if (!ecs->wait_some_more)
+ /* We'll update this if & when we switch to a new thread. */
+ previous_inferior_ptid = inferior_ptid;
- /* We have to invalidate the registers BEFORE calling target_wait
- because they can be loaded from the target while in target_wait.
- This makes remote debugging a bit more efficient for those
- targets that provide critical registers as part of their normal
- status mechanism. */
+ if (non_stop)
+ /* In non-stop mode, the user/frontend should not notice a thread
+ switch due to internal events. Make sure we reverse to the
+ user selected thread and frame after handling the event and
+ running any breakpoint commands. */
+ make_cleanup_restore_current_thread ();
- registers_changed ();
- }
+ /* We have to invalidate the registers BEFORE calling target_wait
+ because they can be loaded from the target while in target_wait.
+ This makes remote debugging a bit more efficient for those
+ targets that provide critical registers as part of their normal
+ status mechanism. */
+
+ registers_changed ();
if (deprecated_target_wait_hook)
ecs->ptid =
- deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp);
+ deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
else
- ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp);
+ ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
+
+ if (non_stop
+ && ecs->ws.kind != TARGET_WAITKIND_IGNORE
+ && ecs->ws.kind != TARGET_WAITKIND_EXITED
+ && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
+ /* In non-stop mode, each thread is handled individually. Switch
+ early, so the global state is set correctly for this
+ thread. */
+ context_switch (ecs->ptid);
/* Now figure out what to do with the result of the result. */
handle_inferior_event (ecs);
if (!ecs->wait_some_more)
{
- delete_step_resume_breakpoint (&step_resume_breakpoint);
+ delete_step_thread_step_resume_breakpoint ();
- normal_stop ();
- if (step_multi && stop_step)
+ if (stop_soon == NO_STOP_QUIETLY)
+ normal_stop ();
+
+ if (target_has_execution
+ && ecs->ws.kind != TARGET_WAITKIND_EXITED
+ && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
+ && ecs->event_thread->step_multi
+ && ecs->event_thread->stop_step)
inferior_event_handler (INF_EXEC_CONTINUE, NULL);
else
inferior_event_handler (INF_EXEC_COMPLETE, NULL);
}
+
+ /* Revert thread and frame. */
+ do_cleanups (old_chain);
+
+ /* If the inferior was in sync execution mode, and now isn't,
+ restore the prompt. */
+ if (was_sync && !sync_execution)
+ display_gdb_prompt (0);
}
/* Prepare an execution control state for looping through a
void
init_execution_control_state (struct execution_control_state *ecs)
{
- ecs->stepping_over_breakpoint = 0;
ecs->random_signal = 0;
- ecs->step_after_step_resume_breakpoint = 0;
- ecs->stepping_through_solib_after_catch = 0;
- ecs->stepping_through_solib_catchpoints = NULL;
- ecs->sal = find_pc_line (prev_pc, 0);
- ecs->current_line = ecs->sal.line;
- ecs->current_symtab = ecs->sal.symtab;
- ecs->infwait_state = infwait_normal_state;
- ecs->waiton_ptid = pid_to_ptid (-1);
- ecs->wp = &(ecs->ws);
+}
+
+/* Clear context switchable stepping state. */
+
+void
+init_thread_stepping_state (struct thread_info *tss)
+{
+ struct symtab_and_line sal;
+
+ tss->stepping_over_breakpoint = 0;
+ tss->step_after_step_resume_breakpoint = 0;
+ tss->stepping_through_solib_after_catch = 0;
+ tss->stepping_through_solib_catchpoints = NULL;
+
+ sal = find_pc_line (tss->prev_pc, 0);
+ tss->current_line = sal.line;
+ tss->current_symtab = sal.symtab;
}
/* Return the cached copy of the last pid/waitstatus returned by
target_last_wait_ptid = minus_one_ptid;
}
-/* Switch thread contexts, maintaining "infrun state". */
+/* Switch thread contexts. */
static void
-context_switch (struct execution_control_state *ecs)
+context_switch (ptid_t ptid)
{
- /* Caution: it may happen that the new thread (or the old one!)
- is not in the thread list. In this case we must not attempt
- to "switch context", or we run the risk that our context may
- be lost. This may happen as a result of the target module
- mishandling thread creation. */
-
if (debug_infrun)
{
fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
target_pid_to_str (inferior_ptid));
fprintf_unfiltered (gdb_stdlog, "to %s\n",
- target_pid_to_str (ecs->ptid));
- }
-
- if (in_thread_list (inferior_ptid) && in_thread_list (ecs->ptid))
- { /* Perform infrun state context switch: */
- /* Save infrun state for the old thread. */
- save_infrun_state (inferior_ptid, prev_pc,
- stepping_over_breakpoint, step_resume_breakpoint,
- step_range_start,
- step_range_end, &step_frame_id,
- ecs->stepping_over_breakpoint,
- ecs->stepping_through_solib_after_catch,
- ecs->stepping_through_solib_catchpoints,
- ecs->current_line, ecs->current_symtab,
- cmd_continuation, intermediate_continuation,
- proceed_to_finish,
- step_over_calls,
- stop_step,
- step_multi,
- stop_signal,
- stop_bpstat);
-
- /* Load infrun state for the new thread. */
- load_infrun_state (ecs->ptid, &prev_pc,
- &stepping_over_breakpoint, &step_resume_breakpoint,
- &step_range_start,
- &step_range_end, &step_frame_id,
- &ecs->stepping_over_breakpoint,
- &ecs->stepping_through_solib_after_catch,
- &ecs->stepping_through_solib_catchpoints,
- &ecs->current_line, &ecs->current_symtab,
- &cmd_continuation, &intermediate_continuation,
- &proceed_to_finish,
- &step_over_calls,
- &stop_step,
- &step_multi,
- &stop_signal,
- &stop_bpstat);
+ target_pid_to_str (ptid));
}
- switch_to_thread (ecs->ptid);
-}
-
-/* Context switch to thread PTID. */
-ptid_t
-context_switch_to (ptid_t ptid)
-{
- ptid_t current_ptid = inferior_ptid;
-
- /* Context switch to the new thread. */
- if (!ptid_equal (ptid, inferior_ptid))
- {
- ecss.ptid = ptid;
- context_switch (&ecss);
- }
- return current_ptid;
+ switch_to_thread (ptid);
}
static void
adjust_pc_after_break (struct execution_control_state *ecs)
{
- struct regcache *regcache = get_thread_regcache (ecs->ptid);
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct regcache *regcache;
+ struct gdbarch *gdbarch;
CORE_ADDR breakpoint_pc;
- /* If this target does not decrement the PC after breakpoints, then
- we have nothing to do. */
- if (gdbarch_decr_pc_after_break (gdbarch) == 0)
- return;
-
/* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
we aren't, just return.
if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP)
return;
+ /* If this target does not decrement the PC after breakpoints, then
+ we have nothing to do. */
+ regcache = get_thread_regcache (ecs->ptid);
+ gdbarch = get_regcache_arch (regcache);
+ if (gdbarch_decr_pc_after_break (gdbarch) == 0)
+ return;
+
/* Find the location where (if we've hit a breakpoint) the
breakpoint would be. */
breakpoint_pc = regcache_read_pc (regcache)
if (singlestep_breakpoints_inserted_p
|| !ptid_equal (ecs->ptid, inferior_ptid)
- || !currently_stepping (ecs)
- || prev_pc == breakpoint_pc)
+ || !currently_stepping (ecs->event_thread)
+ || ecs->event_thread->prev_pc == breakpoint_pc)
regcache_write_pc (regcache, breakpoint_pc);
}
}
+void
+init_infwait_state (void)
+{
+ waiton_ptid = pid_to_ptid (-1);
+ infwait_state = infwait_normal_state;
+}
+
+void
+error_is_running (void)
+{
+ error (_("\
+Cannot execute this command while the selected thread is running."));
+}
+
+void
+ensure_not_running (void)
+{
+ if (is_running (inferior_ptid))
+ error_is_running ();
+}
+
/* Given an execution control state that has been freshly filled in
by an event from the inferior, figure out what it means and take
appropriate action. */
int sw_single_step_trap_p = 0;
int stopped_by_watchpoint;
int stepped_after_stopped_by_watchpoint = 0;
+ struct symtab_and_line stop_pc_sal;
breakpoint_retire_moribund ();
/* Cache the last pid/waitstatus. */
target_last_wait_ptid = ecs->ptid;
- target_last_waitstatus = *ecs->wp;
+ target_last_waitstatus = ecs->ws;
/* Always clear state belonging to the previous time we stopped. */
stop_stack_dummy = 0;
+ /* If it's a new process, add it to the thread database */
+
+ ecs->new_thread_event = (!ptid_equal (ecs->ptid, inferior_ptid)
+ && !ptid_equal (ecs->ptid, minus_one_ptid)
+ && !in_thread_list (ecs->ptid));
+
+ if (ecs->ws.kind != TARGET_WAITKIND_EXITED
+ && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event)
+ add_thread (ecs->ptid);
+
+ ecs->event_thread = find_thread_pid (ecs->ptid);
+
+ /* Dependent on valid ECS->EVENT_THREAD. */
adjust_pc_after_break (ecs);
- switch (ecs->infwait_state)
+ /* Dependent on the current PC value modified by adjust_pc_after_break. */
+ reinit_frame_cache ();
+
+ if (ecs->ws.kind != TARGET_WAITKIND_IGNORE)
+ {
+ /* Mark the non-executing threads accordingly. */
+ if (!non_stop
+ || ecs->ws.kind == TARGET_WAITKIND_EXITED
+ || ecs->ws.kind == TARGET_WAITKIND_SIGNALLED)
+ set_executing (pid_to_ptid (-1), 0);
+ else
+ set_executing (ecs->ptid, 0);
+ }
+
+ switch (infwait_state)
{
case infwait_thread_hop_state:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n");
/* Cancel the waiton_ptid. */
- ecs->waiton_ptid = pid_to_ptid (-1);
+ waiton_ptid = pid_to_ptid (-1);
break;
case infwait_normal_state:
default:
internal_error (__FILE__, __LINE__, _("bad switch"));
}
- ecs->infwait_state = infwait_normal_state;
-
- reinit_frame_cache ();
-
- /* If it's a new process, add it to the thread database */
-
- ecs->new_thread_event = (!ptid_equal (ecs->ptid, inferior_ptid)
- && !ptid_equal (ecs->ptid, minus_one_ptid)
- && !in_thread_list (ecs->ptid));
-
- if (ecs->ws.kind != TARGET_WAITKIND_EXITED
- && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event)
- add_thread (ecs->ptid);
-
- /* Mark all threads as not-executing. In non-stop, this should be
- adjusted to only mark ecs->ptid. */
- if (ecs->ws.kind != TARGET_WAITKIND_IGNORE)
- set_executing (pid_to_ptid (-1), 0);
+ infwait_state = infwait_normal_state;
switch (ecs->ws.kind)
{
/* Record the exit code in the convenience variable $_exitcode, so
that the user can inspect this again later. */
set_internalvar (lookup_internalvar ("_exitcode"),
- value_from_longest (builtin_type_int,
+ value_from_longest (builtin_type_int32,
(LONGEST) ecs->ws.value.integer));
gdb_flush (gdb_stdout);
target_mourn_inferior ();
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SIGNALLED\n");
stop_print_frame = 0;
- stop_signal = ecs->ws.value.sig;
target_terminal_ours (); /* Must do this before mourn anyway */
/* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't
may be needed. */
target_mourn_inferior ();
- print_stop_reason (SIGNAL_EXITED, stop_signal);
+ print_stop_reason (SIGNAL_EXITED, ecs->ws.value.sig);
singlestep_breakpoints_inserted_p = 0;
stop_stepping (ecs);
return;
case TARGET_WAITKIND_VFORKED:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
- stop_signal = TARGET_SIGNAL_TRAP;
pending_follow.kind = ecs->ws.kind;
pending_follow.fork_event.parent_pid = ecs->ptid;
if (!ptid_equal (ecs->ptid, inferior_ptid))
{
- context_switch (ecs);
+ context_switch (ecs->ptid);
reinit_frame_cache ();
}
stop_pc = read_pc ();
- stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
+ ecs->event_thread->stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
- ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
+ ecs->random_signal = !bpstat_explains_signal (ecs->event_thread->stop_bpstat);
/* If no catchpoint triggered for this, then keep going. */
if (ecs->random_signal)
{
- stop_signal = TARGET_SIGNAL_0;
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
keep_going (ecs);
return;
}
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_TRAP;
goto process_event_stop_test;
case TARGET_WAITKIND_EXECD:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
- stop_signal = TARGET_SIGNAL_TRAP;
-
pending_follow.execd_pathname =
savestring (ecs->ws.value.execd_pathname,
strlen (ecs->ws.value.execd_pathname));
xfree (pending_follow.execd_pathname);
stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
- ecs->saved_inferior_ptid = inferior_ptid;
- inferior_ptid = ecs->ptid;
- stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
+ {
+ /* The breakpoints module may need to touch the inferior's
+ memory. Switch to the (stopped) event ptid
+ momentarily. */
+ ptid_t saved_inferior_ptid = inferior_ptid;
+ inferior_ptid = ecs->ptid;
+
+ ecs->event_thread->stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
- ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
- inferior_ptid = ecs->saved_inferior_ptid;
+ ecs->random_signal = !bpstat_explains_signal (ecs->event_thread->stop_bpstat);
+ inferior_ptid = saved_inferior_ptid;
+ }
if (!ptid_equal (ecs->ptid, inferior_ptid))
{
- context_switch (ecs);
+ context_switch (ecs->ptid);
reinit_frame_cache ();
}
/* If no catchpoint triggered for this, then keep going. */
if (ecs->random_signal)
{
- stop_signal = TARGET_SIGNAL_0;
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
keep_going (ecs);
return;
}
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_TRAP;
goto process_event_stop_test;
/* Be careful not to try to gather much state about a thread
case TARGET_WAITKIND_STOPPED:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
- stop_signal = ecs->ws.value.sig;
+ ecs->event_thread->stop_signal = ecs->ws.value.sig;
break;
/* We had an event in the inferior, but we are not interested
return;
}
- /* We may want to consider not doing a resume here in order to give
- the user a chance to play with the new thread. It might be good
- to make that a user-settable option. */
-
- /* At this point, all threads are stopped (happens automatically in
- either the OS or the native code). Therefore we need to continue
- all threads in order to make progress. */
if (ecs->new_thread_event)
{
+ if (non_stop)
+ /* Non-stop assumes that the target handles adding new threads
+ to the thread list. */
+ internal_error (__FILE__, __LINE__, "\
+targets should add new threads to the thread list themselves in non-stop mode.");
+
+ /* We may want to consider not doing a resume here in order to
+ give the user a chance to play with the new thread. It might
+ be good to make that a user-settable option. */
+
+ /* At this point, all threads are stopped (happens automatically
+ in either the OS or the native code). Therefore we need to
+ continue all threads in order to make progress. */
+
target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0);
prepare_to_wait (ecs);
return;
/* Do we need to clean up the state of a thread that has completed a
displaced single-step? (Doing so usually affects the PC, so do
it here, before we set stop_pc.) */
- displaced_step_fixup (ecs->ptid, stop_signal);
+ if (ecs->ws.kind == TARGET_WAITKIND_STOPPED)
+ displaced_step_fixup (ecs->ptid, ecs->event_thread->stop_signal);
stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
/* We've either finished single-stepping past the single-step
breakpoint, or stopped for some other reason. It would be nice if
we could tell, but we can't reliably. */
- if (stop_signal == TARGET_SIGNAL_TRAP)
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepping_past_singlestep_breakpoint\n");
ecs->random_signal = 0;
- ecs->ptid = saved_singlestep_ptid;
- context_switch (ecs);
+ context_switch (saved_singlestep_ptid);
if (deprecated_context_hook)
deprecated_context_hook (pid_to_thread_id (ecs->ptid));
if (!ptid_equal (deferred_step_ptid, null_ptid))
{
+ /* In non-stop mode, there's never a deferred_step_ptid set. */
+ gdb_assert (!non_stop);
+
/* If we stopped for some other reason than single-stepping, ignore
the fact that we were supposed to switch back. */
- if (stop_signal == TARGET_SIGNAL_TRAP)
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP)
{
+ struct thread_info *tp;
+
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog,
"infrun: handling deferred step\n");
another thread. If so, then step that thread past the breakpoint,
and continue it. */
- if (stop_signal == TARGET_SIGNAL_TRAP)
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP)
{
int thread_hop_needed = 0;
if (new_singlestep_pc != singlestep_pc)
{
+ enum target_signal stop_signal;
+
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: unexpected thread,"
" but expected thread advanced also\n");
singlestep_ptid. Don't swap here, since that's
the context we want to use. Just fudge our
state and continue. */
+ stop_signal = ecs->event_thread->stop_signal;
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
ecs->ptid = singlestep_ptid;
+ ecs->event_thread = find_thread_pid (ecs->ptid);
+ ecs->event_thread->stop_signal = stop_signal;
stop_pc = new_singlestep_pc;
}
else
else
{ /* Single step */
if (!ptid_equal (inferior_ptid, ecs->ptid))
- context_switch (ecs);
- ecs->waiton_ptid = ecs->ptid;
- ecs->wp = &(ecs->ws);
- ecs->stepping_over_breakpoint = 1;
+ context_switch (ecs->ptid);
+
+ if (!non_stop)
+ {
+ /* Only need to require the next event from this
+ thread in all-stop mode. */
+ waiton_ptid = ecs->ptid;
+ infwait_state = infwait_thread_hop_state;
+ }
- ecs->infwait_state = infwait_thread_hop_state;
+ ecs->event_thread->stepping_over_breakpoint = 1;
keep_going (ecs);
registers_changed ();
return;
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
- context_switch (ecs);
+ context_switch (ecs->ptid);
if (deprecated_context_hook)
deprecated_context_hook (pid_to_thread_id (ecs->ptid));
remove_breakpoints ();
registers_changed ();
target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */
- ecs->waiton_ptid = ecs->ptid;
+ waiton_ptid = ecs->ptid;
if (HAVE_STEPPABLE_WATCHPOINT)
- ecs->infwait_state = infwait_step_watch_state;
+ infwait_state = infwait_step_watch_state;
else
- ecs->infwait_state = infwait_nonstep_watch_state;
+ infwait_state = infwait_nonstep_watch_state;
prepare_to_wait (ecs);
return;
}
&ecs->stop_func_start, &ecs->stop_func_end);
ecs->stop_func_start
+= gdbarch_deprecated_function_start_offset (current_gdbarch);
- ecs->stepping_over_breakpoint = 0;
- bpstat_clear (&stop_bpstat);
- stop_step = 0;
+ ecs->event_thread->stepping_over_breakpoint = 0;
+ bpstat_clear (&ecs->event_thread->stop_bpstat);
+ ecs->event_thread->stop_step = 0;
stop_print_frame = 1;
ecs->random_signal = 0;
stopped_by_random_signal = 0;
- if (stop_signal == TARGET_SIGNAL_TRAP
- && stepping_over_breakpoint
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP
+ && ecs->event_thread->trap_expected
&& gdbarch_single_step_through_delay_p (current_gdbarch)
- && currently_stepping (ecs))
+ && currently_stepping (ecs->event_thread))
{
/* We're trying to step off a breakpoint. Turns out that we're
also on an instruction that needs to be stepped multiple
get_current_frame ());
if (debug_infrun && step_through_delay)
fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
- if (step_range_end == 0 && step_through_delay)
+ if (ecs->event_thread->step_range_end == 0 && step_through_delay)
{
/* The user issued a continue when stopped at a breakpoint.
Set up for another trap and get out of here. */
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->stepping_over_breakpoint = 1;
keep_going (ecs);
return;
}
case, don't decide that here, just set
ecs->stepping_over_breakpoint, making sure we
single-step again before breakpoints are re-inserted. */
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->stepping_over_breakpoint = 1;
}
}
/* Look at the cause of the stop, and decide what to do.
The alternatives are:
- 1) break; to really stop and return to the debugger,
- 2) drop through to start up again
- (set ecs->stepping_over_breakpoint to 1 to single step once)
+ 1) stop_stepping and return; to really stop and return to the debugger,
+ 2) keep_going and return to start up again
+ (set ecs->event_thread->stepping_over_breakpoint to 1 to single step once)
3) set ecs->random_signal to 1, and the decision between 1 and 2
will be made according to the signal handling tables. */
If we're doing a displaced step past a breakpoint, then the
breakpoint is always inserted at the original instruction;
non-standard signals can't be explained by the breakpoint. */
- if (stop_signal == TARGET_SIGNAL_TRAP
- || (! stepping_over_breakpoint
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP
+ || (! ecs->event_thread->trap_expected
&& breakpoint_inserted_here_p (stop_pc)
- && (stop_signal == TARGET_SIGNAL_ILL
- || stop_signal == TARGET_SIGNAL_SEGV
- || stop_signal == TARGET_SIGNAL_EMT))
+ && (ecs->event_thread->stop_signal == TARGET_SIGNAL_ILL
+ || ecs->event_thread->stop_signal == TARGET_SIGNAL_SEGV
+ || ecs->event_thread->stop_signal == TARGET_SIGNAL_EMT))
|| stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_NO_SIGSTOP
|| stop_soon == STOP_QUIETLY_REMOTE)
{
- if (stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap)
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
}
/* This originates from attach_command(). We need to overwrite
- the stop_signal here, because some kernels don't ignore a
- SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
- See more comments in inferior.h. On the other hand, if we
+ the stop_signal here, because some kernels don't ignore a
+ SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
+ See more comments in inferior.h. On the other hand, if we
get a non-SIGSTOP, report it to the user - assume the backend
- will handle the SIGSTOP if it should show up later. */
+ will handle the SIGSTOP if it should show up later.
+
+ Also consider that the attach is complete when we see a
+ SIGTRAP. Some systems (e.g. Windows), and stubs supporting
+ target extended-remote report it instead of a SIGSTOP
+ (e.g. gdbserver). We already rely on SIGTRAP being our
+ signal, so this is no exception. */
if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
- && stop_signal == TARGET_SIGNAL_STOP)
+ && (ecs->event_thread->stop_signal == TARGET_SIGNAL_STOP
+ || ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP))
{
stop_stepping (ecs);
- stop_signal = TARGET_SIGNAL_0;
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
return;
}
/* See if there is a breakpoint at the current PC. */
- stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
+ ecs->event_thread->stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
/* Following in case break condition called a
function. */
be necessary for call dummies on a non-executable stack on
SPARC. */
- if (stop_signal == TARGET_SIGNAL_TRAP)
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP)
ecs->random_signal
- = !(bpstat_explains_signal (stop_bpstat)
- || stepping_over_breakpoint
- || (step_range_end && step_resume_breakpoint == NULL));
+ = !(bpstat_explains_signal (ecs->event_thread->stop_bpstat)
+ || ecs->event_thread->trap_expected
+ || (ecs->event_thread->step_range_end
+ && ecs->event_thread->step_resume_breakpoint == NULL));
else
{
- ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
+ ecs->random_signal = !bpstat_explains_signal (ecs->event_thread->stop_bpstat);
if (!ecs->random_signal)
- stop_signal = TARGET_SIGNAL_TRAP;
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_TRAP;
}
}
int printed = 0;
if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "infrun: random signal %d\n", stop_signal);
+ fprintf_unfiltered (gdb_stdlog, "infrun: random signal %d\n",
+ ecs->event_thread->stop_signal);
stopped_by_random_signal = 1;
- if (signal_print[stop_signal])
+ if (signal_print[ecs->event_thread->stop_signal])
{
printed = 1;
target_terminal_ours_for_output ();
- print_stop_reason (SIGNAL_RECEIVED, stop_signal);
+ print_stop_reason (SIGNAL_RECEIVED, ecs->event_thread->stop_signal);
}
- if (signal_stop_state (stop_signal))
+ if (signal_stop_state (ecs->event_thread->stop_signal))
{
stop_stepping (ecs);
return;
target_terminal_inferior ();
/* Clear the signal if it should not be passed. */
- if (signal_program[stop_signal] == 0)
- stop_signal = TARGET_SIGNAL_0;
+ if (signal_program[ecs->event_thread->stop_signal] == 0)
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
- if (prev_pc == read_pc ()
- && stepping_over_breakpoint
- && step_resume_breakpoint == NULL)
+ if (ecs->event_thread->prev_pc == read_pc ()
+ && ecs->event_thread->trap_expected
+ && ecs->event_thread->step_resume_breakpoint == NULL)
{
/* We were just starting a new sequence, attempting to
single-step off of a breakpoint and expecting a SIGTRAP.
"breakpoint\n");
insert_step_resume_breakpoint_at_frame (get_current_frame ());
- ecs->step_after_step_resume_breakpoint = 1;
+ ecs->event_thread->step_after_step_resume_breakpoint = 1;
keep_going (ecs);
return;
}
- if (step_range_end != 0
- && stop_signal != TARGET_SIGNAL_0
- && stop_pc >= step_range_start && stop_pc < step_range_end
+ if (ecs->event_thread->step_range_end != 0
+ && ecs->event_thread->stop_signal != TARGET_SIGNAL_0
+ && (ecs->event_thread->step_range_start <= stop_pc
+ && stop_pc < ecs->event_thread->step_range_end)
&& frame_id_eq (get_frame_id (get_current_frame ()),
- step_frame_id)
- && step_resume_breakpoint == NULL)
+ ecs->event_thread->step_frame_id)
+ && ecs->event_thread->step_resume_breakpoint == NULL)
{
/* The inferior is about to take a signal that will take it
out of the single step range. Set a breakpoint at the
CORE_ADDR jmp_buf_pc;
struct bpstat_what what;
- what = bpstat_what (stop_bpstat);
+ what = bpstat_what (ecs->event_thread->stop_bpstat);
if (what.call_dummy)
{
fprintf_unfiltered (gdb_stdlog,
"infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->stepping_over_breakpoint = 1;
if (!gdbarch_get_longjmp_target_p (current_gdbarch)
|| !gdbarch_get_longjmp_target (current_gdbarch,
/* We're going to replace the current step-resume breakpoint
with a longjmp-resume breakpoint. */
- if (step_resume_breakpoint != NULL)
- delete_step_resume_breakpoint (&step_resume_breakpoint);
+ delete_step_resume_breakpoint (ecs->event_thread);
/* Insert a breakpoint at resume address. */
insert_longjmp_resume_breakpoint (jmp_buf_pc);
fprintf_unfiltered (gdb_stdlog,
"infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
- gdb_assert (step_resume_breakpoint != NULL);
- delete_step_resume_breakpoint (&step_resume_breakpoint);
+ gdb_assert (ecs->event_thread->step_resume_breakpoint != NULL);
+ delete_step_resume_breakpoint (ecs->event_thread);
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
case BPSTAT_WHAT_SINGLE:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
- ecs->stepping_over_breakpoint = 1;
+ 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;
return;
case BPSTAT_WHAT_STEP_RESUME:
- /* This proably demands a more elegant solution, but, yeah
- right...
-
- This function's use of the simple variable
- step_resume_breakpoint doesn't seem to accomodate
- simultaneously active step-resume bp's, although the
- breakpoint list certainly can.
-
- If we reach here and step_resume_breakpoint is already
- NULL, then apparently we have multiple active
- step-resume bp's. We'll just delete the breakpoint we
- stopped at, and carry on.
-
- Correction: what the code currently does is delete a
- step-resume bp, but it makes no effort to ensure that
- the one deleted is the one currently stopped at. MVS */
-
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
- if (step_resume_breakpoint == NULL)
- {
- step_resume_breakpoint =
- bpstat_find_step_resume_breakpoint (stop_bpstat);
- }
- delete_step_resume_breakpoint (&step_resume_breakpoint);
- if (ecs->step_after_step_resume_breakpoint)
+ delete_step_resume_breakpoint (ecs->event_thread);
+ if (ecs->event_thread->step_after_step_resume_breakpoint)
{
/* Back when the step-resume breakpoint was inserted, we
were trying to single-step off a breakpoint. Go back
to doing that. */
- ecs->step_after_step_resume_breakpoint = 0;
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->step_after_step_resume_breakpoint = 0;
+ ecs->event_thread->stepping_over_breakpoint = 1;
keep_going (ecs);
return;
}
code or stubs in libdld.sl, such as "shl_load" and
friends) until we reach non-dld code. At that point,
we can stop stepping. */
- bpstat_get_triggered_catchpoints (stop_bpstat,
+ bpstat_get_triggered_catchpoints (ecs->event_thread->stop_bpstat,
&ecs->
+ event_thread->
stepping_through_solib_catchpoints);
- ecs->stepping_through_solib_after_catch = 1;
+ ecs->event_thread->stepping_through_solib_after_catch = 1;
/* Be sure to lift all breakpoints, so the inferior does
actually step past this point... */
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->stepping_over_breakpoint = 1;
break;
}
else
{
/* We want to step over this breakpoint, then keep going. */
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->stepping_over_breakpoint = 1;
break;
}
}
/* Are we stepping to get the inferior out of the dynamic linker's
hook (and possibly the dld itself) after catching a shlib
event? */
- if (ecs->stepping_through_solib_after_catch)
+ if (ecs->event_thread->stepping_through_solib_after_catch)
{
#if defined(SOLIB_ADD)
/* Have we reached our destination? If not, keep going. */
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepping in dynamic linker\n");
- ecs->stepping_over_breakpoint = 1;
+ ecs->event_thread->stepping_over_breakpoint = 1;
keep_going (ecs);
return;
}
fprintf_unfiltered (gdb_stdlog, "infrun: step past dynamic linker\n");
/* Else, stop and report the catchpoint(s) whose triggering
caused us to begin stepping. */
- ecs->stepping_through_solib_after_catch = 0;
- bpstat_clear (&stop_bpstat);
- stop_bpstat = bpstat_copy (ecs->stepping_through_solib_catchpoints);
- bpstat_clear (&ecs->stepping_through_solib_catchpoints);
+ ecs->event_thread->stepping_through_solib_after_catch = 0;
+ bpstat_clear (&ecs->event_thread->stop_bpstat);
+ ecs->event_thread->stop_bpstat
+ = bpstat_copy (ecs->event_thread->stepping_through_solib_catchpoints);
+ bpstat_clear (&ecs->event_thread->stepping_through_solib_catchpoints);
stop_print_frame = 1;
stop_stepping (ecs);
return;
}
- if (step_resume_breakpoint)
+ if (ecs->event_thread->step_resume_breakpoint)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog,
return;
}
- if (step_range_end == 0)
+ if (ecs->event_thread->step_range_end == 0)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
Note that step_range_end is the address of the first instruction
beyond the step range, and NOT the address of the last instruction
within it! */
- if (stop_pc >= step_range_start && stop_pc < step_range_end)
+ if (stop_pc >= ecs->event_thread->step_range_start
+ && stop_pc < ecs->event_thread->step_range_end)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepping inside range [0x%s-0x%s]\n",
- paddr_nz (step_range_start),
- paddr_nz (step_range_end));
+ paddr_nz (ecs->event_thread->step_range_start),
+ paddr_nz (ecs->event_thread->step_range_end));
keep_going (ecs);
return;
}
loader dynamic symbol resolution code, we keep on single stepping
until we exit the run time loader code and reach the callee's
address. */
- if (step_over_calls == STEP_OVER_UNDEBUGGABLE
-#ifdef IN_SOLIB_DYNSYM_RESOLVE_CODE
- && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc)
-#else
- && in_solib_dynsym_resolve_code (stop_pc)
-#endif
- )
+ if (ecs->event_thread->step_over_calls == STEP_OVER_UNDEBUGGABLE
+ && in_solib_dynsym_resolve_code (stop_pc))
{
CORE_ADDR pc_after_resolver =
gdbarch_skip_solib_resolver (current_gdbarch, stop_pc);
return;
}
- if (step_range_end != 1
- && (step_over_calls == STEP_OVER_UNDEBUGGABLE
- || step_over_calls == STEP_OVER_ALL)
+ if (ecs->event_thread->step_range_end != 1
+ && (ecs->event_thread->step_over_calls == STEP_OVER_UNDEBUGGABLE
+ || ecs->event_thread->step_over_calls == STEP_OVER_ALL)
&& get_frame_type (get_current_frame ()) == SIGTRAMP_FRAME)
{
if (debug_infrun)
NOTE: frame_id_eq will never report two invalid frame IDs as
being equal, so to get into this block, both the current and
previous frame must have valid frame IDs. */
- if (!frame_id_eq (get_frame_id (get_current_frame ()), step_frame_id)
- && frame_id_eq (frame_unwind_id (get_current_frame ()), step_frame_id))
+ if (!frame_id_eq (get_frame_id (get_current_frame ()),
+ ecs->event_thread->step_frame_id)
+ && frame_id_eq (frame_unwind_id (get_current_frame ()),
+ ecs->event_thread->step_frame_id))
{
CORE_ADDR real_stop_pc;
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
- if ((step_over_calls == STEP_OVER_NONE)
- || ((step_range_end == 1)
- && in_prologue (prev_pc, ecs->stop_func_start)))
+ if ((ecs->event_thread->step_over_calls == STEP_OVER_NONE)
+ || ((ecs->event_thread->step_range_end == 1)
+ && in_prologue (ecs->event_thread->prev_pc,
+ ecs->stop_func_start)))
{
/* I presume that step_over_calls is only 0 when we're
supposed to be stepping at the assembly language level
/* Also, maybe we just did a "nexti" inside a prolog, so we
thought it was a subroutine call but it was not. Stop as
well. FENN */
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
}
- if (step_over_calls == STEP_OVER_ALL)
+ if (ecs->event_thread->step_over_calls == STEP_OVER_ALL)
{
/* We're doing a "next", set a breakpoint at callee's return
address (the address at which the caller will
if (real_stop_pc != 0)
ecs->stop_func_start = real_stop_pc;
- if (
-#ifdef IN_SOLIB_DYNSYM_RESOLVE_CODE
- IN_SOLIB_DYNSYM_RESOLVE_CODE (ecs->stop_func_start)
-#else
- in_solib_dynsym_resolve_code (ecs->stop_func_start)
-#endif
-)
+ if (in_solib_dynsym_resolve_code (ecs->stop_func_start))
{
struct symtab_and_line sr_sal;
init_sal (&sr_sal);
/* If we have no line number and the step-stop-if-no-debug is
set, we stop the step so that the user has a chance to switch
in assembly mode. */
- if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug)
+ if (ecs->event_thread->step_over_calls == STEP_OVER_UNDEBUGGABLE
+ && step_stop_if_no_debug)
{
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
}
}
- ecs->sal = find_pc_line (stop_pc, 0);
+ stop_pc_sal = find_pc_line (stop_pc, 0);
/* NOTE: tausq/2004-05-24: This if block used to be done before all
the trampoline processing logic, however, there are some trampolines
that have no names, so we should do trampoline handling first. */
- if (step_over_calls == STEP_OVER_UNDEBUGGABLE
+ if (ecs->event_thread->step_over_calls == STEP_OVER_UNDEBUGGABLE
&& ecs->stop_func_name == NULL
- && ecs->sal.line == 0)
+ && stop_pc_sal.line == 0)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped into undebuggable function\n");
/* If we have no line number and the step-stop-if-no-debug
is set, we stop the step so that the user has a chance to
switch in assembly mode. */
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
}
}
- if (step_range_end == 1)
+ if (ecs->event_thread->step_range_end == 1)
{
/* 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");
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
}
- if (ecs->sal.line == 0)
+ if (stop_pc_sal.line == 0)
{
/* We have no line number information. That means to stop
stepping (does this always happen right after one instruction,
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");
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
}
- if ((stop_pc == ecs->sal.pc)
- && (ecs->current_line != ecs->sal.line
- || ecs->current_symtab != ecs->sal.symtab))
+ if ((stop_pc == stop_pc_sal.pc)
+ && (ecs->event_thread->current_line != stop_pc_sal.line
+ || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
{
/* We are at the start of a different line. So stop. Note that
we don't stop if we step into the middle of a different line.
better. */
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped to a different line\n");
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
new line in mid-statement, we continue stepping. This makes
things like for(;;) statements work better.) */
- step_range_start = ecs->sal.pc;
- step_range_end = ecs->sal.end;
- step_frame_id = get_frame_id (get_current_frame ());
- ecs->current_line = ecs->sal.line;
- ecs->current_symtab = ecs->sal.symtab;
-
- /* In the case where we just stepped out of a function into the
- middle of a line of the caller, continue stepping, but
- step_frame_id must be modified to current frame */
-#if 0
- /* NOTE: cagney/2003-10-16: I think this frame ID inner test is too
- generous. It will trigger on things like a step into a frameless
- stackless leaf function. I think the logic should instead look
- at the unwound frame ID has that should give a more robust
- indication of what happened. */
- if (step - ID == current - ID)
- still stepping in same function;
- else if (step - ID == unwind (current - ID))
- stepped into a function;
- else
- stepped out of a function;
- /* Of course this assumes that the frame ID unwind code is robust
- and we're willing to introduce frame unwind logic into this
- function. Fortunately, those days are nearly upon us. */
-#endif
- {
- struct frame_info *frame = get_current_frame ();
- struct frame_id current_frame = get_frame_id (frame);
- if (!(frame_id_inner (get_frame_arch (frame), current_frame,
- step_frame_id)))
- step_frame_id = current_frame;
- }
+ ecs->event_thread->step_range_start = stop_pc_sal.pc;
+ ecs->event_thread->step_range_end = stop_pc_sal.end;
+ ecs->event_thread->step_frame_id = get_frame_id (get_current_frame ());
+ ecs->event_thread->current_line = stop_pc_sal.line;
+ ecs->event_thread->current_symtab = stop_pc_sal.symtab;
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
/* Are we in the middle of stepping? */
static int
-currently_stepping (struct execution_control_state *ecs)
+currently_stepping (struct thread_info *tp)
{
- return (((step_range_end && step_resume_breakpoint == NULL)
- || stepping_over_breakpoint)
- || ecs->stepping_through_solib_after_catch
+ return (((tp->step_range_end && tp->step_resume_breakpoint == NULL)
+ || tp->trap_expected)
+ || tp->stepping_through_solib_after_catch
|| bpstat_should_step ());
}
step_into_function (struct execution_control_state *ecs)
{
struct symtab *s;
- struct symtab_and_line sr_sal;
+ struct symtab_and_line stop_func_sal, sr_sal;
s = find_pc_symtab (stop_pc);
if (s && s->language != language_asm)
ecs->stop_func_start = gdbarch_skip_prologue
(current_gdbarch, ecs->stop_func_start);
- ecs->sal = find_pc_line (ecs->stop_func_start, 0);
+ stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
/* Use the step_resume_break to step until the end of the prologue,
even if that involves jumps (as it seems to on the vax under
4.2). */
/* If the prologue ends in the middle of a source line, continue to
the end of that source line (if it is still within the function).
Otherwise, just go to end of prologue. */
- if (ecs->sal.end
- && ecs->sal.pc != ecs->stop_func_start
- && ecs->sal.end < ecs->stop_func_end)
- ecs->stop_func_start = ecs->sal.end;
+ if (stop_func_sal.end
+ && stop_func_sal.pc != ecs->stop_func_start
+ && stop_func_sal.end < ecs->stop_func_end)
+ ecs->stop_func_start = stop_func_sal.end;
/* Architectures which require breakpoint adjustment might not be able
to place a breakpoint at the computed address. If so, the test
if (ecs->stop_func_start == stop_pc)
{
/* We are already there: stop now. */
- stop_step = 1;
+ ecs->event_thread->stop_step = 1;
print_stop_reason (END_STEPPING_RANGE, 0);
stop_stepping (ecs);
return;
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id);
/* And make sure stepping stops right away then. */
- step_range_end = step_range_start;
+ ecs->event_thread->step_range_end = ecs->event_thread->step_range_start;
}
keep_going (ecs);
}
/* There should never be more than one step-resume or longjmp-resume
breakpoint per thread, so we should never be setting a new
step_resume_breakpoint when one is already active. */
- gdb_assert (step_resume_breakpoint == NULL);
+ gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog,
"infrun: inserting step-resume breakpoint at 0x%s\n",
paddr_nz (sr_sal.pc));
- step_resume_breakpoint = set_momentary_breakpoint (sr_sal, sr_id,
- bp_step_resume);
+ inferior_thread ()->step_resume_breakpoint
+ = set_momentary_breakpoint (sr_sal, sr_id, bp_step_resume);
}
/* Insert a "step-resume breakpoint" at RETURN_FRAME.pc. This is used
/* There should never be more than one step-resume or longjmp-resume
breakpoint per thread, so we should never be setting a new
longjmp_resume_breakpoint when one is already active. */
- gdb_assert (step_resume_breakpoint == NULL);
+ gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog,
"infrun: inserting longjmp-resume breakpoint at 0x%s\n",
paddr_nz (pc));
- step_resume_breakpoint =
+ inferior_thread ()->step_resume_breakpoint =
set_momentary_breakpoint_at_pc (pc, bp_longjmp_resume);
}
keep_going (struct execution_control_state *ecs)
{
/* Save the pc before execution, to compare with pc after stop. */
- prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */
+ ecs->event_thread->prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */
/* If we did not do break;, it means we should keep running the
inferior and not return to debugger. */
- if (stepping_over_breakpoint && stop_signal != TARGET_SIGNAL_TRAP)
+ if (ecs->event_thread->trap_expected
+ && ecs->event_thread->stop_signal != TARGET_SIGNAL_TRAP)
{
/* We took a signal (which we are supposed to pass through to
- the inferior, else we'd have done a break above) and we
- haven't yet gotten our trap. Simply continue. */
- resume (currently_stepping (ecs), stop_signal);
+ the inferior, else we'd not get here) and we haven't yet
+ gotten our trap. Simply continue. */
+ resume (currently_stepping (ecs->event_thread),
+ ecs->event_thread->stop_signal);
}
else
{
already inserted breakpoints. Therefore, we don't
care if breakpoints were already inserted, or not. */
- if (ecs->stepping_over_breakpoint)
+ if (ecs->event_thread->stepping_over_breakpoint)
{
if (! use_displaced_stepping (current_gdbarch))
/* Since we can't do a displaced step, we have to remove
}
}
- stepping_over_breakpoint = ecs->stepping_over_breakpoint;
+ ecs->event_thread->trap_expected = ecs->event_thread->stepping_over_breakpoint;
/* Do not deliver SIGNAL_TRAP (except when the user explicitly
specifies that such a signal should be delivered to the
simulator; the simulator then delivers the hardware
equivalent of a SIGNAL_TRAP to the program being debugged. */
- if (stop_signal == TARGET_SIGNAL_TRAP && !signal_program[stop_signal])
- stop_signal = TARGET_SIGNAL_0;
+ if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP
+ && !signal_program[ecs->event_thread->stop_signal])
+ ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
-
- resume (currently_stepping (ecs), stop_signal);
+ resume (currently_stepping (ecs->event_thread),
+ ecs->event_thread->stop_signal);
}
prepare_to_wait (ecs);
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
- if (ecs->infwait_state == infwait_normal_state)
+ if (infwait_state == infwait_normal_state)
{
overlay_cache_invalid = 1;
as part of their normal status mechanism. */
registers_changed ();
- ecs->waiton_ptid = pid_to_ptid (-1);
- ecs->wp = &(ecs->ws);
+ waiton_ptid = pid_to_ptid (-1);
}
/* This is the old end of the while loop. Let everybody know we
want to wait for the inferior some more and get called again
/* For now print nothing. */
/* Print a message only if not in the middle of doing a "step n"
operation for n > 1 */
- if (!step_multi || !stop_step)
+ if (!inferior_thread ()->step_multi
+ || !inferior_thread ()->stop_step)
if (ui_out_is_mi_like_p (uiout))
ui_out_field_string
(uiout, "reason",
get_last_target_status (&last_ptid, &last);
+ /* In non-stop mode, we don't want GDB to switch threads behind the
+ user's back, to avoid races where the user is typing a command to
+ apply to thread x, but GDB switches to thread y before the user
+ finishes entering the command. */
+
/* As with the notification of thread events, we want to delay
notifying the user that we've switched thread context until
the inferior actually stops.
There's no point in saying anything if the inferior has exited.
Note that SIGNALLED here means "exited with a signal", not
"received a signal". */
- if (!ptid_equal (previous_inferior_ptid, inferior_ptid)
+ if (!non_stop
+ && !ptid_equal (previous_inferior_ptid, inferior_ptid)
&& target_has_execution
&& last.kind != TARGET_WAITKIND_SIGNALLED
&& last.kind != TARGET_WAITKIND_EXITED)
/* Don't print a message if in the middle of doing a "step n"
operation for n > 1 */
- if (step_multi && stop_step)
+ if (target_has_execution
+ && last.kind != TARGET_WAITKIND_SIGNALLED
+ && last.kind != TARGET_WAITKIND_EXITED
+ && inferior_thread ()->step_multi
+ && inferior_thread ()->stop_step)
goto done;
target_terminal_ours ();
if (target_has_stack && !stop_stack_dummy)
set_current_sal_from_frame (get_current_frame (), 1);
- /* Look up the hook_stop and run it (CLI internally handles problem
- of stop_command's pre-hook not existing). */
- if (stop_command)
- catch_errors (hook_stop_stub, stop_command,
- "Error while running hook_stop:\n", RETURN_MASK_ALL);
-
if (!target_has_stack)
- {
+ goto done;
- goto done;
- }
+ if (last.kind == TARGET_WAITKIND_SIGNALLED
+ || last.kind == TARGET_WAITKIND_EXITED)
+ goto done;
/* Select innermost stack frame - i.e., current frame is frame 0,
and current location is based on that.
int bpstat_ret;
int source_flag;
int do_frame_printing = 1;
+ struct thread_info *tp = inferior_thread ();
- bpstat_ret = bpstat_print (stop_bpstat);
+ bpstat_ret = bpstat_print (tp->stop_bpstat);
switch (bpstat_ret)
{
case PRINT_UNKNOWN:
/* FIXME: cagney/2002-12-01: Given that a frame ID does
(or should) carry around the function and does (or
should) use that when doing a frame comparison. */
- if (stop_step
- && frame_id_eq (step_frame_id,
+ if (tp->stop_step
+ && frame_id_eq (tp->step_frame_id,
get_frame_id (get_current_frame ()))
&& step_start_function == find_pc_function (stop_pc))
source_flag = SRC_LINE; /* finished step, just print source line */
}
if (ui_out_is_mi_like_p (uiout))
- ui_out_field_int (uiout, "thread-id",
- pid_to_thread_id (inferior_ptid));
+ {
+
+ ui_out_field_int (uiout, "thread-id",
+ pid_to_thread_id (inferior_ptid));
+ if (non_stop)
+ {
+ struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
+ (uiout, "stopped-threads");
+ ui_out_field_int (uiout, NULL,
+ pid_to_thread_id (inferior_ptid));
+ do_cleanups (back_to);
+ }
+ else
+ ui_out_field_string (uiout, "stopped-threads", "all");
+ }
/* The behavior of this routine with respect to the source
flag is:
SRC_LINE: Print only source line
/* Save the function value return registers, if we care.
We might be about to restore their previous contents. */
- if (proceed_to_finish)
+ if (inferior_thread ()->proceed_to_finish)
{
/* This should not be necessary. */
if (stop_registers)
done:
annotate_stopped ();
- if (!suppress_stop_observer && !step_multi)
- observer_notify_normal_stop (stop_bpstat);
- /* Delete the breakpoint we stopped at, if it wants to be deleted.
- Delete any breakpoint that is to be deleted at the next stop. */
- breakpoint_auto_delete (stop_bpstat);
- set_running (pid_to_ptid (-1), 0);
+ if (!suppress_stop_observer
+ && !(target_has_execution
+ && last.kind != TARGET_WAITKIND_SIGNALLED
+ && last.kind != TARGET_WAITKIND_EXITED
+ && inferior_thread ()->step_multi))
+ {
+ if (!ptid_equal (inferior_ptid, null_ptid))
+ observer_notify_normal_stop (inferior_thread ()->stop_bpstat);
+ else
+ observer_notify_normal_stop (NULL);
+ }
+ if (target_has_execution
+ && last.kind != TARGET_WAITKIND_SIGNALLED
+ && last.kind != TARGET_WAITKIND_EXITED)
+ {
+ /* Delete the breakpoint we stopped at, if it wants to be deleted.
+ Delete any breakpoint that is to be deleted at the next stop. */
+ breakpoint_auto_delete (inferior_thread ()->stop_bpstat);
+
+ if (!non_stop)
+ set_running (pid_to_ptid (-1), 0);
+ else
+ set_running (inferior_ptid, 0);
+ }
+
+ /* Look up the hook_stop and run it (CLI internally handles problem
+ of stop_command's pre-hook not existing). */
+ if (stop_command)
+ catch_errors (hook_stop_stub, stop_command,
+ "Error while running hook_stop:\n", RETURN_MASK_ALL);
+
}
static int
save_inferior_status (int restore_stack_info)
{
struct inferior_status *inf_status = XMALLOC (struct inferior_status);
+ struct thread_info *tp = inferior_thread ();
- inf_status->stop_signal = stop_signal;
+ inf_status->stop_signal = tp->stop_signal;
inf_status->stop_pc = stop_pc;
- inf_status->stop_step = stop_step;
+ inf_status->stop_step = tp->stop_step;
inf_status->stop_stack_dummy = stop_stack_dummy;
inf_status->stopped_by_random_signal = stopped_by_random_signal;
- inf_status->stepping_over_breakpoint = stepping_over_breakpoint;
- inf_status->step_range_start = step_range_start;
- inf_status->step_range_end = step_range_end;
- inf_status->step_frame_id = step_frame_id;
- inf_status->step_over_calls = step_over_calls;
+ inf_status->stepping_over_breakpoint = tp->trap_expected;
+ inf_status->step_range_start = tp->step_range_start;
+ inf_status->step_range_end = tp->step_range_end;
+ inf_status->step_frame_id = tp->step_frame_id;
+ inf_status->step_over_calls = tp->step_over_calls;
inf_status->stop_after_trap = stop_after_trap;
inf_status->stop_soon = stop_soon;
/* Save original bpstat chain here; replace it with copy of chain.
If caller's caller is walking the chain, they'll be happier if we
hand them back the original chain when restore_inferior_status is
called. */
- inf_status->stop_bpstat = stop_bpstat;
- stop_bpstat = bpstat_copy (stop_bpstat);
+ inf_status->stop_bpstat = tp->stop_bpstat;
+ tp->stop_bpstat = bpstat_copy (tp->stop_bpstat);
inf_status->breakpoint_proceeded = breakpoint_proceeded;
inf_status->restore_stack_info = restore_stack_info;
- inf_status->proceed_to_finish = proceed_to_finish;
+ inf_status->proceed_to_finish = tp->proceed_to_finish;
inf_status->registers = regcache_dup (get_current_regcache ());
void
restore_inferior_status (struct inferior_status *inf_status)
{
- stop_signal = inf_status->stop_signal;
+ struct thread_info *tp = inferior_thread ();
+
+ tp->stop_signal = inf_status->stop_signal;
stop_pc = inf_status->stop_pc;
- stop_step = inf_status->stop_step;
+ tp->stop_step = inf_status->stop_step;
stop_stack_dummy = inf_status->stop_stack_dummy;
stopped_by_random_signal = inf_status->stopped_by_random_signal;
- stepping_over_breakpoint = inf_status->stepping_over_breakpoint;
- step_range_start = inf_status->step_range_start;
- step_range_end = inf_status->step_range_end;
- step_frame_id = inf_status->step_frame_id;
- step_over_calls = inf_status->step_over_calls;
+ tp->trap_expected = inf_status->stepping_over_breakpoint;
+ tp->step_range_start = inf_status->step_range_start;
+ tp->step_range_end = inf_status->step_range_end;
+ tp->step_frame_id = inf_status->step_frame_id;
+ tp->step_over_calls = inf_status->step_over_calls;
stop_after_trap = inf_status->stop_after_trap;
stop_soon = inf_status->stop_soon;
- bpstat_clear (&stop_bpstat);
- stop_bpstat = inf_status->stop_bpstat;
+ bpstat_clear (&tp->stop_bpstat);
+ tp->stop_bpstat = inf_status->stop_bpstat;
breakpoint_proceeded = inf_status->breakpoint_proceeded;
- proceed_to_finish = inf_status->proceed_to_finish;
+ tp->proceed_to_finish = inf_status->proceed_to_finish;
/* The inferior can be gone if the user types "print exit(0)"
(and perhaps other times). */
inferior_ptid = null_ptid;
target_last_wait_ptid = minus_one_ptid;
displaced_step_ptid = null_ptid;
+
+ observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
}