diff options
Diffstat (limited to 'gdb/testsuite/gdb.base/bp-permanent.exp')
| -rw-r--r-- | gdb/testsuite/gdb.base/bp-permanent.exp | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/gdb/testsuite/gdb.base/bp-permanent.exp b/gdb/testsuite/gdb.base/bp-permanent.exp new file mode 100644 index 0000000..95db700 --- /dev/null +++ b/gdb/testsuite/gdb.base/bp-permanent.exp @@ -0,0 +1,275 @@ +# Copyright (C) 2014 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# This file is part of the gdb testsuite. + +# Test stepping over permanent breakpoints. + +standard_testfile + +set options { debug } +if { ![target_info exists gdb,nosignals] } { + lappend options "additional_flags=-DSIGNALS" +} + +if {[build_executable "failed to prepare" $testfile $srcfile $options]} { + return -1 +} + +set line_bp [gdb_get_line_number "write permanent bp"] + +# The test proper. ALWAYS_INSERTED indicates whether testing in +# "breakpoint always-inserted" mode. If SW_WATCHPOINT is true, set a +# software watchpoint, which forces constantly single-stepping, and +# exercises stepping the permanent breakpoint while delivering a +# signal at the same time. + +proc test {always_inserted sw_watchpoint} { + global line_bp + global hex decimal + global gdb_prompt + global srcfile binfile + + clean_restart $binfile + + if ![runto_main] then { + return -1 + } + + gdb_test "set breakpoint always-inserted $always_inserted" + + if {$sw_watchpoint} { + # Watching a convenience variable forces a software + # watchpoint. + gdb_test "watch \$dummy_convenience" "Watchpoint .*" + } + + set address_bp "" + set address_after_bp "" + + with_test_prefix "setup" { + + # Set a breakpoint where we'll manually plant a permanent + # breakpoint. + set test "set probe breakpoint" + gdb_test_multiple "break $line_bp" $test { + -re "Breakpoint .* at ($hex).*$gdb_prompt $" { + set address_bp $expect_out(1,string) + pass $test + } + } + if {$address_bp == ""} { + return + } + + # Get the size of the instruction where the breakpoint will + # manually inserted. + set test "get size of instruction" + gdb_test_multiple "x/2i $address_bp" $test { + -re ".*$hex <test\\+$decimal>:\[^\r\n\]+\r\n\[ \]+($hex).*\.\r\n$gdb_prompt $" { + set address_after_bp $expect_out(1,string) + pass $test + } + } + if {$address_after_bp == ""} { + return + } + + # Write address range where the breakpoint is inserted to the + # corresponding variables in the inferior. + gdb_test "p /x addr_bp = $address_bp" " = $address_bp" \ + "write addr_bp" + gdb_test "p /x addr_after_bp = $address_after_bp" " = $address_after_bp" \ + "write addr_after_bp" + + # Run the "setup" function in the inferior. This memcpy's the + # breakpoint instruction to a buffer in the inferior. + gdb_test "next" "test.*" "next over setup" + + delete_breakpoints + + # We now have the breakpoint instruction stored in 'buffer'. Poke it + # to memory manually. + set count [expr $address_after_bp - $address_bp] + for {set i 0} {$i < $count} {incr i} { + gdb_test "p /x addr_bp\[$i\] = buffer\[$i\]" " = .*" + } + } + + with_test_prefix "basics" { + # Run to the permanent breakpoint, just to make sure we've inserted it + # correctly. + gdb_test "continue" "Program received signal SIGTRAP.*" \ + "permanent breakpoint causes random signal" + + # Now set a breakpoint on top, thus creating a permanent breakpoint. + gdb_breakpoint "$line_bp" + + # Depending on whether this is a decr_pc_after_break arch, the PC will + # be either pointing at the permanent breakpoint address, or just + # after. Set the GDB breakpoint on top, and continue, twice. At + # least once, GDB will need to step-over the permanent breakpoint. + + gdb_test "continue" "Breakpoint .*" "stop at permanent breakpoint" + + gdb_test "p \$prev_counter = counter" " = $decimal" + + gdb_test "continue" "Breakpoint .*" "stop at permanent breakpoint twice" + + # Check that indeed the continue made progress, instead of re-trapping + # without advancing. + gdb_test "p counter - \$prev_counter" " = 1" + + gdb_test "info breakpoints" \ + "breakpoint.*keep.*y.*$hex.*in test at .*$srcfile:$line_bp.*already hit 2 times.*" \ + "info breakpoints show enabled breakpoint" + + gdb_test "disable \$bpnum" + + gdb_test "commands\nset \$commands_ran = 1\nend" "" \ + "set breakpoint commands" + + gdb_test "info breakpoints" \ + "breakpoint.*keep.*n.*$hex.*in test at .*$srcfile:$line_bp.*already hit 2 times.*" \ + "info breakpoints shows disabled breakpoint" + + # Run to the permanent breakpoint again. This time, since it's + # disabled, it should act as if we hadn't created it in the first + # place. IOW, we should get a random signal, and, the breakpoint's + # command should not run. + gdb_test "continue" "Program received signal SIGTRAP.*" \ + "disabled permanent breakpoint doesn't explain stop" + + gdb_test "info breakpoints" \ + "breakpoint.*keep.*n.*$hex.*in test at .*$srcfile:$line_bp.*already hit 2 times.*" \ + "info breakpoints still shows same number of hits" + + gdb_test "print \$commands_ran" " = void" \ + "breakpoint commands didn't run" + + # Reenable the breakpoint, and check that it gets hit and accounted + # for this time. + gdb_test "enable \$bpnum" "" "reenable breakpoint" + + gdb_test "continue" "Breakpoint .*" \ + "stop at permanent breakpoint thrice" + + gdb_test "info breakpoints" \ + "breakpoint.*keep.*y.*$hex.*in test at .*$srcfile:$line_bp.*already hit 3 times.*" \ + "info breakpoints shows one more hit" + + gdb_test "print \$commands_ran" " = 1" "breakpoint commands ran" + + # Check that stepi advances only past the permanent breakpoint, and + # not a single instruction more. + gdb_test "stepi" "after permanent bp .*" \ + "single-step past permanent breakpoint" + } + + with_test_prefix "next trips on permanent bp" { + delete_breakpoints + + gdb_breakpoint "test_next" + gdb_continue_to_breakpoint "test_next" + + gdb_breakpoint "$line_bp" + gdb_test "condition \$bpnum 0" + + gdb_test "next" "after next .*" + } + + if ![target_info exists gdb,nosignals] { + + with_test_prefix "continue trips on nested permanent bp" { + delete_breakpoints + + gdb_breakpoint "test_signal_nested" + gdb_continue_to_breakpoint "test_signal_nested" + + gdb_breakpoint "$line_bp" + gdb_continue_to_breakpoint "permanent bp" + gdb_test "condition \$bpnum 0" + + # Let SIGALRM trigger. + sleep 2 + + # We're now stopped at a permanent breakpoint, with a + # signal pending. + gdb_breakpoint "test_signal_nested_done" + gdb_continue_to_breakpoint "test_signal_nested_done" + + # Ensure that the handler did run. There's one call to + # test in the mainline code, and another in the signal + # handler. + gdb_test "p counter" " = 2" + } + + if [can_single_step_to_signal_handler] { + + with_test_prefix "stepi signal with handler" { + delete_breakpoints + + gdb_breakpoint "test_signal_with_handler" + gdb_continue_to_breakpoint "test_signal_with_handler" + + gdb_breakpoint "$line_bp" + + gdb_test "continue" "Breakpoint .*" "stop at permanent breakpoint" + + gdb_test "queue-signal SIGUSR1" + + set test "single-step to handler" + gdb_test_multiple "stepi" $test { + -re "Program received signal SIGTRAP.*$gdb_prompt $" { + fail $test + } + -re "handler .*$gdb_prompt $" { + pass $test + } + } + + # Check that the mainline PC points at the permanent + # breakpoint. + gdb_test "up 2" "test .*" "up to mainline code" + + gdb_test "p /x \$pc" " = $address_bp" \ + "mainline pc points at permanent breakpoint" + + gdb_test "continue" "Breakpoint .*" \ + "stop at permanent breakpoint, out of handler" + } + + with_test_prefix "stepi signal with no handler" { + gdb_breakpoint "test_signal_no_handler" + gdb_continue_to_breakpoint "test_signal_no_handler" + + gdb_test "continue" "Breakpoint .*" "stop at permanent breakpoint" + + gdb_test "queue-signal SIGUSR1" + + gdb_test "stepi" "after permanent bp .*" \ + "single-step past permanent breakpoint" + } + } + } +} + +foreach always_inserted {off on} { + foreach sw_watchpoint {0 1} { + with_test_prefix "always_inserted=$always_inserted, sw_watchpoint=$sw_watchpoint" { + test $always_inserted $sw_watchpoint + } + } +} |