1 /* Start (run) and stop the inferior process, for GDB.
2 Copyright (C) 1986, 1987, 1988, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Notes on the algorithm used in wait_for_inferior to determine if we
21 just did a subroutine call when stepping. We have the following
22 information at that point:
24 Current and previous (just before this step) pc.
25 Current and previous sp.
26 Current and previous start of current function.
28 If the start's of the functions don't match, then
30 a) We did a subroutine call.
32 In this case, the pc will be at the beginning of a function.
34 b) We did a subroutine return.
40 If we did a longjump, we were doing "nexti", since a next would
41 have attempted to skip over the assembly language routine in which
42 the longjmp is coded and would have simply been the equivalent of a
43 continue. I consider this ok behaivior. We'd like one of two
44 things to happen if we are doing a nexti through the longjmp()
45 routine: 1) It behaves as a stepi, or 2) It acts like a continue as
46 above. Given that this is a special case, and that anybody who
47 thinks that the concept of sub calls is meaningful in the context
48 of a longjmp, I'll take either one. Let's see what happens.
50 Acts like a subroutine return. I can handle that with no problem
53 -->So: If the current and previous beginnings of the current
54 function don't match, *and* the pc is at the start of a function,
55 we've done a subroutine call. If the pc is not at the start of a
56 function, we *didn't* do a subroutine call.
58 -->If the beginnings of the current and previous function do match,
61 a) We just did a recursive call.
63 In this case, we would be at the very beginning of a
64 function and 1) it will have a prologue (don't jump to
65 before prologue, or 2) (we assume here that it doesn't have
66 a prologue) there will have been a change in the stack
67 pointer over the last instruction. (Ie. it's got to put
68 the saved pc somewhere. The stack is the usual place. In
69 a recursive call a register is only an option if there's a
70 prologue to do something with it. This is even true on
71 register window machines; the prologue sets up the new
72 window. It might not be true on a register window machine
73 where the call instruction moved the register window
74 itself. Hmmm. One would hope that the stack pointer would
75 also change. If it doesn't, somebody send me a note, and
76 I'll work out a more general theory.
77 bug-gdb@prep.ai.mit.edu). This is true (albeit slipperly
78 so) on all machines I'm aware of:
80 m68k: Call changes stack pointer. Regular jumps don't.
82 sparc: Recursive calls must have frames and therefor,
85 vax: All calls have frames and hence change the
88 b) We did a return from a recursive call. I don't see that we
89 have either the ability or the need to distinguish this
90 from an ordinary jump. The stack frame will be printed
91 when and if the frame pointer changes; if we are in a
92 function without a frame pointer, it's the users own
95 c) We did a jump within a function. We assume that this is
96 true if we didn't do a recursive call.
98 d) We are in no-man's land ("I see no symbols here"). We
99 don't worry about this; it will make calls look like simple
100 jumps (and the stack frames will be printed when the frame
101 pointer moves), which is a reasonably non-violent response.
104 We skip this; it causes more problems than it's worth.
105 #ifdef SUN4_COMPILER_FEATURE
106 We do a special ifdef for the sun 4, forcing it to single step
107 into calls which don't have prologues. This means that we can't
108 nexti over leaf nodes, we can probably next over them (since they
109 won't have debugging symbols, usually), and we can next out of
110 functions returning structures (with a "call .stret4" at the end).
125 #include "inferior.h"
126 #include "breakpoint.h"
131 #include "terminal.h" /* For #ifdef TIOCGPGRP and new_tty */
136 /* unistd.h is needed to #define X_OK */
140 #include <sys/file.h>
143 #ifdef SET_STACK_LIMIT_HUGE
144 #include <sys/time.h>
145 #include <sys/resource.h>
147 extern int original_stack_limit
;
148 #endif /* SET_STACK_LIMIT_HUGE */
150 extern char *getenv ();
151 extern char **environ
;
153 extern struct target_ops child_ops
; /* In inftarg.c */
156 /* Sigtramp is a routine that the kernel calls (which then calls the
157 signal handler). On most machines it is a library routine that
158 is linked into the executable.
160 This macro, given a program counter value and the name of the
161 function in which that PC resides (which can be null if the
162 name is not known), returns nonzero if the PC and name show
163 that we are in sigtramp.
165 On most machines just see if the name is sigtramp (and if we have
166 no name, assume we are not in sigtramp). */
167 #if !defined (IN_SIGTRAMP)
168 #define IN_SIGTRAMP(pc, name) \
169 (name && !strcmp ("_sigtramp", name))
174 int safe_to_init_tdesc_context
= 0;
175 extern dc_dcontext_t current_context
;
178 /* Tables of how to react to signals; the user sets them. */
180 static char signal_stop
[NSIG
];
181 static char signal_print
[NSIG
];
182 static char signal_program
[NSIG
];
184 /* Nonzero if breakpoints are now inserted in the inferior. */
185 /* Nonstatic for initialization during xxx_create_inferior. FIXME. */
187 /*static*/ int breakpoints_inserted
;
189 /* Function inferior was in as of last step command. */
191 static struct symbol
*step_start_function
;
193 /* Nonzero => address for special breakpoint for resuming stepping. */
195 static CORE_ADDR step_resume_break_address
;
197 /* Pointer to orig contents of the byte where the special breakpoint is. */
199 static char step_resume_break_shadow
[BREAKPOINT_MAX
];
201 /* Nonzero means the special breakpoint is a duplicate
202 so it has not itself been inserted. */
204 static int step_resume_break_duplicate
;
206 /* Nonzero if we are expecting a trace trap and should proceed from it. */
208 static int trap_expected
;
210 /* Nonzero if the next time we try to continue the inferior, it will
211 step one instruction and generate a spurious trace trap.
212 This is used to compensate for a bug in HP-UX. */
214 static int trap_expected_after_continue
;
216 /* Nonzero means expecting a trace trap
217 and should stop the inferior and return silently when it happens. */
221 /* Nonzero means expecting a trap and caller will handle it themselves.
222 It is used after attach, due to attaching to a process;
223 when running in the shell before the child program has been exec'd;
224 and when running some kinds of remote stuff (FIXME?). */
226 int stop_soon_quietly
;
228 /* Nonzero if pc has been changed by the debugger
229 since the inferior stopped. */
233 /* Nonzero if proceed is being used for a "finish" command or a similar
234 situation when stop_registers should be saved. */
236 int proceed_to_finish
;
238 /* Save register contents here when about to pop a stack dummy frame,
239 if-and-only-if proceed_to_finish is set.
240 Thus this contains the return value from the called function (assuming
241 values are returned in a register). */
243 char stop_registers
[REGISTER_BYTES
];
245 /* Nonzero if program stopped due to error trying to insert breakpoints. */
247 static int breakpoints_failed
;
249 /* Nonzero after stop if current stack frame should be printed. */
251 static int stop_print_frame
;
253 #ifdef NO_SINGLE_STEP
254 extern int one_stepped
; /* From machine dependent code */
255 extern void single_step (); /* Same. */
256 #endif /* NO_SINGLE_STEP */
258 static void insert_step_breakpoint ();
259 static void remove_step_breakpoint ();
260 /*static*/ void wait_for_inferior ();
261 void init_wait_for_inferior ();
265 /* Things to clean up if we QUIT out of resume (). */
268 resume_cleanups (arg
)
274 /* Resume the inferior, but allow a QUIT. This is useful if the user
275 wants to interrupt some lengthy single-stepping operation
276 (for child processes, the SIGINT goes to the inferior, and so
277 we get a SIGINT random_signal, but for remote debugging and perhaps
278 other targets, that's not true).
280 STEP nonzero if we should step (zero to continue instead).
281 SIG is the signal to give the inferior (zero for none). */
287 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
290 #ifdef NO_SINGLE_STEP
292 single_step(); /* Do it the hard way, w/temp breakpoints */
293 step
= 0; /* ...and don't ask hardware to do it. */
297 /* Handle any optimized stores to the inferior NOW... */
298 #ifdef DO_DEFERRED_STORES
302 target_resume (step
, sig
);
303 discard_cleanups (old_cleanups
);
307 /* Clear out all variables saying what to do when inferior is continued.
308 First do this, then set the ones you want, then call `proceed'. */
311 clear_proceed_status ()
314 step_range_start
= 0;
316 step_frame_address
= 0;
317 step_over_calls
= -1;
318 step_resume_break_address
= 0;
320 stop_soon_quietly
= 0;
321 proceed_to_finish
= 0;
322 breakpoint_proceeded
= 1; /* We're about to proceed... */
324 /* Discard any remaining commands or status from previous stop. */
325 bpstat_clear (&stop_bpstat
);
328 /* Basic routine for continuing the program in various fashions.
330 ADDR is the address to resume at, or -1 for resume where stopped.
331 SIGGNAL is the signal to give it, or 0 for none,
332 or -1 for act according to how it stopped.
333 STEP is nonzero if should trap after one instruction.
334 -1 means return after that and print nothing.
335 You should probably set various step_... variables
336 before calling here, if you are stepping.
338 You should call clear_proceed_status before calling proceed. */
341 proceed (addr
, siggnal
, step
)
349 step_start_function
= find_pc_function (read_pc ());
353 if (addr
== (CORE_ADDR
)-1)
355 /* If there is a breakpoint at the address we will resume at,
356 step one instruction before inserting breakpoints
357 so that we do not stop right away. */
359 if (!pc_changed
&& breakpoint_here_p (read_pc ()))
364 write_register (PC_REGNUM
, addr
);
366 write_register (NPC_REGNUM
, addr
+ 4);
368 write_register (NNPC_REGNUM
, addr
+ 8);
373 if (trap_expected_after_continue
)
375 /* If (step == 0), a trap will be automatically generated after
376 the first instruction is executed. Force step one
377 instruction to clear this condition. This should not occur
378 if step is nonzero, but it is harmless in that case. */
380 trap_expected_after_continue
= 0;
384 /* We will get a trace trap after one instruction.
385 Continue it automatically and insert breakpoints then. */
389 int temp
= insert_breakpoints ();
392 print_sys_errmsg ("ptrace", temp
);
393 error ("Cannot insert breakpoints.\n\
394 The same program may be running in another process.");
396 breakpoints_inserted
= 1;
399 /* Install inferior's terminal modes. */
400 target_terminal_inferior ();
403 stop_signal
= siggnal
;
404 /* If this signal should not be seen by program,
405 give it zero. Used for debugging signals. */
406 else if (stop_signal
< NSIG
&& !signal_program
[stop_signal
])
409 /* Resume inferior. */
410 resume (oneproc
|| step
|| bpstat_should_step (), stop_signal
);
412 /* Wait for it to stop (if not standalone)
413 and in any case decode why it stopped, and act accordingly. */
415 wait_for_inferior ();
420 /* This might be useful (not sure), but isn't currently used. See also
422 /* Writing the inferior pc as a register calls this function
423 to inform infrun that the pc has been set in the debugger. */
434 /* Record the pc and sp of the program the last time it stopped.
435 These are just used internally by wait_for_inferior, but need
436 to be preserved over calls to it and cleared when the inferior
438 static CORE_ADDR prev_pc
;
439 static CORE_ADDR prev_sp
;
440 static CORE_ADDR prev_func_start
;
441 static char *prev_func_name
;
444 /* Start an inferior Unix child process and sets inferior_pid to its pid.
445 EXEC_FILE is the file to run.
446 ALLARGS is a string containing the arguments to the program.
447 ENV is the environment vector to pass. Errors reported with error(). */
450 #define SHELL_FILE "/bin/sh"
454 child_create_inferior (exec_file
, allargs
, env
)
462 extern char *sys_errlist
[];
464 static char default_shell_file
[] = SHELL_FILE
;
467 /* Set debug_fork then attach to the child while it sleeps, to debug. */
468 static int debug_fork
= 0;
469 /* This is set to the result of setpgrp, which if vforked, will be visible
470 to you in the parent process. It's only used by humans for debugging. */
471 static int debug_setpgrp
= 657473;
474 /* The user might want tilde-expansion, and in general probably wants
475 the program to behave the same way as if run from
476 his/her favorite shell. So we let the shell run it for us.
477 FIXME, this should probably search the local environment (as
478 modified by the setenv command), not the env gdb inherited. */
479 shell_file
= getenv ("SHELL");
480 if (shell_file
== NULL
)
481 shell_file
= default_shell_file
;
483 len
= 5 + strlen (exec_file
) + 1 + strlen (allargs
) + 1 + /*slop*/ 10;
484 /* If desired, concat something onto the front of ALLARGS.
485 SHELL_COMMAND is the result. */
486 #ifdef SHELL_COMMAND_CONCAT
487 shell_command
= (char *) alloca (strlen (SHELL_COMMAND_CONCAT
) + len
);
488 strcpy (shell_command
, SHELL_COMMAND_CONCAT
);
490 shell_command
= (char *) alloca (len
);
491 shell_command
[0] = '\0';
493 strcat (shell_command
, "exec ");
494 strcat (shell_command
, exec_file
);
495 strcat (shell_command
, " ");
496 strcat (shell_command
, allargs
);
498 /* exec is said to fail if the executable is open. */
501 /* Retain a copy of our environment variables, since the child will
502 replace the value of environ and if we're vforked, we have to
504 save_our_env
= environ
;
506 /* Tell the terminal handling subsystem what tty we plan to run on;
507 it will just record the information for later. */
509 new_tty_prefork (inferior_io_terminal
);
511 /* It is generally good practice to flush any possible pending stdio
512 output prior to doing a fork, to avoid the possibility of both the
513 parent and child flushing the same data after the fork. */
518 #if defined(USG) && !defined(HAVE_VFORK)
528 perror_with_name ("vfork");
536 /* Run inferior in a separate process group. */
537 debug_setpgrp
= setpgrp (getpid (), getpid ());
538 if (debug_setpgrp
== -1)
539 perror("setpgrp failed in child");
540 #endif /* TIOCGPGRP */
542 #ifdef SET_STACK_LIMIT_HUGE
543 /* Reset the stack limit back to what it was. */
547 getrlimit (RLIMIT_STACK
, &rlim
);
548 rlim
.rlim_cur
= original_stack_limit
;
549 setrlimit (RLIMIT_STACK
, &rlim
);
551 #endif /* SET_STACK_LIMIT_HUGE */
553 /* Ask the tty subsystem to switch to the one we specified earlier
554 (or to share the current terminal, if none was specified). */
558 /* Changing the signal handlers for the inferior after
559 a vfork can also change them for the superior, so we don't mess
560 with signals here. See comments in
561 initialize_signals for how we get the right signal handlers
564 call_ptrace (0, 0, 0, 0); /* "Trace me, Dr. Memory!" */
566 /* There is no execlpe call, so we have to set the environment
567 for our child in the global variable. If we've vforked, this
568 clobbers the parent, but environ is restored a few lines down
569 in the parent. By the way, yes we do need to look down the
570 path to find $SHELL. Rich Pixley says so, and I agree. */
572 execlp (shell_file
, shell_file
, "-c", shell_command
, (char *)0);
574 fprintf (stderr
, "Cannot exec %s: %s.\n", shell_file
,
575 errno
< sys_nerr
? sys_errlist
[errno
] : "unknown error");
580 /* Restore our environment in case a vforked child clob'd it. */
581 environ
= save_our_env
;
583 /* Now that we have a child process, make it our target. */
584 push_target (&child_ops
);
586 #ifdef CREATE_INFERIOR_HOOK
587 CREATE_INFERIOR_HOOK (pid
);
590 /* The process was started by the fork that created it,
591 but it will have stopped one instruction after execing the shell.
592 Here we must get it up to actual execution of the real program. */
594 inferior_pid
= pid
; /* Needed for wait_for_inferior stuff below */
596 clear_proceed_status ();
598 #if defined (START_INFERIOR_HOOK)
599 START_INFERIOR_HOOK ();
602 /* We will get a trace trap after one instruction.
603 Continue it automatically. Eventually (after shell does an exec)
604 it will get another trace trap. Then insert breakpoints and continue. */
606 #ifdef START_INFERIOR_TRAPS_EXPECTED
607 pending_execs
= START_INFERIOR_TRAPS_EXPECTED
;
612 init_wait_for_inferior ();
614 /* Set up the "saved terminal modes" of the inferior
615 based on what modes we are starting it with. */
616 target_terminal_init ();
618 /* Install inferior's terminal modes. */
619 target_terminal_inferior ();
623 stop_soon_quietly
= 1; /* Make wait_for_inferior be quiet */
624 wait_for_inferior ();
625 if (stop_signal
!= SIGTRAP
)
627 /* Let shell child handle its own signals in its own way */
628 /* FIXME, what if child has exit()ed? Must exit loop somehow */
629 resume (0, stop_signal
);
633 /* We handle SIGTRAP, however; it means child did an exec. */
634 if (0 == --pending_execs
)
636 resume (0, 0); /* Just make it go on */
639 stop_soon_quietly
= 0;
641 /* We are now in the child process of interest, having exec'd the
642 correct program, and are poised at the first instruction of the
644 #ifdef SOLIB_CREATE_INFERIOR_HOOK
645 SOLIB_CREATE_INFERIOR_HOOK ();
648 /* Should this perhaps just be a "proceed" call? FIXME */
649 insert_step_breakpoint ();
650 breakpoints_failed
= insert_breakpoints ();
651 if (!breakpoints_failed
)
653 breakpoints_inserted
= 1;
654 target_terminal_inferior();
655 /* Start the child program going on its first instruction, single-
656 stepping if we need to. */
657 resume (bpstat_should_step (), 0);
658 wait_for_inferior ();
663 /* Start remote-debugging of a machine over a serial link. */
668 init_wait_for_inferior ();
669 clear_proceed_status ();
670 stop_soon_quietly
= 1;
672 wait_for_inferior ();
676 /* Initialize static vars when a new inferior begins. */
679 init_wait_for_inferior ()
681 /* These are meaningless until the first time through wait_for_inferior. */
685 prev_func_name
= NULL
;
687 trap_expected_after_continue
= 0;
688 breakpoints_inserted
= 0;
689 mark_breakpoints_out ();
690 stop_signal
= 0; /* Don't confuse first call to proceed(). */
694 /* Attach to process PID, then initialize for debugging it
695 and wait for the trace-trap that results from attaching. */
698 child_attach (args
, from_tty
)
708 error_no_arg ("process-id to attach");
710 #ifndef ATTACH_DETACH
711 error ("Can't attach to a process on this machine.");
715 if (target_has_execution
)
717 if (query ("A program is being debugged already. Kill it? "))
718 target_kill ((char *)0, from_tty
);
720 error ("Inferior not killed.");
723 exec_file
= (char *) get_exec_file (1);
727 printf ("Attaching program: %s pid %d\n",
734 push_target (&child_ops
);
736 mark_breakpoints_out ();
737 target_terminal_init ();
738 clear_proceed_status ();
739 stop_soon_quietly
= 1;
740 /*proceed (-1, 0, -2);*/
741 target_terminal_inferior ();
742 wait_for_inferior ();
744 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
747 #endif /* ATTACH_DETACH */
750 /* Wait for control to return from inferior to debugger.
751 If inferior gets a signal, we may decide to start it up again
752 instead of returning. That is why there is a loop in this function.
753 When this function actually returns it means the inferior
754 should be left stopped and GDB should read more commands. */
763 CORE_ADDR stop_func_start
;
764 char *stop_func_name
;
765 CORE_ADDR prologue_pc
;
766 int stop_step_resume_break
;
767 struct symtab_and_line sal
;
768 int remove_breakpoints_on_following_step
= 0;
770 extern dc_handle_t tdesc_handle
;
775 /* This no longer works now that read_register is lazy;
776 it might try to ptrace when the process is not stopped. */
777 prev_pc
= read_pc ();
778 (void) find_pc_partial_function (prev_pc
, &prev_func_name
,
780 prev_func_start
+= FUNCTION_START_OFFSET
;
781 prev_sp
= read_register (SP_REGNUM
);
784 sal
= find_pc_line(prev_pc
, 0);
785 current_line
= sal
.line
;
789 /* Clean up saved state that will become invalid. */
791 flush_cached_frames ();
792 registers_changed ();
796 /* See if the process still exists; clean up if it doesn't. */
799 target_terminal_ours (); /* Must do this before mourn anyway */
801 safe_to_init_tdesc_context
= 0;
804 printf ("\nProgram exited with code 0%o.\n",
805 (unsigned int)WEXITSTATUS (w
));
808 printf ("\nProgram exited normally.\n");
810 target_mourn_inferior ();
811 #ifdef NO_SINGLE_STEP
814 stop_print_frame
= 0;
817 else if (!WIFSTOPPED (w
))
819 stop_print_frame
= 0;
820 stop_signal
= WTERMSIG (w
);
821 target_terminal_ours (); /* Must do this before mourn anyway */
822 target_kill ((char *)0, 0); /* kill mourns as well */
824 safe_to_init_tdesc_context
= 0;
826 #ifdef PRINT_RANDOM_SIGNAL
827 printf ("\nProgram terminated: ");
828 PRINT_RANDOM_SIGNAL (stop_signal
);
830 printf ("\nProgram terminated with signal %d, %s\n",
833 ? sys_siglist
[stop_signal
]
836 printf ("The inferior process no longer exists.\n");
838 #ifdef NO_SINGLE_STEP
844 #ifdef NO_SINGLE_STEP
846 single_step (0); /* This actually cleans up the ss */
847 #endif /* NO_SINGLE_STEP */
849 stop_pc
= read_pc ();
851 if (safe_to_init_tdesc_context
)
853 current_context
= init_dcontext();
854 set_current_frame ( create_new_frame (get_frame_base (read_pc()),read_pc()));
858 set_current_frame ( create_new_frame (read_register (FP_REGNUM
),
861 stop_frame_address
= FRAME_FP (get_current_frame ());
862 stop_sp
= read_register (SP_REGNUM
);
865 /* Don't care about return value; stop_func_start and stop_func_name
866 will both be 0 if it doesn't work. */
867 (void) find_pc_partial_function (stop_pc
, &stop_func_name
,
869 stop_func_start
+= FUNCTION_START_OFFSET
;
871 bpstat_clear (&stop_bpstat
);
873 stop_stack_dummy
= 0;
874 stop_print_frame
= 1;
875 stop_step_resume_break
= 0;
877 stopped_by_random_signal
= 0;
878 breakpoints_failed
= 0;
880 /* Look at the cause of the stop, and decide what to do.
881 The alternatives are:
882 1) break; to really stop and return to the debugger,
883 2) drop through to start up again
884 (set another_trap to 1 to single step once)
885 3) set random_signal to 1, and the decision between 1 and 2
886 will be made according to the signal handling tables. */
888 stop_signal
= WSTOPSIG (w
);
890 /* First, distinguish signals caused by the debugger from signals
891 that have to do with the program's own actions.
892 Note that breakpoint insns may cause SIGTRAP or SIGILL
893 or SIGEMT, depending on the operating system version.
894 Here we detect when a SIGILL or SIGEMT is really a breakpoint
895 and change it to SIGTRAP. */
897 if (stop_signal
== SIGTRAP
898 || (breakpoints_inserted
&&
899 (stop_signal
== SIGILL
900 || stop_signal
== SIGEMT
))
901 || stop_soon_quietly
)
903 if (stop_signal
== SIGTRAP
&& stop_after_trap
)
905 stop_print_frame
= 0;
908 if (stop_soon_quietly
)
911 /* Don't even think about breakpoints
912 if just proceeded over a breakpoint.
914 However, if we are trying to proceed over a breakpoint
915 and end up in sigtramp, then step_resume_break_address
916 will be set and we should check whether we've hit the
918 if (stop_signal
== SIGTRAP
&& trap_expected
919 && step_resume_break_address
== NULL
)
920 bpstat_clear (&stop_bpstat
);
923 /* See if there is a breakpoint at the current PC. */
924 #if DECR_PC_AFTER_BREAK
925 /* Notice the case of stepping through a jump
926 that leads just after a breakpoint.
927 Don't confuse that with hitting the breakpoint.
928 What we check for is that 1) stepping is going on
929 and 2) the pc before the last insn does not match
930 the address of the breakpoint before the current pc. */
931 if (!(prev_pc
!= stop_pc
- DECR_PC_AFTER_BREAK
932 && step_range_end
&& !step_resume_break_address
))
933 #endif /* DECR_PC_AFTER_BREAK not zero */
935 /* See if we stopped at the special breakpoint for
936 stepping over a subroutine call. If both are zero,
937 this wasn't the reason for the stop. */
938 if (stop_pc
- DECR_PC_AFTER_BREAK
939 == step_resume_break_address
940 && step_resume_break_address
)
942 stop_step_resume_break
= 1;
943 if (DECR_PC_AFTER_BREAK
)
945 stop_pc
-= DECR_PC_AFTER_BREAK
;
946 write_register (PC_REGNUM
, stop_pc
);
953 bpstat_stop_status (&stop_pc
, stop_frame_address
);
954 /* Following in case break condition called a
956 stop_print_frame
= 1;
961 if (stop_signal
== SIGTRAP
)
963 = !(bpstat_explains_signal (stop_bpstat
)
965 || stop_step_resume_break
966 || PC_IN_CALL_DUMMY (stop_pc
, stop_sp
, stop_frame_address
)
967 || (step_range_end
&& !step_resume_break_address
));
971 = !(bpstat_explains_signal (stop_bpstat
)
972 || stop_step_resume_break
973 /* End of a stack dummy. Some systems (e.g. Sony
974 news) give another signal besides SIGTRAP,
975 so check here as well as above. */
976 || (stop_sp INNER_THAN stop_pc
977 && stop_pc INNER_THAN stop_frame_address
)
980 stop_signal
= SIGTRAP
;
986 /* For the program's own signals, act according to
987 the signal handling tables. */
991 /* Signal not for debugging purposes. */
994 stopped_by_random_signal
= 1;
996 if (stop_signal
>= NSIG
997 || signal_print
[stop_signal
])
1000 target_terminal_ours_for_output ();
1001 #ifdef PRINT_RANDOM_SIGNAL
1002 PRINT_RANDOM_SIGNAL (stop_signal
);
1004 printf ("\nProgram received signal %d, %s\n",
1007 ? sys_siglist
[stop_signal
]
1008 : "(undocumented)");
1009 #endif /* PRINT_RANDOM_SIGNAL */
1012 if (stop_signal
>= NSIG
1013 || signal_stop
[stop_signal
])
1015 /* If not going to stop, give terminal back
1016 if we took it away. */
1018 target_terminal_inferior ();
1020 /* Note that virtually all the code below does `if !random_signal'.
1021 Perhaps this code should end with a goto or continue. At least
1022 one (now fixed) bug was caused by this -- a !random_signal was
1023 missing in one of the tests below. */
1026 /* Handle cases caused by hitting a breakpoint. */
1029 && (bpstat_explains_signal (stop_bpstat
) || stop_step_resume_break
))
1031 /* Does a breakpoint want us to stop? */
1032 if (bpstat_stop (stop_bpstat
))
1034 stop_print_frame
= bpstat_should_print (stop_bpstat
);
1037 /* But if we have hit the step-resumption breakpoint,
1038 remove it. It has done its job getting us here.
1039 The sp test is to make sure that we don't get hung
1040 up in recursive calls in functions without frame
1041 pointers. If the stack pointer isn't outside of
1042 where the breakpoint was set (within a routine to be
1043 stepped over), we're in the middle of a recursive
1044 call. Not true for reg window machines (sparc)
1045 because the must change frames to call things and
1046 the stack pointer doesn't have to change if it
1047 the bp was set in a routine without a frame (pc can
1048 be stored in some other window).
1050 The removal of the sp test is to allow calls to
1051 alloca. Nasty things were happening. Oh, well,
1052 gdb can only handle one level deep of lack of
1054 if (stop_step_resume_break
1055 && (step_frame_address
== 0
1056 || (stop_frame_address
== step_frame_address
)))
1058 remove_step_breakpoint ();
1059 step_resume_break_address
= 0;
1061 /* If were waiting for a trap, hitting the step_resume_break
1062 doesn't count as getting it. */
1066 /* Otherwise, must remove breakpoints and single-step
1067 to get us past the one we hit. */
1070 remove_breakpoints ();
1071 remove_step_breakpoint ();
1072 breakpoints_inserted
= 0;
1076 /* We come here if we hit a breakpoint but should not
1077 stop for it. Possibly we also were stepping
1078 and should stop for that. So fall through and
1079 test for stepping. But, if not stepping,
1083 /* If this is the breakpoint at the end of a stack dummy,
1084 just stop silently. */
1086 && PC_IN_CALL_DUMMY (stop_pc
, stop_sp
, stop_frame_address
))
1088 stop_print_frame
= 0;
1089 stop_stack_dummy
= 1;
1091 trap_expected_after_continue
= 1;
1096 if (step_resume_break_address
)
1097 /* Having a step-resume breakpoint overrides anything
1098 else having to do with stepping commands until
1099 that breakpoint is reached. */
1101 /* If stepping through a line, keep going if still within it. */
1102 else if (!random_signal
1104 && stop_pc
>= step_range_start
1105 && stop_pc
< step_range_end
1106 /* The step range might include the start of the
1107 function, so if we are at the start of the
1108 step range and either the stack or frame pointers
1109 just changed, we've stepped outside */
1110 && !(stop_pc
== step_range_start
1111 && stop_frame_address
1112 && (stop_sp INNER_THAN prev_sp
1113 || stop_frame_address
!= step_frame_address
)))
1116 /* When "next"ing through a function,
1117 This causes an extra stop at the end.
1118 Is there any reason for this?
1119 It's confusing to the user. */
1120 /* Don't step through the return from a function
1121 unless that is the first instruction stepped through. */
1122 if (ABOUT_TO_RETURN (stop_pc
))
1130 /* We stepped out of the stepping range. See if that was due
1131 to a subroutine call that we should proceed to the end of. */
1132 else if (!random_signal
&& step_range_end
)
1134 if (stop_func_start
)
1136 prologue_pc
= stop_func_start
;
1137 SKIP_PROLOGUE (prologue_pc
);
1140 /* Did we just take a signal? */
1141 if (IN_SIGTRAMP (stop_pc
, stop_func_name
)
1142 && !IN_SIGTRAMP (prev_pc
, prev_func_name
))
1144 /* This code is needed at least in the following case:
1145 The user types "next" and then a signal arrives (before
1146 the "next" is done). */
1147 /* We've just taken a signal; go until we are back to
1148 the point where we took it and one more. */
1149 step_resume_break_address
= prev_pc
;
1150 step_resume_break_duplicate
=
1151 breakpoint_here_p (step_resume_break_address
);
1152 if (breakpoints_inserted
)
1153 insert_step_breakpoint ();
1154 /* Make sure that the stepping range gets us past
1155 that instruction. */
1156 if (step_range_end
== 1)
1157 step_range_end
= (step_range_start
= prev_pc
) + 1;
1158 remove_breakpoints_on_following_step
= 1;
1161 /* ==> See comments at top of file on this algorithm. <==*/
1163 else if (stop_pc
== stop_func_start
1164 && (stop_func_start
!= prev_func_start
1165 || prologue_pc
!= stop_func_start
1166 || stop_sp
!= prev_sp
))
1168 /* It's a subroutine call */
1169 if (step_over_calls
> 0
1170 || (step_over_calls
&& find_pc_function (stop_pc
) == 0))
1172 /* A subroutine call has happened. */
1173 /* Set a special breakpoint after the return */
1174 step_resume_break_address
=
1176 (SAVED_PC_AFTER_CALL (get_current_frame ()));
1177 step_resume_break_duplicate
1178 = breakpoint_here_p (step_resume_break_address
);
1179 if (breakpoints_inserted
)
1180 insert_step_breakpoint ();
1182 /* Subroutine call with source code we should not step over.
1183 Do step to the first line of code in it. */
1184 else if (step_over_calls
)
1186 SKIP_PROLOGUE (stop_func_start
);
1187 sal
= find_pc_line (stop_func_start
, 0);
1188 /* Use the step_resume_break to step until
1189 the end of the prologue, even if that involves jumps
1190 (as it seems to on the vax under 4.2). */
1191 /* If the prologue ends in the middle of a source line,
1192 continue to the end of that source line.
1193 Otherwise, just go to end of prologue. */
1194 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1195 /* no, don't either. It skips any code that's
1196 legitimately on the first line. */
1198 if (sal
.end
&& sal
.pc
!= stop_func_start
)
1199 stop_func_start
= sal
.end
;
1202 if (stop_func_start
== stop_pc
)
1204 /* We are already there: stop now. */
1209 /* Put the step-breakpoint there and go until there. */
1211 step_resume_break_address
= stop_func_start
;
1213 step_resume_break_duplicate
1214 = breakpoint_here_p (step_resume_break_address
);
1215 if (breakpoints_inserted
)
1216 insert_step_breakpoint ();
1217 /* Do not specify what the fp should be when we stop
1218 since on some machines the prologue
1219 is where the new fp value is established. */
1220 step_frame_address
= 0;
1221 /* And make sure stepping stops right away then. */
1222 step_range_end
= step_range_start
;
1227 /* We get here only if step_over_calls is 0 and we
1228 just stepped into a subroutine. I presume
1229 that step_over_calls is only 0 when we're
1230 supposed to be stepping at the assembly
1236 /* No subroutine call; stop now. */
1239 if (step_range_end
== 1) break; /* Don't do this for stepi/nexti */
1241 /* We've wandered out of the step range (but we haven't done a
1242 subroutine call or return (that's handled elsewhere)). We
1243 don't really want to stop until we encounter the start of a
1244 new statement. If so, we stop. Otherwise, we reset
1245 step_range_start and step_range_end, and just continue. */
1246 sal
= find_pc_line(stop_pc
, 0);
1248 if (sal
.line
== 0 || /* Stop now if no line # info */
1249 (current_line
!= sal
.line
1250 && stop_pc
== sal
.pc
)) {
1254 /* This is probably not necessary, but it probably makes
1255 stepping more efficient, as we avoid calling find_pc_line()
1256 for each instruction we step over. */
1257 step_range_start
= sal
.pc
;
1258 step_range_end
= sal
.end
;
1263 else if (trap_expected
1264 && IN_SIGTRAMP (stop_pc
, stop_func_name
)
1265 && !IN_SIGTRAMP (prev_pc
, prev_func_name
))
1267 /* What has happened here is that we have just stepped the inferior
1268 with a signal (because it is a signal which shouldn't make
1269 us stop), thus stepping into sigtramp.
1271 So we need to set a step_resume_break_address breakpoint
1272 and continue until we hit it, and then step. */
1273 step_resume_break_address
= prev_pc
;
1274 /* Always 1, I think, but it's probably easier to have
1275 the step_resume_break as usual rather than trying to
1276 re-use the breakpoint which is already there. */
1277 step_resume_break_duplicate
=
1278 breakpoint_here_p (step_resume_break_address
);
1279 if (breakpoints_inserted
)
1280 insert_step_breakpoint ();
1281 remove_breakpoints_on_following_step
= 1;
1285 /* Save the pc before execution, to compare with pc after stop. */
1286 prev_pc
= read_pc (); /* Might have been DECR_AFTER_BREAK */
1287 prev_func_start
= stop_func_start
; /* Ok, since if DECR_PC_AFTER
1288 BREAK is defined, the
1289 original pc would not have
1290 been at the start of a
1292 prev_func_name
= stop_func_name
;
1295 /* If we did not do break;, it means we should keep
1296 running the inferior and not return to debugger. */
1298 if (trap_expected
&& stop_signal
!= SIGTRAP
)
1300 /* We took a signal (which we are supposed to pass through to
1301 the inferior, else we'd have done a break above) and we
1302 haven't yet gotten our trap. Simply continue. */
1303 resume ((step_range_end
&& !step_resume_break_address
)
1304 || (trap_expected
&& !step_resume_break_address
)
1305 || bpstat_should_step (),
1310 /* Either the trap was not expected, but we are continuing
1311 anyway (the user asked that this signal be passed to the
1314 The signal was SIGTRAP, e.g. it was our signal, but we
1315 decided we should resume from it.
1317 We're going to run this baby now!
1319 Insert breakpoints now, unless we are trying
1320 to one-proceed past a breakpoint. */
1321 /* If we've just finished a special step resume and we don't
1322 want to hit a breakpoint, pull em out. */
1327 safe_to_init_tdesc_context
= 1;
1331 if (!step_resume_break_address
&&
1332 remove_breakpoints_on_following_step
)
1334 remove_breakpoints_on_following_step
= 0;
1335 remove_breakpoints ();
1336 breakpoints_inserted
= 0;
1338 else if (!breakpoints_inserted
&&
1339 (step_resume_break_address
!= NULL
|| !another_trap
))
1341 insert_step_breakpoint ();
1342 breakpoints_failed
= insert_breakpoints ();
1343 if (breakpoints_failed
)
1345 breakpoints_inserted
= 1;
1348 trap_expected
= another_trap
;
1350 if (stop_signal
== SIGTRAP
)
1353 #ifdef SHIFT_INST_REGS
1354 /* I'm not sure when this following segment applies. I do know, now,
1355 that we shouldn't rewrite the regs when we were stopped by a
1356 random signal from the inferior process. */
1358 if (!bpstat_explains_signal (stop_bpstat
)
1359 && (stop_signal
!= SIGCLD
)
1360 && !stopped_by_random_signal
)
1362 CORE_ADDR pc_contents
= read_register (PC_REGNUM
);
1363 CORE_ADDR npc_contents
= read_register (NPC_REGNUM
);
1364 if (pc_contents
!= npc_contents
)
1366 write_register (NNPC_REGNUM
, npc_contents
);
1367 write_register (NPC_REGNUM
, pc_contents
);
1370 #endif /* SHIFT_INST_REGS */
1372 resume ((step_range_end
&& !step_resume_break_address
)
1373 || (trap_expected
&& !step_resume_break_address
)
1374 || bpstat_should_step (),
1378 if (target_has_execution
)
1380 /* Assuming the inferior still exists, set these up for next
1381 time, just like we did above if we didn't break out of the
1383 prev_pc
= read_pc ();
1384 prev_func_start
= stop_func_start
;
1385 prev_func_name
= stop_func_name
;
1390 /* Here to return control to GDB when the inferior stops for real.
1391 Print appropriate messages, remove breakpoints, give terminal our modes.
1393 STOP_PRINT_FRAME nonzero means print the executing frame
1394 (pc, function, args, file, line number and line text).
1395 BREAKPOINTS_FAILED nonzero means stop was due to error
1396 attempting to insert breakpoints. */
1401 /* Make sure that the current_frame's pc is correct. This
1402 is a correction for setting up the frame info before doing
1403 DECR_PC_AFTER_BREAK */
1404 if (target_has_execution
)
1405 (get_current_frame ())->pc
= read_pc ();
1407 if (breakpoints_failed
)
1409 target_terminal_ours_for_output ();
1410 print_sys_errmsg ("ptrace", breakpoints_failed
);
1411 printf ("Stopped; cannot insert breakpoints.\n\
1412 The same program may be running in another process.\n");
1415 if (target_has_execution
)
1416 remove_step_breakpoint ();
1418 if (target_has_execution
&& breakpoints_inserted
)
1419 if (remove_breakpoints ())
1421 target_terminal_ours_for_output ();
1422 printf ("Cannot remove breakpoints because program is no longer writable.\n\
1423 It might be running in another process.\n\
1424 Further execution is probably impossible.\n");
1427 breakpoints_inserted
= 0;
1429 /* Delete the breakpoint we stopped at, if it wants to be deleted.
1430 Delete any breakpoint that is to be deleted at the next stop. */
1432 breakpoint_auto_delete (stop_bpstat
);
1434 /* If an auto-display called a function and that got a signal,
1435 delete that auto-display to avoid an infinite recursion. */
1437 if (stopped_by_random_signal
)
1438 disable_current_display ();
1440 if (step_multi
&& stop_step
)
1443 target_terminal_ours ();
1445 if (!target_has_stack
)
1448 /* Select innermost stack frame except on return from a stack dummy routine,
1449 or if the program has exited. Print it without a level number if
1450 we have changed functions or hit a breakpoint. Print source line
1452 if (!stop_stack_dummy
)
1454 select_frame (get_current_frame (), 0);
1456 if (stop_print_frame
)
1460 source_only
= bpstat_print (stop_bpstat
);
1461 source_only
= source_only
||
1463 && step_frame_address
== stop_frame_address
1464 && step_start_function
== find_pc_function (stop_pc
));
1466 print_stack_frame (selected_frame
, -1, source_only
? -1: 1);
1468 /* Display the auto-display expressions. */
1473 /* Save the function value return registers, if we care.
1474 We might be about to restore their previous contents. */
1475 if (proceed_to_finish
)
1476 read_register_bytes (0, stop_registers
, REGISTER_BYTES
);
1478 if (stop_stack_dummy
)
1480 /* Pop the empty frame that contains the stack dummy.
1481 POP_FRAME ends with a setting of the current frame, so we
1482 can use that next. */
1484 select_frame (get_current_frame (), 0);
1489 insert_step_breakpoint ()
1491 if (step_resume_break_address
&& !step_resume_break_duplicate
)
1492 target_insert_breakpoint (step_resume_break_address
,
1493 step_resume_break_shadow
);
1497 remove_step_breakpoint ()
1499 if (step_resume_break_address
&& !step_resume_break_duplicate
)
1500 target_remove_breakpoint (step_resume_break_address
,
1501 step_resume_break_shadow
);
1507 printf_filtered ("Signal\t\tStop\tPrint\tPass to program\tDescription\n");
1511 sig_print_info (number
)
1514 char *abbrev
= sig_abbrev(number
);
1516 printf_filtered ("%d\t\t", number
);
1518 printf_filtered ("SIG%s (%d)\t", abbrev
, number
);
1519 printf_filtered ("%s\t", signal_stop
[number
] ? "Yes" : "No");
1520 printf_filtered ("%s\t", signal_print
[number
] ? "Yes" : "No");
1521 printf_filtered ("%s\t\t", signal_program
[number
] ? "Yes" : "No");
1522 printf_filtered ("%s\n", sys_siglist
[number
]);
1525 /* Specify how various signals in the inferior should be handled. */
1528 handle_command (args
, from_tty
)
1532 register char *p
= args
;
1534 register int digits
, wordlen
;
1538 error_no_arg ("signal to handle");
1542 /* Find the end of the next word in the args. */
1544 p
[wordlen
] && p
[wordlen
] != ' ' && p
[wordlen
] != '\t';
1546 /* Set nextarg to the start of the word after the one we just
1547 found, and null-terminate this one. */
1548 if (p
[wordlen
] == '\0')
1549 nextarg
= p
+ wordlen
;
1553 nextarg
= p
+ wordlen
+ 1;
1557 for (digits
= 0; p
[digits
] >= '0' && p
[digits
] <= '9'; digits
++);
1561 /* It is the first argument--must be the signal to operate on. */
1562 if (digits
== wordlen
)
1566 if (signum
<= 0 || signum
>= NSIG
)
1569 error ("Invalid signal %s given as argument to \"handle\".", p
);
1575 signum
= sig_number (p
);
1577 error ("No such signal \"%s\"", p
);
1580 if (signum
== SIGTRAP
|| signum
== SIGINT
)
1582 if (!query ("SIG%s is used by the debugger.\nAre you sure you want to change it? ", sig_abbrev (signum
)))
1583 error ("Not confirmed.");
1586 /* Else, if already got a signal number, look for flag words
1587 saying what to do for it. */
1588 else if (!strncmp (p
, "stop", wordlen
))
1590 signal_stop
[signum
] = 1;
1591 signal_print
[signum
] = 1;
1593 else if (wordlen
>= 2 && !strncmp (p
, "print", wordlen
))
1594 signal_print
[signum
] = 1;
1595 else if (wordlen
>= 2 && !strncmp (p
, "pass", wordlen
))
1596 signal_program
[signum
] = 1;
1597 else if (!strncmp (p
, "ignore", wordlen
))
1598 signal_program
[signum
] = 0;
1599 else if (wordlen
>= 3 && !strncmp (p
, "nostop", wordlen
))
1600 signal_stop
[signum
] = 0;
1601 else if (wordlen
>= 4 && !strncmp (p
, "noprint", wordlen
))
1603 signal_print
[signum
] = 0;
1604 signal_stop
[signum
] = 0;
1606 else if (wordlen
>= 4 && !strncmp (p
, "nopass", wordlen
))
1607 signal_program
[signum
] = 0;
1608 else if (wordlen
>= 3 && !strncmp (p
, "noignore", wordlen
))
1609 signal_program
[signum
] = 1;
1610 /* Not a number and not a recognized flag word => complain. */
1613 error ("Unrecognized flag word: \"%s\".", p
);
1616 /* Find start of next word. */
1618 while (*p
== ' ' || *p
== '\t') p
++;
1623 /* Show the results. */
1624 sig_print_header ();
1625 sig_print_info (signum
);
1629 /* Print current contents of the tables set by the handle command. */
1632 signals_info (signum_exp
)
1636 sig_print_header ();
1640 /* First see if this is a symbol name. */
1641 i
= sig_number (signum_exp
);
1644 /* Nope, maybe it's an address which evaluates to a signal
1646 i
= parse_and_eval_address (signum_exp
);
1647 if (i
>= NSIG
|| i
< 0)
1648 error ("Signal number out of bounds.");
1654 printf_filtered ("\n");
1655 for (i
= 0; i
< NSIG
; i
++)
1662 printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
1665 /* Save all of the information associated with the inferior<==>gdb
1666 connection. INF_STATUS is a pointer to a "struct inferior_status"
1667 (defined in inferior.h). */
1670 save_inferior_status (inf_status
, restore_stack_info
)
1671 struct inferior_status
*inf_status
;
1672 int restore_stack_info
;
1674 inf_status
->pc_changed
= pc_changed
;
1675 inf_status
->stop_signal
= stop_signal
;
1676 inf_status
->stop_pc
= stop_pc
;
1677 inf_status
->stop_frame_address
= stop_frame_address
;
1678 inf_status
->stop_step
= stop_step
;
1679 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
1680 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
1681 inf_status
->trap_expected
= trap_expected
;
1682 inf_status
->step_range_start
= step_range_start
;
1683 inf_status
->step_range_end
= step_range_end
;
1684 inf_status
->step_frame_address
= step_frame_address
;
1685 inf_status
->step_over_calls
= step_over_calls
;
1686 inf_status
->step_resume_break_address
= step_resume_break_address
;
1687 inf_status
->stop_after_trap
= stop_after_trap
;
1688 inf_status
->stop_soon_quietly
= stop_soon_quietly
;
1689 /* Save original bpstat chain here; replace it with copy of chain.
1690 If caller's caller is walking the chain, they'll be happier if we
1691 hand them back the original chain when restore_i_s is called. */
1692 inf_status
->stop_bpstat
= stop_bpstat
;
1693 stop_bpstat
= bpstat_copy (stop_bpstat
);
1694 inf_status
->breakpoint_proceeded
= breakpoint_proceeded
;
1695 inf_status
->restore_stack_info
= restore_stack_info
;
1696 inf_status
->proceed_to_finish
= proceed_to_finish
;
1698 bcopy (stop_registers
, inf_status
->stop_registers
, REGISTER_BYTES
);
1700 record_selected_frame (&(inf_status
->selected_frame_address
),
1701 &(inf_status
->selected_level
));
1706 restore_inferior_status (inf_status
)
1707 struct inferior_status
*inf_status
;
1710 int level
= inf_status
->selected_level
;
1712 pc_changed
= inf_status
->pc_changed
;
1713 stop_signal
= inf_status
->stop_signal
;
1714 stop_pc
= inf_status
->stop_pc
;
1715 stop_frame_address
= inf_status
->stop_frame_address
;
1716 stop_step
= inf_status
->stop_step
;
1717 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
1718 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
1719 trap_expected
= inf_status
->trap_expected
;
1720 step_range_start
= inf_status
->step_range_start
;
1721 step_range_end
= inf_status
->step_range_end
;
1722 step_frame_address
= inf_status
->step_frame_address
;
1723 step_over_calls
= inf_status
->step_over_calls
;
1724 step_resume_break_address
= inf_status
->step_resume_break_address
;
1725 stop_after_trap
= inf_status
->stop_after_trap
;
1726 stop_soon_quietly
= inf_status
->stop_soon_quietly
;
1727 bpstat_clear (&stop_bpstat
);
1728 stop_bpstat
= inf_status
->stop_bpstat
;
1729 breakpoint_proceeded
= inf_status
->breakpoint_proceeded
;
1730 proceed_to_finish
= inf_status
->proceed_to_finish
;
1732 bcopy (inf_status
->stop_registers
, stop_registers
, REGISTER_BYTES
);
1734 /* The inferior can be gone if the user types "print exit(0)"
1735 (and perhaps other times). */
1736 if (target_has_stack
&& inf_status
->restore_stack_info
)
1738 fid
= find_relative_frame (get_current_frame (),
1741 /* If inf_status->selected_frame_address is NULL, there was no
1742 previously selected frame. */
1744 FRAME_FP (fid
) != inf_status
->selected_frame_address
||
1748 /* I'm not sure this error message is a good idea. I have
1749 only seen it occur after "Can't continue previously
1750 requested operation" (we get called from do_cleanups), in
1751 which case it just adds insult to injury (one confusing
1752 error message after another. Besides which, does the
1753 user really care if we can't restore the previously
1755 fprintf (stderr
, "Unable to restore previously selected frame.\n");
1757 select_frame (get_current_frame (), 0);
1761 select_frame (fid
, inf_status
->selected_level
);
1767 _initialize_infrun ()
1771 add_info ("signals", signals_info
,
1772 "What debugger does when program gets various signals.\n\
1773 Specify a signal number as argument to print info on that signal only.");
1775 add_com ("handle", class_run
, handle_command
,
1776 "Specify how to handle a signal.\n\
1777 Args are signal number followed by flags.\n\
1778 Flags allowed are \"stop\", \"print\", \"pass\",\n\
1779 \"nostop\", \"noprint\" or \"nopass\".\n\
1780 Print means print a message if this signal happens.\n\
1781 Stop means reenter debugger if this signal happens (implies print).\n\
1782 Pass means let program see this signal; otherwise program doesn't know.\n\
1783 Pass and Stop may be combined.");
1785 for (i
= 0; i
< NSIG
; i
++)
1788 signal_print
[i
] = 1;
1789 signal_program
[i
] = 1;
1792 /* Signals caused by debugger's own actions
1793 should not be given to the program afterwards. */
1794 signal_program
[SIGTRAP
] = 0;
1795 signal_program
[SIGINT
] = 0;
1797 /* Signals that are not errors should not normally enter the debugger. */
1799 signal_stop
[SIGALRM
] = 0;
1800 signal_print
[SIGALRM
] = 0;
1801 #endif /* SIGALRM */
1803 signal_stop
[SIGVTALRM
] = 0;
1804 signal_print
[SIGVTALRM
] = 0;
1805 #endif /* SIGVTALRM */
1807 signal_stop
[SIGPROF
] = 0;
1808 signal_print
[SIGPROF
] = 0;
1809 #endif /* SIGPROF */
1811 signal_stop
[SIGCHLD
] = 0;
1812 signal_print
[SIGCHLD
] = 0;
1813 #endif /* SIGCHLD */
1815 signal_stop
[SIGCLD
] = 0;
1816 signal_print
[SIGCLD
] = 0;
1819 signal_stop
[SIGIO
] = 0;
1820 signal_print
[SIGIO
] = 0;
1823 signal_stop
[SIGURG
] = 0;
1824 signal_print
[SIGURG
] = 0;