diff options
| -rw-r--r-- | gdb/infcmd.c | 40 | ||||
| -rw-r--r-- | gdb/infrun.c | 16 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.reverse/finish-reverse-next.c | 39 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.reverse/finish-reverse-next.exp | 96 |
4 files changed, 160 insertions, 31 deletions
diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 5fcd2ab..978c07f 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -1720,22 +1720,25 @@ finish_backward (struct finish_command_fsm *sm) sal = find_pc_line (func_addr, 0); frame_info_ptr frame = get_selected_frame (nullptr); + struct gdbarch *gdbarch = get_frame_arch (frame); + CORE_ADDR alt_entry_point = sal.pc; + CORE_ADDR entry_point = alt_entry_point; - if (sal.pc != pc) + if (gdbarch_skip_entrypoint_p (gdbarch)) { - struct gdbarch *gdbarch = get_frame_arch (frame); - - /* Set a step-resume at the function's entry point. Once that's - hit, we'll do one more step backwards. */ - symtab_and_line sr_sal; - sr_sal.pc = sal.pc; - sr_sal.pspace = get_frame_program_space (frame); - insert_step_resume_breakpoint_at_sal (gdbarch, - sr_sal, null_frame_id); + /* Some architectures, like PowerPC use local and global entry points. + There is only one Entry Point (GEP = LEP) for other architectures. + The GEP is an alternate entry point. The LEP is the normal entry + point. The value of entry_point was initialized to the alternate + entry point (GEP). It will be adjusted if the normal entry point + (LEP) was used. */ + entry_point = gdbarch_skip_entrypoint (gdbarch, entry_point); } - else + + if (alt_entry_point <= pc && pc <= entry_point) { - /* We are exactly at the function entry point. Note that this + /* We are exactly at the function entry point, or between the entry + point on platforms that have two (like PowerPC). Note that this can only happen at frame #0. When setting a step range, need to call set_step_info @@ -1744,8 +1747,17 @@ finish_backward (struct finish_command_fsm *sm) /* 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 = sal.pc; - tp->control.step_range_end = sal.pc; + tp->control.step_range_start = alt_entry_point; + tp->control.step_range_end = entry_point; + } + else + { + symtab_and_line sr_sal; + /* Set a step-resume at the function's entry point. */ + sr_sal.pc = entry_point; + sr_sal.pspace = get_frame_program_space (frame); + insert_step_resume_breakpoint_at_sal (gdbarch, + sr_sal, null_frame_id); } proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT); } diff --git a/gdb/infrun.c b/gdb/infrun.c index 05b150b..9c81521 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -1868,6 +1868,7 @@ struct execution_control_state struct target_waitstatus ws; int stop_func_filled_in = 0; + CORE_ADDR stop_func_alt_start = 0; CORE_ADDR stop_func_start = 0; CORE_ADDR stop_func_end = 0; const char *stop_func_name = nullptr; @@ -4663,6 +4664,12 @@ fill_in_stop_func (struct gdbarch *gdbarch, &block); ecs->stop_func_name = gsi == nullptr ? nullptr : gsi->print_name (); + /* PowerPC functions have a Local Entry Point and a Global Entry + Point. There is only one Entry Point (GEP = LEP) for other + architectures. Save the alternate entry point address (GEP) for + use later. */ + ecs->stop_func_alt_start = ecs->stop_func_start; + /* The call to find_pc_partial_function, above, will set stop_func_start and stop_func_end to the start and end of the range containing the stop pc. If this range @@ -4679,6 +4686,9 @@ fill_in_stop_func (struct gdbarch *gdbarch, += gdbarch_deprecated_function_start_offset (gdbarch); if (gdbarch_skip_entrypoint_p (gdbarch)) + /* The PowerPC architecture uses two entry points. Stop at the + regular entry point (LEP on PowerPC) initially. Will setup a + breakpoint for the alternate entry point (GEP) later. */ ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch, ecs->stop_func_start); } @@ -6754,7 +6764,7 @@ process_event_stop_test (struct execution_control_state *ecs) /* 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_start = ecs->stop_func_alt_start; tp->control.step_range_end = ecs->stop_func_start; keep_going (ecs); return; @@ -6891,8 +6901,10 @@ process_event_stop_test (struct execution_control_state *ecs) (unless it's the function entry point, in which case keep going back to the call point). */ CORE_ADDR stop_pc = ecs->event_thread->stop_pc (); + if (stop_pc == ecs->event_thread->control.step_range_start - && stop_pc != ecs->stop_func_start + && (stop_pc < ecs->stop_func_alt_start + || stop_pc > ecs->stop_func_start) && execution_direction == EXEC_REVERSE) end_stepping_range (ecs); else diff --git a/gdb/testsuite/gdb.reverse/finish-reverse-next.c b/gdb/testsuite/gdb.reverse/finish-reverse-next.c index f90ecbb..0347906 100644 --- a/gdb/testsuite/gdb.reverse/finish-reverse-next.c +++ b/gdb/testsuite/gdb.reverse/finish-reverse-next.c @@ -24,11 +24,37 @@ This test verifies the fix for gdb bugzilla: https://sourceware.org/bugzilla/show_bug.cgi?id=29927 -*/ + + PowerPC supports two entry points to a function. The normal entry point + is called the local entry point (LEP). The alternat entry point is called + the global entry point (GEP). The GEP is only used if the table of + contents (TOC) value stored in register r2 needs to be setup prior to + execution starting at the LEP. A function call via a function pointer + will entry via the GEP. A normal function call will enter via the LEP. + + This test has been expanded to include tests to verify the reverse-finish + command works properly if the function is called via the GEP. The original + test only verified the reverse-finish command for a normal call that used + the LEP. */ int function1 (int a, int b) // FUNCTION1 { + /* The assembly code for this function when compiled for PowerPC is as + follows: + + 0000000010000758 <function1>: + 10000758: 02 10 40 3c lis r2,4098 <- GEP + 1000075c: 00 7f 42 38 addi r2,r2,32512 + 10000760: a6 02 08 7c mflr r0 <- LEP + 10000764: 10 00 01 f8 std r0,16(r1) + .... + + When the function is called on PowerPC with function1 (a, b) the call + enters at the Local Entry Point (LEP). When the function is called via + a function pointer, the Global Entry Point (GEP) for function1 is used. + The GEP sets up register 2 before reaching the LEP. + */ int ret = 0; ret = a + b; @@ -39,10 +65,19 @@ int main(int argc, char* argv[]) { int a, b; + int (*funp) (int, int) = &function1; + + /* Call function via Local Entry Point (LEP). */ a = 1; b = 5; - function1 (a, b); // CALL FUNCTION + function1 (a, b); // CALL VIA LEP + + /* Call function via Global Entry Point (GEP). */ + a = 10; + b = 50; + + funp (a, b); // CALL VIA GEP return 0; } diff --git a/gdb/testsuite/gdb.reverse/finish-reverse-next.exp b/gdb/testsuite/gdb.reverse/finish-reverse-next.exp index 63305c1..a9c895d 100644 --- a/gdb/testsuite/gdb.reverse/finish-reverse-next.exp +++ b/gdb/testsuite/gdb.reverse/finish-reverse-next.exp @@ -31,6 +31,16 @@ # This test verifies the fix for gdb bugzilla: # https://sourceware.org/bugzilla/show_bug.cgi?id=29927 +# PowerPC supports two entry points to a function. The normal entry point +# is called the local entry point (LEP). The alternat entry point is called +# the global entry point (GEP). A function call via a function pointer +# will entry via the GEP. A normal function call will enter via the LEP. +# +# This test has been expanded to include tests to verify the reverse-finish +# command works properly if the function is called via the GEP. The original +# test only verified the reverse-finish command for a normal call that used +# the LEP. + if ![supports_reverse] { return } @@ -50,30 +60,30 @@ if [supports_process_record] { } -### TEST 1: reverse finish from the entry point instruction in -### function1. +### TEST 1: reverse finish from the entry point instruction (LEP) in +### function1 when called using the normal entry point (LEP). # Set breakpoint at call to function1 in main. -set bp_FUNCTION [gdb_get_line_number "CALL FUNCTION" $srcfile] -gdb_breakpoint $srcfile:$bp_FUNCTION temporary +set bp_LEP_test [gdb_get_line_number "CALL VIA LEP" $srcfile] +gdb_breakpoint $srcfile:$bp_LEP_test temporary # Continue to break point at function1 call in main. gdb_continue_to_breakpoint \ "stopped at function1 entry point instruction to stepi into function" \ - ".*$srcfile:$bp_FUNCTION\r\n.*" + ".*$srcfile:$bp_LEP_test\r\n.*" # stepi until we see "{" indicating we entered function1 -repeat_cmd_until "stepi" "CALL FUNCTION" "{" "stepi into function1 call" +repeat_cmd_until "stepi" "CALL VIA LEP" "{" "stepi into function1 call" -gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL FUNCTION.*" \ - "reverse-finish function1 " +gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \ + "reverse-finish function1 LEP call from LEP " # Check to make sure we stopped at the first instruction in the source code # line. It should only take one reverse next command to get to the previous # source line. If GDB stops at the last instruction in the source code line # it will take two reverse next instructions to get to the previous source # line. -gdb_test "reverse-next" ".*b = 5;.*" "reverse next at b = 5, call from function" +gdb_test "reverse-next" ".*b = 5;.*" "reverse next at b = 5, call from LEP" # Clear the recorded log. gdb_test "record stop" "Process record is stopped.*" \ @@ -84,21 +94,81 @@ gdb_test_no_output "record" "turn on process record for test2" ### TEST 2: reverse finish from the body of function1. # Set breakpoint at call to function1 in main. -gdb_breakpoint $srcfile:$bp_FUNCTION temporary +gdb_breakpoint $srcfile:$bp_LEP_test temporary # Continue to break point at function1 call in main. gdb_continue_to_breakpoint \ "at function1 entry point instruction to step to body of function" \ - ".*$srcfile:$bp_FUNCTION\r\n.*" + ".*$srcfile:$bp_LEP_test\r\n.*" # do a step instruction to get to the body of the function gdb_test "step" ".*int ret = 0;.*" "step test 1" -gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL FUNCTION.*" \ - "reverse-finish function1 call from function body" +gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \ + "reverse-finish function1 LEP call from function body" # Check to make sure we stopped at the first instruction in the source code # line. It should only take one reverse next command to get to the previous # source line. gdb_test "reverse-next" ".*b = 5;.*" \ "reverse next at b = 5, from function body" + +# Turn off record to clear logs and turn on again +gdb_test "record stop" "Process record is stopped.*" \ + "turn off process record for test2" +gdb_test_no_output "record" "turn on process record for test3" + + +### TEST 3: reverse finish from the alternate entry point instruction (GEP) in +### function1 when called using the alternate entry point (GEP). + +# Set breakpoint at call to funp in main. +set bp_GEP_test [gdb_get_line_number "CALL VIA GEP" $srcfile] +gdb_breakpoint $srcfile:$bp_GEP_test temporary + +# Continue to break point at funp call in main. +gdb_continue_to_breakpoint \ + "stopped at function1 entry point instruction to stepi into funp" \ + ".*$srcfile:$bp_GEP_test\r\n.*" + +# stepi until we see "{" indicating we entered function. +repeat_cmd_until "stepi" "CALL VIA GEP" "{" "stepi into funp call" + +gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \ + "function1 GEP call call from GEP" + +# Check to make sure we stopped at the first instruction in the source code +# line. It should only take one reverse next command to get to the previous +# source line. If GDB stops at the last instruction in the source code line +# it will take two reverse next instructions to get to the previous source +# line. +gdb_test "reverse-next" ".*b = 50;.*" "reverse next at b = 50, call from GEP" + +# Turn off record to clear logs and turn on again +gdb_test "record stop" "Process record is stopped.*" \ + "turn off process record for test3" +gdb_test_no_output "record" "turn on process record for test4" + + +### TEST 4: reverse finish from the body of function 1 when calling using the +### alternate entrypoint (GEP). +gdb_breakpoint $srcfile:$bp_GEP_test temporary + +# Continue to break point at funp call. +gdb_continue_to_breakpoint \ + "at function1 entry point instruction to step to body of funp call" \ + ".*$srcfile:$bp_GEP_test\r\n.*" + +# Step into body of funp, called via GEP. +gdb_test "step" ".*int ret = 0;.*" "step test 2" + +gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \ + "reverse-finish function1 GEP call, from function body " + +# Check to make sure we stopped at the first instruction in the source code +# line. It should only take one reverse next command to get to the previous +# source line. If GDB stops at the last instruction in the source code line +# it will take two reverse next instructions to get to the previous source +# line. +gdb_test "reverse-next" ".*b = 50;.*" \ + "reverse next at b = 50 from function body" |