Refactor infrun a bit.

* infrun.c (currently_stepping): Take a struct
	thread_stepping_state instead of an execution_control_state.
	(struct thread_stepping_state): New, split from
	execution_control_state.
	(gtss, tss): New globals.
	(proceed): Clear the stepping state, set previous_inferior_ptid
	and clear infwait state.
	(init_wait_for_inferior): Clear the stepping state,
	previous_inferior_ptid and infwait state.
	(waiton_ptid, infwait_state): New, split from
	execution_control_state.
	(struct execution_control_state): Members that persist through
	events moved out to either struct thred_stepping_state or made
	global.  Deleted unneeded wp, saved_inferior_ptid, tmpstatus.
	(wait_for_inferior, fetch_inferior_event): Use local
	execution_control_state.  Update to execution_control_state split.
	(init_execution_control_state): Adjust.
	(init_thread_stepping_state): New, extracted from
	init_execution_control_state.
	(context_switch): Take a ptid instead of an
	execution_control_state.
	(context_switch_to): Adjust.
	(adjust_pc_after_break): Adjust.
	(init_infwait_state): New.
	(handle_inferior_event): Adjust.
This commit is contained in:
Pedro Alves 2008-07-09 22:33:16 +00:00
parent a474d7c2a3
commit 0d1e5fa71a
2 changed files with 191 additions and 122 deletions

View File

@ -1,3 +1,33 @@
2008-07-09 Pedro Alves <pedro@codesourcery.com>
Refactor infrun a bit.
* infrun.c (currently_stepping): Take a struct
thread_stepping_state instead of an execution_control_state.
(struct thread_stepping_state): New, split from
execution_control_state.
(gtss, tss): New globals.
(proceed): Clear the stepping state, set previous_inferior_ptid
and clear infwait state.
(init_wait_for_inferior): Clear the stepping state,
previous_inferior_ptid and infwait state.
(waiton_ptid, infwait_state): New, split from
execution_control_state.
(struct execution_control_state): Members that persist through
events moved out to either struct thred_stepping_state or made
global. Deleted unneeded wp, saved_inferior_ptid, tmpstatus.
(wait_for_inferior, fetch_inferior_event): Use local
execution_control_state. Update to execution_control_state split.
(init_execution_control_state): Adjust.
(init_thread_stepping_state): New, extracted from
init_execution_control_state.
(context_switch): Take a ptid instead of an
execution_control_state.
(context_switch_to): Adjust.
(adjust_pc_after_break): Adjust.
(init_infwait_state): New.
(handle_inferior_event): Adjust.
2008-07-09 Pedro Alves <pedro@codesourcery.com> 2008-07-09 Pedro Alves <pedro@codesourcery.com>
Vladimir Prus <vladimir@codesourcery.com> Vladimir Prus <vladimir@codesourcery.com>

View File

