darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Refactor infrun a bit.

Browse source 
* 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
Show stats Download patch file Download diff file Expand all files Collapse all files

30
gdb/ChangeLog
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>
Vladimir Prus <vladimir@codesourcery.com>

275
gdb/infrun.c
View file

@ -72,9 +72,9 @@ static int follow_fork (void);
static void set_schedlock_func (char *args, int from_tty,
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);
@ -288,7 +288,28 @@ static struct breakpoint *step_resume_breakpoint = NULL;
static ptid_t target_last_wait_ptid;
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
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;
init_thread_stepping_state (tss);
previous_inferior_ptid = null_ptid;
init_infwait_state ();
displaced_step_clear ();
}
@ -1368,33 +1393,23 @@ enum inferior_stop_reason
SIGNAL_RECEIVED
};
/* This structure contains what used to be local variables in
wait_for_inferior. Probably many of them can return to being
locals in handle_inferior_event. */
/* The PTID we'll do a target_wait on.*/
ptid_t waiton_ptid;
/* Current inferior wait state. */
enum infwait_states infwait_state;
/* Data to be passed around while handling an event. This data is
discarded between events. */
struct execution_control_state
{
ptid_t ptid;
struct target_waitstatus ws;
struct target_waitstatus *wp;
/* Should we step over breakpoint next time keep_going
is called? */
int stepping_over_breakpoint;
int random_signal;
CORE_ADDR stop_func_start;
CORE_ADDR stop_func_end;
char *stop_func_name;
struct symtab_and_line sal;
int current_line;
struct symtab *current_symtab;
ptid_t ptid;
ptid_t saved_inferior_ptid;
int step_after_step_resume_breakpoint;
int stepping_through_solib_after_catch;
bpstat stepping_through_solib_catchpoints;
int new_thread_event;
struct target_waitstatus tmpstatus;
enum infwait_states infwait_state;
ptid_t waiton_ptid;
int wait_some_more;
};
@ -1431,6 +1446,7 @@ void
wait_for_inferior (int treat_exec_as_sigtrap)
{
struct cleanup *old_cleanups;
struct execution_control_state ecss;
struct execution_control_state *ecs;
if (debug_infrun)
@ -1442,9 +1458,13 @@ wait_for_inferior (int treat_exec_as_sigtrap)
&step_resume_breakpoint);
ecs = &ecss;
memset (ecs, 0, sizeof (*ecs));
/* 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. */
previous_inferior_ptid = inferior_ptid;
@ -1462,9 +1482,9 @@ wait_for_inferior (int treat_exec_as_sigtrap)
while (1)
{
if (deprecated_target_wait_hook)
ecs->ptid = deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp);
ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
else
ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp);
ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
if (treat_exec_as_sigtrap && ecs->ws.kind == TARGET_WAITKIND_EXECD)
{
@ -1494,12 +1514,17 @@ wait_for_inferior (int treat_exec_as_sigtrap)
void
fetch_inferior_event (void *client_data)
{
struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss;
memset (ecs, 0, sizeof (*ecs));
if (!ecs->wait_some_more)
{
/* 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. */
previous_inferior_ptid = inferior_ptid;
@ -1517,9 +1542,9 @@ fetch_inferior_event (void *client_data)
if (deprecated_target_wait_hook)
ecs->ptid =
deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp);
deprecated_target_wait_hook (waiton_ptid, &ecs->ws);
else
ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp);
ecs->ptid = target_wait (waiton_ptid, &ecs->ws);
/* Now figure out what to do with the result of the result. */
handle_inferior_event (ecs);
@ -1542,17 +1567,21 @@ fetch_inferior_event (void *client_data)
void
init_execution_control_state (struct execution_control_state *ecs)
{
ecs->stepping_over_breakpoint = 0;
ecs->random_signal = 0;
ecs->step_after_step_resume_breakpoint = 0;
ecs->stepping_through_solib_after_catch = 0;
ecs->stepping_through_solib_catchpoints = NULL;
ecs->sal = find_pc_line (prev_pc, 0);
ecs->current_line = ecs->sal.line;
ecs->current_symtab = ecs->sal.symtab;
ecs->infwait_state = infwait_normal_state;
ecs->waiton_ptid = pid_to_ptid (-1);
ecs->wp = &(ecs->ws);
}
/* Clear context switchable stepping state. */
void
init_thread_stepping_state (struct thread_stepping_state *tss)
{
tss->stepping_over_breakpoint = 0;
tss->step_after_step_resume_breakpoint = 0;
tss->stepping_through_solib_after_catch = 0;
tss->stepping_through_solib_catchpoints = NULL;
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
@ -1576,7 +1605,7 @@ nullify_last_target_wait_ptid (void)
/* Switch thread contexts, maintaining "infrun state". */
static void
context_switch (struct execution_control_state *ecs)
context_switch (ptid_t ptid)
{
/* Caution: it may happen that the new thread (or the old one!)
is not in the thread list. In this case we must not attempt
@ -1589,20 +1618,20 @@ context_switch (struct execution_control_state *ecs)
fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
target_pid_to_str (inferior_ptid));
fprintf_unfiltered (gdb_stdlog, "to %s\n",
target_pid_to_str (ecs->ptid));
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: */
/* Save infrun state for the old thread. */
save_infrun_state (inferior_ptid, prev_pc,
stepping_over_breakpoint, step_resume_breakpoint,
step_range_start,
step_range_end, &step_frame_id,
ecs->stepping_over_breakpoint,
ecs->stepping_through_solib_after_catch,
ecs->stepping_through_solib_catchpoints,
ecs->current_line, ecs->current_symtab,
tss->stepping_over_breakpoint,
tss->stepping_through_solib_after_catch,
tss->stepping_through_solib_catchpoints,
tss->current_line, tss->current_symtab,
cmd_continuation, intermediate_continuation,
proceed_to_finish,
step_over_calls,
@ -1612,14 +1641,14 @@ context_switch (struct execution_control_state *ecs)
stop_bpstat);
/* 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,
&step_range_start,
&step_range_end, &step_frame_id,
&ecs->stepping_over_breakpoint,
&ecs->stepping_through_solib_after_catch,
&ecs->stepping_through_solib_catchpoints,
&ecs->current_line, &ecs->current_symtab,
&tss->stepping_over_breakpoint,
&tss->stepping_through_solib_after_catch,
&tss->stepping_through_solib_catchpoints,
&tss->current_line, &tss->current_symtab,
&cmd_continuation, &intermediate_continuation,
&proceed_to_finish,
&step_over_calls,
@ -1629,7 +1658,7 @@ context_switch (struct execution_control_state *ecs)
&stop_bpstat);
}
switch_to_thread (ecs->ptid);
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. */
if (!ptid_equal (ptid, inferior_ptid))
{
ecss.ptid = ptid;
context_switch (&ecss);
context_switch (ptid);
}
return current_ptid;
}
@ -1715,12 +1743,19 @@ adjust_pc_after_break (struct execution_control_state *ecs)
if (singlestep_breakpoints_inserted_p
|| !ptid_equal (ecs->ptid, inferior_ptid)
|| !currently_stepping (ecs)
|| !currently_stepping (tss)
|| prev_pc == breakpoint_pc)
regcache_write_pc (regcache, breakpoint_pc);
}
}
void
init_infwait_state (void)
{
waiton_ptid = pid_to_ptid (-1);
infwait_state = infwait_normal_state;
}
/* Given an execution control state that has been freshly filled in
by an event from the inferior, figure out what it means and take
appropriate action. */
@ -1736,20 +1771,20 @@ handle_inferior_event (struct execution_control_state *ecs)
/* Cache the last pid/waitstatus. */
target_last_wait_ptid = ecs->ptid;
target_last_waitstatus = *ecs->wp;
target_last_waitstatus = ecs->ws;
/* Always clear state belonging to the previous time we stopped. */
stop_stack_dummy = 0;
adjust_pc_after_break (ecs);
switch (ecs->infwait_state)
switch (infwait_state)
{
case infwait_thread_hop_state:
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n");
/* Cancel the waiton_ptid. */
ecs->waiton_ptid = pid_to_ptid (-1);
waiton_ptid = pid_to_ptid (-1);
break;
case infwait_normal_state:
@ -1780,7 +1815,7 @@ handle_inferior_event (struct execution_control_state *ecs)
default:
internal_error (__FILE__, __LINE__, _("bad switch"));
}
ecs->infwait_state = infwait_normal_state;
infwait_state = infwait_normal_state;
reinit_frame_cache ();
@ -1929,7 +1964,7 @@ handle_inferior_event (struct execution_control_state *ecs)
if (!ptid_equal (ecs->ptid, inferior_ptid))
{
context_switch (ecs);
context_switch (ecs->ptid);
reinit_frame_cache ();
}
@ -1963,17 +1998,23 @@ handle_inferior_event (struct execution_control_state *ecs)
xfree (pending_follow.execd_pathname);
stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
ecs->saved_inferior_ptid = inferior_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;
stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid);
ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
inferior_ptid = ecs->saved_inferior_ptid;
inferior_ptid = saved_inferior_ptid;
}
if (!ptid_equal (ecs->ptid, inferior_ptid))
{
context_switch (ecs);
context_switch (ecs->ptid);
reinit_frame_cache ();
}
@ -2090,8 +2131,7 @@ handle_inferior_event (struct execution_control_state *ecs)
ecs->random_signal = 0;
ecs->ptid = saved_singlestep_ptid;
context_switch (ecs);
context_switch (saved_singlestep_ptid);
if (deprecated_context_hook)
deprecated_context_hook (pid_to_thread_id (ecs->ptid));
@ -2251,12 +2291,12 @@ handle_inferior_event (struct execution_control_state *ecs)
else
{ /* Single step */
if (!ptid_equal (inferior_ptid, ecs->ptid))
context_switch (ecs);
ecs->waiton_ptid = ecs->ptid;
ecs->wp = &(ecs->ws);
ecs->stepping_over_breakpoint = 1;
context_switch (ecs->ptid);
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);
registers_changed ();
return;
@ -2278,7 +2318,7 @@ handle_inferior_event (struct execution_control_state *ecs)
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
context_switch (ecs);
context_switch (ecs->ptid);
if (deprecated_context_hook)
deprecated_context_hook (pid_to_thread_id (ecs->ptid));
@ -2327,11 +2367,11 @@ handle_inferior_event (struct execution_control_state *ecs)
remove_breakpoints ();
registers_changed ();
target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */
ecs->waiton_ptid = ecs->ptid;
waiton_ptid = ecs->ptid;
if (HAVE_STEPPABLE_WATCHPOINT)
ecs->infwait_state = infwait_step_watch_state;
infwait_state = infwait_step_watch_state;
else
ecs->infwait_state = infwait_nonstep_watch_state;
infwait_state = infwait_nonstep_watch_state;
prepare_to_wait (ecs);
return;
}
@ -2345,7 +2385,7 @@ handle_inferior_event (struct execution_control_state *ecs)
&ecs->stop_func_start, &ecs->stop_func_end);
ecs->stop_func_start
+= gdbarch_deprecated_function_start_offset (current_gdbarch);
ecs->stepping_over_breakpoint = 0;
tss->stepping_over_breakpoint = 0;
bpstat_clear (&stop_bpstat);
stop_step = 0;
stop_print_frame = 1;
@ -2355,7 +2395,7 @@ handle_inferior_event (struct execution_control_state *ecs)
if (stop_signal == TARGET_SIGNAL_TRAP
&& stepping_over_breakpoint
&& 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
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.
Set up for another trap and get out of here. */
ecs->stepping_over_breakpoint = 1;
tss->stepping_over_breakpoint = 1;
keep_going (ecs);
return;
}
@ -2383,15 +2423,15 @@ handle_inferior_event (struct execution_control_state *ecs)
case, don't decide that here, just set
ecs->stepping_over_breakpoint, making sure we
single-step again before breakpoints are re-inserted. */
ecs->stepping_over_breakpoint = 1;
tss->stepping_over_breakpoint = 1;
}
}
/* Look at the cause of the stop, and decide what to do.
The alternatives are:
1) break; to really stop and return to the debugger,
2) drop through to start up again
(set ecs->stepping_over_breakpoint to 1 to single step once)
1) stop_stepping and return; to really stop and return to the debugger,
2) keep_going and return to start up again
(set tss->stepping_over_breakpoint to 1 to single step once)
3) set ecs->random_signal to 1, and the decision between 1 and 2
will be made according to the signal handling tables. */
@ -2552,7 +2592,7 @@ process_event_stop_test:
"breakpoint\n");
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);
return;
}
@ -2616,7 +2656,7 @@ process_event_stop_test:
fprintf_unfiltered (gdb_stdlog,
"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)
|| !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:
if (debug_infrun)
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
where we are stepping and step out of the right range. */
break;
@ -2710,13 +2750,13 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
bpstat_find_step_resume_breakpoint (stop_bpstat);
}
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
were trying to single-step off a breakpoint. Go back
to doing that. */
ecs->step_after_step_resume_breakpoint = 0;
ecs->stepping_over_breakpoint = 1;
tss->step_after_step_resume_breakpoint = 0;
tss->stepping_over_breakpoint = 1;
keep_going (ecs);
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,
we can stop stepping. */
bpstat_get_triggered_catchpoints (stop_bpstat,
&ecs->
&tss->
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
actually step past this point... */
ecs->stepping_over_breakpoint = 1;
tss->stepping_over_breakpoint = 1;
break;
}
else
{
/* We want to step over this breakpoint, then keep going. */
ecs->stepping_over_breakpoint = 1;
tss->stepping_over_breakpoint = 1;
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
hook (and possibly the dld itself) after catching a shlib
event? */
if (ecs->stepping_through_solib_after_catch)
if (tss->stepping_through_solib_after_catch)
{
#if defined(SOLIB_ADD)
/* 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)
fprintf_unfiltered (gdb_stdlog, "infrun: stepping in dynamic linker\n");
ecs->stepping_over_breakpoint = 1;
tss->stepping_over_breakpoint = 1;
keep_going (ecs);
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");
/* Else, stop and report the catchpoint(s) whose triggering
caused us to begin stepping. */
ecs->stepping_through_solib_after_catch = 0;
tss->stepping_through_solib_after_catch = 0;
bpstat_clear (&stop_bpstat);
stop_bpstat = bpstat_copy (ecs->stepping_through_solib_catchpoints);
bpstat_clear (&ecs->stepping_through_solib_catchpoints);
stop_bpstat = bpstat_copy (tss->stepping_through_solib_catchpoints);
bpstat_clear (&tss->stepping_through_solib_catchpoints);
stop_print_frame = 1;
stop_stepping (ecs);
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
the trampoline processing logic, however, there are some trampolines
that have no names, so we should do trampoline handling first. */
if (step_over_calls == STEP_OVER_UNDEBUGGABLE
&& ecs->stop_func_name == NULL
&& ecs->sal.line == 0)
&& tss->sal.line == 0)
{
if (debug_infrun)
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;
}
if (ecs->sal.line == 0)
if (tss->sal.line == 0)
{
/* We have no line number information. That means to stop
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;
}
if ((stop_pc == ecs->sal.pc)
&& (ecs->current_line != ecs->sal.line
|| ecs->current_symtab != ecs->sal.symtab))
if ((stop_pc == tss->sal.pc)
&& (tss->current_line != tss->sal.line
|| tss->current_symtab != tss->sal.symtab))
{
/* We are at the start of a different line. So stop. Note that
we don't stop if we step into the middle of a different line.
@ -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
things like for(;;) statements work better.) */
step_range_start = ecs->sal.pc;
step_range_end = ecs->sal.end;
step_range_start = tss->sal.pc;
step_range_end = tss->sal.end;
step_frame_id = get_frame_id (get_current_frame ());
ecs->current_line = ecs->sal.line;
ecs->current_symtab = ecs->sal.symtab;
tss->current_line = tss->sal.line;
tss->current_symtab = tss->sal.symtab;
/* In the case where we just stepped out of a function into the
middle of a line of the caller, continue stepping, but
@ -3212,11 +3252,11 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
/* Are we in the middle of stepping? */
static int
currently_stepping (struct execution_control_state *ecs)
currently_stepping (struct thread_stepping_state *tss)
{
return (((step_range_end && step_resume_breakpoint == NULL)
|| stepping_over_breakpoint)
|| ecs->stepping_through_solib_after_catch
|| tss->stepping_through_solib_after_catch
|| bpstat_should_step ());
}
@ -3234,17 +3274,17 @@ step_into_function (struct execution_control_state *ecs)
ecs->stop_func_start = gdbarch_skip_prologue
(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,
even if that involves jumps (as it seems to on the vax under
4.2). */
/* If the prologue ends in the middle of a source line, continue to
the end of that source line (if it is still within the function).
Otherwise, just go to end of prologue. */
if (ecs->sal.end
&& ecs->sal.pc != ecs->stop_func_start
&& ecs->sal.end < ecs->stop_func_end)
ecs->stop_func_start = ecs->sal.end;
if (tss->sal.end
&& tss->sal.pc != ecs->stop_func_start
&& tss->sal.end < ecs->stop_func_end)
ecs->stop_func_start = tss->sal.end;
/* Architectures which require breakpoint adjustment might not be able
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
the inferior, else we'd have done a break above) and we
haven't yet gotten our trap. Simply continue. */
resume (currently_stepping (ecs), stop_signal);
resume (currently_stepping (tss), stop_signal);
}
else
{
@ -3438,7 +3478,7 @@ keep_going (struct execution_control_state *ecs)
already inserted breakpoints. Therefore, we don't
care if breakpoints were already inserted, or not. */
if (ecs->stepping_over_breakpoint)
if (tss->stepping_over_breakpoint)
{
if (! use_displaced_stepping (current_gdbarch))
/* 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
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;
resume (currently_stepping (ecs), stop_signal);
resume (currently_stepping (tss), stop_signal);
}
prepare_to_wait (ecs);
@ -3495,7 +3535,7 @@ prepare_to_wait (struct execution_control_state *ecs)
{
if (debug_infrun)
fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
if (ecs->infwait_state == infwait_normal_state)
if (infwait_state == infwait_normal_state)
{
overlay_cache_invalid = 1;
@ -3506,8 +3546,7 @@ prepare_to_wait (struct execution_control_state *ecs)
as part of their normal status mechanism. */
registers_changed ();
ecs->waiton_ptid = pid_to_ptid (-1);
ecs->wp = &(ecs->ws);
waiton_ptid = pid_to_ptid (-1);
}
/* This is the old end of the while loop. Let everybody know we
want to wait for the inferior some more and get called again