--- /dev/null
+#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;
+{
+}
+\f
+/* 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);
+}
+\f
+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;
+}
--- /dev/null
+# 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
projects / external / binutils.git / commitdiff