diff options
author | Carl Love <cel@us.ibm.com> | 2022-12-19 12:48:54 -0500 |
---|---|---|
committer | Carl Love <cel@us.ibm.com> | 2023-01-17 11:39:32 -0500 |
commit | b22548ddb30bfb167708e82d3bb932461c1b703a (patch) | |
tree | a3f90f828ef7a01e547c6f10e94e33bf9990dc6c /gdb/infrun.c | |
parent | 4e2a80ba606fdb48018d06b510ff7873a10e43ae (diff) | |
download | gdb-b22548ddb30bfb167708e82d3bb932461c1b703a.zip gdb-b22548ddb30bfb167708e82d3bb932461c1b703a.tar.gz gdb-b22548ddb30bfb167708e82d3bb932461c1b703a.tar.bz2 |
X86: reverse-finish fix
PR record/29927 - reverse-finish requires two reverse next instructions to
reach previous source line
Currently on X86, when executing the finish command in reverse, gdb does a
single step from the first instruction in the callee to get back to the
caller. GDB stops on the last instruction in the source code line where
the call was made. When stopped at the last instruction of the source code
line, a reverse next or step command will stop at the first instruction
of the same source code line thus requiring two step/next commands to
reach the previous source code line. It should only require one step/next
command to reach the previous source code line.
By contrast, a reverse next or step command from the first line in a
function stops at the first instruction in the source code line where the
call was made.
This patch fixes the reverse finish command so it will stop at the first
instruction of the source line where the function call was made. The
behavior on X86 for the reverse-finish command now matches doing a
reverse-next from the beginning of the function.
The proceed_to_finish flag in struct thread_control_state is no longer
used. This patch removes the declaration, initialization and setting of
the flag.
This patch requires a number of regression tests to be updated. Test
gdb.mi/mi-reverse.exp no longer needs to execute two steps to get to the
previous line. The gdb output for tests gdb.reverse/until-precsave.exp
and gdb.reverse/until-reverse.exp changed slightly. The expected result in
tests gdb.reverse/amd64-failcall-reverse.exp and
gdb.reverse/singlejmp-reverse.exp are updated to the correct expected
result.
This patch adds a new test gdb.reverse/finish-reverse-next.exp to test the
reverse-finish command when returning from the entry point and from the
body of the function.
The step_until proceedure in test gdb.reverse/step-indirect-call-thunk.exp
was moved to lib/gdb.exp and renamed cmd_until.
The patch has been tested on X86 and PowerPC to verify no additional
regression failures occured.
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=29927
Diffstat (limited to 'gdb/infrun.c')
-rw-r--r-- | gdb/infrun.c | 40 |
1 files changed, 17 insertions, 23 deletions
diff --git a/gdb/infrun.c b/gdb/infrun.c index edfb5ab..05b150b 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -2748,8 +2748,6 @@ clear_proceed_status_thread (struct thread_info *tp) tp->control.stop_step = 0; - tp->control.proceed_to_finish = 0; - tp->control.stepping_command = 0; /* Discard any remaining commands or status from previous stop. */ @@ -6737,31 +6735,27 @@ process_event_stop_test (struct execution_control_state *ecs) case BPSTAT_WHAT_STEP_RESUME: infrun_debug_printf ("BPSTAT_WHAT_STEP_RESUME"); - delete_step_resume_breakpoint (ecs->event_thread); - if (ecs->event_thread->control.proceed_to_finish - && execution_direction == EXEC_REVERSE) + fill_in_stop_func (gdbarch, ecs); + + if (execution_direction == EXEC_REVERSE) { struct thread_info *tp = ecs->event_thread; + /* We are finishing a function in reverse or stepping over a function + call in reverse, and just hit the step-resume breakpoint at the + start address of the function, and we're almost there -- just need + to back up to the function call. */ - /* We are finishing a function in reverse, and just hit the - step-resume breakpoint at the start address of the - function, and we're almost there -- just need to back up - by one more single-step, which should take us back to the - function call. */ - tp->control.step_range_start = tp->control.step_range_end = 1; - keep_going (ecs); - return; - } - fill_in_stop_func (gdbarch, ecs); - if (ecs->event_thread->stop_pc () == ecs->stop_func_start - && execution_direction == EXEC_REVERSE) - { - /* We are stepping over a function call in reverse, and just - hit the step-resume breakpoint at the start address of - the function. Go back to single-stepping, which should - take us back to the function call. */ - ecs->event_thread->stepping_over_breakpoint = 1; + stop_pc_sal = find_pc_line (ecs->event_thread->stop_pc (), 0); + + /* When setting a step range, need to call set_step_info + to setup the current_line/symtab fields as well. */ + set_step_info (tp, frame, stop_pc_sal); + + /* Return using a step range so we will keep stepping back to the + first instruction in the source code line. */ + tp->control.step_range_start = ecs->stop_func_start; + tp->control.step_range_end = ecs->stop_func_start; keep_going (ecs); return; } |