mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-23 18:14:13 +08:00
Revert "PowerPC: fix for gdb.reverse/finish-precsave.exp and gdb.reverse/finish-reverse.exp"
This reverts commit 92e07580db.
Reverting patch as the patch series is causing regressions.
This commit is contained in:
Carl Love
parent
722e0dd9e4
commit
15d2b36c5b
40
gdb/infcmd.c
40
gdb/infcmd.c
@ -1720,25 +1720,22 @@ 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 (gdbarch_skip_entrypoint_p (gdbarch))
|
||||
if (sal.pc != pc)
|
||||
{
|
||||
/* 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);
|
||||
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);
|
||||
}
|
||||
|
||||
if (alt_entry_point <= pc && pc <= entry_point)
|
||||
else
|
||||
{
|
||||
/* We are exactly at the function entry point, or between the entry
|
||||
point on platforms that have two (like PowerPC). Note that this
|
||||
/* We are exactly at the function entry point. Note that this
|
||||
can only happen at frame #0.
|
||||
|
||||
When setting a step range, need to call set_step_info
|
||||
@ -1747,17 +1744,8 @@ 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 = 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);
|
||||
tp->control.step_range_start = sal.pc;
|
||||
tp->control.step_range_end = sal.pc;
|
||||
}
|
||||
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
|
||||
}
|
||||
|
||||
16
gdb/infrun.c
16
gdb/infrun.c
@ -1868,7 +1868,6 @@ 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;
|
||||
@ -4664,12 +4663,6 @@ 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
|
||||
@ -4686,9 +4679,6 @@ 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);
|
||||
}
|
||||
@ -6764,7 +6754,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_alt_start;
|
||||
tp->control.step_range_start = ecs->stop_func_start;
|
||||
tp->control.step_range_end = ecs->stop_func_start;
|
||||
keep_going (ecs);
|
||||
return;
|
||||
@ -6901,10 +6891,8 @@ 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_alt_start
|
||||
|| stop_pc > ecs->stop_func_start)
|
||||
&& stop_pc != ecs->stop_func_start
|
||||
&& execution_direction == EXEC_REVERSE)
|
||||
end_stepping_range (ecs);
|
||||
else
|
||||
|
||||
@ -24,37 +24,11 @@
|
||||
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;
|
||||
@ -65,19 +39,10 @@ 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 VIA LEP
|
||||
|
||||
/* Call function via Global Entry Point (GEP). */
|
||||
a = 10;
|
||||
b = 50;
|
||||
|
||||
funp (a, b); // CALL VIA GEP
|
||||
function1 (a, b); // CALL FUNCTION
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -31,16 +31,6 @@
|
||||
# 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
|
||||
}
|
||||
@ -60,30 +50,30 @@ if [supports_process_record] {
|
||||
}
|
||||
|
||||
|
||||
### TEST 1: reverse finish from the entry point instruction (LEP) in
|
||||
### function1 when called using the normal entry point (LEP).
|
||||
### TEST 1: reverse finish from the entry point instruction in
|
||||
### function1.
|
||||
|
||||
# Set breakpoint at call to function1 in main.
|
||||
set bp_LEP_test [gdb_get_line_number "CALL VIA LEP" $srcfile]
|
||||
gdb_breakpoint $srcfile:$bp_LEP_test temporary
|
||||
set bp_FUNCTION [gdb_get_line_number "CALL FUNCTION" $srcfile]
|
||||
gdb_breakpoint $srcfile:$bp_FUNCTION 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_LEP_test\r\n.*"
|
||||
".*$srcfile:$bp_FUNCTION\r\n.*"
|
||||
|
||||
# stepi until we see "{" indicating we entered function1
|
||||
repeat_cmd_until "stepi" "CALL VIA LEP" "{" "stepi into function1 call"
|
||||
repeat_cmd_until "stepi" "CALL FUNCTION" "{" "stepi into function1 call"
|
||||
|
||||
gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \
|
||||
"reverse-finish function1 LEP call from LEP "
|
||||
gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL FUNCTION.*" \
|
||||
"reverse-finish function1 "
|
||||
|
||||
# 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 LEP"
|
||||
gdb_test "reverse-next" ".*b = 5;.*" "reverse next at b = 5, call from function"
|
||||
|
||||
# Clear the recorded log.
|
||||
gdb_test "record stop" "Process record is stopped.*" \
|
||||
@ -94,81 +84,21 @@ 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_LEP_test temporary
|
||||
gdb_breakpoint $srcfile:$bp_FUNCTION 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_LEP_test\r\n.*"
|
||||
".*$srcfile:$bp_FUNCTION\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 VIA LEP.*" \
|
||||
"reverse-finish function1 LEP call from function body"
|
||||
gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL FUNCTION.*" \
|
||||
"reverse-finish function1 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"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user