1 # Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
2 # Free Software Foundation, Inc.
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 3 of the License, or
7 # (at your option) any later version.
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
14 # You should have received a copy of the GNU General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 # The program sigstep.c creates a very simple backtrace containing one
19 # signal handler and signal trampoline. A flag is set and then the
20 # handler returns. This is repeated at infinitum.
22 # This test runs the program up to the signal handler, and then
23 # attempts to step/next out of the handler and back into main.
25 if [target_info exists gdb,nosignals] {
26 verbose "Skipping sigstep.exp because of nosignals."
36 set srcfile ${testfile}.c
37 set binfile ${objdir}/${subdir}/${testfile}
38 if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
39 untested "Couldn't compile ${srcfile}.c"
46 gdb_reinitialize_dir $srcdir/$subdir
49 gdb_test "display/i \$pc"
52 if { ![runto_main] } then {
56 # Pass all the alarms straight through (but verbosely)
57 # gdb_test "handle SIGALRM print pass nostop"
58 # gdb_test "handle SIGVTALRM print pass nostop"
59 # gdb_test "handle SIGPROF print pass nostop"
61 # Run to the signal handler, validate the backtrace.
62 gdb_test "break handler"
63 gdb_test "continue" ".* handler .*" "continue to stepi handler"
64 gdb_test_sequence "bt" "backtrace for nexti" {
65 "\[\r\n\]+.0 \[^\r\n\]* handler "
66 "\[\r\n\]+.1 .signal handler called."
67 "\[\r\n\]+.2 \[^\r\n\]* main "
71 global gdb_prompt inferior_exited_re
72 set prefix "$i from handler"
74 # Get us back into the handler
75 gdb_test "continue" ".* handler .*" "$prefix; continue to handler"
77 set test "$prefix; leave handler"
78 gdb_test_multiple "$i" "${test}" {
79 -re "Could not insert single-step breakpoint.*$gdb_prompt $" {
80 setup_kfail gdb/1736 "sparc*-*-openbsd*"
81 fail "$test (could not insert single-step breakpoint)"
83 -re "done = 1;.*${gdb_prompt} $" {
85 exp_continue -continue_timer
87 -re "\} .. handler .*${gdb_prompt} $" {
89 exp_continue -continue_timer
91 -re "$inferior_exited_re normally.*${gdb_prompt} $" {
92 setup_kfail gdb/1639 powerpc-*-*bsd*
93 fail "$test (program exited)"
95 -re "(while ..done|done = 0).*${gdb_prompt} $" {
96 # After stepping out of a function /r signal-handler, GDB will
97 # advance the inferior until it is at the first instruction of
98 # a code-line. While typically things return to the middle of
99 # the "while..." (and hence GDB advances the inferior to the
100 # "return..." line) it is also possible for the return to land
101 # on the first instruction of "while...". Accept both cases.
107 proc advancei { i } {
108 global gdb_prompt inferior_exited_re
109 set prefix "$i from handleri"
112 # Get us back into the handler
113 gdb_test "continue" ".* handler .*" "$prefix; continue to handler"
115 set test "$prefix; leave handler"
116 gdb_test_multiple "$i" "${test}" {
117 -re "Cannot insert breakpoint 0.*${gdb_prompt} $" {
118 # Some platforms use a special read-only page for signal
119 # trampolines. We can't set a breakpoint there, and we
120 # don't gracefully fall back to single-stepping.
121 setup_kfail gdb/1736 "i?86-*-linux*"
122 setup_kfail gdb/1736 "*-*-openbsd*"
123 fail "$test (could not set breakpoint)"
126 -re "Could not insert single-step breakpoint.*$gdb_prompt $" {
127 setup_kfail gdb/1736 "sparc*-*-openbsd*"
128 fail "$test (could not insert single-step breakpoint)"
130 -re "Breakpoint \[0-9\]*, handler .*${gdb_prompt} $" {
131 fail "$test (hit breakpoint again)"
133 -re "done = 1;.*${gdb_prompt} $" {
135 exp_continue -continue_timer
137 -re "\} .. handler .*${gdb_prompt} $" {
139 exp_continue -continue_timer
141 -re "signal handler called.*${gdb_prompt} $" {
144 -re "main .*${gdb_prompt} $" {
145 fail "$test (in main)"
147 -re "$inferior_exited_re normally.*${gdb_prompt} $" {
148 fail "$test (program exited)"
151 -re "Make handler return now.*y or n. $" {
153 exp_continue -continue_timer
157 set test "$prefix; leave signal trampoline"
158 gdb_test_multiple "$i" "${test}" {
159 -re "while .*${gdb_prompt} $" {
160 pass "$test (in main)"
162 -re "signal handler called.*${gdb_prompt} $" {
164 exp_continue -continue_timer
166 -re "return .*${gdb_prompt} $" {
167 fail "$test (stepped)"
169 -re "Make .*frame return now.*y or n. $" {
171 exp_continue -continue_timer
173 -re "$inferior_exited_re normally.*${gdb_prompt} $" {
174 kfail gdb/1639 "$test (program exited)"
177 -re "The program is not being run.*${gdb_prompt} $" {
178 if { $program_exited } {
179 # Previously kfailed with an exit
180 pass "$test (the program is not being run)"
182 fail "$test (the program is not being run)"
188 # Check that we can step/next our way out of a signal handler.
198 gdb_test_no_output "set done = 1" "Set done as return will have skipped it"
201 # Check that we can step/next our way into / over a signal handler.
203 # There are at least the following cases: breakpoint @pc VS breakpoint
204 # in handler VS step / next / continue.
206 # Use the real-time itimer, as otherwize the process never gets enough
207 # time to expire the timer.
210 set infinite_loop [gdb_get_line_number {while (!done)}]
211 gdb_test_no_output "set itimer = itimer_real"
212 gdb_test "break [gdb_get_line_number {done = 0}]"
214 # Try stepping when there's a signal pending, and a breakpoint at the
215 # handler. Should step into the signal handler.
217 proc skip_to_handler { i } {
220 set prefix "$i to handler"
222 # Run around to the done
223 # You can add more patterns to this if you need them.
224 set test "$prefix; resync"
225 gdb_test_multiple "continue" "$test" {
226 -re "done = 0.*$gdb_prompt " {
231 # Advance to the infinite loop
232 gdb_test "advance $infinite_loop" ".*" "$prefix; advance to infinite loop"
234 # Make the signal pending
237 # Insert / remove the handler breakpoint.
238 gdb_test "break handler" ".*" "$prefix; break handler"
239 gdb_test "$i" " handler .*" "$prefix; performing $i"
240 gdb_test "clear handler" ".*" "$prefix; clear handler"
245 skip_to_handler continue
247 # Try stepping when there's a signal pending, and a breakpoint at the
248 # handler's entry-point. Should step into the signal handler stopping
249 # at the entry-point.
251 # Some systems (e.x., GNU/Linux as of 2004-08-30), when delivering a
252 # signal, resume the process at the first instruction of the signal
253 # handler and not the first instruction of the signal trampoline. The
254 # stack is constructed such that the signal handler still appears to
255 # have been called by the trampoline code. This test checks that it
256 # is possible to stop the inferior, even at that first instruction.
258 proc skip_to_handler_entry { i } {
261 set prefix "$i to handler entry"
263 # Run around to the done
264 # You can add more patterns to this if you need them.
265 set test "$prefix; resync"
266 gdb_test_multiple "continue" "$test" {
267 -re "done = 0.*$gdb_prompt " {
272 # Advance to the infinite loop
273 gdb_test "advance $infinite_loop" ".*" "$prefix; advance to infinite loop"
275 # Make the signal pending
278 # Insert / remove the handler breakpoint.
279 gdb_test "break *handler" ".*" "$prefix; break handler"
280 gdb_test "$i" " handler .*" "$prefix; performing $i"
281 gdb_test "clear *handler" ".*" "$prefix; clear handler"
284 skip_to_handler_entry step
285 skip_to_handler_entry next
286 skip_to_handler_entry continue
288 # Try stepping when there's a signal pending but no breakpoints.
289 # Should skip the handler advancing to the next line.
291 proc skip_over_handler { i } {
294 set prefix "$i over handler"
296 # Run around to the done
297 # You can add more patterns to this if you need them.
298 set test "$prefix; resync"
299 gdb_test_multiple "continue" "$test" {
300 -re "done = 0.*$gdb_prompt " {
305 # Advance to the infinite loop
306 gdb_test "advance $infinite_loop" ".*" "$prefix; advance to infinite loop"
308 # Make the signal pending
311 gdb_test "$i" "done = 0.*" "$prefix; performing $i"
314 skip_over_handler step
315 skip_over_handler next
316 skip_over_handler continue
318 # Try stepping when there's a signal pending, a pre-existing
319 # breakpoint at the current instruction, and a breakpoint in the
320 # handler. Should advance to the signal handler.
322 proc breakpoint_to_handler { i } {
325 set prefix "$i on breakpoint, to handler"
327 # Run around to the done
328 # You can add more patterns to this if you need them.
329 set test "$prefix; resync"
330 gdb_test_multiple "continue" "$test" {
331 -re "done = 0.*$gdb_prompt " {
336 gdb_test "break $infinite_loop" ".*" "$prefix; break infinite loop"
337 gdb_test "break handler" ".*" "$prefix; break handler"
339 # Continue to the infinite loop
340 gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop"
342 # Make the signal pending
345 gdb_test "$i" " handler .*" "$prefix; performing $i"
346 gdb_test "clear $infinite_loop" ".*" "$prefix; clear infinite loop"
347 gdb_test "clear handler" ".*" "$prefix; clear handler"
350 breakpoint_to_handler step
351 breakpoint_to_handler next
352 breakpoint_to_handler continue
354 # Try stepping when there's a signal pending, and a breakpoint at the
355 # handler's entry instruction and a breakpoint at the current
356 # instruction. Should step into the signal handler and breakpoint at
357 # that entry instruction.
359 # Some systems (e.x., GNU/Linux as of 2004-08-30), when delivering a
360 # signal, resume the process at the first instruction of the signal
361 # handler and not the first instruction of the signal trampoline. The
362 # stack is constructed such that the signal handler still appears to
363 # have been called by the trampoline code. This test checks that it
364 # is possible to stop the inferior, even at that first instruction.
366 proc breakpoint_to_handler_entry { i } {
369 set prefix "$i on breakpoint, to handler entry"
371 # Run around to the done
372 # You can add more patterns to this if you need them.
373 set test "$prefix; resync"
374 gdb_test_multiple "continue" "$test" {
375 -re "done = 0.*$gdb_prompt " {
380 gdb_test "break $infinite_loop" ".*" "$prefix; break infinite loop"
381 gdb_test "break *handler" ".*" "$prefix; break handler"
383 # Continue to the infinite loop
384 gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop"
386 # Make the signal pending
389 gdb_test "$i" " handler .*" "$prefix; performing $i"
390 gdb_test "clear $infinite_loop" ".*" "$prefix; clear infinite loop"
391 gdb_test "clear *handler" ".*" "$prefix; clear handler"
394 breakpoint_to_handler_entry step
395 breakpoint_to_handler_entry next
396 breakpoint_to_handler_entry continue
398 # Try stepping when there's a signal pending, and a pre-existing
399 # breakpoint at the current instruction, and no breakpoint in the
400 # handler. Should advance to the next line.
402 proc breakpoint_over_handler { i } {
405 set prefix "$i on breakpoint, skip handler"
407 # Run around to the done
408 # You can add more patterns to this if you need them.
409 set test "$prefix; resync"
410 gdb_test_multiple "continue" "$test" {
411 -re "done = 0.*$gdb_prompt " {
416 gdb_test "break $infinite_loop" ".*" "$prefix; break infinite loop"
418 # Continue to the infinite loop
419 gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop"
421 # Make the signal pending
424 gdb_test "$i" "done = 0.*" "$prefix; performing $i"
425 gdb_test "clear $infinite_loop" ".*" "$prefix; clear infinite loop"
428 breakpoint_over_handler step
429 breakpoint_over_handler next
430 breakpoint_over_handler continue