gdb/testsuite/gdb.base/sigbpt.exp

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