* TODO: Add note about "handle all nostop".

	* gdb.base/{sigall.c, sigall.exp}: New test.
	* gdb.base/Makefile.in: Add it.

4 files changed, 1556 insertions, 0 deletions

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 30dc1f3..da954f8 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  <shebs@andros.cygnus.com>
 
 	* lib/gdb.exp, gdb.base/corefile.exp: Supply -nw as argument
diff --git a/gdb/testsuite/TODO b/gdb/testsuite/TODO
index abb0f32..ec0ce14 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 0000000..ba28298
--- /dev/null
+++ b/gdb/testsuite/gdb.base/sigall.c
@@ -0,0 +1,1368 @@
+#include <signal.h>
+
+/* 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 0000000..4a2b066
--- /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