2009-09-12 Michael Snyder <msnyder@vmware.com>

	* gdb.reverse/step-reverse.exp: Explicitly check for targets
	that can support reverse debuggnig.

2 files changed, 1834 insertions, 0 deletions

diff --git a/gdb/testsuite/gdb.reverse/sigall-reverse.c b/gdb/testsuite/gdb.reverse/sigall-reverse.c
new file mode 100644
index 0000000..220756a
--- /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 <http://www.gnu.org/licenses/>.  */
+
+#include <signal.h>
+#include <unistd.h>
+
+#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 0000000..fa49ad5
--- /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 <http://www.gnu.org/licenses/>.
+
+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