gdb/testsuite/gdb.reverse/sigall-reverse.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2009-2023 Free Software Foundation, Inc.
   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
  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    Ordered ANSI-standard signals first, other signals second,
 382    with signals in each block ordered by their numerical values
 383    on a typical POSIX platform.  */
 384
 385 /* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM
 386    are ANSI-standard signals and are always available.  */
 387
 388 int
 389 gen_ILL (void)
 390 {
 391   kill (getpid (), SIGILL);
 392   return 0;
 393 }
 394
 395 int
 396 gen_ABRT (void)
 397 {
 398   kill (getpid (), SIGABRT);
 399   return 0;
 400 }
 401
 402 int x;
 403
 404 int
 405 gen_FPE (void)
 406 {
 407   /* The intent behind generating SIGFPE this way is to check the mapping
 408      from the CPU exception itself to the signals.  It would be nice to
 409      do the same for SIGBUS, SIGSEGV, etc., but I suspect that even this
 410      test might turn out to be insufficiently portable.  */
 411
 412 #if 0
 413   /* Loses on the PA because after the signal handler executes we try to
 414      re-execute the failing instruction again.  Perhaps we could siglongjmp
 415      out of the signal handler?  */
 416   /* The expect script looks for the word "kill"; don't delete it.  */
 417   return 5 / x; /* and we both started jumping up and down yelling kill */
 418 #else
 419   kill (getpid (), SIGFPE);
 420 #endif
 421   return 0;
 422 }
 423
 424 int
 425 gen_SEGV (void)
 426 {
 427   kill (getpid (), SIGSEGV);
 428   return 0;
 429 }
 430
 431 int
 432 gen_TERM (void)
 433 {
 434   kill (getpid (), SIGTERM);
 435   return 0;
 436 }
 437
 438 /* All other signals need preprocessor conditionals.  */
 439
 440 int
 441 gen_HUP (void)
 442 {
 443 #ifdef SIGHUP
 444   kill (getpid (), SIGHUP);
 445 #else
 446   handle_HUP (0);
 447 #endif
 448 return 0;
 449 }
 450
 451 int
 452 gen_QUIT (void)
 453 {
 454 #ifdef SIGQUIT
 455   kill (getpid (), SIGQUIT);
 456 #else
 457   handle_QUIT (0);
 458 #endif
 459 return 0;
 460 }
 461
 462 int
 463 gen_EMT (void)
 464 {
 465 #ifdef SIGEMT
 466   kill (getpid (), SIGEMT);
 467 #else
 468   handle_EMT (0);
 469 #endif
 470 return 0;
 471 }
 472
 473 int
 474 gen_BUS (void)
 475 {
 476 #ifdef SIGBUS
 477   kill (getpid (), SIGBUS);
 478 #else
 479   handle_BUS (0);
 480 #endif
 481 return 0;
 482 }
 483
 484 int
 485 gen_SYS (void)
 486 {
 487 #ifdef SIGSYS
 488   kill (getpid (), SIGSYS);
 489 #else
 490   handle_SYS (0);
 491 #endif
 492 return 0;
 493 }
 494
 495 int
 496 gen_PIPE (void)
 497 {
 498 #ifdef SIGPIPE
 499   kill (getpid (), SIGPIPE);
 500 #else
 501   handle_PIPE (0);
 502 #endif
 503 return 0;
 504 }
 505
 506 int
 507 gen_ALRM (void)
 508 {
 509 #ifdef SIGALRM
 510   kill (getpid (), SIGALRM);
 511 #else
 512   handle_ALRM (0);
 513 #endif
 514 return 0;
 515 }
 516
 517 int
 518 gen_URG (void)
 519 {
 520 #ifdef SIGURG
 521   kill (getpid (), SIGURG);
 522 #else
 523   handle_URG (0);
 524 #endif
 525 return 0;
 526 }
 527
 528 int
 529 gen_TSTP (void)
 530 {
 531 #ifdef SIGTSTP
 532   kill (getpid (), SIGTSTP);
 533 #else
 534   handle_TSTP (0);
 535 #endif
 536 return 0;
 537 }
 538
 539 int
 540 gen_CONT (void)
 541 {
 542 #ifdef SIGCONT
 543   kill (getpid (), SIGCONT);
 544 #else
 545   handle_CONT (0);
 546 #endif
 547 return 0;
 548 }
 549
 550 int
 551 gen_CHLD (void)
 552 {
 553 #ifdef SIGCHLD
 554   kill (getpid (), SIGCHLD);
 555 #else
 556   handle_CHLD (0);
 557 #endif
 558 return 0;
 559 }
 560
 561 int
 562 gen_TTIN (void)
 563 {
 564 #ifdef SIGTTIN
 565   kill (getpid (), SIGTTIN);
 566 #else
 567   handle_TTIN (0);
 568 #endif
 569 return 0;
 570 }
 571
 572 int
 573 gen_TTOU (void)
 574 {
 575 #ifdef SIGTTOU
 576   kill (getpid (), SIGTTOU);
 577 #else
 578   handle_TTOU (0);
 579 #endif
 580 return 0;
 581 }
 582
 583 int
 584 gen_IO (void)
 585 {
 586 #ifdef SIGIO
 587   kill (getpid (), SIGIO);
 588 #else
 589   handle_IO (0);
 590 #endif
 591 return 0;
 592 }
 593
 594 int
 595 gen_XCPU (void)
 596 {
 597 #ifdef SIGXCPU
 598   kill (getpid (), SIGXCPU);
 599 #else
 600   handle_XCPU (0);
 601 #endif
 602 return 0;
 603 }
 604
 605 int
 606 gen_XFSZ (void)
 607 {
 608 #ifdef SIGXFSZ
 609   kill (getpid (), SIGXFSZ);
 610 #else
 611   handle_XFSZ (0);
 612 #endif
 613 return 0;
 614 }
 615
 616 int
 617 gen_VTALRM (void)
 618 {
 619 #ifdef SIGVTALRM
 620   kill (getpid (), SIGVTALRM);
 621 #else
 622   handle_VTALRM (0);
 623 #endif
 624 return 0;
 625 }
 626
 627 int
 628 gen_PROF (void)
 629 {
 630 #ifdef SIGPROF
 631   kill (getpid (), SIGPROF);
 632 #else
 633   handle_PROF (0);
 634 #endif
 635 return 0;
 636 }
 637
 638 int
 639 gen_WINCH (void)
 640 {
 641 #ifdef SIGWINCH
 642   kill (getpid (), SIGWINCH);
 643 #else
 644   handle_WINCH (0);
 645 #endif
 646 return 0;
 647 }
 648
 649 int
 650 gen_LOST (void)
 651 {
 652 #if defined(SIGLOST) && SIGLOST != SIGABRT
 653   kill (getpid (), SIGLOST);
 654 #else
 655   handle_LOST (0);
 656 #endif
 657 return 0;
 658 }
 659
 660 int
 661 gen_USR1 (void)
 662 {
 663 #ifdef SIGUSR1
 664   kill (getpid (), SIGUSR1);
 665 #else
 666   handle_USR1 (0);
 667 #endif
 668 return 0;
 669 }
 670
 671 int
 672 gen_USR2 (void)
 673 {
 674 #ifdef SIGUSR2
 675   kill (getpid (), SIGUSR2);
 676 #else
 677   handle_USR2 (0);
 678 #endif
 679 return 0;
 680 }
 681
 682 int
 683 gen_PWR (void)
 684 {
 685 #ifdef SIGPWR
 686   kill (getpid (), SIGPWR);
 687 #else
 688   handle_PWR (0);
 689 #endif
 690 return 0;
 691 }
 692
 693 int
 694 gen_POLL (void)
 695 {
 696 #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO)
 697   kill (getpid (), SIGPOLL);
 698 #else
 699   handle_POLL (0);
 700 #endif
 701 return 0;
 702 }
 703
 704 int
 705 gen_WIND (void)
 706 {
 707 #ifdef SIGWIND
 708   kill (getpid (), SIGWIND);
 709 #else
 710   handle_WIND (0);
 711 #endif
 712 return 0;
 713 }
 714
 715 int
 716 gen_PHONE (void)
 717 {
 718 #ifdef SIGPHONE
 719   kill (getpid (), SIGPHONE);
 720 #else
 721   handle_PHONE (0);
 722 #endif
 723 return 0;
 724 }
 725
 726 int
 727 gen_WAITING (void)
 728 {
 729 #ifdef SIGWAITING
 730   kill (getpid (), SIGWAITING);
 731 #else
 732   handle_WAITING (0);
 733 #endif
 734 return 0;
 735 }
 736
 737 int
 738 gen_LWP (void)
 739 {
 740 #ifdef SIGLWP
 741   kill (getpid (), SIGLWP);
 742 #else
 743   handle_LWP (0);
 744 #endif
 745 return 0;
 746 }
 747
 748 int
 749 gen_DANGER (void)
 750 {
 751 #ifdef SIGDANGER
 752   kill (getpid (), SIGDANGER);
 753 #else
 754   handle_DANGER (0);
 755 #endif
 756 return 0;
 757 }
 758
 759 int
 760 gen_GRANT (void)
 761 {
 762 #ifdef SIGGRANT
 763   kill (getpid (), SIGGRANT);
 764 #else
 765   handle_GRANT (0);
 766 #endif
 767 return 0;
 768 }
 769
 770 int
 771 gen_RETRACT (void)
 772 {
 773 #ifdef SIGRETRACT
 774   kill (getpid (), SIGRETRACT);
 775 #else
 776   handle_RETRACT (0);
 777 #endif
 778 return 0;
 779 }
 780
 781 int
 782 gen_MSG (void)
 783 {
 784 #ifdef SIGMSG
 785   kill (getpid (), SIGMSG);
 786 #else
 787   handle_MSG (0);
 788 #endif
 789 return 0;
 790 }
 791
 792 int
 793 gen_SOUND (void)
 794 {
 795 #ifdef SIGSOUND
 796   kill (getpid (), SIGSOUND);
 797 #else
 798   handle_SOUND (0);
 799 #endif
 800 return 0;
 801 }
 802
 803 int
 804 gen_SAK (void)
 805 {
 806 #ifdef SIGSAK
 807   kill (getpid (), SIGSAK);
 808 #else
 809   handle_SAK (0);
 810 #endif
 811 return 0;
 812 }
 813
 814 int
 815 gen_PRIO (void)
 816 {
 817 #ifdef SIGPRIO
 818   kill (getpid (), SIGPRIO);
 819 #else
 820   handle_PRIO (0);
 821 #endif
 822 return 0;
 823 }
 824
 825 int
 826 gen_33 (void)
 827 {
 828 #ifdef SIG33
 829   kill (getpid (), 33);
 830 #else
 831   handle_33 (0);
 832 #endif
 833 return 0;
 834 }
 835
 836 int
 837 gen_34 (void)
 838 {
 839 #ifdef SIG34
 840   kill (getpid (), 34);
 841 #else
 842   handle_34 (0);
 843 #endif
 844 return 0;
 845 }
 846
 847 int
 848 gen_35 (void)
 849 {
 850 #ifdef SIG35
 851   kill (getpid (), 35);
 852 #else
 853   handle_35 (0);
 854 #endif
 855 return 0;
 856 }
 857
 858 int
 859 gen_36 (void)
 860 {
 861 #ifdef SIG36
 862   kill (getpid (), 36);
 863 #else
 864   handle_36 (0);
 865 #endif
 866 return 0;
 867 }
 868
 869 int
 870 gen_37 (void)
 871 {
 872 #ifdef SIG37
 873   kill (getpid (), 37);
 874 #else
 875   handle_37 (0);
 876 #endif
 877 return 0;
 878 }
 879
 880 int
 881 gen_38 (void)
 882 {
 883 #ifdef SIG38
 884   kill (getpid (), 38);
 885 #else
 886   handle_38 (0);
 887 #endif
 888 return 0;
 889 }
 890
 891 int
 892 gen_39 (void)
 893 {
 894 #ifdef SIG39
 895   kill (getpid (), 39);
 896 #else
 897   handle_39 (0);
 898 #endif
 899 return 0;
 900 }
 901
 902 int
 903 gen_40 (void)
 904 {
 905 #ifdef SIG40
 906   kill (getpid (), 40);
 907 #else
 908   handle_40 (0);
 909 #endif
 910 return 0;
 911 }
 912
 913 int
 914 gen_41 (void)
 915 {
 916 #ifdef SIG41
 917   kill (getpid (), 41);
 918 #else
 919   handle_41 (0);
 920 #endif
 921 return 0;
 922 }
 923
 924 int
 925 gen_42 (void)
 926 {
 927 #ifdef SIG42
 928   kill (getpid (), 42);
 929 #else
 930   handle_42 (0);
 931 #endif
 932 return 0;
 933 }
 934
 935 int
 936 gen_43 (void)
 937 {
 938 #ifdef SIG43
 939   kill (getpid (), 43);
 940 #else
 941   handle_43 (0);
 942 #endif
 943 return 0;
 944 }
 945
 946 int
 947 gen_44 (void)
 948 {
 949 #ifdef SIG44
 950   kill (getpid (), 44);
 951 #else
 952   handle_44 (0);
 953 #endif
 954 return 0;
 955 }
 956
 957 int
 958 gen_45 (void)
 959 {
 960 #ifdef SIG45
 961   kill (getpid (), 45);
 962 #else
 963   handle_45 (0);
 964 #endif
 965 return 0;
 966 }
 967
 968 int
 969 gen_46 (void)
 970 {
 971 #ifdef SIG46
 972   kill (getpid (), 46);
 973 #else
 974   handle_46 (0);
 975 #endif
 976 return 0;
 977 }
 978
 979 int
 980 gen_47 (void)
 981 {
 982 #ifdef SIG47
 983   kill (getpid (), 47);
 984 #else
 985   handle_47 (0);
 986 #endif
 987 return 0;
 988 }
 989
 990 int
 991 gen_48 (void)
 992 {
 993 #ifdef SIG48
 994   kill (getpid (), 48);
 995 #else
 996   handle_48 (0);
 997 #endif
 998 return 0;
 999 }
