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