From: Jim Kingdon Date: Sun, 8 Jan 1995 23:03:28 +0000 (+0000) Subject: * TODO: Add note about "handle all nostop". X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=d71511fbd301c7069c13bd51cabffd3300487695;p=binutils-gdb.git * TODO: Add note about "handle all nostop". * gdb.base/{sigall.c, sigall.exp}: New test. * gdb.base/Makefile.in: Add it. --- diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 30dc1f39ed2..da954f8b94b 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,10 @@ +Wed Jan 4 11:35:19 1995 Jim Kingdon (kingdon@lioth.cygnus.com) + + * TODO: Add note about "handle all nostop". + + * gdb.base/{sigall.c, sigall.exp}: New test. + * gdb.base/Makefile.in: Add it. + Thu Jan 5 17:34:03 1995 Stan Shebs * lib/gdb.exp, gdb.base/corefile.exp: Supply -nw as argument diff --git a/gdb/testsuite/TODO b/gdb/testsuite/TODO index abb0f32c97e..ec0ce145166 100644 --- a/gdb/testsuite/TODO +++ b/gdb/testsuite/TODO @@ -183,6 +183,10 @@ compiler dependencies. Test more obscure wait_for_inferior cases, expanding on the tests in watchpoint.exp, signals.exp, etc. +Test "handle all nostop". Right now this is buggy--it (a) prints "?" +for "Unknown signal", (b) prints signal zero (bug or feature?), (c) +dumps core when it is done. + Test that the copyright year in the startup message matches the current year (would produce a single spurious FAIL on old GDB's, but probably still a good idea). diff --git a/gdb/testsuite/gdb.base/sigall.c b/gdb/testsuite/gdb.base/sigall.c new file mode 100644 index 00000000000..ba28298c219 --- /dev/null +++ b/gdb/testsuite/gdb.base/sigall.c @@ -0,0 +1,1368 @@ +#include + +/* Signal handlers, we set breakpoints in them to make sure that the + signals really get delivered. */ + +void +handle_ABRT (sig) + int sig; +{ +} + +void +handle_HUP (sig) + int sig; +{ +} + +void +handle_QUIT (sig) + int sig; +{ +} + +void +handle_ILL (sig) + int sig; +{ +} + +void +handle_EMT (sig) + int sig; +{ +} + +void +handle_FPE (sig) + int sig; +{ +} + +void +handle_BUS (sig) + int sig; +{ +} + +void +handle_SEGV (sig) + int sig; +{ +} + +void +handle_SYS (sig) + int sig; +{ +} + +void +handle_PIPE (sig) + int sig; +{ +} + +void +handle_ALRM (sig) + int sig; +{ +} + +void +handle_URG (sig) + int sig; +{ +} + +void +handle_TSTP (sig) + int sig; +{ +} + +void +handle_CONT (sig) + int sig; +{ +} + +void +handle_CHLD (sig) + int sig; +{ +} + +void +handle_TTIN (sig) + int sig; +{ +} + +void +handle_TTOU (sig) + int sig; +{ +} + +void +handle_IO (sig) + int sig; +{ +} + +void +handle_XCPU (sig) + int sig; +{ +} + +void +handle_XFSZ (sig) + int sig; +{ +} + +void +handle_VTALRM (sig) + int sig; +{ +} + +void +handle_PROF (sig) + int sig; +{ +} + +void +handle_WINCH (sig) + int sig; +{ +} + +void +handle_LOST (sig) + int sig; +{ +} + +void +handle_USR1 (sig) + int sig; +{ +} + +void +handle_USR2 (sig) + int sig; +{ +} + +void +handle_PWR (sig) + int sig; +{ +} + +void +handle_POLL (sig) + int sig; +{ +} + +void +handle_WIND (sig) + int sig; +{ +} + +void +handle_PHONE (sig) + int sig; +{ +} + +void +handle_WAITING (sig) + int sig; +{ +} + +void +handle_LWP (sig) + int sig; +{ +} + +void +handle_DANGER (sig) + int sig; +{ +} + +void +handle_GRANT (sig) + int sig; +{ +} + +void +handle_RETRACT (sig) + int sig; +{ +} + +void +handle_MSG (sig) + int sig; +{ +} + +void +handle_SOUND (sig) + int sig; +{ +} + +void +handle_SAK (sig) + int sig; +{ +} + +void +handle_PRIO (sig) + int sig; +{ +} + +void +handle_33 (sig) + int sig; +{ +} + +void +handle_34 (sig) + int sig; +{ +} + +void +handle_35 (sig) + int sig; +{ +} + +void +handle_36 (sig) + int sig; +{ +} + +void +handle_37 (sig) + int sig; +{ +} + +void +handle_38 (sig) + int sig; +{ +} + +void +handle_39 (sig) + int sig; +{ +} + +void +handle_40 (sig) + int sig; +{ +} + +void +handle_41 (sig) + int sig; +{ +} + +void +handle_42 (sig) + int sig; +{ +} + +void +handle_43 (sig) + int sig; +{ +} + +void +handle_44 (sig) + int sig; +{ +} + +void +handle_45 (sig) + int sig; +{ +} + +void +handle_46 (sig) + int sig; +{ +} + +void +handle_47 (sig) + int sig; +{ +} + +void +handle_48 (sig) + int sig; +{ +} + +void +handle_49 (sig) + int sig; +{ +} + +void +handle_50 (sig) + int sig; +{ +} + +void +handle_51 (sig) + int sig; +{ +} + +void +handle_52 (sig) + int sig; +{ +} + +void +handle_53 (sig) + int sig; +{ +} + +void +handle_54 (sig) + int sig; +{ +} + +void +handle_55 (sig) + int sig; +{ +} + +void +handle_56 (sig) + int sig; +{ +} + +void +handle_57 (sig) + int sig; +{ +} + +void +handle_58 (sig) + int sig; +{ +} + +void +handle_59 (sig) + int sig; +{ +} + +void +handle_60 (sig) + int sig; +{ +} + +void +handle_61 (sig) + int sig; +{ +} + +void +handle_62 (sig) + int sig; +{ +} + +void +handle_63 (sig) + int sig; +{ +} + +void +handle_TERM (sig) + int sig; +{ +} + +/* Functions to send signals. These also serve as markers. */ +int +gen_ABRT () +{ + kill (getpid (), SIGABRT); +} + +int +gen_HUP () +{ +#ifdef SIGHUP + kill (getpid (), SIGHUP); +#else + handle_HUP (); +#endif +} + +int +gen_QUIT () +{ +#ifdef SIGQUIT + kill (getpid (), SIGQUIT); +#else + handle_QUIT (); +#endif +} + +int +gen_ILL () +{ +#ifdef SIGILL + kill (getpid (), SIGILL); +#else + handle_ILL (); +#endif +} + +int +gen_EMT () +{ +#ifdef SIGEMT + kill (getpid (), SIGEMT); +#else + handle_EMT (); +#endif +} + +int x; + +int +gen_FPE () +{ + /* The intent behind generating SIGFPE this way is to check the mapping + from the CPU exception itself to the signals. It would be nice to + do the same for SIGBUS, SIGSEGV, etc., but I suspect that even this + test might turn out to be insufficiently portable. */ + + /* The expect script looks for the word "kill"; don't delete it. */ + return 5 / x; /* and we both started jumping up and down yelling kill */ +} + +int +gen_BUS () +{ +#ifdef SIGBUS + kill (getpid (), SIGBUS); +#else + handle_BUS (); +#endif +} + +int +gen_SEGV () +{ +#ifdef SIGSEGV + kill (getpid (), SIGSEGV); +#else + handle_SEGV (); +#endif +} + +int +gen_SYS () +{ +#ifdef SIGSYS + kill (getpid (), SIGSYS); +#else + handle_SYS (); +#endif +} + +int +gen_PIPE () +{ +#ifdef SIGPIPE + kill (getpid (), SIGPIPE); +#else + handle_PIPE (); +#endif +} + +int +gen_ALRM () +{ +#ifdef SIGALRM + kill (getpid (), SIGALRM); +#else + handle_ALRM (); +#endif +} + +int +gen_URG () +{ +#ifdef SIGURG + kill (getpid (), SIGURG); +#else + handle_URG (); +#endif +} + +int +gen_TSTP () +{ +#ifdef SIGTSTP + kill (getpid (), SIGTSTP); +#else + handle_TSTP (); +#endif +} + +int +gen_CONT () +{ +#ifdef SIGCONT + kill (getpid (), SIGCONT); +#else + handle_CONT (); +#endif +} + +int +gen_CHLD () +{ +#ifdef SIGCHLD + kill (getpid (), SIGCHLD); +#else + handle_CHLD (); +#endif +} + +int +gen_TTIN () +{ +#ifdef SIGTTIN + kill (getpid (), SIGTTIN); +#else + handle_TTIN (); +#endif +} + +int +gen_TTOU () +{ +#ifdef SIGTTOU + kill (getpid (), SIGTTOU); +#else + handle_TTOU (); +#endif +} + +int +gen_IO () +{ +#ifdef SIGIO + kill (getpid (), SIGIO); +#else + handle_IO (); +#endif +} + +int +gen_XCPU () +{ +#ifdef SIGXCPU + kill (getpid (), SIGXCPU); +#else + handle_XCPU (); +#endif +} + +int +gen_XFSZ () +{ +#ifdef SIGXFSZ + kill (getpid (), SIGXFSZ); +#else + handle_XFSZ (); +#endif +} + +int +gen_VTALRM () +{ +#ifdef SIGVTALRM + kill (getpid (), SIGVTALRM); +#else + handle_VTALRM (); +#endif +} + +int +gen_PROF () +{ +#ifdef SIGPROF + kill (getpid (), SIGPROF); +#else + handle_PROF (); +#endif +} + +int +gen_WINCH () +{ +#ifdef SIGWINCH + kill (getpid (), SIGWINCH); +#else + handle_WINCH (); +#endif +} + +int +gen_LOST () +{ +#ifdef SIGLOST + kill (getpid (), SIGLOST); +#else + handle_LOST (); +#endif +} + +int +gen_USR1 () +{ +#ifdef SIGUSR1 + kill (getpid (), SIGUSR1); +#else + handle_USR1 (); +#endif +} + +int +gen_USR2 () +{ +#ifdef SIGUSR2 + kill (getpid (), SIGUSR2); +#else + handle_USR2 (); +#endif +} + +int +gen_PWR () +{ +#ifdef SIGPWR + kill (getpid (), SIGPWR); +#else + handle_PWR (); +#endif +} + +int +gen_POLL () +{ +#ifdef SIGPOLL + kill (getpid (), SIGPOLL); +#else + handle_POLL (); +#endif +} + +int +gen_WIND () +{ +#ifdef SIGWIND + kill (getpid (), SIGWIND); +#else + handle_WIND (); +#endif +} + +int +gen_PHONE () +{ +#ifdef SIGPHONE + kill (getpid (), SIGPHONE); +#else + handle_PHONE (); +#endif +} + +int +gen_WAITING () +{ +#ifdef SIGWAITING + kill (getpid (), SIGWAITING); +#else + handle_WAITING (); +#endif +} + +int +gen_LWP () +{ +#ifdef SIGLWP + kill (getpid (), SIGLWP); +#else + handle_LWP (); +#endif +} + +int +gen_DANGER () +{ +#ifdef SIGDANGER + kill (getpid (), SIGDANGER); +#else + handle_DANGER (); +#endif +} + +int +gen_GRANT () +{ +#ifdef SIGGRANT + kill (getpid (), SIGGRANT); +#else + handle_GRANT (); +#endif +} + +int +gen_RETRACT () +{ +#ifdef SIGRETRACT + kill (getpid (), SIGRETRACT); +#else + handle_RETRACT (); +#endif +} + +int +gen_MSG () +{ +#ifdef SIGMSG + kill (getpid (), SIGMSG); +#else + handle_MSG (); +#endif +} + +int +gen_SOUND () +{ +#ifdef SIGSOUND + kill (getpid (), SIGSOUND); +#else + handle_SOUND (); +#endif +} + +int +gen_SAK () +{ +#ifdef SIGSAK + kill (getpid (), SIGSAK); +#else + handle_SAK (); +#endif +} + +int +gen_PRIO () +{ +#ifdef SIGPRIO + kill (getpid (), SIGPRIO); +#else + handle_PRIO (); +#endif +} + +int +gen_33 () +{ +#ifdef SIG33 + kill (getpid (), 33); +#else + handle_33 (); +#endif +} + +int +gen_34 () +{ +#ifdef SIG34 + kill (getpid (), 34); +#else + handle_34 (); +#endif +} + +int +gen_35 () +{ +#ifdef SIG35 + kill (getpid (), 35); +#else + handle_35 (); +#endif +} + +int +gen_36 () +{ +#ifdef SIG36 + kill (getpid (), 36); +#else + handle_36 (); +#endif +} + +int +gen_37 () +{ +#ifdef SIG37 + kill (getpid (), 37); +#else + handle_37 (); +#endif +} + +int +gen_38 () +{ +#ifdef SIG38 + kill (getpid (), 38); +#else + handle_38 (); +#endif +} + +int +gen_39 () +{ +#ifdef SIG39 + kill (getpid (), 39); +#else + handle_39 (); +#endif +} + +int +gen_40 () +{ +#ifdef SIG40 + kill (getpid (), 40); +#else + handle_40 (); +#endif +} + +int +gen_41 () +{ +#ifdef SIG41 + kill (getpid (), 41); +#else + handle_41 (); +#endif +} + +int +gen_42 () +{ +#ifdef SIG42 + kill (getpid (), 42); +#else + handle_42 (); +#endif +} + +int +gen_43 () +{ +#ifdef SIG43 + kill (getpid (), 43); +#else + handle_43 (); +#endif +} + +int +gen_44 () +{ +#ifdef SIG44 + kill (getpid (), 44); +#else + handle_44 (); +#endif +} + +int +gen_45 () +{ +#ifdef SIG45 + kill (getpid (), 45); +#else + handle_45 (); +#endif +} + +int +gen_46 () +{ +#ifdef SIG46 + kill (getpid (), 46); +#else + handle_46 (); +#endif +} + +int +gen_47 () +{ +#ifdef SIG47 + kill (getpid (), 47); +#else + handle_47 (); +#endif +} + +int +gen_48 () +{ +#ifdef SIG48 + kill (getpid (), 48); +#else + handle_48 (); +#endif +} + +int +gen_49 () +{ +#ifdef SIG49 + kill (getpid (), 49); +#else + handle_49 (); +#endif +} + +int +gen_50 () +{ +#ifdef SIG50 + kill (getpid (), 50); +#else + handle_50 (); +#endif +} + +int +gen_51 () +{ +#ifdef SIG51 + kill (getpid (), 51); +#else + handle_51 (); +#endif +} + +int +gen_52 () +{ +#ifdef SIG52 + kill (getpid (), 52); +#else + handle_52 (); +#endif +} + +int +gen_53 () +{ +#ifdef SIG53 + kill (getpid (), 53); +#else + handle_53 (); +#endif +} + +int +gen_54 () +{ +#ifdef SIG54 + kill (getpid (), 54); +#else + handle_54 (); +#endif +} + +int +gen_55 () +{ +#ifdef SIG55 + kill (getpid (), 55); +#else + handle_55 (); +#endif +} + +int +gen_56 () +{ +#ifdef SIG56 + kill (getpid (), 56); +#else + handle_56 (); +#endif +} + +int +gen_57 () +{ +#ifdef SIG57 + kill (getpid (), 57); +#else + handle_57 (); +#endif +} + +int +gen_58 () +{ +#ifdef SIG58 + kill (getpid (), 58); +#else + handle_58 (); +#endif +} + +int +gen_59 () +{ +#ifdef SIG59 + kill (getpid (), 59); +#else + handle_59 (); +#endif +} + +int +gen_60 () +{ +#ifdef SIG60 + kill (getpid (), 60); +#else + handle_60 (); +#endif +} + +int +gen_61 () +{ +#ifdef SIG61 + kill (getpid (), 61); +#else + handle_61 (); +#endif +} + +int +gen_62 () +{ +#ifdef SIG62 + kill (getpid (), 62); +#else + handle_62 (); +#endif +} + +int +gen_63 () +{ +#ifdef SIG63 + kill (getpid (), 63); +#else + handle_63 (); +#endif +} + +int +gen_TERM () +{ + kill (getpid (), SIGTERM); +} + +int +main () +{ + signal (SIGABRT, handle_ABRT); +#ifdef SIGHUP + signal (SIGHUP, handle_HUP); +#endif +#ifdef SIGQUIT + signal (SIGQUIT, handle_QUIT); +#endif +#ifdef SIGILL + signal (SIGILL, handle_ILL); +#endif +#ifdef SIGEMT + signal (SIGEMT, handle_EMT); +#endif +#ifdef SIGFPE + signal (SIGFPE, handle_FPE); +#endif +#ifdef SIGBUS + signal (SIGBUS, handle_BUS); +#endif +#ifdef SIGSEGV + signal (SIGSEGV, handle_SEGV); +#endif +#ifdef SIGSYS + signal (SIGSYS, handle_SYS); +#endif +#ifdef SIGPIPE + signal (SIGPIPE, handle_PIPE); +#endif +#ifdef SIGALRM + signal (SIGALRM, handle_ALRM); +#endif +#ifdef SIGURG + signal (SIGURG, handle_URG); +#endif +#ifdef SIGTSTP + signal (SIGTSTP, handle_TSTP); +#endif +#ifdef SIGCONT + signal (SIGCONT, handle_CONT); +#endif +#ifdef SIGCHLD + signal (SIGCHLD, handle_CHLD); +#endif +#ifdef SIGTTIN + signal (SIGTTIN, handle_TTIN); +#endif +#ifdef SIGTTOU + signal (SIGTTOU, handle_TTOU); +#endif +#ifdef SIGIO + signal (SIGIO, handle_IO); +#endif +#ifdef SIGXCPU + signal (SIGXCPU, handle_XCPU); +#endif +#ifdef SIGXFSZ + signal (SIGXFSZ, handle_XFSZ); +#endif +#ifdef SIGVTALRM + signal (SIGVTALRM, handle_VTALRM); +#endif +#ifdef SIGPROF + signal (SIGPROF, handle_PROF); +#endif +#ifdef SIGWINCH + signal (SIGWINCH, handle_WINCH); +#endif +#ifdef SIGLOST + signal (SIGLOST, handle_LOST); +#endif +#ifdef SIGUSR1 + signal (SIGUSR1, handle_USR1); +#endif +#ifdef SIGUSR2 + signal (SIGUSR2, handle_USR2); +#endif +#ifdef SIGPWR + signal (SIGPWR, handle_PWR); +#endif +#ifdef SIGPOLL + signal (SIGPOLL, handle_POLL); +#endif +#ifdef SIGWIND + signal (SIGWIND, handle_WIND); +#endif +#ifdef SIGPHONE + signal (SIGPHONE, handle_PHONE); +#endif +#ifdef SIGWAITING + signal (SIGWAITING, handle_WAITING); +#endif +#ifdef SIGLWP + signal (SIGLWP, handle_LWP); +#endif +#ifdef SIGDANGER + signal (SIGDANGER, handle_DANGER); +#endif +#ifdef SIGGRANT + signal (SIGGRANT, handle_GRANT); +#endif +#ifdef SIGRETRACT + signal (SIGRETRACT, handle_RETRACT); +#endif +#ifdef SIGMSG + signal (SIGMSG, handle_MSG); +#endif +#ifdef SIGSOUND + signal (SIGSOUND, handle_SOUND); +#endif +#ifdef SIGSAK + signal (SIGSAK, handle_SAK); +#endif +#ifdef SIGPRIO + signal (SIGPRIO, handle_PRIO); +#endif +#ifdef __Lynx__ + /* Lynx doesn't seem to have anything in signal.h for this. */ + signal (33, handle_33); + signal (34, handle_34); + signal (35, handle_35); + signal (36, handle_36); + signal (37, handle_37); + signal (38, handle_38); + signal (39, handle_39); + signal (40, handle_40); + signal (41, handle_41); + signal (42, handle_42); + signal (43, handle_43); + signal (44, handle_44); + signal (45, handle_45); + signal (46, handle_46); + signal (47, handle_47); + signal (48, handle_48); + signal (49, handle_49); + signal (50, handle_50); + signal (51, handle_51); + signal (52, handle_52); + signal (53, handle_53); + signal (54, handle_54); + signal (55, handle_55); + signal (56, handle_56); + signal (57, handle_57); + signal (58, handle_58); + signal (59, handle_59); + signal (60, handle_60); + signal (61, handle_61); + signal (62, handle_62); + signal (63, handle_63); +#endif /* lynx */ + signal (SIGTERM, handle_TERM); + + x = 0; + + gen_ABRT (); + gen_HUP (); + gen_QUIT (); + gen_ILL (); + gen_EMT (); + gen_FPE (); + gen_BUS (); + gen_SEGV (); + gen_SYS (); + gen_PIPE (); + gen_ALRM (); + gen_URG (); + gen_TSTP (); + gen_CONT (); + gen_CHLD (); + gen_TTIN (); + gen_TTOU (); + gen_IO (); + gen_XCPU (); + gen_XFSZ (); + gen_VTALRM (); + gen_PROF (); + gen_WINCH (); + gen_LOST (); + gen_USR1 (); + gen_USR2 (); + gen_PWR (); + gen_POLL (); + gen_WIND (); + gen_PHONE (); + gen_WAITING (); + gen_LWP (); + gen_DANGER (); + gen_GRANT (); + gen_RETRACT (); + gen_MSG (); + gen_SOUND (); + gen_SAK (); + gen_PRIO (); + gen_33 (); + gen_34 (); + gen_35 (); + gen_36 (); + gen_37 (); + gen_38 (); + gen_39 (); + gen_40 (); + gen_41 (); + gen_42 (); + gen_43 (); + gen_44 (); + gen_45 (); + gen_46 (); + gen_47 (); + gen_48 (); + gen_49 (); + gen_50 (); + gen_51 (); + gen_52 (); + gen_53 (); + gen_54 (); + gen_55 (); + gen_56 (); + gen_57 (); + gen_58 (); + gen_59 (); + gen_60 (); + gen_61 (); + gen_62 (); + gen_63 (); + gen_TERM (); + + return 0; +} diff --git a/gdb/testsuite/gdb.base/sigall.exp b/gdb/testsuite/gdb.base/sigall.exp new file mode 100644 index 00000000000..4a2b06619b6 --- /dev/null +++ b/gdb/testsuite/gdb.base/sigall.exp @@ -0,0 +1,177 @@ +# Copyright (C) 1995 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 2 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, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +if $tracelevel then { + strace $tracelevel +} + +set prms_id 0 +set bug_id 0 + +gdb_reinitialize_dir $srcdir/$subdir +set binfile $objdir/$subdir/sigall + +if ![file exists $binfile] then { + perror "$binfile does not exist." + return 0 +} + +# Make the first signal SIGABRT because it is always supported. +set sig_supported 1 +set thissig "ABRT" + +proc test_one_sig {nextsig} { + global sig_supported + global prompt + global thissig + + set this_sig_supported $sig_supported + gdb_test "handle SIG$thissig stop print" \ + "SIG$thissig\[ \t\]*Yes\[ \t\]*Yes\[ \t\]*Yes" + gdb_test "b handle_$thissig" "Breakpoint \[0-9\]" + gdb_test "b gen_$nextsig" "Breakpoint \[0-9\]" + if $this_sig_supported then { + if {"$thissig" == "POLL"} then { + # If SIGIO and SIGPOLL are the same signal it gets reported + # as SIGIO; it is a feature for GDB to always use the "preferred" + # name (the POSIX name if there is one, etc.); I suspect that is + # SIGIO in this case but I'm not sure. + set pattern "(POLL|IO)" + } else { + set pattern $thissig + } + gdb_test "continue" \ + "Continuing.*Program received signal SIG$pattern" \ + "get signal $thissig" + } + if {"$thissig" == "IO"} then { + # SIGIO and SIGPOLL might be the same signal. + # If so we end up at handle_POLL because we + # establish the handler for SIGPOLL after SIGIO. + set pattern "Breakpoint.*handle_(POLL|IO)" + } else { + set pattern "Breakpoint.*handle_$thissig" + } + gdb_test "continue" $pattern "send signal $thissig" + send "continue\n" + expect { + -re "Breakpoint.*gen_$nextsig.*kill.*$prompt $" { + pass "advance to $nextsig" + set sig_supported 1 + } + -re "Breakpoint.*gen_$nextsig.*handle.*$prompt $" { + pass "advance to $nextsig" + set sig_supported 0 + } + -re ".*$prompt $" { fail "advance to $nextsig" } + default { fail "advance to $nextsig (eof or timeout)" } + } + set thissig $nextsig +} + +gdb_load $binfile + +runto gen_ABRT +test_one_sig HUP +test_one_sig QUIT +test_one_sig ILL +test_one_sig EMT +test_one_sig FPE +test_one_sig BUS +test_one_sig SEGV +test_one_sig SYS +test_one_sig PIPE +test_one_sig ALRM +test_one_sig URG +test_one_sig TSTP +test_one_sig CONT +test_one_sig CHLD +test_one_sig TTIN +test_one_sig TTOU +test_one_sig IO + +# Set an extra breakpoint at handle_POLL, to deal with the fact that +# SIGIO and SIGPOLL might be the same signal. + +gdb_test "b handle_POLL" "Breakpoint \[0-9\]" \ + "set extra handle_POLL breakpoint" + +test_one_sig XCPU +test_one_sig XFSZ +test_one_sig VTALRM +test_one_sig PROF +test_one_sig WINCH +test_one_sig LOST +test_one_sig USR1 +test_one_sig USR2 +test_one_sig PWR +test_one_sig POLL +test_one_sig WIND +test_one_sig PHONE +test_one_sig WAITING +test_one_sig LWP +test_one_sig DANGER +test_one_sig GRANT +test_one_sig RETRACT +test_one_sig MSG +test_one_sig SOUND +test_one_sig SAK +test_one_sig PRIO +test_one_sig 33 +test_one_sig 34 +test_one_sig 35 +test_one_sig 36 +test_one_sig 37 +test_one_sig 38 +test_one_sig 39 +test_one_sig 40 +test_one_sig 41 +test_one_sig 42 +test_one_sig 43 +test_one_sig 44 +test_one_sig 45 +test_one_sig 46 +test_one_sig 47 +test_one_sig 48 +test_one_sig 49 +test_one_sig 50 +test_one_sig 51 +test_one_sig 52 +test_one_sig 53 +test_one_sig 54 +test_one_sig 55 +test_one_sig 56 +test_one_sig 57 +test_one_sig 58 +test_one_sig 59 +test_one_sig 60 +test_one_sig 61 +test_one_sig 62 +test_one_sig 63 +test_one_sig TERM + +# The last signal (SIGTERM) gets handled slightly differently because +# we are not setting up for another test. +gdb_test "handle SIGTERM stop print" \ + "SIGTERM\[ \t\]*Yes\[ \t\]*Yes\[ \t\]*Yes" +gdb_test "b handle_TERM" "Breakpoint \[0-9\]" +gdb_test "continue" \ + "Continuing.*Program received signal SIGTERM" \ + "get signal TERM" +gdb_test "continue" "Breakpoint.*handle_TERM" "send signal TERM" +gdb_test "continue" "Program exited normally" "continue to sigall exit" + +return 0