1# This testcase is part of GDB, the GNU debugger. 2 3# Copyright 2004-2015 Free Software Foundation, Inc. 4 5# This program is free software; you can redistribute it and/or modify 6# it under the terms of the GNU General Public License as published by 7# the Free Software Foundation; either version 3 of the License, or 8# (at your option) any later version. 9# 10# This program is distributed in the hope that it will be useful, 11# but WITHOUT ANY WARRANTY; without even the implied warranty of 12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13# GNU General Public License for more details. 14# 15# You should have received a copy of the GNU General Public License 16# along with this program. If not, see <http://www.gnu.org/licenses/>. 17 18# Check that GDB can and only executes single instructions when 19# stepping through a sequence of breakpoints interleaved by a signal 20# handler. 21 22# This test is known to tickle the following problems: kernel letting 23# the inferior execute both the system call, and the instruction 24# following, when single-stepping a system call; kernel failing to 25# propogate the single-step state when single-stepping the sigreturn 26# system call, instead resuming the inferior at full speed; GDB 27# doesn't know how to software single-step across a sigreturn 28# instruction. Since the kernel problems can be "fixed" using 29# software single-step this is KFAILed rather than XFAILed. 30 31if [target_info exists gdb,nosignals] { 32 verbose "Skipping sigbpt.exp because of nosignals." 33 continue 34} 35 36 37standard_testfile 38 39if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} { 40 untested $testfile.exp 41 return -1 42} 43 44# 45# Run to `main' where we begin our tests. 46# 47 48if ![runto_main] then { 49 gdb_suppress_tests 50} 51 52# If we can examine what's at memory address 0, it is possible that we 53# could also execute it. This could probably make us run away, 54# executing random code, which could have all sorts of ill effects, 55# especially on targets without an MMU. Don't run the tests in that 56# case. 57 58if { [is_address_zero_readable] } { 59 untested "Memory at address 0 is possibly executable" 60 return 61} 62 63gdb_test "break keeper" 64 65# Run to bowler, and then single step until there's a SIGSEGV. Record 66# the address of each single-step instruction (up to and including the 67# instruction that causes the SIGSEGV) in bowler_addrs, and the address 68# of the actual SIGSEGV in segv_addr. 69# Note: this test detects which signal is received. Usually it is SIGSEGV 70# (and we use SIGSEGV in comments) but on Darwin it is SIGBUS. 71 72set bowler_addrs bowler 73set segv_addr none 74gdb_test {display/i $pc} 75gdb_test "advance bowler" "bowler.*" "advance to the bowler" 76set test "stepping to fault" 77set signame "SIGSEGV" 78gdb_test_multiple "stepi" "$test" { 79 -re "Program received signal (SIGBUS|SIGSEGV).*pc(\r\n| *) *=> (0x\[0-9a-f\]*).*$gdb_prompt $" { 80 set signame $expect_out(1,string) 81 set segv_addr $expect_out(3,string) 82 pass "$test" 83 } 84 -re " .*pc(\r\n| *)=> (0x\[0-9a-f\]*).*bowler.*$gdb_prompt $" { 85 set bowler_addrs [concat $expect_out(2,string) $bowler_addrs] 86 send_gdb "stepi\n" 87 exp_continue 88 } 89} 90 91# Now record the address of the instruction following the faulting 92# instruction in bowler_addrs. 93 94set test "get insn after fault" 95gdb_test_multiple {x/2i $pc} "$test" { 96 -re "=> (0x\[0-9a-f\]*).*bowler.*(0x\[0-9a-f\]*).*bowler.*$gdb_prompt $" { 97 set bowler_addrs [concat $expect_out(2,string) $bowler_addrs] 98 pass "$test" 99 } 100} 101 102# Procedures for returning the address of the instruction before, at 103# and after, the faulting instruction. 104 105proc before_segv { } { 106 global bowler_addrs 107 return [lindex $bowler_addrs 2] 108} 109 110proc at_segv { } { 111 global bowler_addrs 112 return [lindex $bowler_addrs 1] 113} 114 115proc after_segv { } { 116 global bowler_addrs 117 return [lindex $bowler_addrs 0] 118} 119 120# Check that the address table and SIGSEGV correspond. 121 122set test "Verify that ${signame} occurs at the last STEPI insn" 123if {[string compare $segv_addr [at_segv]] == 0} { 124 pass "$test" 125} else { 126 fail "$test ($segv_addr [at_segv])" 127} 128 129# Check that the inferior is correctly single stepped all the way back 130# to a faulting instruction. 131 132proc stepi_out { name args } { 133 global gdb_prompt 134 global signame 135 136 # Set SIGSEGV to pass+nostop and then run the inferior all the way 137 # through to the signal handler. With the handler is reached, 138 # disable SIGSEGV, ensuring that further signals stop the 139 # inferior. Stops a SIGSEGV infinite loop when a broke system 140 # keeps re-executing the faulting instruction. 141 rerun_to_main 142 gdb_test "handle ${signame} nostop print pass" ".*" "${name}; pass ${signame}" 143 gdb_test "continue" "keeper.*" "${name}; continue to keeper" 144 gdb_test "handle ${signame} stop print nopass" ".*" "${name}; nopass ${signame}" 145 146 # Insert all the breakpoints. To avoid the need to step over 147 # these instructions, this is delayed until after the keeper has 148 # been reached. 149 for {set i 0} {$i < [llength $args]} {incr i} { 150 gdb_test "break [lindex $args $i]" "Breakpoint.*" \ 151 "${name}; set breakpoint $i of [llength $args]" 152 } 153 154 # Single step our way out of the keeper, through the signal 155 # trampoline, and back to the instruction that faulted. 156 set test "${name}; stepi out of handler" 157 gdb_test_multiple "stepi" "$test" { 158 -re "Could not insert single-step breakpoint.*$gdb_prompt $" { 159 setup_kfail gdb/8841 "sparc*-*-openbsd*" 160 fail "$test (could not insert single-step breakpoint)" 161 } 162 -re "keeper.*$gdb_prompt $" { 163 send_gdb "stepi\n" 164 exp_continue 165 } 166 -re "signal handler.*$gdb_prompt $" { 167 send_gdb "stepi\n" 168 exp_continue 169 } 170 -re "Program received signal SIGSEGV.*$gdb_prompt $" { 171 kfail gdb/8807 "$test (executed fault insn)" 172 } 173 -re "Breakpoint.*pc(\r\n| *)[at_segv] .*bowler.*$gdb_prompt $" { 174 pass "$test (at breakpoint)" 175 } 176 -re "Breakpoint.*pc(\r\n| *)[after_segv] .*bowler.*$gdb_prompt $" { 177 kfail gdb/8807 "$test (executed breakpoint)" 178 } 179 -re "pc(\r\n| *)[at_segv] .*bowler.*$gdb_prompt $" { 180 pass "$test" 181 } 182 -re "pc(\r\n| *)[after_segv] .*bowler.*$gdb_prompt $" { 183 kfail gdb/8807 "$test (skipped fault insn)" 184 } 185 -re "pc(\r\n| *)=> 0x\[a-z0-9\]* .*bowler.*$gdb_prompt $" { 186 kfail gdb/8807 "$test (corrupt pc)" 187 } 188 } 189 190 # Clear any breakpoints 191 for {set i 0} {$i < [llength $args]} {incr i} { 192 gdb_test "clear [lindex $args $i]" "Deleted .*" \ 193 "${name}; clear breakpoint $i of [llength $args]" 194 } 195} 196 197# Let a signal handler exit, returning to a breakpoint instruction 198# inserted at the original fault instruction. Check that the 199# breakpoint is hit, and that single stepping off that breakpoint 200# executes the underlying fault instruction causing a SIGSEGV. 201 202proc cont_out { name args } { 203 global gdb_prompt 204 global signame 205 206 # Set SIGSEGV to pass+nostop and then run the inferior all the way 207 # through to the signal handler. With the handler is reached, 208 # disable SIGSEGV, ensuring that further signals stop the 209 # inferior. Stops a SIGSEGV infinite loop when a broke system 210 # keeps re-executing the faulting instruction. 211 rerun_to_main 212 gdb_test "handle ${signame} nostop print pass" ".*" "${name}; pass ${signame}" 213 gdb_test "continue" "keeper.*" "${name}; continue to keeper" 214 gdb_test "handle ${signame} stop print nopass" ".*" "${name}; nopass ${signame}" 215 216 # Insert all the breakpoints. To avoid the need to step over 217 # these instructions, this is delayed until after the keeper has 218 # been reached. Always set a breakpoint at the signal trampoline 219 # instruction. 220 set args [concat $args "*[at_segv]"] 221 for {set i 0} {$i < [llength $args]} {incr i} { 222 gdb_test "break [lindex $args $i]" "Breakpoint.*" \ 223 "${name}; set breakpoint $i of [llength $args]" 224 } 225 226 # Let the handler return, it should "appear to hit" the breakpoint 227 # inserted at the faulting instruction. Note that the breakpoint 228 # instruction wasn't executed, rather the inferior was SIGTRAPed 229 # with the PC at the breakpoint. 230 gdb_test "continue" "Breakpoint.*pc(\r\n| *)=> [at_segv] .*" \ 231 "${name}; continue to breakpoint at fault" 232 233 # Now single step the faulted instrction at that breakpoint. 234 gdb_test "stepi" \ 235 "Program received signal ${signame}.*pc(\r\n| *)=> [at_segv] .*" \ 236 "${name}; stepi fault" 237 238 # Clear any breakpoints 239 for {set i 0} {$i < [llength $args]} {incr i} { 240 gdb_test "clear [lindex $args $i]" "Deleted .*" \ 241 "${name}; clear breakpoint $i of [llength $args]" 242 } 243 244} 245 246 247 248# Try to confuse DECR_PC_AFTER_BREAK architectures by scattering 249# breakpoints around the faulting address. In all cases the inferior 250# should single-step out of the signal trampoline halting (but not 251# executing) the fault instruction. 252 253stepi_out "stepi" 254stepi_out "stepi bp before segv" "*[before_segv]" 255stepi_out "stepi bp at segv" "*[at_segv]" 256stepi_out "stepi bp before and at segv" "*[at_segv]" "*[before_segv]" 257 258 259# Try to confuse DECR_PC_AFTER_BREAK architectures by scattering 260# breakpoints around the faulting address. In all cases the inferior 261# should exit the signal trampoline halting at the breakpoint that 262# replaced the fault instruction. 263cont_out "cont" 264cont_out "cont bp after segv" "*[before_segv]" 265cont_out "cont bp before and after segv" "*[before_segv]" "*[after_segv]" 266