From 2dedb159fe430ce8f7d2f6de0207609a31c7abf0 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Tue, 31 Aug 2004 14:43:18 +0000 Subject: 2004-08-31 Andrew Cagney * gdb.base/sigstep.exp (breakpoint_to_handler_entry) (skip_to_handler_entry): New procedures. Test stepping into a handler when the breakpoint is at the handler's entry point. --- gdb/testsuite/ChangeLog | 6 +++ gdb/testsuite/gdb.base/sigstep.exp | 86 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+) diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index ef2b73d..10b8161 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,9 @@ +2004-08-31 Andrew Cagney + + * gdb.base/sigstep.exp (breakpoint_to_handler_entry) + (skip_to_handler_entry): New procedures. Test stepping into a + handler when the breakpoint is at the handler's entry point. + 2004-08-30 Andrew Cagney * gdb.base/sigstep.exp (breakpoint_over_handler): Remove kfail diff --git a/gdb/testsuite/gdb.base/sigstep.exp b/gdb/testsuite/gdb.base/sigstep.exp index 2304091..988af2f 100644 --- a/gdb/testsuite/gdb.base/sigstep.exp +++ b/gdb/testsuite/gdb.base/sigstep.exp @@ -235,6 +235,47 @@ skip_to_handler step skip_to_handler next skip_to_handler continue +# Try stepping when there's a signal pending, and a breakpoint at the +# handler's entry-point. Should step into the signal handler stopping +# at the entry-point. + +# Some systems (e.x., GNU/Linux as of 2004-08-30), when delivering a +# signal, resume the process at the first instruction of the signal +# handler and not the first instruction of the signal trampoline. The +# stack is constructed such that the signal handler still appears to +# have been called by the trampoline code. This test checks that it +# is possible to stop the inferior, even at that first instruction. + +proc skip_to_handler_entry { i } { + global gdb_prompt + global infinite_loop + set prefix "$i to handler entry" + + # Run around to the done + set test "$prefix; resync" + gdb_test_multiple "continue" "$test" { + -re "done = 0.*$gdb_prompt " { + pass "$test" + } + # other patterns can go here + } + + # Advance to the infinite loop + gdb_test "advance $infinite_loop" "" "$prefix; advance to infinite loop" + + # Make the signal pending + sleep 1 + + # Insert / remove the handler breakpoint. + gdb_test "break *handler" "" "$prefix; break handler" + gdb_test "$i" " handler .*" "$prefix; performing $i" + gdb_test "clear *handler" "" "$prefix; clear handler" +} + +skip_to_handler_entry step +skip_to_handler_entry next +skip_to_handler_entry continue + # Try stepping when there's a signal pending but no breakpoints. # Should skip the handler advancing to the next line. @@ -302,6 +343,51 @@ breakpoint_to_handler step breakpoint_to_handler next breakpoint_to_handler continue +# Try stepping when there's a signal pending, and a breakpoint at the +# handler's entry instruction and a breakpoint at the current +# instruction. Should step into the signal handler and breakpoint at +# that entry instruction. + +# Some systems (e.x., GNU/Linux as of 2004-08-30), when delivering a +# signal, resume the process at the first instruction of the signal +# handler and not the first instruction of the signal trampoline. The +# stack is constructed such that the signal handler still appears to +# have been called by the trampoline code. This test checks that it +# is possible to stop the inferior, even at that first instruction. + +proc breakpoint_to_handler_entry { i } { + global gdb_prompt + global infinite_loop + set prefix "$i on breakpoint, to handler entry" + + # Run around to the done + set test "$prefix; resync" + gdb_test_multiple "continue" "$test" { + -re "done = 0.*$gdb_prompt " { + pass "$test" + } + # other patterns can go here + } + + gdb_test "break $infinite_loop" "" "$prefix; break infinite loop" + gdb_test "break *handler" "" "$prefix; break handler" + + # Continue to the infinite loop + gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop" + + # Make the signal pending + sleep 1 + + setup_kfail "i*86-*-*" gdb/1738 + gdb_test "$i" " handler .*" "$prefix; performing $i" + gdb_test "clear $infinite_loop" "" "$prefix; clear infinite loop" + gdb_test "clear *handler" "" "$prefix; clear handler" +} + +breakpoint_to_handler_entry step +breakpoint_to_handler_entry next +breakpoint_to_handler_entry continue + # Try stepping when there's a signal pending, and a pre-existing # breakpoint at the current instruction, and no breakpoint in the # handler. Should advance to the next line. -- cgit v1.1