diff options
| -rw-r--r-- | gdb/ChangeLog | 9 | ||||
| -rw-r--r-- | gdb/infcmd.c | 3 | ||||
| -rw-r--r-- | gdb/infrun.c | 94 |
3 files changed, 59 insertions, 47 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 0937f8b..fe0b96e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,12 @@ +2004-05-12 Andrew Cagney <cagney@redhat.com> + + * infrun.c (adjust_pc_after_break): Rewrite decr logic, + eliminate reference to step_sp. + (struct execution_control_state, init_execution_control_state) + (handle_inferior_event, keep_going): Delete update_step_sp and + step_sp. + * infcmd.c (step_sp): Note that variable is unused. + 2004-05-11 Andrew Cagney <cagney@redhat.com> * infrun.c (step_over_function): Delete function. diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 2cbfce3..0b91266 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -187,7 +187,8 @@ CORE_ADDR step_range_end; /* Exclusive */ struct frame_id step_frame_id; /* Our notion of the current stack pointer. */ - +/* NOTE: cagney/2004-05-09: This variable is not used and should be + garbage collected. */ CORE_ADDR step_sp; enum step_over_calls_kind step_over_calls; diff --git a/gdb/infrun.c b/gdb/infrun.c index 8cb772a..970e6c5 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -950,7 +950,6 @@ struct execution_control_state int handling_longjmp; /* FIXME */ ptid_t ptid; ptid_t saved_inferior_ptid; - int update_step_sp; int stepping_through_solib_after_catch; bpstat stepping_through_solib_catchpoints; int enable_hw_watchpoints_after_wait; @@ -1102,7 +1101,6 @@ init_execution_control_state (struct execution_control_state *ecs) ecs->random_signal = 0; ecs->remove_breakpoints_on_following_step = 0; ecs->handling_longjmp = 0; /* FIXME */ - ecs->update_step_sp = 0; ecs->stepping_through_solib_after_catch = 0; ecs->stepping_through_solib_catchpoints = NULL; ecs->enable_hw_watchpoints_after_wait = 0; @@ -1260,7 +1258,7 @@ handle_step_into_function (struct execution_control_state *ecs) static void adjust_pc_after_break (struct execution_control_state *ecs) { - CORE_ADDR stop_pc; + CORE_ADDR breakpoint_pc; /* If this target does not decrement the PC after breakpoints, then we have nothing to do. */ @@ -1294,40 +1292,53 @@ adjust_pc_after_break (struct execution_control_state *ecs) if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP) return; - /* Find the location where (if we've hit a breakpoint) the breakpoint would - be. */ - stop_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK; - - /* If we're software-single-stepping, then assume this is a breakpoint. - NOTE drow/2004-01-17: This doesn't check that the PC matches, or that - we're even in the right thread. The software-single-step code needs - some modernization. - - If we're not software-single-stepping, then we first check that there - is an enabled software breakpoint at this address. If there is, and - we weren't using hardware-single-step, then we've hit the breakpoint. - - If we were using hardware-single-step, we check prev_pc; if we just - stepped over an inserted software breakpoint, then we should decrement - the PC and eventually report hitting the breakpoint. The prev_pc check - prevents us from decrementing the PC if we just stepped over a jump - instruction and landed on the instruction after a breakpoint. - - The last bit checks that we didn't hit a breakpoint in a signal handler - without an intervening stop in sigtramp, which is detected by a new - stack pointer value below any usual function calling stack adjustments. - - NOTE drow/2004-01-17: I'm not sure that this is necessary. The check - predates checking for software single step at the same time. Also, - if we've moved into a signal handler we should have seen the - signal. */ - - if ((SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p) - || (software_breakpoint_inserted_here_p (stop_pc) - && !(currently_stepping (ecs) - && prev_pc != stop_pc - && !(step_range_end && INNER_THAN (read_sp (), (step_sp - 16)))))) - write_pc_pid (stop_pc, ecs->ptid); + /* Find the location where (if we've hit a breakpoint) the + breakpoint would be. */ + breakpoint_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK; + + if (SOFTWARE_SINGLE_STEP_P ()) + { + /* When using software single-step, a SIGTRAP can only indicate + an inserted breakpoint. This actually makes things + easier. */ + if (singlestep_breakpoints_inserted_p) + /* When software single stepping, the instruction at [prev_pc] + is never a breakpoint, but the instruction following + [prev_pc] (in program execution order) always is. Assume + that following instruction was reached and hence a software + breakpoint was hit. */ + write_pc_pid (breakpoint_pc, ecs->ptid); + else if (software_breakpoint_inserted_here_p (breakpoint_pc)) + /* The inferior was free running (i.e., no single-step + breakpoints inserted) and it hit a software breakpoint. */ + write_pc_pid (breakpoint_pc, ecs->ptid); + } + else + { + /* 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 but the former does not. */ + if (currently_stepping (ecs)) + { + if (prev_pc == breakpoint_pc + && software_breakpoint_inserted_here_p (breakpoint_pc)) + /* Hardware single-stepped a software breakpoint (as + occures when the inferior is resumed with PC pointing + at not-yet-hit software breakpoint). Since the + breakpoint really is executed, the inferior needs to be + backed up to the breakpoint address. */ + write_pc_pid (breakpoint_pc, ecs->ptid); + } + else + { + if (software_breakpoint_inserted_here_p (breakpoint_pc)) + /* The inferior was free running (i.e., no hardware + single-step and no possibility of a false SIGTRAP) and + hit a software breakpoint. */ + write_pc_pid (breakpoint_pc, ecs->ptid); + } + } } /* Given an execution control state that has been freshly filled in @@ -2410,11 +2421,6 @@ process_event_stop_test: return; } - /* We can't update step_sp every time through the loop, because - reading the stack pointer would slow down stepping too much. - But we can update it every time we leave the step range. */ - ecs->update_step_sp = 1; - if (step_range_end != 1 && (step_over_calls == STEP_OVER_UNDEBUGGABLE || step_over_calls == STEP_OVER_ALL) @@ -2704,10 +2710,6 @@ keep_going (struct execution_control_state *ecs) /* Save the pc before execution, to compare with pc after stop. */ prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */ - if (ecs->update_step_sp) - step_sp = read_sp (); - ecs->update_step_sp = 0; - /* If we did not do break;, it means we should keep running the inferior and not return to debugger. */ |