Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
#include "language.h"
#include "solib.h"
#include "main.h"
-
#include "gdb_assert.h"
#include "mi/mi-common.h"
#include "event-top.h"
+#include "record.h"
/* Prototypes for local functions */
static int currently_stepping (struct thread_info *tp);
-static int currently_stepping_callback (struct thread_info *tp, void *data);
+static int currently_stepping_or_nexting_callback (struct thread_info *tp,
+ void *data);
static void xdb_handle_command (char *args, int from_tty);
void _initialize_infrun (void);
+void nullify_last_target_wait_ptid (void);
+
/* When set, stop the 'step' command if we enter a function which has
no line number information. The normal behavior is that we step
over such function. */
int stop_after_trap;
-/* Save register contents here when about to pop a stack dummy frame,
- if-and-only-if proceed_to_finish is set.
+/* Save register contents here when executing a "finish" command or are
+ 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
values are returned in a register). */
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
- followed at the next resume of the inferior, and not
- immediately. */
-static struct
-{
- enum target_waitkind kind;
- struct
- {
- ptid_t parent_pid;
- ptid_t child_pid;
- }
- fork_event;
- char *execd_pathname;
-}
-pending_follow;
-
static const char follow_fork_mode_child[] = "child";
static const char follow_fork_mode_parent[] = "parent";
}
\f
+/* Tell the target to follow the fork we're stopped at. Returns true
+ if the inferior should be resumed; false, if the target for some
+ reason decided it's best not to resume. */
+
static int
follow_fork (void)
{
int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
+ int should_resume = 1;
+ struct thread_info *tp;
+
+ /* Copy user stepping state to the new inferior thread. FIXME: the
+ followed fork child thread should have a copy of most of the
+ parent thread structure's run control related fields, not just these.
+ Initialized to avoid "may be used uninitialized" warnings from gcc. */
+ struct breakpoint *step_resume_breakpoint = NULL;
+ CORE_ADDR step_range_start = 0;
+ CORE_ADDR step_range_end = 0;
+ struct frame_id step_frame_id = { 0 };
- return target_follow_fork (follow_child);
+ if (!non_stop)
+ {
+ ptid_t wait_ptid;
+ struct target_waitstatus wait_status;
+
+ /* Get the last target status returned by target_wait(). */
+ get_last_target_status (&wait_ptid, &wait_status);
+
+ /* If not stopped at a fork event, then there's nothing else to
+ do. */
+ if (wait_status.kind != TARGET_WAITKIND_FORKED
+ && wait_status.kind != TARGET_WAITKIND_VFORKED)
+ return 1;
+
+ /* Check if we switched over from WAIT_PTID, since the event was
+ reported. */
+ if (!ptid_equal (wait_ptid, minus_one_ptid)
+ && !ptid_equal (inferior_ptid, wait_ptid))
+ {
+ /* We did. Switch back to WAIT_PTID thread, to tell the
+ target to follow it (in either direction). We'll
+ afterwards refuse to resume, and inform the user what
+ happened. */
+ switch_to_thread (wait_ptid);
+ should_resume = 0;
+ }
+ }
+
+ tp = inferior_thread ();
+
+ /* If there were any forks/vforks that were caught and are now to be
+ followed, then do so now. */
+ switch (tp->pending_follow.kind)
+ {
+ case TARGET_WAITKIND_FORKED:
+ case TARGET_WAITKIND_VFORKED:
+ {
+ ptid_t parent, child;
+
+ /* If the user did a next/step, etc, over a fork call,
+ preserve the stepping state in the fork child. */
+ if (follow_child && should_resume)
+ {
+ step_resume_breakpoint
+ = clone_momentary_breakpoint (tp->step_resume_breakpoint);
+ step_range_start = tp->step_range_start;
+ step_range_end = tp->step_range_end;
+ step_frame_id = tp->step_frame_id;
+
+ /* For now, delete the parent's sr breakpoint, otherwise,
+ parent/child sr breakpoints are considered duplicates,
+ and the child version will not be installed. Remove
+ this when the breakpoints module becomes aware of
+ inferiors and address spaces. */
+ delete_step_resume_breakpoint (tp);
+ tp->step_range_start = 0;
+ tp->step_range_end = 0;
+ tp->step_frame_id = null_frame_id;
+ }
+
+ parent = inferior_ptid;
+ child = tp->pending_follow.value.related_pid;
+
+ /* Tell the target to do whatever is necessary to follow
+ either parent or child. */
+ if (target_follow_fork (follow_child))
+ {
+ /* Target refused to follow, or there's some other reason
+ we shouldn't resume. */
+ should_resume = 0;
+ }
+ else
+ {
+ /* This pending follow fork event is now handled, one way
+ or another. The previous selected thread may be gone
+ from the lists by now, but if it is still around, need
+ to clear the pending follow request. */
+ tp = find_thread_ptid (parent);
+ if (tp)
+ tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
+
+ /* This makes sure we don't try to apply the "Switched
+ over from WAIT_PID" logic above. */
+ nullify_last_target_wait_ptid ();
+
+ /* If we followed the child, switch to it... */
+ if (follow_child)
+ {
+ switch_to_thread (child);
+
+ /* ... and preserve the stepping state, in case the
+ user was stepping over the fork call. */
+ if (should_resume)
+ {
+ tp = inferior_thread ();
+ tp->step_resume_breakpoint = step_resume_breakpoint;
+ tp->step_range_start = step_range_start;
+ tp->step_range_end = step_range_end;
+ tp->step_frame_id = step_frame_id;
+ }
+ else
+ {
+ /* If we get here, it was because we're trying to
+ resume from a fork catchpoint, but, the user
+ has switched threads away from the thread that
+ forked. In that case, the resume command
+ issued is most likely not applicable to the
+ child, so just warn, and refuse to resume. */
+ warning (_("\
+Not resuming: switched threads before following fork child.\n"));
+ }
+
+ /* Reset breakpoints in the child as appropriate. */
+ follow_inferior_reset_breakpoints ();
+ }
+ else
+ switch_to_thread (parent);
+ }
+ }
+ break;
+ case TARGET_WAITKIND_SPURIOUS:
+ /* Nothing to follow. */
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ "Unexpected pending_follow.kind %d\n",
+ tp->pending_follow.kind);
+ break;
+ }
+
+ return should_resume;
}
void
th->step_range_start = 0;
th->step_range_end = 0;
+ /* The target reports the exec event to the main thread, even if
+ some other thread does the exec, and even if the main thread was
+ already stopped --- if debugging in non-stop mode, it's possible
+ the user had the main thread held stopped in the previous image
+ --- release it now. This is the same behavior as step-over-exec
+ with scheduler-locking on in all-stop mode. */
+ th->stop_requested = 0;
+
/* What is this a.out's name? */
printf_unfiltered (_("Executing new program: %s\n"), execd_pathname);
return (((can_use_displaced_stepping == can_use_displaced_stepping_auto
&& non_stop)
|| can_use_displaced_stepping == can_use_displaced_stepping_on)
- && gdbarch_displaced_step_copy_insn_p (gdbarch));
+ && gdbarch_displaced_step_copy_insn_p (gdbarch)
+ && !RECORD_IS_USED);
}
/* Clean out any stray displaced stepping state. */
}
static void
-cleanup_displaced_step_closure (void *ptr)
+displaced_step_clear_cleanup (void *ignore)
{
- struct displaced_step_closure *closure = ptr;
-
- gdbarch_displaced_step_free_closure (current_gdbarch, closure);
+ displaced_step_clear ();
}
/* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
/* We don't support the fully-simulated case at present. */
gdb_assert (closure);
- make_cleanup (cleanup_displaced_step_closure, closure);
+ /* Save the information we need to fix things up if the step
+ succeeds. */
+ displaced_step_ptid = ptid;
+ displaced_step_gdbarch = gdbarch;
+ displaced_step_closure = closure;
+ displaced_step_original = original;
+ displaced_step_copy = copy;
+
+ make_cleanup (displaced_step_clear_cleanup, 0);
/* Resume execution at the copy. */
regcache_write_pc (regcache, copy);
fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to 0x%s\n",
paddr_nz (copy));
- /* Save the information we need to fix things up if the step
- succeeds. */
- displaced_step_ptid = ptid;
- displaced_step_gdbarch = gdbarch;
- displaced_step_closure = closure;
- displaced_step_original = original;
- displaced_step_copy = copy;
return 1;
}
-static void
-displaced_step_clear_cleanup (void *ignore)
-{
- displaced_step_clear ();
-}
-
static void
write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
{
context_switch (ptid);
- actual_pc = read_pc ();
+ actual_pc = regcache_read_pc (get_thread_regcache (ptid));
if (breakpoint_here_p (actual_pc))
{
}
}
+/* True if execution commands resume all threads of all processes by
+ default; otherwise, resume only threads of the current inferior
+ process. */
+int sched_multi = 0;
+
+/* Try to setup for software single stepping over the specified location.
+ Return 1 if target_resume() should use hardware single step.
+
+ GDBARCH the current gdbarch.
+ PC the location to step over. */
+
+static int
+maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+ int hw_step = 1;
+
+ if (gdbarch_software_single_step_p (gdbarch)
+ && gdbarch_software_single_step (gdbarch, get_current_frame ()))
+ {
+ hw_step = 0;
+ /* Do not pull these breakpoints until after a `wait' in
+ `wait_for_inferior' */
+ singlestep_breakpoints_inserted_p = 1;
+ singlestep_ptid = inferior_ptid;
+ singlestep_pc = pc;
+ }
+ return hw_step;
+}
/* Resume the inferior, but allow a QUIT. This is useful if the user
wants to interrupt some lengthy single-stepping operation
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct thread_info *tp = inferior_thread ();
CORE_ADDR pc = regcache_read_pc (regcache);
+
QUIT;
if (debug_infrun)
}
}
- if (step && gdbarch_software_single_step_p (gdbarch))
- {
- /* Do it the hard way, w/temp breakpoints */
- if (gdbarch_software_single_step (gdbarch, get_current_frame ()))
- {
- /* ...and don't ask hardware to do it. */
- step = 0;
- /* and do not pull these breakpoints until after a `wait' in
- `wait_for_inferior' */
- singlestep_breakpoints_inserted_p = 1;
- singlestep_ptid = inferior_ptid;
- singlestep_pc = pc;
- }
- }
-
- /* If there were any forks/vforks/execs that were caught and are
- now to be followed, then do so. */
- switch (pending_follow.kind)
- {
- case TARGET_WAITKIND_FORKED:
- case TARGET_WAITKIND_VFORKED:
- pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
- if (follow_fork ())
- should_resume = 0;
- break;
-
- case TARGET_WAITKIND_EXECD:
- /* follow_exec is called as soon as the exec event is seen. */
- pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
- break;
-
- default:
- break;
- }
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
+ /* Do we need to do it the hard way, w/temp breakpoints? */
+ if (step)
+ step = maybe_software_singlestep (gdbarch, pc);
if (should_resume)
{
ptid_t resume_ptid;
- resume_ptid = RESUME_ALL; /* Default */
-
/* If STEP is set, it's a request to use hardware stepping
facilities. But in that case, we should never
use singlestep breakpoint. */
gdb_assert (!(singlestep_breakpoints_inserted_p && step));
+ /* Decide the set of threads to ask the target to resume. Start
+ by assuming everything will be resumed, than narrow the set
+ by applying increasingly restricting conditions. */
+
+ /* By default, resume all threads of all processes. */
+ resume_ptid = RESUME_ALL;
+
+ /* Maybe resume only all threads of the current process. */
+ if (!sched_multi && target_supports_multi_process ())
+ {
+ resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
+ }
+
+ /* Maybe resume a single thread after all. */
if (singlestep_breakpoints_inserted_p
&& stepping_past_singlestep_breakpoint)
{
to support, and has no value. */
resume_ptid = inferior_ptid;
}
-
- if ((step || singlestep_breakpoints_inserted_p)
- && tp->trap_expected)
+ else if ((step || singlestep_breakpoints_inserted_p)
+ && tp->trap_expected)
{
/* We're allowing a thread to run past a breakpoint it has
hit, by single-stepping the thread with the breakpoint
breakpoint, not just the one at PC. */
resume_ptid = inferior_ptid;
}
-
- if (non_stop)
+ else if (non_stop)
{
/* With non-stop mode on, threads are always handled
individually. */
displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
}
- target_resume (resume_ptid, step, sig);
+ /* Install inferior's terminal modes. */
+ target_terminal_inferior ();
/* Avoid confusing the next resume, if the next stop/resume
happens to apply to another thread. */
tp->stop_signal = TARGET_SIGNAL_0;
+
+ target_resume (resume_ptid, step, sig);
}
discard_cleanups (old_cleanups);
}
stop_after_trap = 0;
- breakpoint_proceeded = 1; /* We're about to proceed... */
+
+ observer_notify_about_to_proceed ();
if (stop_registers)
{
}
}
-/* This should be suitable for any targets that support threads. */
+/* Check the current thread against the thread that reported the most recent
+ event. If a step-over is required return TRUE and set the current thread
+ to the old thread. Otherwise return FALSE.
+
+ This should be suitable for any targets that support threads. */
static int
prepare_to_proceed (int step)
{
ptid_t wait_ptid;
struct target_waitstatus wait_status;
+ int schedlock_enabled;
+
+ /* With non-stop mode on, threads are always handled individually. */
+ gdb_assert (! non_stop);
/* Get the last target status returned by target_wait(). */
get_last_target_status (&wait_ptid, &wait_status);
return 0;
}
+ schedlock_enabled = (scheduler_mode == schedlock_on
+ || (scheduler_mode == schedlock_step
+ && step));
+
+ /* Don't switch over to WAIT_PTID if scheduler locking is on. */
+ if (schedlock_enabled)
+ return 0;
+
+ /* Don't switch over if we're about to resume some other process
+ other than WAIT_PTID's, and schedule-multiple is off. */
+ if (!sched_multi
+ && ptid_get_pid (wait_ptid) != ptid_get_pid (inferior_ptid))
+ return 0;
+
/* Switched over from WAIT_PID. */
if (!ptid_equal (wait_ptid, minus_one_ptid)
&& !ptid_equal (inferior_ptid, wait_ptid))
void
proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
{
- struct regcache *regcache = get_current_regcache ();
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct regcache *regcache;
+ struct gdbarch *gdbarch;
struct thread_info *tp;
- CORE_ADDR pc = regcache_read_pc (regcache);
+ CORE_ADDR pc;
int oneproc = 0;
- enum target_signal stop_signal;
+
+ /* If we're stopped at a fork/vfork, follow the branch set by the
+ "set follow-fork-mode" command; otherwise, we'll just proceed
+ resuming the current thread. */
+ if (!follow_fork ())
+ {
+ /* The target for some reason decided not to resume. */
+ normal_stop ();
+ return;
+ }
+
+ regcache = get_current_regcache ();
+ gdbarch = get_regcache_arch (regcache);
+ pc = regcache_read_pc (regcache);
if (step > 0)
step_start_function = find_pc_function (pc);
&& !ptid_equal (last_ptid, null_ptid)
&& !ptid_equal (last_ptid, minus_one_ptid))
{
- last_thread = find_thread_pid (last_ptid);
+ last_thread = find_thread_ptid (last_ptid);
if (last_thread)
{
tp->stop_signal = last_thread->stop_signal;
breakpoint_init_inferior (inf_starting);
- /* The first resume is not following a fork/vfork/exec. */
- pending_follow.kind = TARGET_WAITKIND_SPURIOUS; /* I.e., none. */
-
clear_proceed_status ();
stepping_past_singlestep_breakpoint = 0;
void handle_inferior_event (struct execution_control_state *ecs);
-static void handle_step_into_function (struct execution_control_state *ecs);
-static void handle_step_into_function_backward (struct execution_control_state *ecs);
+static void handle_step_into_function (struct gdbarch *gdbarch,
+ struct execution_control_state *ecs);
+static void handle_step_into_function_backward (struct gdbarch *gdbarch,
+ struct execution_control_state *ecs);
static void insert_step_resume_breakpoint_at_frame (struct frame_info *step_frame);
static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
static void insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal,
have consistent output as if the stop event had been
reported. */
ecs->ptid = info->ptid;
- ecs->event_thread = find_thread_pid (info->ptid);
+ ecs->event_thread = find_thread_ptid (info->ptid);
ecs->ws.kind = TARGET_WAITKIND_STOPPED;
ecs->ws.value.sig = TARGET_SIGNAL_0;
Cleanup local state that assumed the PTID was to be resumed, and
report the stop to the frontend. */
-void
+static void
infrun_thread_stop_requested (ptid_t ptid)
{
struct displaced_step_request *it, *next, *prev = NULL;
iterate_over_threads (infrun_thread_stop_requested_callback, &ptid);
}
+static void
+infrun_thread_thread_exit (struct thread_info *tp, int silent)
+{
+ if (ptid_equal (target_last_wait_ptid, tp->ptid))
+ nullify_last_target_wait_ptid ();
+}
+
/* Callback for iterate_over_threads. */
static int
delete_step_thread_step_resume_breakpoint ();
}
+/* Pretty print the results of target_wait, for debugging purposes. */
+
+static void
+print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
+ const struct target_waitstatus *ws)
+{
+ char *status_string = target_waitstatus_to_string (ws);
+ struct ui_file *tmp_stream = mem_fileopen ();
+ char *text;
+ long len;
+
+ /* The text is split over several lines because it was getting too long.
+ Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
+ output as a unit; we want only one timestamp printed if debug_timestamp
+ is set. */
+
+ fprintf_unfiltered (tmp_stream,
+ "infrun: target_wait (%d", PIDGET (waiton_ptid));
+ if (PIDGET (waiton_ptid) != -1)
+ fprintf_unfiltered (tmp_stream,
+ " [%s]", target_pid_to_str (waiton_ptid));
+ fprintf_unfiltered (tmp_stream, ", status) =\n");
+ fprintf_unfiltered (tmp_stream,
+ "infrun: %d [%s],\n",
+ PIDGET (result_ptid), target_pid_to_str (result_ptid));
+ fprintf_unfiltered (tmp_stream,
+ "infrun: %s\n",
+ status_string);
+
+ text = ui_file_xstrdup (tmp_stream, &len);
+
+ /* This uses %s in part to handle %'s in the text, but also to avoid
+ a gcc error: the format attribute requires a string literal. */
+ fprintf_unfiltered (gdb_stdlog, "%s", text);
+
+ xfree (status_string);
+ xfree (text);
+ ui_file_delete (tmp_stream);
+}
+
/* Wait for control to return from inferior to debugger.
If TREAT_EXEC_AS_SIGTRAP is non-zero, then handle EXEC signals
while (1)
{
+ struct cleanup *old_chain;
+
if (deprecated_target_wait_hook)
- ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
+ ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0);
else
- ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
+ ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0);
+
+ if (debug_infrun)
+ print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
if (treat_exec_as_sigtrap && ecs->ws.kind == TARGET_WAITKIND_EXECD)
{
ecs->ws.value.sig = TARGET_SIGNAL_TRAP;
}
+ /* If an error happens while handling the event, propagate GDB's
+ knowledge of the executing state to the frontend/user running
+ state. */
+ old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
+
/* Now figure out what to do with the result of the result. */
handle_inferior_event (ecs);
+ /* No error, don't finish the state yet. */
+ discard_cleanups (old_chain);
+
if (!ecs->wait_some_more)
break;
}
struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss;
struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
+ struct cleanup *ts_old_chain;
int was_sync = sync_execution;
memset (ecs, 0, sizeof (*ecs));
if (deprecated_target_wait_hook)
ecs->ptid =
- deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
+ deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
else
- ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
+ ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
+
+ if (debug_infrun)
+ print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
if (non_stop
&& ecs->ws.kind != TARGET_WAITKIND_IGNORE
thread. */
context_switch (ecs->ptid);
+ /* If an error happens while handling the event, propagate GDB's
+ knowledge of the executing state to the frontend/user running
+ state. */
+ if (!non_stop)
+ ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
+ else
+ ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
+
/* Now figure out what to do with the result of the result. */
handle_inferior_event (ecs);
inferior_event_handler (INF_EXEC_COMPLETE, NULL);
}
+ /* No error, don't finish the thread states yet. */
+ discard_cleanups (ts_old_chain);
+
/* Revert thread and frame. */
do_cleanups (old_chain);
if (software_breakpoint_inserted_here_p (breakpoint_pc)
|| (non_stop && moribund_breakpoint_here_p (breakpoint_pc)))
{
+ struct cleanup *old_cleanups = NULL;
+ if (RECORD_IS_USED)
+ old_cleanups = record_gdb_operation_disable_set ();
+
/* When using hardware single-step, a SIGTRAP is reported for both
a completed single-step and a software breakpoint. Need to
differentiate between the two, as the latter needs adjusting
|| !currently_stepping (ecs->event_thread)
|| ecs->event_thread->prev_pc == breakpoint_pc)
regcache_write_pc (regcache, breakpoint_pc);
+
+ if (RECORD_IS_USED)
+ do_cleanups (old_cleanups);
}
}
void
handle_inferior_event (struct execution_control_state *ecs)
{
+ struct frame_info *frame;
+ struct gdbarch *gdbarch;
int sw_single_step_trap_p = 0;
int stopped_by_watchpoint;
int stepped_after_stopped_by_watchpoint = 0;
&& ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event)
add_thread (ecs->ptid);
- ecs->event_thread = find_thread_pid (ecs->ptid);
+ ecs->event_thread = find_thread_ptid (ecs->ptid);
/* Dependent on valid ECS->EVENT_THREAD. */
adjust_pc_after_break (ecs);
{
breakpoint_retire_moribund ();
- /* 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);
+ /* 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. If
+ we're handling a process exit in non-stop mode, there's
+ nothing to do, as threads of the dead process are gone, and
+ threads of any other process were left running. */
+ if (!non_stop)
+ set_executing (minus_one_ptid, 0);
+ else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
+ && ecs->ws.kind != TARGET_WAITKIND_EXITED)
+ set_executing (inferior_ptid, 0);
}
switch (infwait_state)
operations such as address => section name and hence
require the table to contain all sections (including
those found in shared libraries). */
- /* NOTE: cagney/2003-11-25: Pass current_target and not
- exec_ops to SOLIB_ADD. This is because current GDB is
- only tooled to propagate section_table changes out from
- the "current_target" (see target_resize_to_sections), and
- not up from the exec stratum. This, of course, isn't
- right. "infrun.c" should only interact with the
- exec/process stratum, instead relying on the target stack
- to propagate relevant changes (stop, section table
- changed, ...) up to other layers. */
#ifdef SOLIB_ADD
SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
#else
case TARGET_WAITKIND_EXITED:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXITED\n");
+ inferior_ptid = ecs->ptid;
target_terminal_ours (); /* Must do this before mourn anyway */
print_stop_reason (EXITED, ecs->ws.value.integer);
/* 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_int32,
- (LONGEST) ecs->ws.value.integer));
+ set_internalvar_integer (lookup_internalvar ("_exitcode"),
+ (LONGEST) ecs->ws.value.integer);
gdb_flush (gdb_stdout);
target_mourn_inferior ();
singlestep_breakpoints_inserted_p = 0;
case TARGET_WAITKIND_SIGNALLED:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SIGNALLED\n");
+ inferior_ptid = ecs->ptid;
stop_print_frame = 0;
target_terminal_ours (); /* Must do this before mourn anyway */
case TARGET_WAITKIND_VFORKED:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
- pending_follow.kind = ecs->ws.kind;
-
- pending_follow.fork_event.parent_pid = ecs->ptid;
- pending_follow.fork_event.child_pid = ecs->ws.value.related_pid;
if (!ptid_equal (ecs->ptid, inferior_ptid))
{
reinit_frame_cache ();
}
- stop_pc = read_pc ();
+ /* Immediately detach breakpoints from the child before there's
+ any chance of letting the user delete breakpoints from the
+ breakpoint lists. If we don't do this early, it's easy to
+ leave left over traps in the child, vis: "break foo; catch
+ fork; c; <fork>; del; c; <child calls foo>". We only follow
+ the fork on the last `continue', and by that time the
+ breakpoint at "foo" is long gone from the breakpoint table.
+ If we vforked, then we don't need to unpatch here, since both
+ parent and child are sharing the same memory pages; we'll
+ need to unpatch at follow/detach time instead to be certain
+ that new breakpoints added between catchpoint hit time and
+ vfork follow are detached. */
+ if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
+ {
+ int child_pid = ptid_get_pid (ecs->ws.value.related_pid);
+
+ /* This won't actually modify the breakpoint list, but will
+ physically remove the breakpoints from the child. */
+ detach_breakpoints (child_pid);
+ }
+
+ /* In case the event is caught by a catchpoint, remember that
+ the event is to be followed at the next resume of the thread,
+ and not immediately. */
+ ecs->event_thread->pending_follow = ecs->ws;
+
+ stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
ecs->event_thread->stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
/* If no catchpoint triggered for this, then keep going. */
if (ecs->random_signal)
{
+ int should_resume;
+
ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
- keep_going (ecs);
+
+ should_resume = follow_fork ();
+
+ ecs->event_thread = inferior_thread ();
+ ecs->ptid = inferior_ptid;
+
+ if (should_resume)
+ keep_going (ecs);
+ else
+ stop_stepping (ecs);
return;
}
ecs->event_thread->stop_signal = TARGET_SIGNAL_TRAP;
case TARGET_WAITKIND_EXECD:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
- pending_follow.execd_pathname =
- savestring (ecs->ws.value.execd_pathname,
- strlen (ecs->ws.value.execd_pathname));
if (!ptid_equal (ecs->ptid, inferior_ptid))
{
reinit_frame_cache ();
}
- stop_pc = read_pc ();
+ stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
/* This causes the eventpoints and symbol table to be reset.
Must do this now, before trying to determine whether to
stop. */
- follow_exec (inferior_ptid, pending_follow.execd_pathname);
- xfree (pending_follow.execd_pathname);
+ follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
ecs->event_thread->stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
ecs->random_signal = !bpstat_explains_signal (ecs->event_thread->stop_bpstat);
+ /* Note that this may be referenced from inside
+ bpstat_stop_status above, through inferior_has_execd. */
+ xfree (ecs->ws.value.execd_pathname);
+ ecs->ws.value.execd_pathname = NULL;
+
/* If no catchpoint triggered for this, then keep going. */
if (ecs->random_signal)
{
case TARGET_WAITKIND_NO_HISTORY:
/* Reverse execution: target ran out of history info. */
- stop_pc = read_pc ();
+ stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
print_stop_reason (NO_HISTORY, 0);
stop_stepping (ecs);
return;
{
fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = 0x%s\n",
paddr_nz (stop_pc));
- if (STOPPED_BY_WATCHPOINT (&ecs->ws))
+ if (target_stopped_by_watchpoint ())
{
CORE_ADDR addr;
fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
}
}
- stepping_past_singlestep_breakpoint = 0;
-
if (!ptid_equal (deferred_step_ptid, null_ptid))
{
/* In non-stop mode, there's never a deferred_step_ptid set. */
the fact that we were supposed to switch back. */
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");
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 = find_thread_ptid (ecs->ptid);
ecs->event_thread->stop_signal = stop_signal;
stop_pc = new_singlestep_pc;
}
if (thread_hop_needed)
{
+ struct regcache *thread_regcache;
int remove_status = 0;
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: thread_hop_needed\n");
+ /* Switch context before touching inferior memory, the
+ previous thread may have exited. */
+ if (!ptid_equal (inferior_ptid, ecs->ptid))
+ context_switch (ecs->ptid);
+
/* Saw a breakpoint, but it was hit by the wrong thread.
Just continue. */
/* If the arch can displace step, don't remove the
breakpoints. */
- if (!use_displaced_stepping (current_gdbarch))
+ thread_regcache = get_thread_regcache (ecs->ptid);
+ if (!use_displaced_stepping (get_regcache_arch (thread_regcache)))
remove_status = remove_breakpoints ();
/* Did we fail to remove breakpoints? If so, try
error (_("Cannot step over breakpoint hit in wrong thread"));
else
{ /* Single step */
- if (!ptid_equal (inferior_ptid, ecs->ptid))
- context_switch (ecs->ptid);
-
if (!non_stop)
{
/* Only need to require the next event from this
deprecated_context_hook (pid_to_thread_id (ecs->ptid));
}
+ /* At this point, get hold of the now-current thread's frame. */
+ frame = get_current_frame ();
+ gdbarch = get_frame_arch (frame);
+
if (singlestep_breakpoints_inserted_p)
{
/* Pull the single step breakpoints out of the target. */
/* If necessary, step over this watchpoint. We'll be back to display
it in a moment. */
if (stopped_by_watchpoint
- && (HAVE_STEPPABLE_WATCHPOINT
- || gdbarch_have_nonsteppable_watchpoint (current_gdbarch)))
+ && (target_have_steppable_watchpoint
+ || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
{
/* At this point, we are stopped at an instruction which has
attempted to write to a piece of memory under control of
the inferior over it. If we have non-steppable watchpoints,
we must disable the current watchpoint; it's simplest to
disable all watchpoints and breakpoints. */
-
- if (!HAVE_STEPPABLE_WATCHPOINT)
+ int hw_step = 1;
+
+ if (!target_have_steppable_watchpoint)
remove_breakpoints ();
+ /* Single step */
+ hw_step = maybe_software_singlestep (gdbarch, stop_pc);
+ target_resume (ecs->ptid, hw_step, TARGET_SIGNAL_0);
registers_changed ();
- target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */
waiton_ptid = ecs->ptid;
- if (HAVE_STEPPABLE_WATCHPOINT)
+ if (target_have_steppable_watchpoint)
infwait_state = infwait_step_watch_state;
else
infwait_state = infwait_nonstep_watch_state;
find_pc_partial_function (stop_pc, &ecs->stop_func_name,
&ecs->stop_func_start, &ecs->stop_func_end);
ecs->stop_func_start
- += gdbarch_deprecated_function_start_offset (current_gdbarch);
+ += gdbarch_deprecated_function_start_offset (gdbarch);
ecs->event_thread->stepping_over_breakpoint = 0;
bpstat_clear (&ecs->event_thread->stop_bpstat);
ecs->event_thread->stop_step = 0;
if (ecs->event_thread->stop_signal == TARGET_SIGNAL_TRAP
&& ecs->event_thread->trap_expected
- && gdbarch_single_step_through_delay_p (current_gdbarch)
+ && gdbarch_single_step_through_delay_p (gdbarch)
&& currently_stepping (ecs->event_thread))
{
/* We're trying to step off a breakpoint. Turns out that we're
with a delay slot. It needs to be stepped twice, once for
the instruction and once for the delay slot. */
int step_through_delay
- = gdbarch_single_step_through_delay (current_gdbarch,
- get_current_frame ());
+ = gdbarch_single_step_through_delay (gdbarch, frame);
if (debug_infrun && step_through_delay)
fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
if (ecs->event_thread->step_range_end == 0 && step_through_delay)
ecs->random_signal = 1;
process_event_stop_test:
+
+ /* Re-fetch current thread's frame in case we did a
+ "goto process_event_stop_test" above. */
+ frame = get_current_frame ();
+ gdbarch = get_frame_arch (frame);
+
/* For the program's own signals, act according to
the signal handling tables. */
if (signal_program[ecs->event_thread->stop_signal] == 0)
ecs->event_thread->stop_signal = TARGET_SIGNAL_0;
- if (ecs->event_thread->prev_pc == read_pc ()
+ if (ecs->event_thread->prev_pc == stop_pc
&& ecs->event_thread->trap_expected
&& ecs->event_thread->step_resume_breakpoint == NULL)
{
"infrun: signal arrived while stepping over "
"breakpoint\n");
- insert_step_resume_breakpoint_at_frame (get_current_frame ());
+ insert_step_resume_breakpoint_at_frame (frame);
ecs->event_thread->step_after_step_resume_breakpoint = 1;
keep_going (ecs);
return;
&& 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 ()),
+ && frame_id_eq (get_frame_id (frame),
ecs->event_thread->step_frame_id)
&& ecs->event_thread->step_resume_breakpoint == NULL)
{
"infrun: signal may take us out of "
"single-step range\n");
- insert_step_resume_breakpoint_at_frame (get_current_frame ());
+ insert_step_resume_breakpoint_at_frame (frame);
keep_going (ecs);
return;
}
ecs->event_thread->stepping_over_breakpoint = 1;
- if (!gdbarch_get_longjmp_target_p (current_gdbarch)
- || !gdbarch_get_longjmp_target (current_gdbarch,
- get_current_frame (), &jmp_buf_pc))
+ if (!gdbarch_get_longjmp_target_p (gdbarch)
+ || !gdbarch_get_longjmp_target (gdbarch, frame, &jmp_buf_pc))
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "\
break;
case BPSTAT_WHAT_CHECK_SHLIBS:
- case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK:
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_CHECK_SHLIBS\n");
operations such as address => section name and hence
require the table to contain all sections (including
those found in shared libraries). */
- /* NOTE: cagney/2003-11-25: Pass current_target and not
- exec_ops to SOLIB_ADD. This is because current GDB is
- only tooled to propagate section_table changes out from
- the "current_target" (see target_resize_to_sections), and
- not up from the exec stratum. This, of course, isn't
- right. "infrun.c" should only interact with the
- exec/process stratum, instead relying on the target stack
- to propagate relevant changes (stop, section table
- changed, ...) up to other layers. */
#ifdef SOLIB_ADD
SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
#else
if (!non_stop)
{
struct thread_info *tp;
- tp = iterate_over_threads (currently_stepping_callback,
+ tp = iterate_over_threads (currently_stepping_or_nexting_callback,
ecs->event_thread);
if (tp)
{
return;
}
+ /* If the stepping thread exited, then don't try to switch
+ back and resume it, which could fail in several different
+ ways depending on the target. Instead, just keep going.
+
+ We can find a stepping dead thread in the thread list in
+ two cases:
+
+ - The target supports thread exit events, and when the
+ target tries to delete the thread from the thread list,
+ inferior_ptid pointed at the exiting thread. In such
+ case, calling delete_thread does not really remove the
+ thread from the list; instead, the thread is left listed,
+ with 'exited' state.
+
+ - The target's debug interface does not support thread
+ exit events, and so we have no idea whatsoever if the
+ previously stepping thread is still alive. For that
+ reason, we need to synchronously query the target
+ now. */
+ if (is_exited (tp->ptid)
+ || !target_thread_alive (tp->ptid))
+ {
+ if (debug_infrun)
+ fprintf_unfiltered (gdb_stdlog, "\
+infrun: not switching back to stepped thread, it has vanished\n");
+
+ delete_thread (tp->ptid);
+ keep_going (ecs);
+ return;
+ }
+
/* Otherwise, we no longer expect a trap in the current thread.
Clear the trap_expected flag before switching back -- this is
what keep_going would do as well, if we called it. */
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! */
+ within it!
+
+ Note also that during reverse execution, we may be stepping
+ through a function epilogue and therefore must detect when
+ the current-frame changes in the middle of a line. */
+
if (stop_pc >= ecs->event_thread->step_range_start
- && stop_pc < ecs->event_thread->step_range_end)
+ && stop_pc < ecs->event_thread->step_range_end
+ && (execution_direction != EXEC_REVERSE
+ || frame_id_eq (get_frame_id (get_current_frame ()),
+ ecs->event_thread->step_frame_id)))
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepping inside range [0x%s-0x%s]\n",
&& in_solib_dynsym_resolve_code (stop_pc))
{
CORE_ADDR pc_after_resolver =
- gdbarch_skip_solib_resolver (current_gdbarch, stop_pc);
+ gdbarch_skip_solib_resolver (gdbarch, stop_pc);
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped into dynsym resolve code\n");
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)
+ && get_frame_type (frame) == SIGTRAMP_FRAME)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped into signal trampoline\n");
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 ()),
+ if (!frame_id_eq (get_frame_id (frame),
ecs->event_thread->step_frame_id)
- && (frame_id_eq (frame_unwind_id (get_current_frame ()),
+ && (frame_id_eq (frame_unwind_id (frame),
ecs->event_thread->step_frame_id)
|| execution_direction == EXEC_REVERSE))
{
if ((ecs->event_thread->step_over_calls == STEP_OVER_NONE)
|| ((ecs->event_thread->step_range_end == 1)
- && in_prologue (ecs->event_thread->prev_pc,
+ && in_prologue (gdbarch, ecs->event_thread->prev_pc,
ecs->stop_func_start)))
{
/* I presume that step_over_calls is only 0 when we're
keep_going (ecs);
return;
}
- /* Normal (staticly linked) function call return. */
- init_sal (&sr_sal);
- sr_sal.pc = ecs->stop_func_start;
- insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id);
+ if (gdbarch_skip_trampoline_code(current_gdbarch,
+ get_current_frame (),
+ stop_pc))
+ {
+ /* We are in a function call trampoline.
+ Keep stepping backward to get to the caller. */
+ ecs->event_thread->stepping_over_breakpoint = 1;
+ }
+ else
+ {
+ /* Normal function call return (static or dynamic). */
+ init_sal (&sr_sal);
+ sr_sal.pc = ecs->stop_func_start;
+ insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id);
+ }
}
else
- insert_step_resume_breakpoint_at_caller (get_current_frame ());
+ insert_step_resume_breakpoint_at_caller (frame);
keep_going (ecs);
return;
function. That's what tells us (a) whether we want to step
into it at all, and (b) what prologue we want to run to the
end of, if we do step into it. */
- real_stop_pc = skip_language_trampoline (get_current_frame (), stop_pc);
+ real_stop_pc = skip_language_trampoline (frame, stop_pc);
if (real_stop_pc == 0)
- real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, get_current_frame (), stop_pc);
+ real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
if (real_stop_pc != 0)
ecs->stop_func_start = real_stop_pc;
if (tmp_sal.line != 0)
{
if (execution_direction == EXEC_REVERSE)
- handle_step_into_function_backward (ecs);
+ handle_step_into_function_backward (gdbarch, ecs);
else
- handle_step_into_function (ecs);
+ handle_step_into_function (gdbarch, ecs);
return;
}
}
else
/* Set a breakpoint at callee's return address (the address
at which the caller will resume). */
- insert_step_resume_breakpoint_at_caller (get_current_frame ());
+ insert_step_resume_breakpoint_at_caller (frame);
keep_going (ecs);
return;
/* If we're in the return path from a shared library trampoline,
we want to proceed through the trampoline when stepping. */
- if (gdbarch_in_solib_return_trampoline (current_gdbarch,
+ if (gdbarch_in_solib_return_trampoline (gdbarch,
stop_pc, ecs->stop_func_name))
{
/* Determine where this trampoline returns. */
CORE_ADDR real_stop_pc;
- real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, get_current_frame (), stop_pc);
+ 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");
set step-mode) or we no longer know how to get back
to the call site. */
if (step_stop_if_no_debug
- || !frame_id_p (frame_unwind_id (get_current_frame ())))
+ || !frame_id_p (frame_unwind_id (frame)))
{
/* 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
{
/* Set a breakpoint at callee's return address (the address
at which the caller will resume). */
- insert_step_resume_breakpoint_at_caller (get_current_frame ());
+ insert_step_resume_breakpoint_at_caller (frame);
keep_going (ecs);
return;
}
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->step_frame_id = get_frame_id (frame);
ecs->event_thread->current_line = stop_pc_sal.line;
ecs->event_thread->current_symtab = stop_pc_sal.symtab;
keep_going (ecs);
}
-/* Are we in the middle of stepping? */
+/* Is thread TP in the middle of single-stepping? */
static int
-currently_stepping_thread (struct thread_info *tp)
+currently_stepping (struct thread_info *tp)
{
- return (tp->step_range_end && tp->step_resume_breakpoint == NULL)
- || tp->trap_expected
- || tp->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 ());
}
-static int
-currently_stepping_callback (struct thread_info *tp, void *data)
-{
- /* Return true if any thread *but* the one passed in "data" is
- in the middle of stepping. */
- return tp != data && currently_stepping_thread (tp);
-}
+/* Returns true if any thread *but* the one passed in "data" is in the
+ middle of stepping or of handling a "next". */
static int
-currently_stepping (struct thread_info *tp)
+currently_stepping_or_nexting_callback (struct thread_info *tp, void *data)
{
- return currently_stepping_thread (tp) || bpstat_should_step ();
+ if (tp == data)
+ return 0;
+
+ return (tp->step_range_end
+ || tp->trap_expected
+ || tp->stepping_through_solib_after_catch);
}
/* Inferior has stepped into a subroutine call with source code that
it. */
static void
-handle_step_into_function (struct execution_control_state *ecs)
+handle_step_into_function (struct gdbarch *gdbarch,
+ struct execution_control_state *ecs)
{
struct symtab *s;
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 = gdbarch_skip_prologue (gdbarch,
ecs->stop_func_start);
stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
the VLIW instruction. Thus, we need to make the corresponding
adjustment here when computing the stop address. */
- if (gdbarch_adjust_breakpoint_address_p (current_gdbarch))
+ if (gdbarch_adjust_breakpoint_address_p (gdbarch))
{
ecs->stop_func_start
- = gdbarch_adjust_breakpoint_address (current_gdbarch,
+ = gdbarch_adjust_breakpoint_address (gdbarch,
ecs->stop_func_start);
}
last line of code in it. */
static void
-handle_step_into_function_backward (struct execution_control_state *ecs)
+handle_step_into_function_backward (struct gdbarch *gdbarch,
+ struct execution_control_state *ecs)
{
struct symtab *s;
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 = gdbarch_skip_prologue (gdbarch,
ecs->stop_func_start);
stop_func_sal = find_pc_line (stop_pc, 0);
static void
insert_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
{
+ struct gdbarch *gdbarch = get_frame_arch (return_frame);
struct symtab_and_line sr_sal;
gdb_assert (return_frame != NULL);
init_sal (&sr_sal); /* initialize to zeros */
- sr_sal.pc = gdbarch_addr_bits_remove
- (current_gdbarch, get_frame_pc (return_frame));
+ sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
sr_sal.section = find_pc_overlay (sr_sal.pc);
insert_step_resume_breakpoint_at_sal (sr_sal, get_frame_id (return_frame));
static void
insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
struct symtab_and_line sr_sal;
/* We shouldn't have gotten here if we don't know where the call site
init_sal (&sr_sal); /* initialize to zeros */
- sr_sal.pc = gdbarch_addr_bits_remove
- (current_gdbarch, frame_pc_unwind (next_frame));
+ sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, frame_pc_unwind (next_frame));
sr_sal.section = find_pc_overlay (sr_sal.pc);
insert_step_resume_breakpoint_at_sal (sr_sal, frame_unwind_id (next_frame));
keep_going (struct execution_control_state *ecs)
{
/* Save the pc before execution, to compare with pc after stop. */
- ecs->event_thread->prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */
+ ecs->event_thread->prev_pc
+ = regcache_read_pc (get_thread_regcache (ecs->ptid));
/* If we did not do break;, it means we should keep running the
inferior and not return to debugger. */
if (ecs->event_thread->stepping_over_breakpoint)
{
- if (! use_displaced_stepping (current_gdbarch))
+ struct regcache *thread_regcache = get_thread_regcache (ecs->ptid);
+ if (!use_displaced_stepping (get_regcache_arch (thread_regcache)))
/* Since we can't do a displaced step, we have to remove
the breakpoint while we step it. To keep things
simple, we remove them all. */
{
struct target_waitstatus last;
ptid_t last_ptid;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
get_last_target_status (&last_ptid, &last);
+ /* If an exception is thrown from this point on, make sure to
+ propagate GDB's knowledge of the executing state to the
+ frontend/user running state. A QUIT is an easy exception to see
+ here, so do this before any filtered output. */
+ if (!non_stop)
+ make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
+ else if (last.kind != TARGET_WAITKIND_SIGNALLED
+ && last.kind != TARGET_WAITKIND_EXITED)
+ make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
+
/* 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
previous_inferior_ptid = inferior_ptid;
}
- /* NOTE drow/2004-01-17: Is this still necessary? */
- /* Make sure that the current_frame's pc is correct. This
- is a correction for setting up the frame info before doing
- gdbarch_decr_pc_after_break */
- if (target_has_execution)
- /* FIXME: cagney/2002-12-06: Has the PC changed? Thanks to
- gdbarch_decr_pc_after_break, the program counter can change. Ask the
- frame code to check for this and sort out any resultant mess.
- gdbarch_decr_pc_after_break needs to just go away. */
- deprecated_update_frame_pc_hack (get_current_frame (), read_pc ());
-
if (!breakpoints_always_inserted_mode () && target_has_execution)
{
if (remove_breakpoints ())
target_terminal_ours_for_output ();
printf_filtered (_("\
Cannot remove breakpoints because program is no longer writable.\n\
-It might be running in another process.\n\
Further execution is probably impossible.\n"));
}
}
/* Set the current source location. This will also happen if we
display the frame below, but the current SAL will be incorrect
during a user hook-stop function. */
- if (target_has_stack && !stop_stack_dummy)
+ if (has_stack_frames () && !stop_stack_dummy)
set_current_sal_from_frame (get_current_frame (), 1);
- if (!target_has_stack)
+ /* Let the user/frontend see the threads as stopped. */
+ do_cleanups (old_chain);
+
+ /* 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 (!has_stack_frames ())
goto done;
if (last.kind == TARGET_WAITKIND_SIGNALLED
internal_error (__FILE__, __LINE__, _("Unknown value."));
}
- if (ui_out_is_mi_like_p (uiout))
- {
-
- 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
if (stop_stack_dummy)
{
- /* Pop the empty frame that contains the stack dummy. POP_FRAME
- ends with a setting of the current frame, so we can use that
- next. */
- frame_pop (get_current_frame ());
- /* Set stop_pc to what it was before we called the function.
- Can't rely on restore_inferior_status because that only gets
- called if we don't stop in the called function. */
- stop_pc = read_pc ();
+ /* Pop the empty frame that contains the stack dummy.
+ This also restores inferior state prior to the call
+ (struct inferior_thread_state). */
+ struct frame_info *frame = get_current_frame ();
+ gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
+ frame_pop (frame);
+ /* frame_pop() calls reinit_frame_cache as the last thing it does
+ which means there's currently no selected frame. We don't need
+ to re-establish a selected frame if the dummy call returns normally,
+ that will be done by restore_inferior_status. However, we do have
+ to handle the case where the dummy call is returning after being
+ stopped (e.g. the dummy call previously hit a breakpoint). We
+ can't know which case we have so just always re-establish a
+ selected frame here. */
select_frame (get_current_frame ());
}
done:
annotate_stopped ();
- if (!suppress_stop_observer
- && !(target_has_execution
- && last.kind != TARGET_WAITKIND_SIGNALLED
- && last.kind != TARGET_WAITKIND_EXITED
- && inferior_thread ()->step_multi))
+
+ /* Suppress the stop observer if we're in the middle of:
+
+ - a step n (n > 1), as there still more steps to be done.
+
+ - a "finish" command, as the observer will be called in
+ finish_command_continuation, so it can include the inferior
+ function's return value.
+
+ - calling an inferior function, as we pretend we inferior didn't
+ run at all. The return value of the call is handled by the
+ expression evaluator, through call_function_by_hand. */
+
+ if (!target_has_execution
+ || last.kind == TARGET_WAITKIND_SIGNALLED
+ || last.kind == TARGET_WAITKIND_EXITED
+ || (!inferior_thread ()->step_multi
+ && !(inferior_thread ()->stop_bpstat
+ && inferior_thread ()->proceed_to_finish)
+ && !inferior_thread ()->in_infcall))
{
if (!ptid_equal (inferior_ptid, null_ptid))
- observer_notify_normal_stop (inferior_thread ()->stop_bpstat);
+ observer_notify_normal_stop (inferior_thread ()->stop_bpstat,
+ stop_print_frame);
else
- observer_notify_normal_stop (NULL);
+ observer_notify_normal_stop (NULL, stop_print_frame);
}
- 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);
+ if (target_has_execution)
+ {
+ if (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);
}
-
- /* 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
static void
sig_print_info (enum target_signal oursig)
{
- char *name = target_signal_to_name (oursig);
+ const char *name = target_signal_to_name (oursig);
int name_padding = 13 - strlen (name);
if (name_padding <= 0)
case TARGET_SIGNAL_INT:
if (!allsigs && !sigs[signum])
{
- if (query ("%s is used by the debugger.\n\
-Are you sure you want to change it? ", target_signal_to_name ((enum target_signal) signum)))
+ if (query (_("%s is used by the debugger.\n\
+Are you sure you want to change it? "), target_signal_to_name ((enum target_signal) signum)))
{
sigs[signum] = 1;
}
argv++;
}
- target_notice_signals (inferior_ptid);
+ for (signum = 0; signum < nsigs; signum++)
+ if (sigs[signum])
+ {
+ target_notice_signals (inferior_ptid);
- if (from_tty)
- {
- /* Show the results. */
- sig_print_header ();
- for (signum = 0; signum < nsigs; signum++)
- {
- if (sigs[signum])
- {
- sig_print_info (signum);
- }
- }
- }
+ if (from_tty)
+ {
+ /* Show the results. */
+ sig_print_header ();
+ for (; signum < nsigs; signum++)
+ if (sigs[signum])
+ sig_print_info (signum);
+ }
+
+ break;
+ }
do_cleanups (old_chain);
}
printf_filtered (_("\nUse the \"handle\" command to change these tables.\n"));
}
+
+/* The $_siginfo convenience variable is a bit special. We don't know
+ for sure the type of the value until we actually have a chance to
+ fetch the data. The type can change depending on gdbarch, so it it
+ also dependent on which thread you have selected.
+
+ 1. making $_siginfo be an internalvar that creates a new value on
+ access.
+
+ 2. making the value of $_siginfo be an lval_computed value. */
+
+/* This function implements the lval_computed support for reading a
+ $_siginfo value. */
+
+static void
+siginfo_value_read (struct value *v)
+{
+ LONGEST transferred;
+
+ transferred =
+ target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO,
+ NULL,
+ value_contents_all_raw (v),
+ value_offset (v),
+ TYPE_LENGTH (value_type (v)));
+
+ if (transferred != TYPE_LENGTH (value_type (v)))
+ error (_("Unable to read siginfo"));
+}
+
+/* This function implements the lval_computed support for writing a
+ $_siginfo value. */
+
+static void
+siginfo_value_write (struct value *v, struct value *fromval)
+{
+ LONGEST transferred;
+
+ transferred = target_write (¤t_target,
+ TARGET_OBJECT_SIGNAL_INFO,
+ NULL,
+ value_contents_all_raw (fromval),
+ value_offset (v),
+ TYPE_LENGTH (value_type (fromval)));
+
+ if (transferred != TYPE_LENGTH (value_type (fromval)))
+ error (_("Unable to write siginfo"));
+}
+
+static struct lval_funcs siginfo_value_funcs =
+ {
+ siginfo_value_read,
+ siginfo_value_write
+ };
+
+/* Return a new value with the correct type for the siginfo object of
+ the current thread. Return a void value if there's no object
+ available. */
+
+static struct value *
+siginfo_make_value (struct internalvar *var)
+{
+ struct type *type;
+ struct gdbarch *gdbarch;
+
+ if (target_has_stack
+ && !ptid_equal (inferior_ptid, null_ptid))
+ {
+ gdbarch = get_frame_arch (get_current_frame ());
+
+ if (gdbarch_get_siginfo_type_p (gdbarch))
+ {
+ type = gdbarch_get_siginfo_type (gdbarch);
+
+ return allocate_computed_value (type, &siginfo_value_funcs, NULL);
+ }
+ }
+
+ return allocate_value (builtin_type_void);
+}
+
\f
-struct inferior_status
+/* Inferior thread state.
+ These are details related to the inferior itself, and don't include
+ things like what frame the user had selected or what gdb was doing
+ with the target at the time.
+ For inferior function calls these are things we want to restore
+ regardless of whether the function call successfully completes
+ or the dummy frame has to be manually popped. */
+
+struct inferior_thread_state
{
enum target_signal stop_signal;
CORE_ADDR stop_pc;
+ struct regcache *registers;
+};
+
+struct inferior_thread_state *
+save_inferior_thread_state (void)
+{
+ struct inferior_thread_state *inf_state = XMALLOC (struct inferior_thread_state);
+ struct thread_info *tp = inferior_thread ();
+
+ inf_state->stop_signal = tp->stop_signal;
+ inf_state->stop_pc = stop_pc;
+
+ inf_state->registers = regcache_dup (get_current_regcache ());
+
+ return inf_state;
+}
+
+/* Restore inferior session state to INF_STATE. */
+
+void
+restore_inferior_thread_state (struct inferior_thread_state *inf_state)
+{
+ struct thread_info *tp = inferior_thread ();
+
+ tp->stop_signal = inf_state->stop_signal;
+ stop_pc = inf_state->stop_pc;
+
+ /* The inferior can be gone if the user types "print exit(0)"
+ (and perhaps other times). */
+ if (target_has_execution)
+ /* NB: The register write goes through to the target. */
+ regcache_cpy (get_current_regcache (), inf_state->registers);
+ regcache_xfree (inf_state->registers);
+ xfree (inf_state);
+}
+
+static void
+do_restore_inferior_thread_state_cleanup (void *state)
+{
+ restore_inferior_thread_state (state);
+}
+
+struct cleanup *
+make_cleanup_restore_inferior_thread_state (struct inferior_thread_state *inf_state)
+{
+ return make_cleanup (do_restore_inferior_thread_state_cleanup, inf_state);
+}
+
+void
+discard_inferior_thread_state (struct inferior_thread_state *inf_state)
+{
+ regcache_xfree (inf_state->registers);
+ xfree (inf_state);
+}
+
+struct regcache *
+get_inferior_thread_state_regcache (struct inferior_thread_state *inf_state)
+{
+ return inf_state->registers;
+}
+
+/* Session related state for inferior function calls.
+ These are the additional bits of state that need to be restored
+ when an inferior function call successfully completes. */
+
+struct inferior_status
+{
bpstat stop_bpstat;
int stop_step;
int stop_stack_dummy;
int stop_after_trap;
int stop_soon;
- /* These are here because if call_function_by_hand has written some
- registers and then decides to call error(), we better not have changed
- any registers. */
- struct regcache *registers;
-
- /* A frame unique identifier. */
+ /* ID if the selected frame when the inferior function call was made. */
struct frame_id selected_frame_id;
- int breakpoint_proceeded;
- int restore_stack_info;
int proceed_to_finish;
+ int in_infcall;
};
/* Save all of the information associated with the inferior<==>gdb
- connection. INF_STATUS is a pointer to a "struct inferior_status"
- (defined in inferior.h). */
+ connection. */
struct inferior_status *
-save_inferior_status (int restore_stack_info)
+save_inferior_status (void)
{
struct inferior_status *inf_status = XMALLOC (struct inferior_status);
struct thread_info *tp = inferior_thread ();
struct inferior *inf = current_inferior ();
- inf_status->stop_signal = tp->stop_signal;
- inf_status->stop_pc = stop_pc;
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;
called. */
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 = tp->proceed_to_finish;
-
- inf_status->registers = regcache_dup (get_current_regcache ());
+ inf_status->in_infcall = tp->in_infcall;
inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
+
return inf_status;
}
return (1);
}
+/* Restore inferior session state to INF_STATUS. */
+
void
restore_inferior_status (struct inferior_status *inf_status)
{
struct thread_info *tp = inferior_thread ();
struct inferior *inf = current_inferior ();
- tp->stop_signal = inf_status->stop_signal;
- stop_pc = inf_status->stop_pc;
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;
inf->stop_soon = inf_status->stop_soon;
bpstat_clear (&tp->stop_bpstat);
tp->stop_bpstat = inf_status->stop_bpstat;
- breakpoint_proceeded = inf_status->breakpoint_proceeded;
+ inf_status->stop_bpstat = NULL;
tp->proceed_to_finish = inf_status->proceed_to_finish;
+ tp->in_infcall = inf_status->in_infcall;
- /* The inferior can be gone if the user types "print exit(0)"
- (and perhaps other times). */
- if (target_has_execution)
- /* NB: The register write goes through to the target. */
- regcache_cpy (get_current_regcache (), inf_status->registers);
- regcache_xfree (inf_status->registers);
-
- /* FIXME: If we are being called after stopping in a function which
- is called from gdb, we should not be trying to restore the
- selected frame; it just prints a spurious error message (The
- message is useful, however, in detecting bugs in gdb (like if gdb
- clobbers the stack)). In fact, should we be restoring the
- inferior status at all in that case? . */
-
- if (target_has_stack && inf_status->restore_stack_info)
+ if (target_has_stack)
{
/* The point of catch_errors is that if the stack is clobbered,
walking the stack might encounter a garbage pointer and
/* Error in restoring the selected frame. Select the innermost
frame. */
select_frame (get_current_frame ());
-
}
xfree (inf_status);
{
/* See save_inferior_status for info on stop_bpstat. */
bpstat_clear (&inf_status->stop_bpstat);
- regcache_xfree (inf_status->registers);
xfree (inf_status);
}
-
+\f
int
inferior_has_forked (ptid_t pid, ptid_t *child_pid)
{
value);
}
+static void
+show_schedule_multiple (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Resuming the execution of threads of all processes is %s.\n"), value);
+}
void
_initialize_infrun (void)
show_scheduler_mode,
&setlist, &showlist);
+ add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
+Set mode for resuming threads of all processes."), _("\
+Show mode for resuming threads of all processes."), _("\
+When on, execution commands (such as 'continue' or 'next') resume all\n\
+threads of all processes. When off (which is the default), execution\n\
+commands only resume the threads of the current process. The set of\n\
+threads that are resumed is further refined by the scheduler-locking\n\
+mode (see help set scheduler-locking)."),
+ NULL,
+ show_schedule_multiple,
+ &setlist, &showlist);
+
add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
Set mode of the step operation."), _("\
Show mode of the step operation."), _("\
observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
observer_attach_thread_stop_requested (infrun_thread_stop_requested);
+ observer_attach_thread_exit (infrun_thread_thread_exit);
+
+ /* Explicitly create without lookup, since that tries to create a
+ value with a void typed value, and when we get here, gdbarch
+ isn't initialized yet. At this point, we're quite sure there
+ isn't another convenience variable of the same name. */
+ create_internalvar_type_lazy ("_siginfo", siginfo_make_value);
}