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

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

1 files changed, 1368 insertions, 0 deletions

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;
+}