]>
Commit | Line | Data |
---|---|---|
b43b923a MS |
1 | /* This testcase is part of GDB, the GNU debugger. |
2 | ||
ecd75fc8 | 3 | Copyright 2009-2014 Free Software Foundation, Inc. |
b43b923a MS |
4 | |
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 3 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
17 | ||
18 | #include <signal.h> | |
19 | #include <unistd.h> | |
20 | ||
b43b923a MS |
21 | |
22 | /* Signal handlers, we set breakpoints in them to make sure that the | |
23 | signals really get delivered. */ | |
24 | ||
25 | void | |
26 | handle_ABRT (int sig) | |
27 | { | |
28 | } | |
29 | ||
30 | void | |
31 | handle_HUP (int sig) | |
32 | { | |
33 | } | |
34 | ||
35 | void | |
36 | handle_QUIT (int sig) | |
37 | { | |
38 | } | |
39 | ||
40 | void | |
41 | handle_ILL (int sig) | |
42 | { | |
43 | } | |
44 | ||
45 | void | |
46 | handle_EMT (int sig) | |
47 | { | |
48 | } | |
49 | ||
50 | void | |
51 | handle_FPE (int sig) | |
52 | { | |
53 | } | |
54 | ||
55 | void | |
56 | handle_BUS (int sig) | |
57 | { | |
58 | } | |
59 | ||
60 | void | |
61 | handle_SEGV (int sig) | |
62 | { | |
63 | } | |
64 | ||
65 | void | |
66 | handle_SYS (int sig) | |
67 | { | |
68 | } | |
69 | ||
70 | void | |
71 | handle_PIPE (int sig) | |
72 | { | |
73 | } | |
74 | ||
75 | void | |
76 | handle_ALRM (int sig) | |
77 | { | |
78 | } | |
79 | ||
80 | void | |
81 | handle_URG (int sig) | |
82 | { | |
83 | } | |
84 | ||
85 | void | |
86 | handle_TSTP (int sig) | |
87 | { | |
88 | } | |
89 | ||
90 | void | |
91 | handle_CONT (int sig) | |
92 | { | |
93 | } | |
94 | ||
95 | void | |
96 | handle_CHLD (int sig) | |
97 | { | |
98 | } | |
99 | ||
100 | void | |
101 | handle_TTIN (int sig) | |
102 | { | |
103 | } | |
104 | ||
105 | void | |
106 | handle_TTOU (int sig) | |
107 | { | |
108 | } | |
109 | ||
110 | void | |
111 | handle_IO (int sig) | |
112 | { | |
113 | } | |
114 | ||
115 | void | |
116 | handle_XCPU (int sig) | |
117 | { | |
118 | } | |
119 | ||
120 | void | |
121 | handle_XFSZ (int sig) | |
122 | { | |
123 | } | |
124 | ||
125 | void | |
126 | handle_VTALRM (int sig) | |
127 | { | |
128 | } | |
129 | ||
130 | void | |
131 | handle_PROF (int sig) | |
132 | { | |
133 | } | |
134 | ||
135 | void | |
136 | handle_WINCH (int sig) | |
137 | { | |
138 | } | |
139 | ||
140 | void | |
141 | handle_LOST (int sig) | |
142 | { | |
143 | } | |
144 | ||
145 | void | |
146 | handle_USR1 (int sig) | |
147 | { | |
148 | } | |
149 | ||
150 | void | |
151 | handle_USR2 (int sig) | |
152 | { | |
153 | } | |
154 | ||
155 | void | |
156 | handle_PWR (int sig) | |
157 | { | |
158 | } | |
159 | ||
160 | void | |
161 | handle_POLL (int sig) | |
162 | { | |
163 | } | |
164 | ||
165 | void | |
166 | handle_WIND (int sig) | |
167 | { | |
168 | } | |
169 | ||
170 | void | |
171 | handle_PHONE (int sig) | |
172 | { | |
173 | } | |
174 | ||
175 | void | |
176 | handle_WAITING (int sig) | |
177 | { | |
178 | } | |
179 | ||
180 | void | |
181 | handle_LWP (int sig) | |
182 | { | |
183 | } | |
184 | ||
185 | void | |
186 | handle_DANGER (int sig) | |
187 | { | |
188 | } | |
189 | ||
190 | void | |
191 | handle_GRANT (int sig) | |
192 | { | |
193 | } | |
194 | ||
195 | void | |
196 | handle_RETRACT (int sig) | |
197 | { | |
198 | } | |
199 | ||
200 | void | |
201 | handle_MSG (int sig) | |
202 | { | |
203 | } | |
204 | ||
205 | void | |
206 | handle_SOUND (int sig) | |
207 | { | |
208 | } | |
209 | ||
210 | void | |
211 | handle_SAK (int sig) | |
212 | { | |
213 | } | |
214 | ||
215 | void | |
216 | handle_PRIO (int sig) | |
217 | { | |
218 | } | |
219 | ||
220 | void | |
221 | handle_33 (int sig) | |
222 | { | |
223 | } | |
224 | ||
225 | void | |
226 | handle_34 (int sig) | |
227 | { | |
228 | } | |
229 | ||
230 | void | |
231 | handle_35 (int sig) | |
232 | { | |
233 | } | |
234 | ||
235 | void | |
236 | handle_36 (int sig) | |
237 | { | |
238 | } | |
239 | ||
240 | void | |
241 | handle_37 (int sig) | |
242 | { | |
243 | } | |
244 | ||
245 | void | |
246 | handle_38 (int sig) | |
247 | { | |
248 | } | |
249 | ||
250 | void | |
251 | handle_39 (int sig) | |
252 | { | |
253 | } | |
254 | ||
255 | void | |
256 | handle_40 (int sig) | |
257 | { | |
258 | } | |
259 | ||
260 | void | |
261 | handle_41 (int sig) | |
262 | { | |
263 | } | |
264 | ||
265 | void | |
266 | handle_42 (int sig) | |
267 | { | |
268 | } | |
269 | ||
270 | void | |
271 | handle_43 (int sig) | |
272 | { | |
273 | } | |
274 | ||
275 | void | |
276 | handle_44 (int sig) | |
277 | { | |
278 | } | |
279 | ||
280 | void | |
281 | handle_45 (int sig) | |
282 | { | |
283 | } | |
284 | ||
285 | void | |
286 | handle_46 (int sig) | |
287 | { | |
288 | } | |
289 | ||
290 | void | |
291 | handle_47 (int sig) | |
292 | { | |
293 | } | |
294 | ||
295 | void | |
296 | handle_48 (int sig) | |
297 | { | |
298 | } | |
299 | ||
300 | void | |
301 | handle_49 (int sig) | |
302 | { | |
303 | } | |
304 | ||
305 | void | |
306 | handle_50 (int sig) | |
307 | { | |
308 | } | |
309 | ||
310 | void | |
311 | handle_51 (int sig) | |
312 | { | |
313 | } | |
314 | ||
315 | void | |
316 | handle_52 (int sig) | |
317 | { | |
318 | } | |
319 | ||
320 | void | |
321 | handle_53 (int sig) | |
322 | { | |
323 | } | |
324 | ||
325 | void | |
326 | handle_54 (int sig) | |
327 | { | |
328 | } | |
329 | ||
330 | void | |
331 | handle_55 (int sig) | |
332 | { | |
333 | } | |
334 | ||
335 | void | |
336 | handle_56 (int sig) | |
337 | { | |
338 | } | |
339 | ||
340 | void | |
341 | handle_57 (int sig) | |
342 | { | |
343 | } | |
344 | ||
345 | void | |
346 | handle_58 (int sig) | |
347 | { | |
348 | } | |
349 | ||
350 | void | |
351 | handle_59 (int sig) | |
352 | { | |
353 | } | |
354 | ||
355 | void | |
356 | handle_60 (int sig) | |
357 | { | |
358 | } | |
359 | ||
360 | void | |
361 | handle_61 (int sig) | |
362 | { | |
363 | } | |
364 | ||
365 | void | |
366 | handle_62 (int sig) | |
367 | { | |
368 | } | |
369 | ||
370 | void | |
371 | handle_63 (int sig) | |
372 | { | |
373 | } | |
374 | ||
375 | void | |
376 | handle_TERM (int sig) | |
377 | { | |
378 | } | |
379 | \f | |
380 | /* Functions to send signals. These also serve as markers. */ | |
381 | int | |
382 | gen_ABRT (void) | |
383 | { | |
384 | kill (getpid (), SIGABRT); | |
385 | return 0; | |
386 | } | |
387 | ||
388 | int | |
389 | gen_HUP (void) | |
390 | { | |
391 | #ifdef SIGHUP | |
392 | kill (getpid (), SIGHUP); | |
393 | #else | |
394 | handle_HUP (0); | |
395 | #endif | |
396 | return 0; | |
397 | } | |
398 | ||
399 | int | |
400 | gen_QUIT (void) | |
401 | { | |
402 | #ifdef SIGQUIT | |
403 | kill (getpid (), SIGQUIT); | |
404 | #else | |
405 | handle_QUIT (0); | |
406 | #endif | |
407 | return 0; | |
408 | } | |
409 | ||
410 | int | |
411 | gen_ILL (void) | |
412 | { | |
413 | #ifdef SIGILL | |
414 | kill (getpid (), SIGILL); | |
415 | #else | |
416 | handle_ILL (0); | |
417 | #endif | |
418 | return 0; | |
419 | } | |
420 | ||
421 | int | |
422 | gen_EMT (void) | |
423 | { | |
424 | #ifdef SIGEMT | |
425 | kill (getpid (), SIGEMT); | |
426 | #else | |
427 | handle_EMT (0); | |
428 | #endif | |
429 | return 0; | |
430 | } | |
431 | ||
432 | int x; | |
433 | ||
434 | int | |
435 | gen_FPE (void) | |
436 | { | |
437 | /* The intent behind generating SIGFPE this way is to check the mapping | |
438 | from the CPU exception itself to the signals. It would be nice to | |
439 | do the same for SIGBUS, SIGSEGV, etc., but I suspect that even this | |
440 | test might turn out to be insufficiently portable. */ | |
441 | ||
442 | #if 0 | |
443 | /* Loses on the PA because after the signal handler executes we try to | |
444 | re-execute the failing instruction again. Perhaps we could siglongjmp | |
445 | out of the signal handler? */ | |
446 | /* The expect script looks for the word "kill"; don't delete it. */ | |
447 | return 5 / x; /* and we both started jumping up and down yelling kill */ | |
448 | #else | |
449 | kill (getpid (), SIGFPE); | |
450 | #endif | |
451 | return 0; | |
452 | } | |
453 | ||
454 | int | |
455 | gen_BUS (void) | |
456 | { | |
457 | #ifdef SIGBUS | |
458 | kill (getpid (), SIGBUS); | |
459 | #else | |
460 | handle_BUS (0); | |
461 | #endif | |
462 | return 0; | |
463 | } | |
464 | ||
465 | int | |
466 | gen_SEGV (void) | |
467 | { | |
468 | #ifdef SIGSEGV | |
469 | kill (getpid (), SIGSEGV); | |
470 | #else | |
471 | handle_SEGV (0); | |
472 | #endif | |
473 | return 0; | |
474 | } | |
475 | ||
476 | int | |
477 | gen_SYS (void) | |
478 | { | |
479 | #ifdef SIGSYS | |
480 | kill (getpid (), SIGSYS); | |
481 | #else | |
482 | handle_SYS (0); | |
483 | #endif | |
484 | return 0; | |
485 | } | |
486 | ||
487 | int | |
488 | gen_PIPE (void) | |
489 | { | |
490 | #ifdef SIGPIPE | |
491 | kill (getpid (), SIGPIPE); | |
492 | #else | |
493 | handle_PIPE (0); | |
494 | #endif | |
495 | return 0; | |
496 | } | |
497 | ||
498 | int | |
499 | gen_ALRM (void) | |
500 | { | |
501 | #ifdef SIGALRM | |
502 | kill (getpid (), SIGALRM); | |
503 | #else | |
504 | handle_ALRM (0); | |
505 | #endif | |
506 | return 0; | |
507 | } | |
508 | ||
509 | int | |
510 | gen_URG (void) | |
511 | { | |
512 | #ifdef SIGURG | |
513 | kill (getpid (), SIGURG); | |
514 | #else | |
515 | handle_URG (0); | |
516 | #endif | |
517 | return 0; | |
518 | } | |
519 | ||
520 | int | |
521 | gen_TSTP (void) | |
522 | { | |
523 | #ifdef SIGTSTP | |
524 | kill (getpid (), SIGTSTP); | |
525 | #else | |
526 | handle_TSTP (0); | |
527 | #endif | |
528 | return 0; | |
529 | } | |
530 | ||
531 | int | |
532 | gen_CONT (void) | |
533 | { | |
534 | #ifdef SIGCONT | |
535 | kill (getpid (), SIGCONT); | |
536 | #else | |
537 | handle_CONT (0); | |
538 | #endif | |
539 | return 0; | |
540 | } | |
541 | ||
542 | int | |
543 | gen_CHLD (void) | |
544 | { | |
545 | #ifdef SIGCHLD | |
546 | kill (getpid (), SIGCHLD); | |
547 | #else | |
548 | handle_CHLD (0); | |
549 | #endif | |
550 | return 0; | |
551 | } | |
552 | ||
553 | int | |
554 | gen_TTIN (void) | |
555 | { | |
556 | #ifdef SIGTTIN | |
557 | kill (getpid (), SIGTTIN); | |
558 | #else | |
559 | handle_TTIN (0); | |
560 | #endif | |
561 | return 0; | |
562 | } | |
563 | ||
564 | int | |
565 | gen_TTOU (void) | |
566 | { | |
567 | #ifdef SIGTTOU | |
568 | kill (getpid (), SIGTTOU); | |
569 | #else | |
570 | handle_TTOU (0); | |
571 | #endif | |
572 | return 0; | |
573 | } | |
574 | ||
575 | int | |
576 | gen_IO (void) | |
577 | { | |
578 | #ifdef SIGIO | |
579 | kill (getpid (), SIGIO); | |
580 | #else | |
581 | handle_IO (0); | |
582 | #endif | |
583 | return 0; | |
584 | } | |
585 | ||
586 | int | |
587 | gen_XCPU (void) | |
588 | { | |
589 | #ifdef SIGXCPU | |
590 | kill (getpid (), SIGXCPU); | |
591 | #else | |
592 | handle_XCPU (0); | |
593 | #endif | |
594 | return 0; | |
595 | } | |
596 | ||
597 | int | |
598 | gen_XFSZ (void) | |
599 | { | |
600 | #ifdef SIGXFSZ | |
601 | kill (getpid (), SIGXFSZ); | |
602 | #else | |
603 | handle_XFSZ (0); | |
604 | #endif | |
605 | return 0; | |
606 | } | |
607 | ||
608 | int | |
609 | gen_VTALRM (void) | |
610 | { | |
611 | #ifdef SIGVTALRM | |
612 | kill (getpid (), SIGVTALRM); | |
613 | #else | |
614 | handle_VTALRM (0); | |
615 | #endif | |
616 | return 0; | |
617 | } | |
618 | ||
619 | int | |
620 | gen_PROF (void) | |
621 | { | |
622 | #ifdef SIGPROF | |
623 | kill (getpid (), SIGPROF); | |
624 | #else | |
625 | handle_PROF (0); | |
626 | #endif | |
627 | return 0; | |
628 | } | |
629 | ||
630 | int | |
631 | gen_WINCH (void) | |
632 | { | |
633 | #ifdef SIGWINCH | |
634 | kill (getpid (), SIGWINCH); | |
635 | #else | |
636 | handle_WINCH (0); | |
637 | #endif | |
638 | return 0; | |
639 | } | |
640 | ||
641 | int | |
642 | gen_LOST (void) | |
643 | { | |
644 | #if defined(SIGLOST) && (!defined(SIGABRT) || SIGLOST != SIGABRT) | |
645 | kill (getpid (), SIGLOST); | |
646 | #else | |
647 | handle_LOST (0); | |
648 | #endif | |
649 | return 0; | |
650 | } | |
651 | ||
652 | int | |
653 | gen_USR1 (void) | |
654 | { | |
655 | #ifdef SIGUSR1 | |
656 | kill (getpid (), SIGUSR1); | |
657 | #else | |
658 | handle_USR1 (0); | |
659 | #endif | |
660 | return 0; | |
661 | } | |
662 | ||
663 | int | |
664 | gen_USR2 (void) | |
665 | { | |
666 | #ifdef SIGUSR2 | |
667 | kill (getpid (), SIGUSR2); | |
668 | #else | |
669 | handle_USR2 (0); | |
670 | #endif | |
671 | return 0; | |
672 | } | |
673 | ||
674 | int | |
675 | gen_PWR (void) | |
676 | { | |
677 | #ifdef SIGPWR | |
678 | kill (getpid (), SIGPWR); | |
679 | #else | |
680 | handle_PWR (0); | |
681 | #endif | |
682 | return 0; | |
683 | } | |
684 | ||
685 | int | |
686 | gen_POLL (void) | |
687 | { | |
688 | #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO) | |
689 | kill (getpid (), SIGPOLL); | |
690 | #else | |
691 | handle_POLL (0); | |
692 | #endif | |
693 | return 0; | |
694 | } | |
695 | ||
696 | int | |
697 | gen_WIND (void) | |
698 | { | |
699 | #ifdef SIGWIND | |
700 | kill (getpid (), SIGWIND); | |
701 | #else | |
702 | handle_WIND (0); | |
703 | #endif | |
704 | return 0; | |
705 | } | |
706 | ||
707 | int | |
708 | gen_PHONE (void) | |
709 | { | |
710 | #ifdef SIGPHONE | |
711 | kill (getpid (), SIGPHONE); | |
712 | #else | |
713 | handle_PHONE (0); | |
714 | #endif | |
715 | return 0; | |
716 | } | |
717 | ||
718 | int | |
719 | gen_WAITING (void) | |
720 | { | |
721 | #ifdef SIGWAITING | |
722 | kill (getpid (), SIGWAITING); | |
723 | #else | |
724 | handle_WAITING (0); | |
725 | #endif | |
726 | return 0; | |
727 | } | |
728 | ||
729 | int | |
730 | gen_LWP (void) | |
731 | { | |
732 | #ifdef SIGLWP | |
733 | kill (getpid (), SIGLWP); | |
734 | #else | |
735 | handle_LWP (0); | |
736 | #endif | |
737 | return 0; | |
738 | } | |
739 | ||
740 | int | |
741 | gen_DANGER (void) | |
742 | { | |
743 | #ifdef SIGDANGER | |
744 | kill (getpid (), SIGDANGER); | |
745 | #else | |
746 | handle_DANGER (0); | |
747 | #endif | |
748 | return 0; | |
749 | } | |
750 | ||
751 | int | |
752 | gen_GRANT (void) | |
753 | { | |
754 | #ifdef SIGGRANT | |
755 | kill (getpid (), SIGGRANT); | |
756 | #else | |
757 | handle_GRANT (0); | |
758 | #endif | |
759 | return 0; | |
760 | } | |
761 | ||
762 | int | |
763 | gen_RETRACT (void) | |
764 | { | |
765 | #ifdef SIGRETRACT | |
766 | kill (getpid (), SIGRETRACT); | |
767 | #else | |
768 | handle_RETRACT (0); | |
769 | #endif | |
770 | return 0; | |
771 | } | |
772 | ||
773 | int | |
774 | gen_MSG (void) | |
775 | { | |
776 | #ifdef SIGMSG | |
777 | kill (getpid (), SIGMSG); | |
778 | #else | |
779 | handle_MSG (0); | |
780 | #endif | |
781 | return 0; | |
782 | } | |
783 | ||
784 | int | |
785 | gen_SOUND (void) | |
786 | { | |
787 | #ifdef SIGSOUND | |
788 | kill (getpid (), SIGSOUND); | |
789 | #else | |
790 | handle_SOUND (0); | |
791 | #endif | |
792 | return 0; | |
793 | } | |
794 | ||
795 | int | |
796 | gen_SAK (void) | |
797 | { | |
798 | #ifdef SIGSAK | |
799 | kill (getpid (), SIGSAK); | |
800 | #else | |
801 | handle_SAK (0); | |
802 | #endif | |
803 | return 0; | |
804 | } | |
805 | ||
806 | int | |
807 | gen_PRIO (void) | |
808 | { | |
809 | #ifdef SIGPRIO | |
810 | kill (getpid (), SIGPRIO); | |
811 | #else | |
812 | handle_PRIO (0); | |
813 | #endif | |
814 | return 0; | |
815 | } | |
816 | ||
817 | int | |
818 | gen_33 (void) | |
819 | { | |
820 | #ifdef SIG33 | |
821 | kill (getpid (), 33); | |
822 | #else | |
823 | handle_33 (0); | |
824 | #endif | |
825 | return 0; | |
826 | } | |
827 | ||
828 | int | |
829 | gen_34 (void) | |
830 | { | |
831 | #ifdef SIG34 | |
832 | kill (getpid (), 34); | |
833 | #else | |
834 | handle_34 (0); | |
835 | #endif | |
836 | return 0; | |
837 | } | |
838 | ||
839 | int | |
840 | gen_35 (void) | |
841 | { | |
842 | #ifdef SIG35 | |
843 | kill (getpid (), 35); | |
844 | #else | |
845 | handle_35 (0); | |
846 | #endif | |
847 | return 0; | |
848 | } | |
849 | ||
850 | int | |
851 | gen_36 (void) | |
852 | { | |
853 | #ifdef SIG36 | |
854 | kill (getpid (), 36); | |
855 | #else | |
856 | handle_36 (0); | |
857 | #endif | |
858 | return 0; | |
859 | } | |
860 | ||
861 | int | |
862 | gen_37 (void) | |
863 | { | |
864 | #ifdef SIG37 | |
865 | kill (getpid (), 37); | |
866 | #else | |
867 | handle_37 (0); | |
868 | #endif | |
869 | return 0; | |
870 | } | |
871 | ||
872 | int | |
873 | gen_38 (void) | |
874 | { | |
875 | #ifdef SIG38 | |
876 | kill (getpid (), 38); | |
877 | #else | |
878 | handle_38 (0); | |
879 | #endif | |
880 | return 0; | |
881 | } | |
882 | ||
883 | int | |
884 | gen_39 (void) | |
885 | { | |
886 | #ifdef SIG39 | |
887 | kill (getpid (), 39); | |
888 | #else | |
889 | handle_39 (0); | |
890 | #endif | |
891 | return 0; | |
892 | } | |
893 | ||
894 | int | |
895 | gen_40 (void) | |
896 | { | |
897 | #ifdef SIG40 | |
898 | kill (getpid (), 40); | |
899 | #else | |
900 | handle_40 (0); | |
901 | #endif | |
902 | return 0; | |
903 | } | |
904 | ||
905 | int | |
906 | gen_41 (void) | |
907 | { | |
908 | #ifdef SIG41 | |
909 | kill (getpid (), 41); | |
910 | #else | |
911 | handle_41 (0); | |
912 | #endif | |
913 | return 0; | |
914 | } | |
915 | ||
916 | int | |
917 | gen_42 (void) | |
918 | { | |
919 | #ifdef SIG42 | |
920 | kill (getpid (), 42); | |
921 | #else | |
922 | handle_42 (0); | |
923 | #endif | |
924 | return 0; | |
925 | } | |
926 | ||
927 | int | |
928 | gen_43 (void) | |
929 | { | |
930 | #ifdef SIG43 | |
931 | kill (getpid (), 43); | |
932 | #else | |
933 | handle_43 (0); | |
934 | #endif | |
935 | return 0; | |
936 | } | |
937 | ||
938 | int | |
939 | gen_44 (void) | |
940 | { | |
941 | #ifdef SIG44 | |
942 | kill (getpid (), 44); | |
943 | #else | |
944 | handle_44 (0); | |
945 | #endif | |
946 | return 0; | |
947 | } | |
948 | ||
949 | int | |
950 | gen_45 (void) | |
951 | { | |
952 | #ifdef SIG45 | |
953 | kill (getpid (), 45); | |
954 | #else | |
955 | handle_45 (0); | |
956 | #endif | |
957 | return 0; | |
958 | } | |
959 | ||
960 | int | |
961 | gen_46 (void) | |
962 | { | |
963 | #ifdef SIG46 | |
964 | kill (getpid (), 46); | |
965 | #else | |
966 | handle_46 (0); | |
967 | #endif | |
968 | return 0; | |
969 | } | |
970 | ||
971 | int | |
972 | gen_47 (void) | |
973 | { | |
974 | #ifdef SIG47 | |
975 | kill (getpid (), 47); | |
976 | #else | |
977 | handle_47 (0); | |
978 | #endif | |
979 | return 0; | |
980 | } | |
981 | ||
982 | int | |
983 | gen_48 (void) | |
984 | { | |
985 | #ifdef SIG48 | |
986 | kill (getpid (), 48); | |
987 | #else | |
988 | handle_48 (0); | |
989 | #endif | |
990 | return 0; | |
991 | } | |
992 | ||
993 | int | |
994 | gen_49 (void) | |
995 | { | |
996 | #ifdef SIG49 | |
997 | kill (getpid (), 49); | |
998 | #else | |
999 | handle_49 (0); | |
1000 | #endif | |
1001 | return 0; | |
1002 | } | |
1003 | ||
1004 | int | |
1005 | gen_50 (void) | |
1006 | { | |
1007 | #ifdef SIG50 | |
1008 | kill (getpid (), 50); | |
1009 | #else | |
1010 | handle_50 (0); | |
1011 | #endif | |
1012 | return 0; | |
1013 | } | |
1014 | ||
1015 | int | |
1016 | gen_51 (void) | |
1017 | { | |
1018 | #ifdef SIG51 | |
1019 | kill (getpid (), 51); | |
1020 | #else | |
1021 | handle_51 (0); | |
1022 | #endif | |
1023 | return 0; | |
1024 | } | |
1025 | ||
1026 | int | |
1027 | gen_52 (void) | |
1028 | { | |
1029 | #ifdef SIG52 | |
1030 | kill (getpid (), 52); | |
1031 | #else | |
1032 | handle_52 (0); | |
1033 | #endif | |
1034 | return 0; | |
1035 | } | |
1036 | ||
1037 | int | |
1038 | gen_53 (void) | |
1039 | { | |
1040 | #ifdef SIG53 | |
1041 | kill (getpid (), 53); | |
1042 | #else | |
1043 | handle_53 (0); | |
1044 | #endif | |
1045 | return 0; | |
1046 | } | |
1047 | ||
1048 | int | |
1049 | gen_54 (void) | |
1050 | { | |
1051 | #ifdef SIG54 | |
1052 | kill (getpid (), 54); | |
1053 | #else | |
1054 | handle_54 (0); | |
1055 | #endif | |
1056 | return 0; | |
1057 | } | |
1058 | ||
1059 | int | |
1060 | gen_55 (void) | |
1061 | { | |
1062 | #ifdef SIG55 | |
1063 | kill (getpid (), 55); | |
1064 | #else | |
1065 | handle_55 (0); | |
1066 | #endif | |
1067 | return 0; | |
1068 | } | |
1069 | ||
1070 | int | |
1071 | gen_56 (void) | |
1072 | { | |
1073 | #ifdef SIG56 | |
1074 | kill (getpid (), 56); | |
1075 | #else | |
1076 | handle_56 (0); | |
1077 | #endif | |
1078 | return 0; | |
1079 | } | |
1080 | ||
1081 | int | |
1082 | gen_57 (void) | |
1083 | { | |
1084 | #ifdef SIG57 | |
1085 | kill (getpid (), 57); | |
1086 | #else | |
1087 | handle_57 (0); | |
1088 | #endif | |
1089 | return 0; | |
1090 | } | |
1091 | ||
1092 | int | |
1093 | gen_58 (void) | |
1094 | { | |
1095 | #ifdef SIG58 | |
1096 | kill (getpid (), 58); | |
1097 | #else | |
1098 | handle_58 (0); | |
1099 | #endif | |
1100 | return 0; | |
1101 | } | |
1102 | ||
1103 | int | |
1104 | gen_59 (void) | |
1105 | { | |
1106 | #ifdef SIG59 | |
1107 | kill (getpid (), 59); | |
1108 | #else | |
1109 | handle_59 (0); | |
1110 | #endif | |
1111 | return 0; | |
1112 | } | |
1113 | ||
1114 | int | |
1115 | gen_60 (void) | |
1116 | { | |
1117 | #ifdef SIG60 | |
1118 | kill (getpid (), 60); | |
1119 | #else | |
1120 | handle_60 (0); | |
1121 | #endif | |
1122 | return 0; | |
1123 | } | |
1124 | ||
1125 | int | |
1126 | gen_61 (void) | |
1127 | { | |
1128 | #ifdef SIG61 | |
1129 | kill (getpid (), 61); | |
1130 | #else | |
1131 | handle_61 (0); | |
1132 | #endif | |
1133 | return 0; | |
1134 | } | |
1135 | ||
1136 | int | |
1137 | gen_62 (void) | |
1138 | { | |
1139 | #ifdef SIG62 | |
1140 | kill (getpid (), 62); | |
1141 | #else | |
1142 | handle_62 (0); | |
1143 | #endif | |
1144 | return 0; | |
1145 | } | |
1146 | ||
1147 | int | |
1148 | gen_63 (void) | |
1149 | { | |
1150 | #ifdef SIG63 | |
1151 | kill (getpid (), 63); | |
1152 | #else | |
1153 | handle_63 (0); | |
1154 | #endif | |
1155 | return 0; | |
1156 | } | |
1157 | ||
1158 | int | |
1159 | gen_TERM (void) | |
1160 | { | |
1161 | kill (getpid (), SIGTERM); | |
1162 | return 0; | |
1163 | } | |
1164 | \f | |
1165 | int | |
1166 | main () | |
1167 | { | |
b43b923a MS |
1168 | #ifdef SIG_SETMASK |
1169 | /* Ensure all the signals aren't blocked. | |
1170 | The environment in which the testsuite is run may have blocked some | |
1171 | for whatever reason. */ | |
1172 | { | |
1173 | sigset_t newset; | |
1174 | sigemptyset (&newset); | |
1175 | sigprocmask (SIG_SETMASK, &newset, NULL); | |
1176 | } | |
1177 | #endif | |
1178 | ||
1179 | signal (SIGABRT, handle_ABRT); | |
1180 | #ifdef SIGHUP | |
1181 | signal (SIGHUP, handle_HUP); | |
1182 | #endif | |
1183 | #ifdef SIGQUIT | |
1184 | signal (SIGQUIT, handle_QUIT); | |
1185 | #endif | |
1186 | #ifdef SIGILL | |
1187 | signal (SIGILL, handle_ILL); | |
1188 | #endif | |
1189 | #ifdef SIGEMT | |
1190 | signal (SIGEMT, handle_EMT); | |
1191 | #endif | |
1192 | #ifdef SIGFPE | |
1193 | signal (SIGFPE, handle_FPE); | |
1194 | #endif | |
1195 | #ifdef SIGBUS | |
1196 | signal (SIGBUS, handle_BUS); | |
1197 | #endif | |
1198 | #ifdef SIGSEGV | |
1199 | signal (SIGSEGV, handle_SEGV); | |
1200 | #endif | |
1201 | #ifdef SIGSYS | |
1202 | signal (SIGSYS, handle_SYS); | |
1203 | #endif | |
1204 | #ifdef SIGPIPE | |
1205 | signal (SIGPIPE, handle_PIPE); | |
1206 | #endif | |
1207 | #ifdef SIGALRM | |
1208 | signal (SIGALRM, handle_ALRM); | |
1209 | #endif | |
1210 | #ifdef SIGURG | |
1211 | signal (SIGURG, handle_URG); | |
1212 | #endif | |
1213 | #ifdef SIGTSTP | |
1214 | signal (SIGTSTP, handle_TSTP); | |
1215 | #endif | |
1216 | #ifdef SIGCONT | |
1217 | signal (SIGCONT, handle_CONT); | |
1218 | #endif | |
1219 | #ifdef SIGCHLD | |
1220 | signal (SIGCHLD, handle_CHLD); | |
1221 | #endif | |
1222 | #ifdef SIGTTIN | |
1223 | signal (SIGTTIN, handle_TTIN); | |
1224 | #endif | |
1225 | #ifdef SIGTTOU | |
1226 | signal (SIGTTOU, handle_TTOU); | |
1227 | #endif | |
1228 | #ifdef SIGIO | |
1229 | signal (SIGIO, handle_IO); | |
1230 | #endif | |
1231 | #ifdef SIGXCPU | |
1232 | signal (SIGXCPU, handle_XCPU); | |
1233 | #endif | |
1234 | #ifdef SIGXFSZ | |
1235 | signal (SIGXFSZ, handle_XFSZ); | |
1236 | #endif | |
1237 | #ifdef SIGVTALRM | |
1238 | signal (SIGVTALRM, handle_VTALRM); | |
1239 | #endif | |
1240 | #ifdef SIGPROF | |
1241 | signal (SIGPROF, handle_PROF); | |
1242 | #endif | |
1243 | #ifdef SIGWINCH | |
1244 | signal (SIGWINCH, handle_WINCH); | |
1245 | #endif | |
1246 | #if defined(SIGLOST) && (!defined(SIGABRT) || SIGLOST != SIGABRT) | |
1247 | signal (SIGLOST, handle_LOST); | |
1248 | #endif | |
1249 | #ifdef SIGUSR1 | |
1250 | signal (SIGUSR1, handle_USR1); | |
1251 | #endif | |
1252 | #ifdef SIGUSR2 | |
1253 | signal (SIGUSR2, handle_USR2); | |
1254 | #endif | |
1255 | #ifdef SIGPWR | |
1256 | signal (SIGPWR, handle_PWR); | |
1257 | #endif | |
1258 | #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO) | |
1259 | signal (SIGPOLL, handle_POLL); | |
1260 | #endif | |
1261 | #ifdef SIGWIND | |
1262 | signal (SIGWIND, handle_WIND); | |
1263 | #endif | |
1264 | #ifdef SIGPHONE | |
1265 | signal (SIGPHONE, handle_PHONE); | |
1266 | #endif | |
1267 | #ifdef SIGWAITING | |
1268 | signal (SIGWAITING, handle_WAITING); | |
1269 | #endif | |
1270 | #ifdef SIGLWP | |
1271 | signal (SIGLWP, handle_LWP); | |
1272 | #endif | |
1273 | #ifdef SIGDANGER | |
1274 | signal (SIGDANGER, handle_DANGER); | |
1275 | #endif | |
1276 | #ifdef SIGGRANT | |
1277 | signal (SIGGRANT, handle_GRANT); | |
1278 | #endif | |
1279 | #ifdef SIGRETRACT | |
1280 | signal (SIGRETRACT, handle_RETRACT); | |
1281 | #endif | |
1282 | #ifdef SIGMSG | |
1283 | signal (SIGMSG, handle_MSG); | |
1284 | #endif | |
1285 | #ifdef SIGSOUND | |
1286 | signal (SIGSOUND, handle_SOUND); | |
1287 | #endif | |
1288 | #ifdef SIGSAK | |
1289 | signal (SIGSAK, handle_SAK); | |
1290 | #endif | |
1291 | #ifdef SIGPRIO | |
1292 | signal (SIGPRIO, handle_PRIO); | |
1293 | #endif | |
1294 | #ifdef __Lynx__ | |
1295 | /* Lynx doesn't seem to have anything in signal.h for this. */ | |
1296 | signal (33, handle_33); | |
1297 | signal (34, handle_34); | |
1298 | signal (35, handle_35); | |
1299 | signal (36, handle_36); | |
1300 | signal (37, handle_37); | |
1301 | signal (38, handle_38); | |
1302 | signal (39, handle_39); | |
1303 | signal (40, handle_40); | |
1304 | signal (41, handle_41); | |
1305 | signal (42, handle_42); | |
1306 | signal (43, handle_43); | |
1307 | signal (44, handle_44); | |
1308 | signal (45, handle_45); | |
1309 | signal (46, handle_46); | |
1310 | signal (47, handle_47); | |
1311 | signal (48, handle_48); | |
1312 | signal (49, handle_49); | |
1313 | signal (50, handle_50); | |
1314 | signal (51, handle_51); | |
1315 | signal (52, handle_52); | |
1316 | signal (53, handle_53); | |
1317 | signal (54, handle_54); | |
1318 | signal (55, handle_55); | |
1319 | signal (56, handle_56); | |
1320 | signal (57, handle_57); | |
1321 | signal (58, handle_58); | |
1322 | signal (59, handle_59); | |
1323 | signal (60, handle_60); | |
1324 | signal (61, handle_61); | |
1325 | signal (62, handle_62); | |
1326 | signal (63, handle_63); | |
1327 | #endif /* lynx */ | |
1328 | signal (SIGTERM, handle_TERM); | |
1329 | ||
1330 | x = 0; | |
1331 | ||
1332 | gen_ABRT (); | |
1333 | gen_HUP (); | |
1334 | gen_QUIT (); | |
1335 | gen_ILL (); | |
1336 | gen_EMT (); | |
1337 | gen_FPE (); | |
1338 | gen_BUS (); | |
1339 | gen_SEGV (); | |
1340 | gen_SYS (); | |
1341 | gen_PIPE (); | |
1342 | gen_ALRM (); | |
1343 | gen_URG (); | |
1344 | gen_TSTP (); | |
1345 | gen_CONT (); | |
1346 | gen_CHLD (); | |
1347 | gen_TTIN (); | |
1348 | gen_TTOU (); | |
1349 | gen_IO (); | |
1350 | gen_XCPU (); | |
1351 | gen_XFSZ (); | |
1352 | gen_VTALRM (); | |
1353 | gen_PROF (); | |
1354 | gen_WINCH (); | |
1355 | gen_LOST (); | |
1356 | gen_USR1 (); | |
1357 | gen_USR2 (); | |
1358 | gen_PWR (); | |
1359 | gen_POLL (); | |
1360 | gen_WIND (); | |
1361 | gen_PHONE (); | |
1362 | gen_WAITING (); | |
1363 | gen_LWP (); | |
1364 | gen_DANGER (); | |
1365 | gen_GRANT (); | |
1366 | gen_RETRACT (); | |
1367 | gen_MSG (); | |
1368 | gen_SOUND (); | |
1369 | gen_SAK (); | |
1370 | gen_PRIO (); | |
1371 | gen_33 (); | |
1372 | gen_34 (); | |
1373 | gen_35 (); | |
1374 | gen_36 (); | |
1375 | gen_37 (); | |
1376 | gen_38 (); | |
1377 | gen_39 (); | |
1378 | gen_40 (); | |
1379 | gen_41 (); | |
1380 | gen_42 (); | |
1381 | gen_43 (); | |
1382 | gen_44 (); | |
1383 | gen_45 (); | |
1384 | gen_46 (); | |
1385 | gen_47 (); | |
1386 | gen_48 (); | |
1387 | gen_49 (); | |
1388 | gen_50 (); | |
1389 | gen_51 (); | |
1390 | gen_52 (); | |
1391 | gen_53 (); | |
1392 | gen_54 (); | |
1393 | gen_55 (); | |
1394 | gen_56 (); | |
1395 | gen_57 (); | |
1396 | gen_58 (); | |
1397 | gen_59 (); | |
1398 | gen_60 (); | |
1399 | gen_61 (); | |
1400 | gen_62 (); | |
1401 | gen_63 (); | |
1402 | gen_TERM (); | |
1403 | ||
33b9c32b | 1404 | return 0; /* end of main */ |
b43b923a | 1405 | } |