@ -72,9 +72,9 @@ static int follow_fork (void);
static void set_schedlock_func (char *args, int from_tty, static void set_schedlock_func (char *args, int from_tty,
struct cmd_list_element *c); struct cmd_list_element *c);
struct execution_control_state; struct thread_stepping_state;
static int currently_stepping (struct execution_control_state *ecs); static int currently_stepping (struct thread_stepping_state *tss);
static void xdb_handle_command (char *args, int from_tty); static void xdb_handle_command (char *args, int from_tty);
@ -288,7 +288,28 @@ static struct breakpoint *step_resume_breakpoint = NULL;
static ptid_t target_last_wait_ptid; static ptid_t target_last_wait_ptid;
static struct target_waitstatus target_last_waitstatus; static struct target_waitstatus target_last_waitstatus;
struct execution_control_state ecss; /* Context-switchable data. */
struct thread_stepping_state
{
/* Should we step over breakpoint next time keep_going
is called? */
int stepping_over_breakpoint;
struct symtab_and_line sal;
int current_line;
struct symtab *current_symtab;
int step_after_step_resume_breakpoint;
int stepping_through_solib_after_catch;
bpstat stepping_through_solib_catchpoints;
};
struct thread_stepping_state gtss;
struct thread_stepping_state *tss = &gtss;
static void context_switch (ptid_t ptid);
void init_thread_stepping_state (struct thread_stepping_state *tss);
void init_infwait_state (void);
/* This is used to remember when a fork, vfork or exec event /* This is used to remember when a fork, vfork or exec event
was caught by a catchpoint, and thus the event is to be was caught by a catchpoint, and thus the event is to be
@ -1338,6 +1359,10 @@ init_wait_for_inferior (void)
target_last_wait_ptid = minus_one_ptid; target_last_wait_ptid = minus_one_ptid;
init_thread_stepping_state (tss);
previous_inferior_ptid = null_ptid;
init_infwait_state ();
displaced_step_clear (); displaced_step_clear ();
} }
@ -1368,33 +1393,23 @@ enum inferior_stop_reason
SIGNAL_RECEIVED SIGNAL_RECEIVED
}; };
/* This structure contains what used to be local variables in /* The PTID we'll do a target_wait on.*/
wait_for_inferior. Probably many of them can return to being ptid_t waiton_ptid;
locals in handle_inferior_event. */
/* 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 struct execution_control_state
{ {
ptid_t ptid;
struct target_waitstatus ws; 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; int random_signal;
CORE_ADDR stop_func_start; CORE_ADDR stop_func_start;
CORE_ADDR stop_func_end; CORE_ADDR stop_func_end;
char *stop_func_name; 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; int new_thread_event;
struct target_waitstatus tmpstatus;
enum infwait_states infwait_state;
ptid_t waiton_ptid;
int wait_some_more; int wait_some_more;
}; };
@ -1431,6 +1446,7 @@ void
wait_for_inferior (int treat_exec_as_sigtrap) wait_for_inferior (int treat_exec_as_sigtrap)
{ {
struct cleanup *old_cleanups; struct cleanup *old_cleanups;
struct execution_control_state ecss;
struct execution_control_state *ecs; struct execution_control_state *ecs;
if (debug_infrun) if (debug_infrun)
@ -1442,9 +1458,13 @@ wait_for_inferior (int treat_exec_as_sigtrap)
&step_resume_breakpoint); &step_resume_breakpoint);
ecs = &ecss; ecs = &ecss;
memset (ecs, 0, sizeof (*ecs));
/* Fill in with reasonable starting values. */ /* Fill in with reasonable starting values. */
init_execution_control_state (ecs); init_thread_stepping_state (tss);
/* Reset to normal state. */
init_infwait_state ();
/* 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; previous_inferior_ptid = inferior_ptid;
@ -1462,9 +1482,9 @@ wait_for_inferior (int treat_exec_as_sigtrap)
while (1) while (1)
{ {
if (deprecated_target_wait_hook) 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 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 (treat_exec_as_sigtrap && ecs->ws.kind == TARGET_WAITKIND_EXECD)
{ {
@ -1494,12 +1514,17 @@ wait_for_inferior (int treat_exec_as_sigtrap)
void void
fetch_inferior_event (void *client_data) fetch_inferior_event (void *client_data)
{ {
struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss; struct execution_control_state *ecs = &ecss;
memset (ecs, 0, sizeof (*ecs));
if (!ecs->wait_some_more) if (!ecs->wait_some_more)
{ {
/* Fill in with reasonable starting values. */ /* Fill in with reasonable starting values. */
init_execution_control_state (ecs); init_thread_stepping_state (tcs);
init_infwait_state ();
/* 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; previous_inferior_ptid = inferior_ptid;
@ -1517,9 +1542,9 @@ fetch_inferior_event (void *client_data)
if (deprecated_target_wait_hook) if (deprecated_target_wait_hook)
ecs->ptid = ecs->ptid =
deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp); deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
else else
ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp); ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
/* Now figure out what to do with the result of the result. */ /* Now figure out what to do with the result of the result. */
handle_inferior_event (ecs); handle_inferior_event (ecs);
@ -1542,17 +1567,21 @@ fetch_inferior_event (void *client_data)
void void
init_execution_control_state (struct execution_control_state *ecs) init_execution_control_state (struct execution_control_state *ecs)
{ {
ecs->stepping_over_breakpoint = 0;
ecs->random_signal = 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; /* Clear context switchable stepping state. */
ecs->sal = find_pc_line (prev_pc, 0);
ecs->current_line = ecs->sal.line; void
ecs->current_symtab = ecs->sal.symtab; init_thread_stepping_state (struct thread_stepping_state *tss)
ecs->infwait_state = infwait_normal_state; {
ecs->waiton_ptid = pid_to_ptid (-1); tss->stepping_over_breakpoint = 0;
ecs->wp = &(ecs->ws); tss->step_after_step_resume_breakpoint = 0;
tss->stepping_through_solib_after_catch = 0;
tss->stepping_through_solib_catchpoints = NULL;
tss->sal = find_pc_line (prev_pc, 0);
tss->current_line = tss->sal.line;
tss->current_symtab = tss->sal.symtab;
} }
/* Return the cached copy of the last pid/waitstatus returned by /* Return the cached copy of the last pid/waitstatus returned by
@ -1576,7 +1605,7 @@ nullify_last_target_wait_ptid (void)
/* Switch thread contexts, maintaining "infrun state". */ /* Switch thread contexts, maintaining "infrun state". */
static void 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!) /* 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 is not in the thread list. In this case we must not attempt
@ -1589,20 +1618,20 @@ context_switch (struct execution_control_state *ecs)
fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ", fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
target_pid_to_str (inferior_ptid)); target_pid_to_str (inferior_ptid));
fprintf_unfiltered (gdb_stdlog, "to %s\n", fprintf_unfiltered (gdb_stdlog, "to %s\n",
target_pid_to_str (ecs->ptid)); target_pid_to_str (ptid));
} }
if (in_thread_list (inferior_ptid) && in_thread_list (ecs->ptid)) if (in_thread_list (inferior_ptid) && in_thread_list (ptid))
{ /* Perform infrun state context switch: */ { /* Perform infrun state context switch: */
/* Save infrun state for the old thread. */ /* Save infrun state for the old thread. */
save_infrun_state (inferior_ptid, prev_pc, save_infrun_state (inferior_ptid, prev_pc,
stepping_over_breakpoint, step_resume_breakpoint, stepping_over_breakpoint, step_resume_breakpoint,
step_range_start, step_range_start,
step_range_end, &step_frame_id, step_range_end, &step_frame_id,
ecs->stepping_over_breakpoint, tss->stepping_over_breakpoint,
ecs->stepping_through_solib_after_catch, tss->stepping_through_solib_after_catch,
ecs->stepping_through_solib_catchpoints, tss->stepping_through_solib_catchpoints,
ecs->current_line, ecs->current_symtab, tss->current_line, tss->current_symtab,
cmd_continuation, intermediate_continuation, cmd_continuation, intermediate_continuation,
proceed_to_finish, proceed_to_finish,
step_over_calls, step_over_calls,
@ -1612,14 +1641,14 @@ context_switch (struct execution_control_state *ecs)
stop_bpstat); stop_bpstat);
/* Load infrun state for the new thread. */ /* Load infrun state for the new thread. */
load_infrun_state (ecs->ptid, &prev_pc, load_infrun_state (ptid, &prev_pc,
&stepping_over_breakpoint, &step_resume_breakpoint, &stepping_over_breakpoint, &step_resume_breakpoint,
&step_range_start, &step_range_start,
&step_range_end, &step_frame_id, &step_range_end, &step_frame_id,
&ecs->stepping_over_breakpoint, &tss->stepping_over_breakpoint,
&ecs->stepping_through_solib_after_catch, &tss->stepping_through_solib_after_catch,
&ecs->stepping_through_solib_catchpoints, &tss->stepping_through_solib_catchpoints,
&ecs->current_line, &ecs->current_symtab, &tss->current_line, &tss->current_symtab,
&cmd_continuation, &intermediate_continuation, &cmd_continuation, &intermediate_continuation,
&proceed_to_finish, &proceed_to_finish,
&step_over_calls, &step_over_calls,
@ -1629,7 +1658,7 @@ context_switch (struct execution_control_state *ecs)
&stop_bpstat); &stop_bpstat);
} }
switch_to_thread (ecs->ptid); switch_to_thread (ptid);
} }
/* Context switch to thread PTID. */ /* Context switch to thread PTID. */
@ -1641,8 +1670,7 @@ context_switch_to (ptid_t ptid)
/* Context switch to the new thread. */ /* Context switch to the new thread. */
if (!ptid_equal (ptid, inferior_ptid)) if (!ptid_equal (ptid, inferior_ptid))
{ {
ecss.ptid = ptid; context_switch (ptid);
context_switch (&ecss);
} }
return current_ptid; return current_ptid;
} }
@ -1715,12 +1743,19 @@ adjust_pc_after_break (struct execution_control_state *ecs)
if (singlestep_breakpoints_inserted_p if (singlestep_breakpoints_inserted_p
|| !ptid_equal (ecs->ptid, inferior_ptid) || !ptid_equal (ecs->ptid, inferior_ptid)
|| !currently_stepping (ecs) || !currently_stepping (tss)
|| prev_pc == breakpoint_pc) || prev_pc == breakpoint_pc)
regcache_write_pc (regcache, breakpoint_pc); regcache_write_pc (regcache, breakpoint_pc);
} }
} }
void
init_infwait_state (void)
{
waiton_ptid = pid_to_ptid (-1);
infwait_state = infwait_normal_state;
}
/* Given an execution control state that has been freshly filled in /* Given an execution control state that has been freshly filled in
by an event from the inferior, figure out what it means and take by an event from the inferior, figure out what it means and take
appropriate action. */ appropriate action. */
@ -1736,20 +1771,20 @@ handle_inferior_event (struct execution_control_state *ecs)
/* Cache the last pid/waitstatus. */ /* Cache the last pid/waitstatus. */
target_last_wait_ptid = ecs->ptid; 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. */ /* Always clear state belonging to the previous time we stopped. */
stop_stack_dummy = 0; stop_stack_dummy = 0;
adjust_pc_after_break (ecs); adjust_pc_after_break (ecs);
switch (ecs->infwait_state) switch (infwait_state)
{ {
case infwait_thread_hop_state: case infwait_thread_hop_state:
if (debug_infrun) if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n"); fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n");
/* Cancel the waiton_ptid. */ /* Cancel the waiton_ptid. */
ecs->waiton_ptid = pid_to_ptid (-1); waiton_ptid = pid_to_ptid (-1);
break; break;
case infwait_normal_state: case infwait_normal_state:
@ -1780,7 +1815,7 @@ handle_inferior_event (struct execution_control_state *ecs)
default: default:
internal_error (__FILE__, __LINE__, _("bad switch")); internal_error (__FILE__, __LINE__, _("bad switch"));
} }
ecs->infwait_state = infwait_normal_state; infwait_state = infwait_normal_state;
reinit_frame_cache (); reinit_frame_cache ();
@ -1929,7 +1964,7 @@ handle_inferior_event (struct execution_control_state *ecs)
if (!ptid_equal (ecs->ptid, inferior_ptid)) if (!ptid_equal (ecs->ptid, inferior_ptid))
{ {
context_switch (ecs); context_switch (ecs->ptid);
reinit_frame_cache (); reinit_frame_cache ();
} }
@ -1963,17 +1998,23 @@ handle_inferior_event (struct execution_control_state *ecs)
xfree (pending_follow.execd_pathname); xfree (pending_follow.execd_pathname);
stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid)); 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->random_signal = !bpstat_explains_signal (stop_bpstat); stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
inferior_ptid = ecs->saved_inferior_ptid;
ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
inferior_ptid = saved_inferior_ptid;
}
if (!ptid_equal (ecs->ptid, inferior_ptid)) if (!ptid_equal (ecs->ptid, inferior_ptid))
{ {
context_switch (ecs); context_switch (ecs->ptid);
reinit_frame_cache (); reinit_frame_cache ();
} }
@ -2090,8 +2131,7 @@ handle_inferior_event (struct execution_control_state *ecs)
ecs->random_signal = 0; ecs->random_signal = 0;
ecs->ptid = saved_singlestep_ptid; context_switch (saved_singlestep_ptid);
context_switch (ecs);
if (deprecated_context_hook) if (deprecated_context_hook)
deprecated_context_hook (pid_to_thread_id (ecs->ptid)); deprecated_context_hook (pid_to_thread_id (ecs->ptid));
@ -2251,12 +2291,12 @@ handle_inferior_event (struct execution_control_state *ecs)
else else
{ /* Single step */ { /* Single step */
if (!ptid_equal (inferior_ptid, ecs->ptid)) if (!ptid_equal (inferior_ptid, ecs->ptid))
context_switch (ecs); context_switch (ecs->ptid);
ecs->waiton_ptid = ecs->ptid;
ecs->wp = &(ecs->ws);
ecs->stepping_over_breakpoint = 1;
ecs->infwait_state = infwait_thread_hop_state; waiton_ptid = ecs->ptid;
infwait_state = infwait_thread_hop_state;
tss->stepping_over_breakpoint = 1;
keep_going (ecs); keep_going (ecs);
registers_changed (); registers_changed ();
return; return;
@ -2278,7 +2318,7 @@ handle_inferior_event (struct execution_control_state *ecs)
if (debug_infrun) if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n"); fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
context_switch (ecs); context_switch (ecs->ptid);
if (deprecated_context_hook) if (deprecated_context_hook)
deprecated_context_hook (pid_to_thread_id (ecs->ptid)); deprecated_context_hook (pid_to_thread_id (ecs->ptid));
@ -2327,11 +2367,11 @@ handle_inferior_event (struct execution_control_state *ecs)
remove_breakpoints (); remove_breakpoints ();
registers_changed (); registers_changed ();
target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */ target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */
ecs->waiton_ptid = ecs->ptid; waiton_ptid = ecs->ptid;
if (HAVE_STEPPABLE_WATCHPOINT) if (HAVE_STEPPABLE_WATCHPOINT)
ecs->infwait_state = infwait_step_watch_state; infwait_state = infwait_step_watch_state;
else else
ecs->infwait_state = infwait_nonstep_watch_state; infwait_state = infwait_nonstep_watch_state;
prepare_to_wait (ecs); prepare_to_wait (ecs);
return; return;
} }
@ -2345,7 +2385,7 @@ handle_inferior_event (struct execution_control_state *ecs)
&ecs->stop_func_start, &ecs->stop_func_end); &ecs->stop_func_start, &ecs->stop_func_end);
ecs->stop_func_start ecs->stop_func_start
+= gdbarch_deprecated_function_start_offset (current_gdbarch); += gdbarch_deprecated_function_start_offset (current_gdbarch);
ecs->stepping_over_breakpoint = 0; tss->stepping_over_breakpoint = 0;
bpstat_clear (&stop_bpstat); bpstat_clear (&stop_bpstat);
stop_step = 0; stop_step = 0;
stop_print_frame = 1; stop_print_frame = 1;
@ -2355,7 +2395,7 @@ handle_inferior_event (struct execution_control_state *ecs)
if (stop_signal == TARGET_SIGNAL_TRAP if (stop_signal == TARGET_SIGNAL_TRAP
&& stepping_over_breakpoint && stepping_over_breakpoint
&& gdbarch_single_step_through_delay_p (current_gdbarch) && gdbarch_single_step_through_delay_p (current_gdbarch)
&& currently_stepping (ecs)) && currently_stepping (tss))
{ {
/* We're trying to step off a breakpoint. Turns out that we're /* We're trying to step off a breakpoint. Turns out that we're
also on an instruction that needs to be stepped multiple also on an instruction that needs to be stepped multiple
@ -2371,7 +2411,7 @@ handle_inferior_event (struct execution_control_state *ecs)
{ {
/* The user issued a continue when stopped at a breakpoint. /* The user issued a continue when stopped at a breakpoint.
Set up for another trap and get out of here. */ Set up for another trap and get out of here. */
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
keep_going (ecs); keep_going (ecs);
return; return;
} }
@ -2383,15 +2423,15 @@ handle_inferior_event (struct execution_control_state *ecs)
case, don't decide that here, just set case, don't decide that here, just set
ecs->stepping_over_breakpoint, making sure we ecs->stepping_over_breakpoint, making sure we
single-step again before breakpoints are re-inserted. */ single-step again before breakpoints are re-inserted. */
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
} }
} }
/* Look at the cause of the stop, and decide what to do. /* Look at the cause of the stop, and decide what to do.
The alternatives are: The alternatives are:
1) break; to really stop and return to the debugger, 1) stop_stepping and return; to really stop and return to the debugger,
2) drop through to start up again 2) keep_going and return to start up again
(set ecs->stepping_over_breakpoint to 1 to single step once) (set tss->stepping_over_breakpoint to 1 to single step once)
3) set ecs->random_signal to 1, and the decision between 1 and 2 3) set ecs->random_signal to 1, and the decision between 1 and 2
will be made according to the signal handling tables. */ will be made according to the signal handling tables. */
@ -2552,7 +2592,7 @@ process_event_stop_test:
"breakpoint\n"); "breakpoint\n");
insert_step_resume_breakpoint_at_frame (get_current_frame ()); insert_step_resume_breakpoint_at_frame (get_current_frame ());
ecs->step_after_step_resume_breakpoint = 1; tss->step_after_step_resume_breakpoint = 1;
keep_going (ecs); keep_going (ecs);
return; return;
} }
@ -2616,7 +2656,7 @@ process_event_stop_test:
fprintf_unfiltered (gdb_stdlog, fprintf_unfiltered (gdb_stdlog,
"infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n"); "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
if (!gdbarch_get_longjmp_target_p (current_gdbarch) if (!gdbarch_get_longjmp_target_p (current_gdbarch)
|| !gdbarch_get_longjmp_target (current_gdbarch, || !gdbarch_get_longjmp_target (current_gdbarch,
@ -2656,7 +2696,7 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
case BPSTAT_WHAT_SINGLE: case BPSTAT_WHAT_SINGLE:
if (debug_infrun) if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n"); fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
/* Still need to check other stuff, at least the case /* Still need to check other stuff, at least the case
where we are stepping and step out of the right range. */ where we are stepping and step out of the right range. */
break; break;
@ -2710,13 +2750,13 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
bpstat_find_step_resume_breakpoint (stop_bpstat); bpstat_find_step_resume_breakpoint (stop_bpstat);
} }
delete_step_resume_breakpoint (&step_resume_breakpoint); delete_step_resume_breakpoint (&step_resume_breakpoint);
if (ecs->step_after_step_resume_breakpoint) if (tss->step_after_step_resume_breakpoint)
{ {
/* Back when the step-resume breakpoint was inserted, we /* Back when the step-resume breakpoint was inserted, we
were trying to single-step off a breakpoint. Go back were trying to single-step off a breakpoint. Go back
to doing that. */ to doing that. */
ecs->step_after_step_resume_breakpoint = 0; tss->step_after_step_resume_breakpoint = 0;
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
keep_going (ecs); keep_going (ecs);
return; return;
} }
@ -2791,19 +2831,19 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
friends) until we reach non-dld code. At that point, friends) until we reach non-dld code. At that point,
we can stop stepping. */ we can stop stepping. */
bpstat_get_triggered_catchpoints (stop_bpstat, bpstat_get_triggered_catchpoints (stop_bpstat,
&ecs-> &tss->
stepping_through_solib_catchpoints); stepping_through_solib_catchpoints);
ecs->stepping_through_solib_after_catch = 1; tss->stepping_through_solib_after_catch = 1;
/* Be sure to lift all breakpoints, so the inferior does /* Be sure to lift all breakpoints, so the inferior does
actually step past this point... */ actually step past this point... */
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
break; break;
} }
else else
{ {
/* We want to step over this breakpoint, then keep going. */ /* We want to step over this breakpoint, then keep going. */
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
break; break;
} }
} }
@ -2826,7 +2866,7 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
/* Are we stepping to get the inferior out of the dynamic linker's /* Are we stepping to get the inferior out of the dynamic linker's
hook (and possibly the dld itself) after catching a shlib hook (and possibly the dld itself) after catching a shlib
event? */ event? */
if (ecs->stepping_through_solib_after_catch) if (tss->stepping_through_solib_after_catch)
{ {
#if defined(SOLIB_ADD) #if defined(SOLIB_ADD)
/* Have we reached our destination? If not, keep going. */ /* Have we reached our destination? If not, keep going. */
@ -2834,7 +2874,7 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
{ {
if (debug_infrun) if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepping in dynamic linker\n"); fprintf_unfiltered (gdb_stdlog, "infrun: stepping in dynamic linker\n");
ecs->stepping_over_breakpoint = 1; tss->stepping_over_breakpoint = 1;
keep_going (ecs); keep_going (ecs);
return; return;
} }
@ -2843,10 +2883,10 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
fprintf_unfiltered (gdb_stdlog, "infrun: step past dynamic linker\n"); fprintf_unfiltered (gdb_stdlog, "infrun: step past dynamic linker\n");
/* Else, stop and report the catchpoint(s) whose triggering /* Else, stop and report the catchpoint(s) whose triggering
caused us to begin stepping. */ caused us to begin stepping. */
ecs->stepping_through_solib_after_catch = 0; tss->stepping_through_solib_after_catch = 0;
bpstat_clear (&stop_bpstat); bpstat_clear (&stop_bpstat);
stop_bpstat = bpstat_copy (ecs->stepping_through_solib_catchpoints); stop_bpstat = bpstat_copy (tss->stepping_through_solib_catchpoints);
bpstat_clear (&ecs->stepping_through_solib_catchpoints); bpstat_clear (&tss->stepping_through_solib_catchpoints);
stop_print_frame = 1; stop_print_frame = 1;
stop_stepping (ecs); stop_stepping (ecs);
return; return;
@ -3081,14 +3121,14 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
} }
} }
ecs->sal = find_pc_line (stop_pc, 0); tss->sal = find_pc_line (stop_pc, 0);
/* NOTE: tausq/2004-05-24: This if block used to be done before all /* NOTE: tausq/2004-05-24: This if block used to be done before all
the trampoline processing logic, however, there are some trampolines the trampoline processing logic, however, there are some trampolines
that have no names, so we should do trampoline handling first. */ that have no names, so we should do trampoline handling first. */
if (step_over_calls == STEP_OVER_UNDEBUGGABLE if (step_over_calls == STEP_OVER_UNDEBUGGABLE
&& ecs->stop_func_name == NULL && ecs->stop_func_name == NULL
&& ecs->sal.line == 0) && tss->sal.line == 0)
{ {
if (debug_infrun) if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: stepped into undebuggable function\n"); fprintf_unfiltered (gdb_stdlog, "infrun: stepped into undebuggable function\n");
@ -3134,7 +3174,7 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
return; return;
} }
if (ecs->sal.line == 0) if (tss->sal.line == 0)
{ {
/* We have no line number information. That means to stop /* We have no line number information. That means to stop
stepping (does this always happen right after one instruction, stepping (does this always happen right after one instruction,
@ -3148,9 +3188,9 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
return; return;
} }
if ((stop_pc == ecs->sal.pc) if ((stop_pc == tss->sal.pc)
&& (ecs->current_line != ecs->sal.line && (tss->current_line != tss->sal.line
|| ecs->current_symtab != ecs->sal.symtab)) || tss->current_symtab != tss->sal.symtab))
{ {
/* We are at the start of a different line. So stop. Note that /* 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. we don't stop if we step into the middle of a different line.
@ -3171,11 +3211,11 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
new line in mid-statement, we continue stepping. This makes new line in mid-statement, we continue stepping. This makes
things like for(;;) statements work better.) */ things like for(;;) statements work better.) */
step_range_start = ecs->sal.pc; step_range_start = tss->sal.pc;
step_range_end = ecs->sal.end; step_range_end = tss->sal.end;
step_frame_id = get_frame_id (get_current_frame ()); step_frame_id = get_frame_id (get_current_frame ());
ecs->current_line = ecs->sal.line; tss->current_line = tss->sal.line;
ecs->current_symtab = ecs->sal.symtab; tss->current_symtab = tss->sal.symtab;
/* In the case where we just stepped out of a function into the /* In the case where we just stepped out of a function into the
middle of a line of the caller, continue stepping, but middle of a line of the caller, continue stepping, but
@ -3212,11 +3252,11 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
/* Are we in the middle of stepping? */ /* Are we in the middle of stepping? */
static int static int
currently_stepping (struct execution_control_state *ecs) currently_stepping (struct thread_stepping_state *tss)
{ {
return (((step_range_end && step_resume_breakpoint == NULL) return (((step_range_end && step_resume_breakpoint == NULL)
|| stepping_over_breakpoint) || stepping_over_breakpoint)
|| ecs->stepping_through_solib_after_catch || tss->stepping_through_solib_after_catch
|| bpstat_should_step ()); || bpstat_should_step ());
} }
@ -3234,17 +3274,17 @@ step_into_function (struct execution_control_state *ecs)
ecs->stop_func_start = gdbarch_skip_prologue ecs->stop_func_start = gdbarch_skip_prologue
(current_gdbarch, ecs->stop_func_start); (current_gdbarch, ecs->stop_func_start);
ecs->sal = find_pc_line (ecs->stop_func_start, 0); tss->sal = find_pc_line (ecs->stop_func_start, 0);
/* Use the step_resume_break to step until the end of the prologue, /* 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 even if that involves jumps (as it seems to on the vax under
4.2). */ 4.2). */
/* If the prologue ends in the middle of a source line, continue to /* 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). the end of that source line (if it is still within the function).
Otherwise, just go to end of prologue. */ Otherwise, just go to end of prologue. */
if (ecs->sal.end if (tss->sal.end
&& ecs->sal.pc != ecs->stop_func_start && tss->sal.pc != ecs->stop_func_start
&& ecs->sal.end < ecs->stop_func_end) && tss->sal.end < ecs->stop_func_end)
ecs->stop_func_start = ecs->sal.end; ecs->stop_func_start = tss->sal.end;
/* Architectures which require breakpoint adjustment might not be able /* Architectures which require breakpoint adjustment might not be able
to place a breakpoint at the computed address. If so, the test to place a breakpoint at the computed address. If so, the test
@ -3421,7 +3461,7 @@ keep_going (struct execution_control_state *ecs)
/* We took a signal (which we are supposed to pass through to /* We took a signal (which we are supposed to pass through to
the inferior, else we'd have done a break above) and we the inferior, else we'd have done a break above) and we
haven't yet gotten our trap. Simply continue. */ haven't yet gotten our trap. Simply continue. */
resume (currently_stepping (ecs), stop_signal); resume (currently_stepping (tss), stop_signal);
} }
else else
{ {
@ -3438,7 +3478,7 @@ keep_going (struct execution_control_state *ecs)
already inserted breakpoints. Therefore, we don't already inserted breakpoints. Therefore, we don't
care if breakpoints were already inserted, or not. */ care if breakpoints were already inserted, or not. */
if (ecs->stepping_over_breakpoint) if (tss->stepping_over_breakpoint)
{ {
if (! use_displaced_stepping (current_gdbarch)) if (! use_displaced_stepping (current_gdbarch))
/* Since we can't do a displaced step, we have to remove /* Since we can't do a displaced step, we have to remove
@ -3462,7 +3502,7 @@ keep_going (struct execution_control_state *ecs)
} }
} }
stepping_over_breakpoint = ecs->stepping_over_breakpoint; stepping_over_breakpoint = tss->stepping_over_breakpoint;
/* Do not deliver SIGNAL_TRAP (except when the user explicitly /* Do not deliver SIGNAL_TRAP (except when the user explicitly
specifies that such a signal should be delivered to the specifies that such a signal should be delivered to the
@ -3480,7 +3520,7 @@ keep_going (struct execution_control_state *ecs)
stop_signal = TARGET_SIGNAL_0; stop_signal = TARGET_SIGNAL_0;
resume (currently_stepping (ecs), stop_signal); resume (currently_stepping (tss), stop_signal);
} }
prepare_to_wait (ecs); prepare_to_wait (ecs);
@ -3495,7 +3535,7 @@ prepare_to_wait (struct execution_control_state *ecs)
{ {
if (debug_infrun) if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n"); 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; overlay_cache_invalid = 1;
@ -3506,8 +3546,7 @@ prepare_to_wait (struct execution_control_state *ecs)
as part of their normal status mechanism. */ as part of their normal status mechanism. */
registers_changed (); registers_changed ();
ecs->waiton_ptid = pid_to_ptid (-1); waiton_ptid = pid_to_ptid (-1);
ecs->wp = &(ecs->ws);
} }
/* This is the old end of the while loop. Let everybody know we /* 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 want to wait for the inferior some more and get called again