From b43b923a25d813161bf3596b31a7f00ef9608537 Mon Sep 17 00:00:00 2001 From: Michael Snyder Date: Sun, 13 Sep 2009 00:28:39 +0000 Subject: [PATCH] 2009-09-12 Michael Snyder * gdb.reverse/step-reverse.exp: Explicitly check for targets that can support reverse debuggnig. --- gdb/testsuite/ChangeLog | 5 + gdb/testsuite/gdb.reverse/sigall-reverse.c | 1413 ++++++++++++++++++ gdb/testsuite/gdb.reverse/sigall-reverse.exp | 421 ++++++ 3 files changed, 1839 insertions(+) create mode 100644 gdb/testsuite/gdb.reverse/sigall-reverse.c create mode 100644 gdb/testsuite/gdb.reverse/sigall-reverse.exp diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 1ce646b9e02..ccf5677e129 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2009-09-12 Michael Snyder + + * gdb.reverse/step-reverse.exp: Explicitly check for targets + that can support reverse debuggnig. + 2009-09-11 Tom Tromey * gdb.dwarf2/valop.S: New file. diff --git a/gdb/testsuite/gdb.reverse/sigall-reverse.c b/gdb/testsuite/gdb.reverse/sigall-reverse.c new file mode 100644 index 00000000000..220756a0551 --- /dev/null +++ b/gdb/testsuite/gdb.reverse/sigall-reverse.c @@ -0,0 +1,1413 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2009 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 . */ + +#include +#include + +#ifdef __sh__ +#define signal(a,b) /* Signals not supported on this target - make them go away */ +#endif + +/* Signal handlers, we set breakpoints in them to make sure that the + signals really get delivered. */ + +void +handle_ABRT (int sig) +{ +} + +void +handle_HUP (int sig) +{ +} + +void +handle_QUIT (int sig) +{ +} + +void +handle_ILL (int sig) +{ +} + +void +handle_EMT (int sig) +{ +} + +void +handle_FPE (int sig) +{ +} + +void +handle_BUS (int sig) +{ +} + +void +handle_SEGV (int sig) +{ +} + +void +handle_SYS (int sig) +{ +} + +void +handle_PIPE (int sig) +{ +} + +void +handle_ALRM (int sig) +{ +} + +void +handle_URG (int sig) +{ +} + +void +handle_TSTP (int sig) +{ +} + +void +handle_CONT (int sig) +{ +} + +void +handle_CHLD (int sig) +{ +} + +void +handle_TTIN (int sig) +{ +} + +void +handle_TTOU (int sig) +{ +} + +void +handle_IO (int sig) +{ +} + +void +handle_XCPU (int sig) +{ +} + +void +handle_XFSZ (int sig) +{ +} + +void +handle_VTALRM (int sig) +{ +} + +void +handle_PROF (int sig) +{ +} + +void +handle_WINCH (int sig) +{ +} + +void +handle_LOST (int sig) +{ +} + +void +handle_USR1 (int sig) +{ +} + +void +handle_USR2 (int sig) +{ +} + +void +handle_PWR (int sig) +{ +} + +void +handle_POLL (int sig) +{ +} + +void +handle_WIND (int sig) +{ +} + +void +handle_PHONE (int sig) +{ +} + +void +handle_WAITING (int sig) +{ +} + +void +handle_LWP (int sig) +{ +} + +void +handle_DANGER (int sig) +{ +} + +void +handle_GRANT (int sig) +{ +} + +void +handle_RETRACT (int sig) +{ +} + +void +handle_MSG (int sig) +{ +} + +void +handle_SOUND (int sig) +{ +} + +void +handle_SAK (int sig) +{ +} + +void +handle_PRIO (int sig) +{ +} + +void +handle_33 (int sig) +{ +} + +void +handle_34 (int sig) +{ +} + +void +handle_35 (int sig) +{ +} + +void +handle_36 (int sig) +{ +} + +void +handle_37 (int sig) +{ +} + +void +handle_38 (int sig) +{ +} + +void +handle_39 (int sig) +{ +} + +void +handle_40 (int sig) +{ +} + +void +handle_41 (int sig) +{ +} + +void +handle_42 (int sig) +{ +} + +void +handle_43 (int sig) +{ +} + +void +handle_44 (int sig) +{ +} + +void +handle_45 (int sig) +{ +} + +void +handle_46 (int sig) +{ +} + +void +handle_47 (int sig) +{ +} + +void +handle_48 (int sig) +{ +} + +void +handle_49 (int sig) +{ +} + +void +handle_50 (int sig) +{ +} + +void +handle_51 (int sig) +{ +} + +void +handle_52 (int sig) +{ +} + +void +handle_53 (int sig) +{ +} + +void +handle_54 (int sig) +{ +} + +void +handle_55 (int sig) +{ +} + +void +handle_56 (int sig) +{ +} + +void +handle_57 (int sig) +{ +} + +void +handle_58 (int sig) +{ +} + +void +handle_59 (int sig) +{ +} + +void +handle_60 (int sig) +{ +} + +void +handle_61 (int sig) +{ +} + +void +handle_62 (int sig) +{ +} + +void +handle_63 (int sig) +{ +} + +void +handle_TERM (int sig) +{ +} + +/* Functions to send signals. These also serve as markers. */ +int +gen_ABRT (void) +{ + kill (getpid (), SIGABRT); + return 0; +} + +int +gen_HUP (void) +{ +#ifdef SIGHUP + kill (getpid (), SIGHUP); +#else + handle_HUP (0); +#endif +return 0; +} + +int +gen_QUIT (void) +{ +#ifdef SIGQUIT + kill (getpid (), SIGQUIT); +#else + handle_QUIT (0); +#endif +return 0; +} + +int +gen_ILL (void) +{ +#ifdef SIGILL + kill (getpid (), SIGILL); +#else + handle_ILL (0); +#endif +return 0; +} + +int +gen_EMT (void) +{ +#ifdef SIGEMT + kill (getpid (), SIGEMT); +#else + handle_EMT (0); +#endif +return 0; +} + +int x; + +int +gen_FPE (void) +{ + /* 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. */ + +#if 0 + /* Loses on the PA because after the signal handler executes we try to + re-execute the failing instruction again. Perhaps we could siglongjmp + out of the signal handler? */ + /* 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 */ +#else + kill (getpid (), SIGFPE); +#endif +return 0; +} + +int +gen_BUS (void) +{ +#ifdef SIGBUS + kill (getpid (), SIGBUS); +#else + handle_BUS (0); +#endif +return 0; +} + +int +gen_SEGV (void) +{ +#ifdef SIGSEGV + kill (getpid (), SIGSEGV); +#else + handle_SEGV (0); +#endif +return 0; +} + +int +gen_SYS (void) +{ +#ifdef SIGSYS + kill (getpid (), SIGSYS); +#else + handle_SYS (0); +#endif +return 0; +} + +int +gen_PIPE (void) +{ +#ifdef SIGPIPE + kill (getpid (), SIGPIPE); +#else + handle_PIPE (0); +#endif +return 0; +} + +int +gen_ALRM (void) +{ +#ifdef SIGALRM + kill (getpid (), SIGALRM); +#else + handle_ALRM (0); +#endif +return 0; +} + +int +gen_URG (void) +{ +#ifdef SIGURG + kill (getpid (), SIGURG); +#else + handle_URG (0); +#endif +return 0; +} + +int +gen_TSTP (void) +{ +#ifdef SIGTSTP + kill (getpid (), SIGTSTP); +#else + handle_TSTP (0); +#endif +return 0; +} + +int +gen_CONT (void) +{ +#ifdef SIGCONT + kill (getpid (), SIGCONT); +#else + handle_CONT (0); +#endif +return 0; +} + +int +gen_CHLD (void) +{ +#ifdef SIGCHLD + kill (getpid (), SIGCHLD); +#else + handle_CHLD (0); +#endif +return 0; +} + +int +gen_TTIN (void) +{ +#ifdef SIGTTIN + kill (getpid (), SIGTTIN); +#else + handle_TTIN (0); +#endif +return 0; +} + +int +gen_TTOU (void) +{ +#ifdef SIGTTOU + kill (getpid (), SIGTTOU); +#else + handle_TTOU (0); +#endif +return 0; +} + +int +gen_IO (void) +{ +#ifdef SIGIO + kill (getpid (), SIGIO); +#else + handle_IO (0); +#endif +return 0; +} + +int +gen_XCPU (void) +{ +#ifdef SIGXCPU + kill (getpid (), SIGXCPU); +#else + handle_XCPU (0); +#endif +return 0; +} + +int +gen_XFSZ (void) +{ +#ifdef SIGXFSZ + kill (getpid (), SIGXFSZ); +#else + handle_XFSZ (0); +#endif +return 0; +} + +int +gen_VTALRM (void) +{ +#ifdef SIGVTALRM + kill (getpid (), SIGVTALRM); +#else + handle_VTALRM (0); +#endif +return 0; +} + +int +gen_PROF (void) +{ +#ifdef SIGPROF + kill (getpid (), SIGPROF); +#else + handle_PROF (0); +#endif +return 0; +} + +int +gen_WINCH (void) +{ +#ifdef SIGWINCH + kill (getpid (), SIGWINCH); +#else + handle_WINCH (0); +#endif +return 0; +} + +int +gen_LOST (void) +{ +#if defined(SIGLOST) && (!defined(SIGABRT) || SIGLOST != SIGABRT) + kill (getpid (), SIGLOST); +#else + handle_LOST (0); +#endif +return 0; +} + +int +gen_USR1 (void) +{ +#ifdef SIGUSR1 + kill (getpid (), SIGUSR1); +#else + handle_USR1 (0); +#endif +return 0; +} + +int +gen_USR2 (void) +{ +#ifdef SIGUSR2 + kill (getpid (), SIGUSR2); +#else + handle_USR2 (0); +#endif +return 0; +} + +int +gen_PWR (void) +{ +#ifdef SIGPWR + kill (getpid (), SIGPWR); +#else + handle_PWR (0); +#endif +return 0; +} + +int +gen_POLL (void) +{ +#if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO) + kill (getpid (), SIGPOLL); +#else + handle_POLL (0); +#endif +return 0; +} + +int +gen_WIND (void) +{ +#ifdef SIGWIND + kill (getpid (), SIGWIND); +#else + handle_WIND (0); +#endif +return 0; +} + +int +gen_PHONE (void) +{ +#ifdef SIGPHONE + kill (getpid (), SIGPHONE); +#else + handle_PHONE (0); +#endif +return 0; +} + +int +gen_WAITING (void) +{ +#ifdef SIGWAITING + kill (getpid (), SIGWAITING); +#else + handle_WAITING (0); +#endif +return 0; +} + +int +gen_LWP (void) +{ +#ifdef SIGLWP + kill (getpid (), SIGLWP); +#else + handle_LWP (0); +#endif +return 0; +} + +int +gen_DANGER (void) +{ +#ifdef SIGDANGER + kill (getpid (), SIGDANGER); +#else + handle_DANGER (0); +#endif +return 0; +} + +int +gen_GRANT (void) +{ +#ifdef SIGGRANT + kill (getpid (), SIGGRANT); +#else + handle_GRANT (0); +#endif +return 0; +} + +int +gen_RETRACT (void) +{ +#ifdef SIGRETRACT + kill (getpid (), SIGRETRACT); +#else + handle_RETRACT (0); +#endif +return 0; +} + +int +gen_MSG (void) +{ +#ifdef SIGMSG + kill (getpid (), SIGMSG); +#else + handle_MSG (0); +#endif +return 0; +} + +int +gen_SOUND (void) +{ +#ifdef SIGSOUND + kill (getpid (), SIGSOUND); +#else + handle_SOUND (0); +#endif +return 0; +} + +int +gen_SAK (void) +{ +#ifdef SIGSAK + kill (getpid (), SIGSAK); +#else + handle_SAK (0); +#endif +return 0; +} + +int +gen_PRIO (void) +{ +#ifdef SIGPRIO + kill (getpid (), SIGPRIO); +#else + handle_PRIO (0); +#endif +return 0; +} + +int +gen_33 (void) +{ +#ifdef SIG33 + kill (getpid (), 33); +#else + handle_33 (0); +#endif +return 0; +} + +int +gen_34 (void) +{ +#ifdef SIG34 + kill (getpid (), 34); +#else + handle_34 (0); +#endif +return 0; +} + +int +gen_35 (void) +{ +#ifdef SIG35 + kill (getpid (), 35); +#else + handle_35 (0); +#endif +return 0; +} + +int +gen_36 (void) +{ +#ifdef SIG36 + kill (getpid (), 36); +#else + handle_36 (0); +#endif +return 0; +} + +int +gen_37 (void) +{ +#ifdef SIG37 + kill (getpid (), 37); +#else + handle_37 (0); +#endif +return 0; +} + +int +gen_38 (void) +{ +#ifdef SIG38 + kill (getpid (), 38); +#else + handle_38 (0); +#endif +return 0; +} + +int +gen_39 (void) +{ +#ifdef SIG39 + kill (getpid (), 39); +#else + handle_39 (0); +#endif +return 0; +} + +int +gen_40 (void) +{ +#ifdef SIG40 + kill (getpid (), 40); +#else + handle_40 (0); +#endif +return 0; +} + +int +gen_41 (void) +{ +#ifdef SIG41 + kill (getpid (), 41); +#else + handle_41 (0); +#endif +return 0; +} + +int +gen_42 (void) +{ +#ifdef SIG42 + kill (getpid (), 42); +#else + handle_42 (0); +#endif +return 0; +} + +int +gen_43 (void) +{ +#ifdef SIG43 + kill (getpid (), 43); +#else + handle_43 (0); +#endif +return 0; +} + +int +gen_44 (void) +{ +#ifdef SIG44 + kill (getpid (), 44); +#else + handle_44 (0); +#endif +return 0; +} + +int +gen_45 (void) +{ +#ifdef SIG45 + kill (getpid (), 45); +#else + handle_45 (0); +#endif +return 0; +} + +int +gen_46 (void) +{ +#ifdef SIG46 + kill (getpid (), 46); +#else + handle_46 (0); +#endif +return 0; +} + +int +gen_47 (void) +{ +#ifdef SIG47 + kill (getpid (), 47); +#else + handle_47 (0); +#endif +return 0; +} + +int +gen_48 (void) +{ +#ifdef SIG48 + kill (getpid (), 48); +#else + handle_48 (0); +#endif +return 0; +} + +int +gen_49 (void) +{ +#ifdef SIG49 + kill (getpid (), 49); +#else + handle_49 (0); +#endif +return 0; +} + +int +gen_50 (void) +{ +#ifdef SIG50 + kill (getpid (), 50); +#else + handle_50 (0); +#endif +return 0; +} + +int +gen_51 (void) +{ +#ifdef SIG51 + kill (getpid (), 51); +#else + handle_51 (0); +#endif +return 0; +} + +int +gen_52 (void) +{ +#ifdef SIG52 + kill (getpid (), 52); +#else + handle_52 (0); +#endif +return 0; +} + +int +gen_53 (void) +{ +#ifdef SIG53 + kill (getpid (), 53); +#else + handle_53 (0); +#endif +return 0; +} + +int +gen_54 (void) +{ +#ifdef SIG54 + kill (getpid (), 54); +#else + handle_54 (0); +#endif +return 0; +} + +int +gen_55 (void) +{ +#ifdef SIG55 + kill (getpid (), 55); +#else + handle_55 (0); +#endif +return 0; +} + +int +gen_56 (void) +{ +#ifdef SIG56 + kill (getpid (), 56); +#else + handle_56 (0); +#endif +return 0; +} + +int +gen_57 (void) +{ +#ifdef SIG57 + kill (getpid (), 57); +#else + handle_57 (0); +#endif +return 0; +} + +int +gen_58 (void) +{ +#ifdef SIG58 + kill (getpid (), 58); +#else + handle_58 (0); +#endif +return 0; +} + +int +gen_59 (void) +{ +#ifdef SIG59 + kill (getpid (), 59); +#else + handle_59 (0); +#endif +return 0; +} + +int +gen_60 (void) +{ +#ifdef SIG60 + kill (getpid (), 60); +#else + handle_60 (0); +#endif +return 0; +} + +int +gen_61 (void) +{ +#ifdef SIG61 + kill (getpid (), 61); +#else + handle_61 (0); +#endif +return 0; +} + +int +gen_62 (void) +{ +#ifdef SIG62 + kill (getpid (), 62); +#else + handle_62 (0); +#endif +return 0; +} + +int +gen_63 (void) +{ +#ifdef SIG63 + kill (getpid (), 63); +#else + handle_63 (0); +#endif +return 0; +} + +int +gen_TERM (void) +{ + kill (getpid (), SIGTERM); +return 0; +} + +int +main () +{ +#ifdef usestubs + set_debug_traps (); + breakpoint (); +#endif + +#ifdef SIG_SETMASK + /* Ensure all the signals aren't blocked. + The environment in which the testsuite is run may have blocked some + for whatever reason. */ + { + sigset_t newset; + sigemptyset (&newset); + sigprocmask (SIG_SETMASK, &newset, NULL); + } +#endif + + 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 +#if defined(SIGLOST) && (!defined(SIGABRT) || SIGLOST != SIGABRT) + 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 +#if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO) + 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.reverse/sigall-reverse.exp b/gdb/testsuite/gdb.reverse/sigall-reverse.exp new file mode 100644 index 00000000000..fa49ad51c8f --- /dev/null +++ b/gdb/testsuite/gdb.reverse/sigall-reverse.exp @@ -0,0 +1,421 @@ +# Copyright 2009 +# 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 . + +if [target_info exists gdb,nosignals] { + verbose "Skipping sigall-reverse.exp because of nosignals." + return +} + +if ![target_info exists gdb,can_reverse] { + return +} + +if $tracelevel then { + strace $tracelevel +} + +set prms_id 0 +set bug_id 0 + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +set testfile sigall-reverse +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + untested sigall.exp + return -1 +} + +# 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 gdb_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\]+ .*" + + set need_another_continue 1 + set missed_handler 0 + if $this_sig_supported then { + if { $thissig == "IO" } { + setup_xfail "i*86-pc-linuxoldld-gnu" "i*86-pc-linuxaout-gnu" + } + set testmsg "get signal $thissig" + gdb_test_multiple "continue" $testmsg { + -re "Program received signal SIG$thissig.*handle_$thissig.*$gdb_prompt $" { + fail "$testmsg (wrong location)" + } + -re "Program received signal SIG$thissig.*$gdb_prompt $" { + pass $testmsg + } + -re "Breakpoint.* handle_$thissig.*$gdb_prompt $" { + xfail $testmsg + set need_another_continue 0 + } + } + } + if [ istarget "alpha-dec-osf3*" ] then { + # OSF/1-3.x is unable to continue with a job control stop signal. + # The inferior remains stopped without an event of interest + # and GDB waits forever for the inferior to stop on an event + # of interest. Work around the kernel bug. + if { $thissig == "TSTP" || $thissig == "TTIN" || $thissig == "TTOU" } { + setup_xfail "alpha-dec-osf3*" + fail "cannot continue from signal $thissig" + set need_another_continue 0 + } + } + + if $need_another_continue then { + if { $thissig == "URG" } { + setup_xfail "i*86-pc-linuxoldld-gnu" "i*86-pc-linuxaout-gnu" + } + # Either Lynx or GDB screws up on SIGPRIO + if { $thissig == "PRIO" } { + setup_xfail "*-*-*lynx*" + } + set testmsg "send signal $thissig" + gdb_test_multiple "continue" $testmsg { + -re "Breakpoint.*handle_$thissig.*$gdb_prompt $" { + pass $testmsg + } + -re "Breakpoint.*gen_$nextsig.*kill.*$gdb_prompt $" { + fail "missed breakpoint at handle_$thissig" + set missed_handler 1 + } + } + } + + if { $missed_handler == "0" } then { + set testmsg "advance to $nextsig" + gdb_test_multiple "signal 0" $testmsg { + -re "Breakpoint.*gen_$nextsig.*kill.*$gdb_prompt $" { + pass $testmsg + set sig_supported 1 + } + -re "Breakpoint.*gen_$nextsig.*handle.*$gdb_prompt $" { + pass $testmsg + set sig_supported 0 + } + } + } + set thissig $nextsig +} + +proc test_one_sig_reverse {prevsig} { + global gdb_prompt + + gdb_test "reverse-continue" "Breakpoint .* handle_$prevsig.*" \ + "reverse to handler of $prevsig" + + set saw_signal 0 + set testmsg "reverse to gen_$prevsig" + gdb_test_multiple "reverse-continue" $testmsg { + -re "Breakpoint.*handle_.*$gdb_prompt " { + pass "$testmsg (un-handled)" + } + -re "Program received signal SIG$prevsig.*$gdb_prompt " { + pass "reverse to signal event, $prevsig" + + set nested_testmsg "reverse signal delivered" + gdb_test_multiple "frame" $nested_testmsg { + -re ".*handle_$prevsig.*$gdb_prompt " { + fail "$nested_testmsg (wrong location)" + } + -re ".*$gdb_prompt " { + pass $nested_testmsg + } + } + + set saw_signal 1 + send_gdb "reverse-continue\n" + exp_continue + } + -re "Breakpoint.*kill.*$gdb_prompt " { + if { $saw_signal } then { + pass "$testmsg (handled)" + } else { + xfail "$testmsg (handled)" + } + } + -re "No more reverse-execution history.*kill.*$gdb_prompt " { + if { $saw_signal } then { + pass "$testmsg (handled)" + } else { + xfail "$testmsg (handled)" + } + } + } +} + +gdb_load $binfile + +runto gen_ABRT + +if [target_info exists gdb,use_precord] { + # Activate process record/replay + gdb_test "record" "" "Turn on process record" + # FIXME: command ought to acknowledge, so we can test if it succeeded. +} + +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 +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" + +set testmsg "continue to sigall exit" +gdb_test_multiple "continue" $testmsg { + -re ".*Do you want to stop the program.*$" { + send_gdb "yes\n" + exp_continue + } + -re "$gdb_prompt " { + pass $testmsg + } +} + +test_one_sig_reverse TERM +test_one_sig_reverse 63 +test_one_sig_reverse 62 +test_one_sig_reverse 61 +test_one_sig_reverse 60 +test_one_sig_reverse 59 +test_one_sig_reverse 58 +test_one_sig_reverse 57 +test_one_sig_reverse 56 +test_one_sig_reverse 55 +test_one_sig_reverse 54 +test_one_sig_reverse 53 +test_one_sig_reverse 52 +test_one_sig_reverse 51 +test_one_sig_reverse 50 +test_one_sig_reverse 49 +test_one_sig_reverse 48 +test_one_sig_reverse 47 +test_one_sig_reverse 46 +test_one_sig_reverse 45 +test_one_sig_reverse 44 +test_one_sig_reverse 43 +test_one_sig_reverse 42 +test_one_sig_reverse 41 +test_one_sig_reverse 40 +test_one_sig_reverse 39 +test_one_sig_reverse 38 +test_one_sig_reverse 37 +test_one_sig_reverse 36 +test_one_sig_reverse 35 +test_one_sig_reverse 34 +test_one_sig_reverse 33 +test_one_sig_reverse PRIO +test_one_sig_reverse SAK +test_one_sig_reverse SOUND +test_one_sig_reverse MSG +test_one_sig_reverse RETRACT +test_one_sig_reverse GRANT +test_one_sig_reverse DANGER +test_one_sig_reverse LWP +test_one_sig_reverse WAITING +test_one_sig_reverse PHONE +test_one_sig_reverse WIND +test_one_sig_reverse POLL +test_one_sig_reverse PWR +test_one_sig_reverse USR2 +test_one_sig_reverse USR1 +test_one_sig_reverse LOST +test_one_sig_reverse WINCH +test_one_sig_reverse PROF +test_one_sig_reverse VTALRM +test_one_sig_reverse XFSZ +test_one_sig_reverse XCPU +test_one_sig_reverse IO +test_one_sig_reverse TTOU +test_one_sig_reverse TTIN +test_one_sig_reverse CHLD +test_one_sig_reverse CONT +test_one_sig_reverse TSTP +test_one_sig_reverse URG +test_one_sig_reverse ALRM +test_one_sig_reverse PIPE +test_one_sig_reverse SYS +test_one_sig_reverse SEGV +test_one_sig_reverse BUS +test_one_sig_reverse FPE +test_one_sig_reverse EMT +test_one_sig_reverse ILL +test_one_sig_reverse QUIT +test_one_sig_reverse HUP +test_one_sig_reverse ABRT + +# Make the first signal SIGABRT because it is always supported. +set sig_supported 1 +set thissig "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 +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 -- 2.30.2