1 /* Start and stop the inferior process, for GDB.
2 Copyright (C) 1986, 1987 Free Software Foundation, Inc.
4 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5 WARRANTY. No author or distributor accepts responsibility to anyone
6 for the consequences of using it or for whether it serves any
7 particular purpose or works at all, unless he says so in writing.
8 Refer to the GDB General Public License for full details.
10 Everyone is granted permission to copy, modify and redistribute GDB,
11 but only under the conditions described in the GDB General Public
12 License. A copy of this license is supposed to have been given to you
13 along with GDB so you can know your rights and responsibilities. It
14 should be in a file named COPYING. Among other things, the copyright
15 notice and this notice must be preserved on all copies.
17 In other words, go ahead and share GDB, but don't try to stop
18 anyone else from sharing it farther. Help stamp out software hoarding!
22 #include "initialize.h"
34 #include <sys/param.h>
35 #include <sys/ptrace.h>
38 extern char *sys_siglist
[];
41 /* Tables of how to react to signals; the user sets them. */
43 static char signal_stop
[NSIG
];
44 static char signal_print
[NSIG
];
45 static char signal_program
[NSIG
];
47 /* Nonzero if breakpoints are now inserted in the inferior. */
49 static int breakpoints_inserted
;
51 /* Function inferior was in as of last step command. */
53 static struct symbol
*step_start_function
;
55 /* This is the sequence of bytes we insert for a breakpoint. */
57 static char break_insn
[] = BREAKPOINT
;
59 /* Nonzero => address for special breakpoint for resuming stepping. */
61 static CORE_ADDR step_resume_break_address
;
63 /* Original contents of the byte where the special breakpoint is. */
65 static char step_resume_break_shadow
[sizeof break_insn
];
67 /* Nonzero means the special breakpoint is a duplicate
68 so it has not itself been inserted. */
70 static int step_resume_break_duplicate
;
72 /* Nonzero if we are expecting a trace trap and should proceed from it.
73 2 means expecting 2 trace traps and should continue both times.
74 That occurs when we tell sh to exec the program: we will get
75 a trap after the exec of sh and a second when the program is exec'd. */
77 static int trap_expected
;
79 /* Nonzero means expecting a trace trap
80 and should stop the inferior and return silently when it happens. */
82 static int stop_after_trap
;
84 /* Nonzero means expecting a trace trap due to attaching to a process. */
86 static int stop_after_attach
;
88 /* Nonzero if pc has been changed by the debugger
89 since the inferior stopped. */
93 /* Save register contents here when about to pop a stack dummy frame. */
95 char stop_registers
[REGISTER_BYTES
];
97 /* Nonzero if program stopped due to error trying to insert breakpoints. */
99 static int breakpoints_failed
;
101 /* Nonzero if inferior is in sh before our program got exec'd. */
103 static int running_in_shell
;
105 /* Nonzero after stop if current stack frame should be printed. */
107 static int stop_print_frame
;
109 static void insert_step_breakpoint ();
110 static void remove_step_breakpoint ();
111 static void wait_for_inferior ();
112 static void normal_stop ();
116 /* Clear out all variables saying what to do when inferior is continued.
117 First do this, then set the ones you want, then call `proceed'. */
120 clear_proceed_status ()
123 step_range_start
= 0;
126 step_over_calls
= -1;
127 step_resume_break_address
= 0;
129 stop_after_attach
= 0;
131 /* Discard any remaining commands left by breakpoint we had stopped at. */
132 clear_breakpoint_commands ();
135 /* Basic routine for continuing the program in various fashions.
137 ADDR is the address to resume at, or -1 for resume where stopped.
138 SIGNAL is the signal to give it, or 0 for none,
139 or -1 for act according to how it stopped.
140 STEP is nonzero if should trap after one instruction.
141 -1 means return after that and print nothing.
142 You should probably set various step_... variables
143 before calling here, if you are stepping.
145 You should call clear_proceed_status before calling proceed. */
148 proceed (addr
, signal
, step
)
156 step_start_function
= find_pc_function (read_pc ());
162 /* If there is a breakpoint at the address we will resume at,
163 step one instruction before inserting breakpoints
164 so that we do not stop right away. */
166 if (!pc_changed
&& breakpoint_here_p (read_pc ()))
169 /* We will get a trace trap after one instruction.
170 Continue it automatically and insert breakpoints then. */
175 write_register (PC_REGNUM
, addr
);
179 int temp
= insert_breakpoints ();
182 print_sys_errmsg ("ptrace", temp
);
183 error ("Cannot insert breakpoints.\n\
184 The same program may be running in another process.");
186 breakpoints_inserted
= 1;
189 /* Install inferior's terminal modes. */
190 terminal_inferior ();
193 stop_signal
= signal
;
194 /* If this signal should not be seen by program,
195 give it zero. Used for debugging signals. */
196 else if (stop_signal
< NSIG
&& !signal_program
[stop_signal
])
199 /* Resume inferior. */
200 resume (oneproc
|| step
, stop_signal
);
202 /* Wait for it to stop (if not standalone)
203 and in any case decode why it stopped, and act accordingly. */
205 wait_for_inferior ();
209 /* Writing the inferior pc as a register calls this function
210 to inform infrun that the pc has been set in the debugger. */
219 /* Start an inferior process for the first time.
220 Actually it was started by the fork that created it,
221 but it will have stopped one instruction after execing sh.
222 Here we must get it up to actual execution of the real program. */
226 /* We will get a trace trap after one instruction.
227 Continue it automatically. Eventually (after shell does an exec)
228 it will get another trace trap. Then insert breakpoints and continue. */
230 running_in_shell
= 0; /* Set to 1 at first SIGTRAP, 0 at second. */
231 breakpoints_inserted
= 0;
232 mark_breakpoints_out ();
234 /* Set up the "saved terminal modes" of the inferior
235 based on what modes we are starting it with. */
236 terminal_init_inferior ();
238 /* Install inferior's terminal modes. */
239 terminal_inferior ();
241 wait_for_inferior ();
247 /* Attach to process PID, then initialize for debugging it
248 and wait for the trace-trap that results from attaching. */
257 mark_breakpoints_out ();
258 terminal_init_inferior ();
259 clear_proceed_status ();
260 stop_after_attach
= 1;
261 /*proceed (-1, 0, -2);*/
262 wait_for_inferior ();
265 #endif /* ATTACH_DETACH */
267 /* Wait for control to return from inferior to debugger.
268 If inferior gets a signal, we may decide to start it up again
269 instead of returning. That is why there is a loop in this function.
270 When this function actually returns it means the inferior
271 should be left stopped and GDB should read more commands. */
283 int stop_step_resume_break
;
286 struct symbol
*newfun
;
287 struct symtab_and_line sal
;
292 prev_pc
= read_pc ();
295 fetch_inferior_registers ();
296 stop_pc
= read_pc ();
297 set_current_frame (read_register (FP_REGNUM
));
298 stop_frame
= get_current_frame ();
299 stop_sp
= read_register (SP_REGNUM
);
303 stop_stack_dummy
= 0;
304 stop_print_frame
= 1;
305 stop_step_resume_break
= 0;
307 breakpoints_failed
= 0;
309 /* Look at the cause of the stop, and decide what to do.
310 The alternatives are:
311 1) break; to really stop and return to the debugger,
312 2) drop through to start up again
313 (set another_trap to 1 to single step once)
314 3) set random_signal to 1, and the decision between 1 and 2
315 will be made according to the signal handling tables. */
319 terminal_ours_for_output ();
321 printf ("\nProgram exited with code 0%o.\n", WRETCODE (w
));
323 printf ("\nProgram exited normally.\n");
326 stop_print_frame
= 0;
329 else if (!WIFSTOPPED (w
))
332 stop_print_frame
= 0;
333 stop_signal
= WTERMSIG (w
);
334 terminal_ours_for_output ();
335 printf ("\nProgram terminated with signal %d, %s\n",
338 ? sys_siglist
[stop_signal
]
340 printf ("The inferior process no longer exists.\n");
346 stop_signal
= WSTOPSIG (w
);
348 /* First, distinguish signals caused by the debugger from signals
349 that have to do with the program's own actions.
350 Note that breakpoint insns may cause SIGTRAP or SIGILL
351 or SIGEMT, depending on the operating system version.
352 Here we detect when a SIGILL or SIGEMT is really a breakpoint
353 and change it to SIGTRAP. */
355 if (stop_signal
== SIGTRAP
356 || (breakpoints_inserted
&&
357 (stop_signal
== SIGILL
358 || stop_signal
== SIGEMT
))
359 || stop_after_attach
)
361 if (stop_signal
== SIGTRAP
&& stop_after_trap
)
363 stop_print_frame
= 0;
366 if (stop_after_attach
)
368 /* Don't even think about breakpoints
369 if still running the shell that will exec the program
370 or if just proceeded over a breakpoint. */
371 if (stop_signal
== SIGTRAP
&& trap_expected
)
374 /* See if there is a breakpoint at the current PC. */
375 #if DECR_PC_AFTER_BREAK
376 /* Notice the case of stepping through a jump
377 that leads just after a breakpoint.
378 Don't confuse that with hitting the breakpoint.
379 What we check for is that 1) stepping is going on
380 and 2) the pc before the last insn does not match
381 the address of the breakpoint before the current pc. */
382 if (!(prev_pc
!= stop_pc
- DECR_PC_AFTER_BREAK
383 && step_range_end
&& !step_resume_break_address
))
384 #endif /* DECR_PC_AFTER_BREAK not zero */
386 select_frame (stop_frame
, 0); /* For condition exprs. */
387 stop_breakpoint
= breakpoint_stop_status (stop_pc
, stop_frame
);
388 /* Following in case break condition called a function. */
389 stop_print_frame
= 1;
390 if (stop_breakpoint
&& DECR_PC_AFTER_BREAK
)
392 stop_pc
-= DECR_PC_AFTER_BREAK
;
393 write_register (PC_REGNUM
, stop_pc
);
397 /* See if we stopped at the special breakpoint for
398 stepping over a subroutine call. */
399 if (stop_pc
- DECR_PC_AFTER_BREAK
== step_resume_break_address
)
401 stop_step_resume_break
= 1;
402 if (DECR_PC_AFTER_BREAK
)
404 stop_pc
-= DECR_PC_AFTER_BREAK
;
405 write_register (PC_REGNUM
, stop_pc
);
410 if (stop_signal
== SIGTRAP
)
412 = !(stop_breakpoint
|| trap_expected
413 || stop_step_resume_break
414 || (stop_sp INNER_THAN stop_pc
&& stop_pc INNER_THAN stop_frame
)
415 || (step_range_end
&& !step_resume_break_address
));
419 = !(stop_breakpoint
|| stop_step_resume_break
);
421 stop_signal
= SIGTRAP
;
427 /* For the program's own signals, act according to
428 the signal handling tables. */
431 && !(running_in_shell
&& stop_signal
== SIGSEGV
))
433 /* Signal not for debugging purposes. */
436 if (stop_signal
>= NSIG
437 || signal_print
[stop_signal
])
440 terminal_ours_for_output ();
441 printf ("\nProgram received signal %d, %s\n",
444 ? sys_siglist
[stop_signal
]
448 if (stop_signal
>= NSIG
449 || signal_stop
[stop_signal
])
451 /* If not going to stop, give terminal back
452 if we took it away. */
454 terminal_inferior ();
457 /* Handle cases caused by hitting a breakpoint. */
460 && (stop_breakpoint
|| stop_step_resume_break
))
462 /* Does a breakpoint want us to stop? */
463 if (stop_breakpoint
&& stop_breakpoint
!= -1)
465 /* 0x1000000 is set in stop_breakpoint as returned by
466 breakpoint_status_p to indicate a silent breakpoint. */
467 if (stop_breakpoint
> 0 && stop_breakpoint
& 0x1000000)
469 stop_breakpoint
&= ~0x1000000;
470 stop_print_frame
= 0;
474 /* But if we have hit the step-resumption breakpoint,
475 remove it. It has done its job getting us here. */
476 if (stop_step_resume_break
477 && (step_frame
== 0 || stop_frame
== step_frame
))
479 remove_step_breakpoint ();
480 step_resume_break_address
= 0;
482 /* Otherwise, must remove breakpoints and single-step
483 to get us past the one we hit. */
486 remove_breakpoints ();
487 remove_step_breakpoint ();
488 breakpoints_inserted
= 0;
492 /* We come here if we hit a breakpoint but should not
493 stop for it. Possibly we also were stepping
494 and should stop for that. So fall through and
495 test for stepping. But, if not stepping,
499 /* If this is the breakpoint at the end of a stack dummy,
500 just stop silently. */
501 if (stop_sp INNER_THAN stop_pc
&& stop_pc INNER_THAN stop_frame
)
503 stop_print_frame
= 0;
504 stop_stack_dummy
= 1;
508 if (step_resume_break_address
)
509 /* Having a step-resume breakpoint overrides anything
510 else having to do with stepping commands until
511 that breakpoint is reached. */
513 /* If stepping through a line, keep going if still within it. */
514 else if (!random_signal
516 && stop_pc
>= step_range_start
517 && stop_pc
< step_range_end
)
519 /* Don't step through the return from a function
520 unless that is the first instruction stepped through. */
521 if (ABOUT_TO_RETURN (stop_pc
))
528 /* We stepped out of the stepping range. See if that was due
529 to a subroutine call that we should proceed to the end of. */
530 else if (!random_signal
&& step_range_end
)
532 newfun
= find_pc_function (stop_pc
);
535 newfun_pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (newfun
))
536 + FUNCTION_START_OFFSET
;
540 newmisc
= find_pc_misc_function (stop_pc
);
542 newfun_pc
= misc_function_vector
[newmisc
].address
543 + FUNCTION_START_OFFSET
;
546 if (stop_pc
== newfun_pc
547 && (step_over_calls
> 0 || (step_over_calls
&& newfun
== 0)))
549 /* A subroutine call has happened. */
550 /* Set a special breakpoint after the return */
551 step_resume_break_address
= SAVED_PC_AFTER_CALL (stop_frame
);
552 step_resume_break_duplicate
553 = breakpoint_here_p (step_resume_break_address
);
554 if (breakpoints_inserted
)
555 insert_step_breakpoint ();
557 /* Subroutine call with source code we should not step over.
558 Do step to the first line of code in it. */
559 else if (stop_pc
== newfun_pc
&& step_over_calls
)
561 SKIP_PROLOGUE (newfun_pc
);
562 sal
= find_pc_line (newfun_pc
, 0);
563 /* Use the step_resume_break to step until
564 the end of the prologue, even if that involves jumps
565 (as it seems to on the vax under 4.2). */
566 /* If the prologue ends in the middle of a source line,
567 continue to the end of that source line.
568 Otherwise, just go to end of prologue. */
569 if (sal
.end
&& sal
.pc
!= newfun_pc
)
570 step_resume_break_address
= sal
.end
;
572 step_resume_break_address
= newfun_pc
;
574 step_resume_break_duplicate
575 = breakpoint_here_p (step_resume_break_address
);
576 if (breakpoints_inserted
)
577 insert_step_breakpoint ();
578 /* Do not specify what the fp should be when we stop
579 since on some machines the prologue
580 is where the new fp value is established. */
582 /* And make sure stepping stops right away then. */
583 step_range_end
= step_range_start
;
585 /* No subroutince call; stop now. */
594 /* If we did not do break;, it means we should keep
595 running the inferior and not return to debugger. */
597 /* If trap_expected is 2, it means continue once more
598 and insert breakpoints at the next trap.
599 If trap_expected is 1 and the signal was SIGSEGV, it means
600 the shell is doing some memory allocation--just resume it
602 Otherwise insert breakpoints now, and possibly single step. */
604 if (trap_expected
> 1)
607 running_in_shell
= 1;
610 else if (running_in_shell
&& stop_signal
== SIGSEGV
)
616 /* Here, we are not awaiting another exec to get
617 the program we really want to debug.
618 Insert breakpoints now, unless we are trying
619 to one-proceed past a breakpoint. */
620 running_in_shell
= 0;
621 if (!breakpoints_inserted
&& !another_trap
)
623 insert_step_breakpoint ();
624 breakpoints_failed
= insert_breakpoints ();
625 if (breakpoints_failed
)
627 breakpoints_inserted
= 1;
630 trap_expected
= another_trap
;
632 if (stop_signal
== SIGTRAP
)
635 resume ((step_range_end
&& !step_resume_break_address
)
642 /* Here to return control to GDB when the inferior stops for real.
643 Print appropriate messages, remove breakpoints, give terminal our modes.
645 RUNNING_IN_SHELL nonzero means the shell got a signal before
646 exec'ing the program we wanted to run.
647 STOP_PRINT_FRAME nonzero means print the executing frame
648 (pc, function, args, file, line number and line text).
649 BREAKPOINTS_FAILED nonzero means stop was due to error
650 attempting to insert breakpoints. */
655 if (breakpoints_failed
)
657 terminal_ours_for_output ();
658 print_sys_errmsg ("ptrace", breakpoints_failed
);
659 printf ("Stopped; cannot insert breakpoints.\n\
660 The same program may be running in another process.\n");
664 remove_step_breakpoint ();
666 if (inferior_pid
&& breakpoints_inserted
)
667 if (remove_breakpoints ())
669 terminal_ours_for_output ();
670 printf ("Cannot remove breakpoints because program is no longer writable.\n\
671 It must be running in another process.\n\
672 Further execution is probably impossible.\n");
675 breakpoints_inserted
= 0;
677 /* Delete the breakpoint we stopped at, if it wants to be deleted.
678 Delete any breakpoint that is to be deleted at the next stop. */
680 breakpoint_auto_delete (stop_breakpoint
);
682 if (step_multi
&& stop_step
)
687 if (running_in_shell
)
689 if (stop_signal
== SIGSEGV
)
691 You have just encountered a bug in \"sh\". GDB starts your program\n\
692 by running \"sh\" with a command to exec your program.\n\
693 This is so that \"sh\" will process wildcards and I/O redirection.\n\
694 This time, \"sh\" crashed.\n\
696 One known bug in \"sh\" bites when the environment takes up a lot of space.\n\
697 Try \"info env\" to see the environment; then use \"unset-env\" to kill\n\
698 some variables whose values are large; then do \"run\" again.\n\
700 If that works, you might want to put those \"unset-env\" commands\n\
701 into a \".gdbinit\" file in this directory so they will happen every time.\n");
702 /* Don't confuse user with his program's symbols on sh's data. */
703 stop_print_frame
= 0;
706 if (inferior_pid
== 0)
709 /* Select innermost stack frame except on return from a stack dummy routine,
710 or if the program has exited. */
711 if (!stop_stack_dummy
)
713 select_frame (stop_frame
, 0);
715 if (stop_print_frame
)
717 if (stop_breakpoint
> 0)
718 printf ("\nBpt %d, ", stop_breakpoint
);
719 print_sel_frame (stop_step
720 && step_frame
== stop_frame
721 && step_start_function
== find_pc_function (stop_pc
));
722 /* Display the auto-display expressions. */
727 /* Save the function value return registers
728 We might be about to restore their previous contents. */
729 read_register_bytes (0, stop_registers
, REGISTER_BYTES
);
731 if (stop_stack_dummy
)
733 /* Pop the empty frame that contains the stack dummy. */
735 select_frame (read_register (FP_REGNUM
), 0);
740 insert_step_breakpoint ()
742 if (step_resume_break_address
&& !step_resume_break_duplicate
)
744 read_memory (step_resume_break_address
,
745 step_resume_break_shadow
, sizeof break_insn
);
746 write_memory (step_resume_break_address
,
747 break_insn
, sizeof break_insn
);
752 remove_step_breakpoint ()
754 if (step_resume_break_address
&& !step_resume_break_duplicate
)
755 write_memory (step_resume_break_address
, step_resume_break_shadow
,
759 /* Specify how various signals in the inferior should be handled. */
762 handle_command (args
, from_tty
)
766 register char *p
= args
;
768 register int digits
, wordlen
;
771 error_no_arg ("signal to handle");
775 /* Find the end of the next word in the args. */
776 for (wordlen
= 0; p
[wordlen
] && p
[wordlen
] != ' ' && p
[wordlen
] != '\t';
778 for (digits
= 0; p
[digits
] >= '0' && p
[digits
] <= '9'; digits
++);
780 /* If it is all digits, it is signal number to operate on. */
781 if (digits
== wordlen
)
784 if (signum
== SIGTRAP
|| signum
== SIGINT
)
786 if (!query ("Signal %d is used by the debugger.\nAre you sure you want to change it? ", signum
))
787 error ("Not confirmed.");
790 else if (signum
== 0)
791 error ("First argument is not a signal number.");
793 /* Else, if already got a signal number, look for flag words
794 saying what to do for it. */
795 else if (!strncmp (p
, "stop", wordlen
))
797 signal_stop
[signum
] = 1;
798 signal_print
[signum
] = 1;
800 else if (wordlen
>= 2 && !strncmp (p
, "print", wordlen
))
801 signal_print
[signum
] = 1;
802 else if (wordlen
>= 2 && !strncmp (p
, "pass", wordlen
))
803 signal_program
[signum
] = 1;
804 else if (!strncmp (p
, "ignore", wordlen
))
805 signal_program
[signum
] = 0;
806 else if (wordlen
>= 3 && !strncmp (p
, "nostop", wordlen
))
807 signal_stop
[signum
] = 0;
808 else if (wordlen
>= 4 && !strncmp (p
, "noprint", wordlen
))
810 signal_print
[signum
] = 0;
811 signal_stop
[signum
] = 0;
813 else if (wordlen
>= 4 && !strncmp (p
, "nopass", wordlen
))
814 signal_program
[signum
] = 0;
815 else if (wordlen
>= 3 && !strncmp (p
, "noignore", wordlen
))
816 signal_program
[signum
] = 1;
817 /* Not a number and not a recognized flag word => complain. */
821 error ("Unrecognized flag word: \"%s\".", p
);
824 /* Find start of next word. */
826 while (*p
== ' ' || *p
== '\t') p
++;
831 /* Show the results. */
832 printf ("Number\tStop\tPrint\tPass to program\tDescription\n");
833 printf ("%d\t", signum
);
834 printf ("%s\t", signal_stop
[signum
] ? "Yes" : "No");
835 printf ("%s\t", signal_print
[signum
] ? "Yes" : "No");
836 printf ("%s\t\t", signal_program
[signum
] ? "Yes" : "No");
837 printf ("%s\n", sys_siglist
[signum
]);
841 /* Print current contents of the tables set by the handle command. */
844 signals_info (signum_exp
)
848 printf ("Number\tStop\tPrint\tPass to program\tDescription\n");
852 i
= parse_and_eval_address (signum_exp
);
854 printf ("%s\t", signal_stop
[i
] ? "Yes" : "No");
855 printf ("%s\t", signal_print
[i
] ? "Yes" : "No");
856 printf ("%s\t\t", signal_program
[i
] ? "Yes" : "No");
857 printf ("%s\n", sys_siglist
[i
]);
862 for (i
= 0; i
< NSIG
; i
++)
865 if (i
> 0 && i
% 16 == 0)
867 printf ("[Type Return to see more]");
872 printf ("%s\t", signal_stop
[i
] ? "Yes" : "No");
873 printf ("%s\t", signal_print
[i
] ? "Yes" : "No");
874 printf ("%s\t\t", signal_program
[i
] ? "Yes" : "No");
875 printf ("%s\n", sys_siglist
[i
]);
878 printf ("\nUse the \"handle\" command to change these tables.\n");
886 add_info ("signals", signals_info
,
887 "What debugger does when program gets various signals.\n\
888 Specify a signal number as argument to print info on that signal only.");
890 add_com ("handle", class_run
, handle_command
,
891 "Specify how to handle a signal.\n\
892 Args are signal number followed by flags.\n\
893 Flags allowed are \"stop\", \"print\", \"pass\",\n\
894 \"nostop\", \"noprint\" or \"nopass\".\n\
895 Print means print a message if this signal happens.\n\
896 Stop means reenter debugger if this signal happens (implies print).\n\
897 Pass means let program see this signal; otherwise program doesn't know.\n\
898 Pass and Stop may be combined.");
900 for (i
= 0; i
< NSIG
; i
++)
904 signal_program
[i
] = 1;
907 /* Signals caused by debugger's own actions
908 should not be given to the program afterwards. */
909 signal_program
[SIGTRAP
] = 0;
910 signal_program
[SIGINT
] = 0;
912 /* Signals that are not errors should not normally enter the debugger. */
914 signal_stop
[SIGALRM
] = 0;
915 signal_print
[SIGALRM
] = 0;
918 signal_stop
[SIGVTALRM
] = 0;
919 signal_print
[SIGVTALRM
] = 0;
920 #endif /* SIGVTALRM */
922 signal_stop
[SIGPROF
] = 0;
923 signal_print
[SIGPROF
] = 0;
926 signal_stop
[SIGCHLD
] = 0;
927 signal_print
[SIGCHLD
] = 0;
930 signal_stop
[SIGCLD
] = 0;
931 signal_print
[SIGCLD
] = 0;
934 signal_stop
[SIGIO
] = 0;
935 signal_print
[SIGIO
] = 0;
938 signal_stop
[SIGURG
] = 0;
939 signal_print
[SIGURG
] = 0;