1000
1001 int
1002 gen_49 (void)
1003 {
1004 #ifdef SIG49
1005   kill (getpid (), 49);
1006 #else
1007   handle_49 (0);
1008 #endif
1009 return 0;
1010 }
1011
1012 int
1013 gen_50 (void)
1014 {
1015 #ifdef SIG50
1016   kill (getpid (), 50);
1017 #else
1018   handle_50 (0);
1019 #endif
1020 return 0;
1021 }
1022
1023 int
1024 gen_51 (void)
1025 {
1026 #ifdef SIG51
1027   kill (getpid (), 51);
1028 #else
1029   handle_51 (0);
1030 #endif
1031 return 0;
1032 }
1033
1034 int
1035 gen_52 (void)
1036 {
1037 #ifdef SIG52
1038   kill (getpid (), 52);
1039 #else
1040   handle_52 (0);
1041 #endif
1042 return 0;
1043 }
1044
1045 int
1046 gen_53 (void)
1047 {
1048 #ifdef SIG53
1049   kill (getpid (), 53);
1050 #else
1051   handle_53 (0);
1052 #endif
1053 return 0;
1054 }
1055
1056 int
1057 gen_54 (void)
1058 {
1059 #ifdef SIG54
1060   kill (getpid (), 54);
1061 #else
1062   handle_54 (0);
1063 #endif
1064 return 0;
1065 }
1066
1067 int
1068 gen_55 (void)
1069 {
1070 #ifdef SIG55
1071   kill (getpid (), 55);
1072 #else
1073   handle_55 (0);
1074 #endif
1075 return 0;
1076 }
1077
1078 int
1079 gen_56 (void)
1080 {
1081 #ifdef SIG56
1082   kill (getpid (), 56);
1083 #else
1084   handle_56 (0);
1085 #endif
1086 return 0;
1087 }
1088
1089 int
1090 gen_57 (void)
1091 {
1092 #ifdef SIG57
1093   kill (getpid (), 57);
1094 #else
1095   handle_57 (0);
1096 #endif
1097 return 0;
1098 }
1099
1100 int
1101 gen_58 (void)
1102 {
1103 #ifdef SIG58
1104   kill (getpid (), 58);
1105 #else
1106   handle_58 (0);
1107 #endif
1108 return 0;
1109 }
1110
1111 int
1112 gen_59 (void)
1113 {
1114 #ifdef SIG59
1115   kill (getpid (), 59);
1116 #else
1117   handle_59 (0);
1118 #endif
1119 return 0;
1120 }
1121
1122 int
1123 gen_60 (void)
1124 {
1125 #ifdef SIG60
1126   kill (getpid (), 60);
1127 #else
1128   handle_60 (0);
1129 #endif
1130 return 0;
1131 }
1132
1133 int
1134 gen_61 (void)
1135 {
1136 #ifdef SIG61
1137   kill (getpid (), 61);
1138 #else
1139   handle_61 (0);
1140 #endif
1141 return 0;
1142 }
1143
1144 int
1145 gen_62 (void)
1146 {
1147 #ifdef SIG62
1148   kill (getpid (), 62);
1149 #else
1150   handle_62 (0);
1151 #endif
1152 return 0;
1153 }
1154
1155 int
1156 gen_63 (void)
1157 {
1158 #ifdef SIG63
1159   kill (getpid (), 63);
1160 #else
1161   handle_63 (0);
1162 #endif
1163 return 0;
1164 }
1165 \f
1166 int
1167 main ()
1168 {
1169 #ifdef SIG_SETMASK
1170   /* Ensure all the signals aren't blocked.
1171      The environment in which the testsuite is run may have blocked some
1172      for whatever reason.  */
1173   {
1174     sigset_t newset;
1175     sigemptyset (&newset);
1176     sigprocmask (SIG_SETMASK, &newset, NULL);
1177   }
1178 #endif
1179
1180   /* Signals are ordered ANSI-standard signals first, other signals
1181      second, with signals in each block ordered by their numerical
1182      values on a typical POSIX platform.  */
1183
1184   /* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM
1185      are ANSI-standard signals and are always available.  */
1186   signal (SIGILL, handle_ILL);
1187   signal (SIGABRT, handle_ABRT);
1188   signal (SIGFPE, handle_FPE);
1189   signal (SIGSEGV, handle_SEGV);
1190   signal (SIGTERM, handle_TERM);
1191
1192   /* All other signals need preprocessor conditionals.  */
1193 #ifdef SIGHUP
1194   signal (SIGHUP, handle_HUP);
1195 #endif
1196 #ifdef SIGQUIT
1197   signal (SIGQUIT, handle_QUIT);
1198 #endif
1199 #ifdef SIGEMT
1200   signal (SIGEMT, handle_EMT);
1201 #endif
1202 #ifdef SIGBUS
1203   signal (SIGBUS, handle_BUS);
1204 #endif
1205 #ifdef SIGSYS
1206   signal (SIGSYS, handle_SYS);
1207 #endif
1208 #ifdef SIGPIPE
1209   signal (SIGPIPE, handle_PIPE);
1210 #endif
1211 #ifdef SIGALRM
1212   signal (SIGALRM, handle_ALRM);
1213 #endif
1214 #ifdef SIGURG
1215   signal (SIGURG, handle_URG);
1216 #endif
1217 #ifdef SIGTSTP
1218   signal (SIGTSTP, handle_TSTP);
1219 #endif
1220 #ifdef SIGCONT
1221   signal (SIGCONT, handle_CONT);
1222 #endif
1223 #ifdef SIGCHLD
1224   signal (SIGCHLD, handle_CHLD);
1225 #endif
1226 #ifdef SIGTTIN
1227   signal (SIGTTIN, handle_TTIN);
1228 #endif
1229 #ifdef SIGTTOU
1230   signal (SIGTTOU, handle_TTOU);
1231 #endif
1232 #ifdef SIGIO
1233   signal (SIGIO, handle_IO);
1234 #endif
1235 #ifdef SIGXCPU
1236   signal (SIGXCPU, handle_XCPU);
1237 #endif
1238 #ifdef SIGXFSZ
1239   signal (SIGXFSZ, handle_XFSZ);
1240 #endif
1241 #ifdef SIGVTALRM
1242   signal (SIGVTALRM, handle_VTALRM);
1243 #endif
1244 #ifdef SIGPROF
1245   signal (SIGPROF, handle_PROF);
1246 #endif
1247 #ifdef SIGWINCH
1248   signal (SIGWINCH, handle_WINCH);
1249 #endif
1250 #if defined(SIGLOST) && SIGLOST != SIGABRT
1251   signal (SIGLOST, handle_LOST);
1252 #endif
1253 #ifdef SIGUSR1
1254   signal (SIGUSR1, handle_USR1);
1255 #endif
1256 #ifdef SIGUSR2
1257   signal (SIGUSR2, handle_USR2);
1258 #endif
1259 #ifdef SIGPWR
1260   signal (SIGPWR, handle_PWR);
1261 #endif
1262 #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO)
1263   signal (SIGPOLL, handle_POLL);
1264 #endif
1265 #ifdef SIGWIND
1266   signal (SIGWIND, handle_WIND);
1267 #endif
1268 #ifdef SIGPHONE
1269   signal (SIGPHONE, handle_PHONE);
1270 #endif
1271 #ifdef SIGWAITING
1272   signal (SIGWAITING, handle_WAITING);
1273 #endif
1274 #ifdef SIGLWP
1275   signal (SIGLWP, handle_LWP);
1276 #endif
1277 #ifdef SIGDANGER
1278   signal (SIGDANGER, handle_DANGER);
1279 #endif
1280 #ifdef SIGGRANT
1281   signal (SIGGRANT, handle_GRANT);
1282 #endif
1283 #ifdef SIGRETRACT
1284   signal (SIGRETRACT, handle_RETRACT);
1285 #endif
1286 #ifdef SIGMSG
1287   signal (SIGMSG, handle_MSG);
1288 #endif
1289 #ifdef SIGSOUND
1290   signal (SIGSOUND, handle_SOUND);
1291 #endif
1292 #ifdef SIGSAK
1293   signal (SIGSAK, handle_SAK);
1294 #endif
1295 #ifdef SIGPRIO
1296   signal (SIGPRIO, handle_PRIO);
1297 #endif
1298 #ifdef __Lynx__
1299   /* Lynx doesn't seem to have anything in signal.h for this.  */
1300   signal (33, handle_33);
1301   signal (34, handle_34);
1302   signal (35, handle_35);
1303   signal (36, handle_36);
1304   signal (37, handle_37);
1305   signal (38, handle_38);
1306   signal (39, handle_39);
1307   signal (40, handle_40);
1308   signal (41, handle_41);
1309   signal (42, handle_42);
1310   signal (43, handle_43);
1311   signal (44, handle_44);
1312   signal (45, handle_45);
1313   signal (46, handle_46);
1314   signal (47, handle_47);
1315   signal (48, handle_48);
1316   signal (49, handle_49);
1317   signal (50, handle_50);
1318   signal (51, handle_51);
1319   signal (52, handle_52);
1320   signal (53, handle_53);
1321   signal (54, handle_54);
1322   signal (55, handle_55);
1323   signal (56, handle_56);
1324   signal (57, handle_57);
1325   signal (58, handle_58);
1326   signal (59, handle_59);
1327   signal (60, handle_60);
1328   signal (61, handle_61);
1329   signal (62, handle_62);
1330   signal (63, handle_63);
1331 #endif /* lynx */
1332
1333   x = 0;
1334
1335   gen_ABRT ();
1336   gen_HUP ();
1337   gen_QUIT ();
1338   gen_ILL ();
1339   gen_EMT ();
1340   gen_FPE ();
1341   gen_BUS ();
1342   gen_SEGV ();
1343   gen_SYS ();
1344   gen_PIPE ();
1345   gen_ALRM ();
1346   gen_URG ();
1347   gen_TSTP ();
1348   gen_CONT ();
1349   gen_CHLD ();
1350   gen_TTIN ();
1351   gen_TTOU ();
1352   gen_IO ();
1353   gen_XCPU ();
1354   gen_XFSZ ();
1355   gen_VTALRM ();
1356   gen_PROF ();
1357   gen_WINCH ();
1358   gen_LOST ();
1359   gen_USR1 ();
1360   gen_USR2 ();
1361   gen_PWR ();
1362   gen_POLL ();
1363   gen_WIND ();
1364   gen_PHONE ();
1365   gen_WAITING ();
1366   gen_LWP ();
1367   gen_DANGER ();
1368   gen_GRANT ();
1369   gen_RETRACT ();
1370   gen_MSG ();
1371   gen_SOUND ();
1372   gen_SAK ();
1373   gen_PRIO ();
1374   gen_33 ();
1375   gen_34 ();
1376   gen_35 ();
1377   gen_36 ();
1378   gen_37 ();
1379   gen_38 ();
1380   gen_39 ();
1381   gen_40 ();
1382   gen_41 ();
1383   gen_42 ();
1384   gen_43 ();
1385   gen_44 ();
1386   gen_45 ();
1387   gen_46 ();
1388   gen_47 ();
1389   gen_48 ();
1390   gen_49 ();
1391   gen_50 ();
1392   gen_51 ();
1393   gen_52 ();
1394   gen_53 ();
1395   gen_54 ();
1396   gen_55 ();
1397   gen_56 ();
1398   gen_57 ();
1399   gen_58 ();
1400   gen_59 ();
1401   gen_60 ();
1402   gen_61 ();
1403   gen_62 ();
1404   gen_63 ();
1405   gen_TERM ();
1406
1407   return 0;     /* end of main */
1408 }