1 /* Start and stop the inferior process, for GDB.
2 Copyright (C) 1986, 1987, 1988, 1989 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB 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 1, or (at your option)
11 GDB 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 GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 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 extern int original_stack_limit
;
145 #endif /* SET_STACK_LIMIT_HUGE */
147 /* Required by <sys/user.h>. */
148 #include <sys/types.h>
149 /* Required by <sys/user.h>, at least on system V. */
151 /* Needed by IN_SIGTRAMP on some machines (e.g. vax). */
152 #include <sys/param.h>
153 /* Needed by IN_SIGTRAMP on some machines (e.g. vax). */
154 #include <sys/user.h>
157 extern char *getenv ();
159 extern struct target_ops child_ops
; /* In inftarg.c */
161 /* Copy of inferior_io_terminal when inferior was last started. */
163 extern char *inferior_thisrun_terminal
;
166 /* Sigtramp is a routine that the kernel calls (which then calls the
167 signal handler). On most machines it is a library routine that
168 is linked into the executable.
170 This macro, given a program counter value and the name of the
171 function in which that PC resides (which can be null if the
172 name is not known), returns nonzero if the PC and name show
173 that we are in sigtramp.
175 On most machines just see if the name is sigtramp (and if we have
176 no name, assume we are not in sigtramp). */
177 #if !defined (IN_SIGTRAMP)
178 #define IN_SIGTRAMP(pc, name) \
179 name && !strcmp ("_sigtramp", name)
182 /* Tables of how to react to signals; the user sets them. */
184 static char signal_stop
[NSIG
];
185 static char signal_print
[NSIG
];
186 static char signal_program
[NSIG
];
188 /* Nonzero if breakpoints are now inserted in the inferior. */
189 /* Nonstatic for initialization during xxx_create_inferior. FIXME. */
191 /*static*/ int breakpoints_inserted
;
193 /* Function inferior was in as of last step command. */
195 static struct symbol
*step_start_function
;
197 /* Nonzero => address for special breakpoint for resuming stepping. */
199 static CORE_ADDR step_resume_break_address
;
201 /* Pointer to orig contents of the byte where the special breakpoint is. */
203 static char step_resume_break_shadow
[BREAKPOINT_MAX
];
205 /* Nonzero means the special breakpoint is a duplicate
206 so it has not itself been inserted. */
208 static int step_resume_break_duplicate
;
210 /* Nonzero if we are expecting a trace trap and should proceed from it. */
212 static int trap_expected
;
214 /* Nonzero if the next time we try to continue the inferior, it will
215 step one instruction and generate a spurious trace trap.
216 This is used to compensate for a bug in HP-UX. */
218 static int trap_expected_after_continue
;
220 /* Nonzero means expecting a trace trap
221 and should stop the inferior and return silently when it happens. */
225 /* Nonzero means expecting a trap and caller will handle it themselves.
226 It is used after attach, due to attaching to a process;
227 when running in the shell before the child program has been exec'd;
228 and when running some kinds of remote stuff (FIXME?). */
230 int stop_soon_quietly
;
232 /* Nonzero if pc has been changed by the debugger
233 since the inferior stopped. */
237 /* Nonzero if proceed is being used for a "finish" command or a similar
238 situation when stop_registers should be saved. */
240 int proceed_to_finish
;
242 /* Save register contents here when about to pop a stack dummy frame,
243 if-and-only-if proceed_to_finish is set.
244 Thus this contains the return value from the called function (assuming
245 values are returned in a register). */
247 char stop_registers
[REGISTER_BYTES
];
249 /* Nonzero if program stopped due to error trying to insert breakpoints. */
251 static int breakpoints_failed
;
253 /* Nonzero after stop if current stack frame should be printed. */
255 static int stop_print_frame
;
257 #ifdef NO_SINGLE_STEP
258 extern int one_stepped
; /* From machine dependent code */
259 extern void single_step (); /* Same. */
260 #endif /* NO_SINGLE_STEP */
262 static void insert_step_breakpoint ();
263 static void remove_step_breakpoint ();
264 /*static*/ void wait_for_inferior ();
265 void init_wait_for_inferior ();
266 static void normal_stop ();
269 /* Clear out all variables saying what to do when inferior is continued.
270 First do this, then set the ones you want, then call `proceed'. */
273 clear_proceed_status ()
276 step_range_start
= 0;
278 step_frame_address
= 0;
279 step_over_calls
= -1;
280 step_resume_break_address
= 0;
282 stop_soon_quietly
= 0;
283 proceed_to_finish
= 0;
284 breakpoint_proceeded
= 1; /* We're about to proceed... */
286 /* Discard any remaining commands or status from previous stop. */
287 bpstat_clear (&stop_bpstat
);
290 /* Basic routine for continuing the program in various fashions.
292 ADDR is the address to resume at, or -1 for resume where stopped.
293 SIGGNAL is the signal to give it, or 0 for none,
294 or -1 for act according to how it stopped.
295 STEP is nonzero if should trap after one instruction.
296 -1 means return after that and print nothing.
297 You should probably set various step_... variables
298 before calling here, if you are stepping.
300 You should call clear_proceed_status before calling proceed. */
303 proceed (addr
, siggnal
, step
)
311 step_start_function
= find_pc_function (read_pc ());
317 /* If there is a breakpoint at the address we will resume at,
318 step one instruction before inserting breakpoints
319 so that we do not stop right away. */
321 if (!pc_changed
&& breakpoint_here_p (read_pc ()))
326 write_register (PC_REGNUM
, addr
);
328 write_register (NPC_REGNUM
, addr
+ 4);
330 write_register (NNPC_REGNUM
, addr
+ 8);
335 if (trap_expected_after_continue
)
337 /* If (step == 0), a trap will be automatically generated after
338 the first instruction is executed. Force step one
339 instruction to clear this condition. This should not occur
340 if step is nonzero, but it is harmless in that case. */
342 trap_expected_after_continue
= 0;
346 /* We will get a trace trap after one instruction.
347 Continue it automatically and insert breakpoints then. */
351 int temp
= insert_breakpoints ();
354 print_sys_errmsg ("ptrace", temp
);
355 error ("Cannot insert breakpoints.\n\
356 The same program may be running in another process.");
358 breakpoints_inserted
= 1;
361 /* Install inferior's terminal modes. */
362 target_terminal_inferior ();
365 stop_signal
= siggnal
;
366 /* If this signal should not be seen by program,
367 give it zero. Used for debugging signals. */
368 else if (stop_signal
< NSIG
&& !signal_program
[stop_signal
])
371 /* Handle any optimized stores to the inferior NOW... */
372 #ifdef DO_DEFERRED_STORES
376 /* Resume inferior. */
377 target_resume (oneproc
|| step
|| bpstat_should_step (), stop_signal
);
379 /* Wait for it to stop (if not standalone)
380 and in any case decode why it stopped, and act accordingly. */
382 wait_for_inferior ();
387 /* This might be useful (not sure), but isn't currently used. See also
389 /* Writing the inferior pc as a register calls this function
390 to inform infrun that the pc has been set in the debugger. */
401 /* Record the pc and sp of the program the last time it stopped.
402 These are just used internally by wait_for_inferior, but need
403 to be preserved over calls to it and cleared when the inferior
405 static CORE_ADDR prev_pc
;
406 static CORE_ADDR prev_sp
;
407 static CORE_ADDR prev_func_start
;
408 static char *prev_func_name
;
410 /* Start an inferior Unix child process and sets inferior_pid to its pid.
411 EXEC_FILE is the file to run.
412 ALLARGS is a string containing the arguments to the program.
413 ENV is the environment vector to pass. Errors reported with error(). */
416 #define SHELL_FILE "/bin/sh"
420 child_create_inferior (exec_file
, allargs
, env
)
428 extern char *sys_errlist
[];
431 static char default_shell_file
[] = SHELL_FILE
;
434 /* Set debug_fork then attach to the child while it sleeps, to debug. */
435 static int debug_fork
= 0;
436 /* This is set to the result of setpgrp, which if vforked, will be visible
437 to you in the parent process. It's only used by humans for debugging. */
438 static int debug_setpgrp
= 657473;
440 /* The user might want tilde-expansion, and in general probably wants
441 the program to behave the same way as if run from
442 his/her favorite shell. So we let the shell run it for us.
443 FIXME, this should probably search the local environment (as
444 modified by the setenv command), not the env gdb inherited. */
445 shell_file
= getenv ("SHELL");
446 if (shell_file
== NULL
)
447 shell_file
= default_shell_file
;
449 len
= 5 + strlen (exec_file
) + 1 + strlen (allargs
) + 1 + /*slop*/ 10;
450 /* If desired, concat something onto the front of ALLARGS.
451 SHELL_COMMAND is the result. */
452 #ifdef SHELL_COMMAND_CONCAT
453 shell_command
= (char *) alloca (strlen (SHELL_COMMAND_CONCAT
) + len
);
454 strcpy (shell_command
, SHELL_COMMAND_CONCAT
);
456 shell_command
= (char *) alloca (len
);
457 shell_command
[0] = '\0';
459 strcat (shell_command
, "exec ");
460 strcat (shell_command
, exec_file
);
461 strcat (shell_command
, " ");
462 strcat (shell_command
, allargs
);
464 /* exec is said to fail if the executable is open. */
467 #if defined(USG) && !defined(HAVE_VFORK)
477 perror_with_name ("vfork");
485 /* Run inferior in a separate process group. */
486 debug_setpgrp
= setpgrp (getpid (), getpid ());
487 if (0 != debug_setpgrp
)
488 perror("setpgrp failed in child");
489 #endif /* TIOCGPGRP */
491 #ifdef SET_STACK_LIMIT_HUGE
492 /* Reset the stack limit back to what it was. */
496 getrlimit (RLIMIT_STACK
, &rlim
);
497 rlim
.rlim_cur
= original_stack_limit
;
498 setrlimit (RLIMIT_STACK
, &rlim
);
500 #endif /* SET_STACK_LIMIT_HUGE */
502 /* Tell the terminal handling subsystem what tty we plan to run on;
503 it will now switch to that one if non-null. */
505 new_tty (inferior_io_terminal
);
507 /* Changing the signal handlers for the inferior after
508 a vfork can also change them for the superior, so we don't mess
509 with signals here. See comments in
510 initialize_signals for how we get the right signal handlers
513 call_ptrace (0, 0, 0, 0); /* "Trace me, Dr. Memory!" */
514 execle (shell_file
, shell_file
, "-c", shell_command
, (char *)0, env
);
516 fprintf (stderr
, "Cannot exec %s: %s.\n", shell_file
,
517 errno
< sys_nerr
? sys_errlist
[errno
] : "unknown error");
522 /* Now that we have a child process, make it our target. */
523 push_target (&child_ops
);
525 #ifdef CREATE_INFERIOR_HOOK
526 CREATE_INFERIOR_HOOK (pid
);
529 /* The process was started by the fork that created it,
530 but it will have stopped one instruction after execing the shell.
531 Here we must get it up to actual execution of the real program. */
533 inferior_pid
= pid
; /* Needed for wait_for_inferior stuff below */
535 clear_proceed_status ();
537 #if defined (START_INFERIOR_HOOK)
538 START_INFERIOR_HOOK ();
541 /* We will get a trace trap after one instruction.
542 Continue it automatically. Eventually (after shell does an exec)
543 it will get another trace trap. Then insert breakpoints and continue. */
545 #ifdef START_INFERIOR_TRAPS_EXPECTED
546 pending_execs
= START_INFERIOR_TRAPS_EXPECTED
;
551 init_wait_for_inferior ();
553 /* Set up the "saved terminal modes" of the inferior
554 based on what modes we are starting it with. */
555 target_terminal_init ();
557 /* Install inferior's terminal modes. */
558 target_terminal_inferior ();
562 stop_soon_quietly
= 1; /* Make wait_for_inferior be quiet */
563 wait_for_inferior ();
564 if (stop_signal
!= SIGTRAP
)
566 /* Let shell child handle its own signals in its own way */
567 /* FIXME, what if child has exit()ed? Must exit loop somehow */
568 target_resume (0, stop_signal
);
572 /* We handle SIGTRAP, however; it means child did an exec. */
573 if (0 == --pending_execs
)
575 target_resume (0, 0); /* Just make it go on */
578 stop_soon_quietly
= 0;
580 /* Should this perhaps just be a "proceed" call? FIXME */
581 insert_step_breakpoint ();
582 breakpoints_failed
= insert_breakpoints ();
583 if (!breakpoints_failed
)
585 breakpoints_inserted
= 1;
586 target_terminal_inferior();
587 /* Start the child program going on its first instruction, single-
588 stepping if we need to. */
589 target_resume (bpstat_should_step (), 0);
590 wait_for_inferior ();
595 /* Start remote-debugging of a machine over a serial link. */
600 init_wait_for_inferior ();
601 clear_proceed_status ();
602 stop_soon_quietly
= 1;
606 /* Initialize static vars when a new inferior begins. */
609 init_wait_for_inferior ()
611 /* These are meaningless until the first time through wait_for_inferior. */
615 prev_func_name
= NULL
;
617 trap_expected_after_continue
= 0;
618 breakpoints_inserted
= 0;
619 mark_breakpoints_out ();
623 /* Attach to process PID, then initialize for debugging it
624 and wait for the trace-trap that results from attaching. */
627 child_open (args
, from_tty
)
637 error_no_arg ("process-id to attach");
639 #ifndef ATTACH_DETACH
640 error ("Can't attach to a process on this machine.");
644 if (target_has_execution
)
646 if (query ("A program is being debugged already. Kill it? "))
647 target_kill ((char *)0, from_tty
);
649 error ("Inferior not killed.");
652 exec_file
= (char *) get_exec_file (1);
656 printf ("Attaching program: %s pid %d\n",
663 push_target (&child_ops
);
665 mark_breakpoints_out ();
666 target_terminal_init ();
667 clear_proceed_status ();
668 stop_soon_quietly
= 1;
669 /*proceed (-1, 0, -2);*/
670 target_terminal_inferior ();
671 wait_for_inferior ();
673 #endif /* ATTACH_DETACH */
676 /* Wait for control to return from inferior to debugger.
677 If inferior gets a signal, we may decide to start it up again
678 instead of returning. That is why there is a loop in this function.
679 When this function actually returns it means the inferior
680 should be left stopped and GDB should read more commands. */
689 CORE_ADDR stop_func_start
;
690 char *stop_func_name
;
691 CORE_ADDR prologue_pc
;
692 int stop_step_resume_break
;
693 struct symtab_and_line sal
;
694 int remove_breakpoints_on_following_step
= 0;
697 /* This no longer works now that read_register is lazy;
698 it might try to ptrace when the process is not stopped. */
699 prev_pc
= read_pc ();
700 (void) find_pc_partial_function (prev_pc
, &prev_func_name
,
702 prev_func_start
+= FUNCTION_START_OFFSET
;
703 prev_sp
= read_register (SP_REGNUM
);
708 /* Clean up saved state that will become invalid. */
710 flush_cached_frames ();
711 registers_changed ();
715 /* See if the process still exists; clean up if it doesn't. */
718 target_terminal_ours_for_output ();
720 printf ("\nProgram exited with code 0%o.\n",
721 (unsigned int)WEXITSTATUS (w
));
724 printf ("\nProgram exited normally.\n");
726 target_mourn_inferior ();
727 #ifdef NO_SINGLE_STEP
730 stop_print_frame
= 0;
733 else if (!WIFSTOPPED (w
))
735 target_kill ((char *)0, 0);
736 stop_print_frame
= 0;
737 stop_signal
= WTERMSIG (w
);
738 target_terminal_ours_for_output ();
739 printf ("\nProgram terminated with signal %d, %s\n",
742 ? sys_siglist
[stop_signal
]
744 printf ("The inferior process no longer exists.\n");
746 #ifdef NO_SINGLE_STEP
752 #ifdef NO_SINGLE_STEP
754 single_step (0); /* This actually cleans up the ss */
755 #endif /* NO_SINGLE_STEP */
757 stop_pc
= read_pc ();
758 set_current_frame ( create_new_frame (read_register (FP_REGNUM
),
761 stop_frame_address
= FRAME_FP (get_current_frame ());
762 stop_sp
= read_register (SP_REGNUM
);
765 /* Don't care about return value; stop_func_start and stop_func_name
766 will both be 0 if it doesn't work. */
767 (void) find_pc_partial_function (stop_pc
, &stop_func_name
,
769 stop_func_start
+= FUNCTION_START_OFFSET
;
771 bpstat_clear (&stop_bpstat
);
773 stop_stack_dummy
= 0;
774 stop_print_frame
= 1;
775 stop_step_resume_break
= 0;
777 stopped_by_random_signal
= 0;
778 breakpoints_failed
= 0;
780 /* Look at the cause of the stop, and decide what to do.
781 The alternatives are:
782 1) break; to really stop and return to the debugger,
783 2) drop through to start up again
784 (set another_trap to 1 to single step once)
785 3) set random_signal to 1, and the decision between 1 and 2
786 will be made according to the signal handling tables. */
788 stop_signal
= WSTOPSIG (w
);
790 /* First, distinguish signals caused by the debugger from signals
791 that have to do with the program's own actions.
792 Note that breakpoint insns may cause SIGTRAP or SIGILL
793 or SIGEMT, depending on the operating system version.
794 Here we detect when a SIGILL or SIGEMT is really a breakpoint
795 and change it to SIGTRAP. */
797 if (stop_signal
== SIGTRAP
798 || (breakpoints_inserted
&&
799 (stop_signal
== SIGILL
800 || stop_signal
== SIGEMT
))
801 || stop_soon_quietly
)
803 if (stop_signal
== SIGTRAP
&& stop_after_trap
)
805 stop_print_frame
= 0;
808 if (stop_soon_quietly
)
811 /* Don't even think about breakpoints
812 if just proceeded over a breakpoint.
814 However, if we are trying to proceed over a breakpoint
815 and end up in sigtramp, then step_resume_break_address
816 will be set and we should check whether we've hit the
818 if (stop_signal
== SIGTRAP
&& trap_expected
819 && step_resume_break_address
== NULL
)
820 bpstat_clear (&stop_bpstat
);
823 /* See if there is a breakpoint at the current PC. */
824 #if DECR_PC_AFTER_BREAK
825 /* Notice the case of stepping through a jump
826 that leads just after a breakpoint.
827 Don't confuse that with hitting the breakpoint.
828 What we check for is that 1) stepping is going on
829 and 2) the pc before the last insn does not match
830 the address of the breakpoint before the current pc. */
831 if (!(prev_pc
!= stop_pc
- DECR_PC_AFTER_BREAK
832 && step_range_end
&& !step_resume_break_address
))
833 #endif /* DECR_PC_AFTER_BREAK not zero */
835 /* See if we stopped at the special breakpoint for
836 stepping over a subroutine call. */
837 if (stop_pc
- DECR_PC_AFTER_BREAK
838 == step_resume_break_address
)
840 stop_step_resume_break
= 1;
841 if (DECR_PC_AFTER_BREAK
)
843 stop_pc
-= DECR_PC_AFTER_BREAK
;
844 write_register (PC_REGNUM
, stop_pc
);
851 bpstat_stop_status (&stop_pc
, stop_frame_address
);
852 /* Following in case break condition called a
854 stop_print_frame
= 1;
859 if (stop_signal
== SIGTRAP
)
861 = !(bpstat_explains_signal (stop_bpstat
)
863 || stop_step_resume_break
864 || PC_IN_CALL_DUMMY (stop_pc
, stop_sp
, stop_frame_address
)
865 || (step_range_end
&& !step_resume_break_address
));
869 = !(bpstat_explains_signal (stop_bpstat
)
870 || stop_step_resume_break
871 /* End of a stack dummy. Some systems (e.g. Sony
872 news) give another signal besides SIGTRAP,
873 so check here as well as above. */
874 || (stop_sp INNER_THAN stop_pc
875 && stop_pc INNER_THAN stop_frame_address
)
878 stop_signal
= SIGTRAP
;
884 /* For the program's own signals, act according to
885 the signal handling tables. */
889 /* Signal not for debugging purposes. */
892 stopped_by_random_signal
= 1;
894 if (stop_signal
>= NSIG
895 || signal_print
[stop_signal
])
898 target_terminal_ours_for_output ();
899 #ifdef PRINT_RANDOM_SIGNAL
900 PRINT_RANDOM_SIGNAL (stop_signal
);
902 printf ("\nProgram received signal %d, %s\n",
905 ? sys_siglist
[stop_signal
]
907 #endif /* PRINT_RANDOM_SIGNAL */
910 if (stop_signal
>= NSIG
911 || signal_stop
[stop_signal
])
913 /* If not going to stop, give terminal back
914 if we took it away. */
916 target_terminal_inferior ();
919 /* Handle cases caused by hitting a user breakpoint. */
921 if (!random_signal
&& bpstat_explains_signal (stop_bpstat
))
923 /* Does a breakpoint want us to stop? */
924 if (bpstat_stop (stop_bpstat
))
926 stop_print_frame
= bpstat_should_print (stop_bpstat
);
930 /* Otherwise we continue. Must remove breakpoints and single-step
931 to get us past the one we hit. Possibly we also were stepping
932 and should stop for that. So fall through and
933 test for stepping. But, if not stepping,
937 remove_breakpoints ();
938 remove_step_breakpoint (); /* FIXME someday, do we need this? */
939 breakpoints_inserted
= 0;
944 /* Handle cases caused by hitting a step-resumption breakpoint. */
946 else if (!random_signal
&& stop_step_resume_break
)
948 /* We have hit the step-resumption breakpoint.
949 If we aren't in a recursive call that hit it again
950 before returning from the original call, remove it;
951 it has done its job getting us here. We then resume
952 the stepping we were doing before the function call.
954 If we are in a recursive call, just proceed from this
955 breakpoint as usual, keeping it around to catch the final
958 There used to be an sp test to make sure that we don't get hung
959 up in recursive calls in functions without frame
960 pointers. If the stack pointer isn't outside of
961 where the breakpoint was set (within a routine to be
962 stepped over), we're in the middle of a recursive
963 call. Not true for reg window machines (sparc)
964 because they must change frames to call things and
965 the stack pointer doesn't have to change if
966 the bp was set in a routine without a frame (pc can
967 be stored in some other window).
969 The removal of the sp test is to allow calls to
970 alloca. Nasty things were happening. Oh, well,
971 gdb can only handle one level deep of lack of
973 if (step_frame_address
== 0
974 || (stop_frame_address
== step_frame_address
))
976 /* We really hit it: not a recursive call. */
977 remove_step_breakpoint ();
978 step_resume_break_address
= 0;
980 /* If we're waiting for a trap, hitting the step_resume_break
981 doesn't count as getting it. */
984 /* Fall through to resume stepping... */
988 /* Otherwise, it's the recursive call case. */
989 remove_breakpoints ();
990 remove_step_breakpoint ();
991 breakpoints_inserted
= 0;
993 /* Fall through to continue executing at full speed
994 (with a possible single-step lurch over the step-resumption
995 breakpoint as we start.) */
999 /* If this is the breakpoint at the end of a stack dummy,
1000 just stop silently. */
1001 if (PC_IN_CALL_DUMMY (stop_pc
, stop_sp
, stop_frame_address
))
1003 stop_print_frame
= 0;
1004 stop_stack_dummy
= 1;
1006 trap_expected_after_continue
= 1;
1011 if (step_resume_break_address
)
1012 /* Having a step-resume breakpoint overrides anything
1013 else having to do with stepping commands until
1014 that breakpoint is reached. */
1016 /* If stepping through a line, keep going if still within it. */
1017 else if (!random_signal
1019 && stop_pc
>= step_range_start
1020 && stop_pc
< step_range_end
1021 /* The step range might include the start of the
1022 function, so if we are at the start of the
1023 step range and either the stack or frame pointers
1024 just changed, we've stepped outside */
1025 && !(stop_pc
== step_range_start
1026 && stop_frame_address
1027 && (stop_sp INNER_THAN prev_sp
1028 || stop_frame_address
!= step_frame_address
)))
1031 /* When "next"ing through a function,
1032 This causes an extra stop at the end.
1033 Is there any reason for this?
1034 It's confusing to the user. */
1035 /* Don't step through the return from a function
1036 unless that is the first instruction stepped through. */
1037 if (ABOUT_TO_RETURN (stop_pc
))
1045 /* We stepped out of the stepping range. See if that was due
1046 to a subroutine call that we should proceed to the end of. */
1047 else if (!random_signal
&& step_range_end
)
1049 if (stop_func_start
)
1051 prologue_pc
= stop_func_start
;
1052 SKIP_PROLOGUE (prologue_pc
);
1055 /* Did we just take a signal? */
1056 if (IN_SIGTRAMP (stop_pc
, stop_func_name
)
1057 && !IN_SIGTRAMP (prev_pc
, prev_func_name
))
1059 /* This code is needed at least in the following case:
1060 The user types "next" and then a signal arrives (before
1061 the "next" is done). */
1062 /* We've just taken a signal; go until we are back to
1063 the point where we took it and one more. */
1064 step_resume_break_address
= prev_pc
;
1065 step_resume_break_duplicate
=
1066 breakpoint_here_p (step_resume_break_address
);
1067 if (breakpoints_inserted
)
1068 insert_step_breakpoint ();
1069 /* Make sure that the stepping range gets us past
1070 that instruction. */
1071 if (step_range_end
== 1)
1072 step_range_end
= (step_range_start
= prev_pc
) + 1;
1073 remove_breakpoints_on_following_step
= 1;
1076 /* ==> See comments at top of file on this algorithm. <==*/
1078 else if (stop_pc
== stop_func_start
1079 && (stop_func_start
!= prev_func_start
1080 || prologue_pc
!= stop_func_start
1081 || stop_sp
!= prev_sp
))
1083 /* It's a subroutine call */
1084 if (step_over_calls
> 0
1085 || (step_over_calls
&& find_pc_function (stop_pc
) == 0))
1087 /* A subroutine call has happened. */
1088 /* Set a special breakpoint after the return */
1089 step_resume_break_address
=
1091 (SAVED_PC_AFTER_CALL (get_current_frame ()));
1092 step_resume_break_duplicate
1093 = breakpoint_here_p (step_resume_break_address
);
1094 if (breakpoints_inserted
)
1095 insert_step_breakpoint ();
1097 /* Subroutine call with source code we should not step over.
1098 Do step to the first line of code in it. */
1099 else if (step_over_calls
)
1101 SKIP_PROLOGUE (stop_func_start
);
1102 sal
= find_pc_line (stop_func_start
, 0);
1103 /* Use the step_resume_break to step until
1104 the end of the prologue, even if that involves jumps
1105 (as it seems to on the vax under 4.2). */
1106 /* If the prologue ends in the middle of a source line,
1107 continue to the end of that source line.
1108 Otherwise, just go to end of prologue. */
1109 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1110 /* no, don't either. It skips any code that's
1111 legitimately on the first line. */
1113 if (sal
.end
&& sal
.pc
!= stop_func_start
)
1114 stop_func_start
= sal
.end
;
1117 if (stop_func_start
== stop_pc
)
1119 /* We are already there: stop now. */
1124 /* Put the step-breakpoint there and go until there. */
1126 step_resume_break_address
= stop_func_start
;
1128 step_resume_break_duplicate
1129 = breakpoint_here_p (step_resume_break_address
);
1130 if (breakpoints_inserted
)
1131 insert_step_breakpoint ();
1132 /* Do not specify what the fp should be when we stop
1133 since on some machines the prologue
1134 is where the new fp value is established. */
1135 step_frame_address
= 0;
1136 /* And make sure stepping stops right away then. */
1137 step_range_end
= step_range_start
;
1142 /* We get here only if step_over_calls is 0 and we
1143 just stepped into a subroutine. I presume
1144 that step_over_calls is only 0 when we're
1145 supposed to be stepping at the assembly
1151 /* No subroutine call; stop now. */
1159 else if (trap_expected
1160 && IN_SIGTRAMP (stop_pc
, stop_func_name
)
1161 && !IN_SIGTRAMP (prev_pc
, prev_func_name
))
1163 /* What has happened here is that we have just stepped the inferior
1164 with a signal (because it is a signal which shouldn't make
1165 us stop), thus stepping into sigtramp.
1167 So we need to set a step_resume_break_address breakpoint
1168 and continue until we hit it, and then step. */
1169 step_resume_break_address
= prev_pc
;
1170 /* Always 1, I think, but it's probably easier to have
1171 the step_resume_break as usual rather than trying to
1172 re-use the breakpoint which is already there. */
1173 step_resume_break_duplicate
=
1174 breakpoint_here_p (step_resume_break_address
);
1175 if (breakpoints_inserted
)
1176 insert_step_breakpoint ();
1177 remove_breakpoints_on_following_step
= 1;
1181 /* Save the pc before execution, to compare with pc after stop. */
1182 prev_pc
= read_pc (); /* Might have been DECR_AFTER_BREAK */
1183 prev_func_start
= stop_func_start
; /* Ok, since if DECR_PC_AFTER
1184 BREAK is defined, the
1185 original pc would not have
1186 been at the start of a
1188 prev_func_name
= stop_func_name
;
1191 /* If we did not do break;, it means we should keep
1192 running the inferior and not return to debugger. */
1194 if (trap_expected
&& stop_signal
!= SIGTRAP
)
1196 /* We took a signal (which we are supposed to pass through to
1197 the inferior, else we'd have done a break above) and we
1198 haven't yet gotten our trap. Simply continue. */
1199 target_resume ((step_range_end
&& !step_resume_break_address
)
1200 || (trap_expected
&& !step_resume_break_address
)
1201 || bpstat_should_step (),
1206 /* Either the trap was not expected, but we are continuing
1207 anyway (the user asked that this signal be passed to the
1210 The signal was SIGTRAP, e.g. it was our signal, but we
1211 decided we should resume from it.
1213 We're going to run this baby now!
1215 Insert breakpoints now, unless we are trying
1216 to one-proceed past a breakpoint. */
1217 /* If we've just finished a special step resume and we don't
1218 want to hit a breakpoint, pull em out. */
1219 if (!step_resume_break_address
&&
1220 remove_breakpoints_on_following_step
)
1222 remove_breakpoints_on_following_step
= 0;
1223 remove_breakpoints ();
1224 breakpoints_inserted
= 0;
1226 else if (!breakpoints_inserted
&&
1227 (step_resume_break_address
!= NULL
|| !another_trap
))
1229 insert_step_breakpoint ();
1230 breakpoints_failed
= insert_breakpoints ();
1231 if (breakpoints_failed
)
1233 breakpoints_inserted
= 1;
1236 trap_expected
= another_trap
;
1238 if (stop_signal
== SIGTRAP
)
1241 #ifdef SHIFT_INST_REGS
1242 /* I'm not sure when this following segment applies. I do know, now,
1243 that we shouldn't rewrite the regs when we were stopped by a
1244 random signal from the inferior process. */
1246 if (!stop_breakpoint
&& (stop_signal
!= SIGCLD
)
1247 && !stopped_by_random_signal
)
1249 CORE_ADDR pc_contents
= read_register (PC_REGNUM
);
1250 CORE_ADDR npc_contents
= read_register (NPC_REGNUM
);
1251 if (pc_contents
!= npc_contents
)
1253 write_register (NNPC_REGNUM
, npc_contents
);
1254 write_register (NPC_REGNUM
, pc_contents
);
1257 #endif /* SHIFT_INST_REGS */
1259 target_resume ((step_range_end
&& !step_resume_break_address
)
1260 || (trap_expected
&& !step_resume_break_address
)
1261 || bpstat_should_step (),
1265 if (target_has_execution
)
1267 /* Assuming the inferior still exists, set these up for next
1268 time, just like we did above if we didn't break out of the
1270 prev_pc
= read_pc ();
1271 prev_func_start
= stop_func_start
;
1272 prev_func_name
= stop_func_name
;
1277 /* Here to return control to GDB when the inferior stops for real.
1278 Print appropriate messages, remove breakpoints, give terminal our modes.
1280 STOP_PRINT_FRAME nonzero means print the executing frame
1281 (pc, function, args, file, line number and line text).
1282 BREAKPOINTS_FAILED nonzero means stop was due to error
1283 attempting to insert breakpoints. */
1288 /* Make sure that the current_frame's pc is correct. This
1289 is a correction for setting up the frame info before doing
1290 DECR_PC_AFTER_BREAK */
1291 if (target_has_execution
)
1292 (get_current_frame ())->pc
= read_pc ();
1294 if (breakpoints_failed
)
1296 target_terminal_ours_for_output ();
1297 print_sys_errmsg ("ptrace", breakpoints_failed
);
1298 printf ("Stopped; cannot insert breakpoints.\n\
1299 The same program may be running in another process.\n");
1302 if (target_has_execution
)
1303 remove_step_breakpoint ();
1305 if (target_has_execution
&& breakpoints_inserted
)
1306 if (remove_breakpoints ())
1308 target_terminal_ours_for_output ();
1309 printf ("Cannot remove breakpoints because program is no longer writable.\n\
1310 It must be running in another process.\n\
1311 Further execution is probably impossible.\n");
1314 breakpoints_inserted
= 0;
1316 /* Delete the breakpoint we stopped at, if it wants to be deleted.
1317 Delete any breakpoint that is to be deleted at the next stop. */
1319 breakpoint_auto_delete (stop_bpstat
);
1321 /* If an auto-display called a function and that got a signal,
1322 delete that auto-display to avoid an infinite recursion. */
1324 if (stopped_by_random_signal
)
1325 disable_current_display ();
1327 if (step_multi
&& stop_step
)
1330 target_terminal_ours ();
1332 if (!target_has_stack
)
1335 /* Select innermost stack frame except on return from a stack dummy routine,
1336 or if the program has exited. */
1337 if (!stop_stack_dummy
)
1339 select_frame (get_current_frame (), 0);
1341 if (stop_print_frame
)
1343 int source_only
= bpstat_print (stop_bpstat
);
1347 && step_frame_address
== stop_frame_address
1348 && step_start_function
== find_pc_function (stop_pc
)));
1350 /* Display the auto-display expressions. */
1355 /* Save the function value return registers, if we care.
1356 We might be about to restore their previous contents. */
1357 if (proceed_to_finish
)
1358 read_register_bytes (0, stop_registers
, REGISTER_BYTES
);
1360 if (stop_stack_dummy
)
1362 /* Pop the empty frame that contains the stack dummy.
1363 POP_FRAME ends with a setting of the current frame, so we
1364 can use that next. */
1366 select_frame (get_current_frame (), 0);
1371 insert_step_breakpoint ()
1373 if (step_resume_break_address
&& !step_resume_break_duplicate
)
1374 target_insert_breakpoint (step_resume_break_address
,
1375 step_resume_break_shadow
);
1379 remove_step_breakpoint ()
1381 if (step_resume_break_address
&& !step_resume_break_duplicate
)
1382 target_remove_breakpoint (step_resume_break_address
,
1383 step_resume_break_shadow
);
1389 printf_filtered ("Signal\t\tStop\tPrint\tPass to program\tDescription\n");
1393 sig_print_info (number
)
1396 char *abbrev
= sig_abbrev(number
);
1398 printf_filtered ("%d\t\t", number
);
1400 printf_filtered ("SIG%s (%d)\t", abbrev
, number
);
1401 printf_filtered ("%s\t", signal_stop
[number
] ? "Yes" : "No");
1402 printf_filtered ("%s\t", signal_print
[number
] ? "Yes" : "No");
1403 printf_filtered ("%s\t\t", signal_program
[number
] ? "Yes" : "No");
1404 printf_filtered ("%s\n", sys_siglist
[number
]);
1407 /* Specify how various signals in the inferior should be handled. */
1410 handle_command (args
, from_tty
)
1414 register char *p
= args
;
1416 register int digits
, wordlen
;
1420 error_no_arg ("signal to handle");
1424 /* Find the end of the next word in the args. */
1426 p
[wordlen
] && p
[wordlen
] != ' ' && p
[wordlen
] != '\t';
1428 /* Set nextarg to the start of the word after the one we just
1429 found, and null-terminate this one. */
1430 if (p
[wordlen
] == '\0')
1431 nextarg
= p
+ wordlen
;
1435 nextarg
= p
+ wordlen
+ 1;
1439 for (digits
= 0; p
[digits
] >= '0' && p
[digits
] <= '9'; digits
++);
1443 /* It is the first argument--must be the signal to operate on. */
1444 if (digits
== wordlen
)
1448 if (signum
<= 0 || signum
>= NSIG
)
1451 error ("Invalid signal %s given as argument to \"handle\".", p
);
1457 signum
= sig_number (p
);
1459 error ("No such signal \"%s\"", p
);
1462 if (signum
== SIGTRAP
|| signum
== SIGINT
)
1464 if (!query ("SIG%s is used by the debugger.\nAre you sure you want to change it? ", sig_abbrev (signum
)))
1465 error ("Not confirmed.");
1468 /* Else, if already got a signal number, look for flag words
1469 saying what to do for it. */
1470 else if (!strncmp (p
, "stop", wordlen
))
1472 signal_stop
[signum
] = 1;
1473 signal_print
[signum
] = 1;
1475 else if (wordlen
>= 2 && !strncmp (p
, "print", wordlen
))
1476 signal_print
[signum
] = 1;
1477 else if (wordlen
>= 2 && !strncmp (p
, "pass", wordlen
))
1478 signal_program
[signum
] = 1;
1479 else if (!strncmp (p
, "ignore", wordlen
))
1480 signal_program
[signum
] = 0;
1481 else if (wordlen
>= 3 && !strncmp (p
, "nostop", wordlen
))
1482 signal_stop
[signum
] = 0;
1483 else if (wordlen
>= 4 && !strncmp (p
, "noprint", wordlen
))
1485 signal_print
[signum
] = 0;
1486 signal_stop
[signum
] = 0;
1488 else if (wordlen
>= 4 && !strncmp (p
, "nopass", wordlen
))
1489 signal_program
[signum
] = 0;
1490 else if (wordlen
>= 3 && !strncmp (p
, "noignore", wordlen
))
1491 signal_program
[signum
] = 1;
1492 /* Not a number and not a recognized flag word => complain. */
1495 error ("Unrecognized flag word: \"%s\".", p
);
1498 /* Find start of next word. */
1500 while (*p
== ' ' || *p
== '\t') p
++;
1505 /* Show the results. */
1506 sig_print_header ();
1507 sig_print_info (signum
);
1511 /* Print current contents of the tables set by the handle command. */
1514 signals_info (signum_exp
)
1518 sig_print_header ();
1522 /* First see if this is a symbol name. */
1523 i
= sig_number (signum_exp
);
1526 /* Nope, maybe it's an address which evaluates to a signal
1528 i
= parse_and_eval_address (signum_exp
);
1529 if (i
>= NSIG
|| i
< 0)
1530 error ("Signal number out of bounds.");
1536 printf_filtered ("\n");
1537 for (i
= 0; i
< NSIG
; i
++)
1544 printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
1547 /* Save all of the information associated with the inferior<==>gdb
1548 connection. INF_STATUS is a pointer to a "struct inferior_status"
1549 (defined in inferior.h). */
1552 save_inferior_status (inf_status
, restore_stack_info
)
1553 struct inferior_status
*inf_status
;
1554 int restore_stack_info
;
1556 inf_status
->pc_changed
= pc_changed
;
1557 inf_status
->stop_signal
= stop_signal
;
1558 inf_status
->stop_pc
= stop_pc
;
1559 inf_status
->stop_frame_address
= stop_frame_address
;
1560 inf_status
->stop_step
= stop_step
;
1561 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
1562 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
1563 inf_status
->trap_expected
= trap_expected
;
1564 inf_status
->step_range_start
= step_range_start
;
1565 inf_status
->step_range_end
= step_range_end
;
1566 inf_status
->step_frame_address
= step_frame_address
;
1567 inf_status
->step_over_calls
= step_over_calls
;
1568 inf_status
->step_resume_break_address
= step_resume_break_address
;
1569 inf_status
->stop_after_trap
= stop_after_trap
;
1570 inf_status
->stop_soon_quietly
= stop_soon_quietly
;
1571 /* Save original bpstat chain here; replace it with copy of chain.
1572 If caller's caller is walking the chain, they'll be happier if we
1573 hand them back the original chain when restore_i_s is called. */
1574 inf_status
->stop_bpstat
= stop_bpstat
;
1575 stop_bpstat
= bpstat_copy (stop_bpstat
);
1576 inf_status
->breakpoint_proceeded
= breakpoint_proceeded
;
1577 inf_status
->restore_stack_info
= restore_stack_info
;
1578 inf_status
->proceed_to_finish
= proceed_to_finish
;
1580 bcopy (stop_registers
, inf_status
->stop_registers
, REGISTER_BYTES
);
1582 record_selected_frame (&(inf_status
->selected_frame_address
),
1583 &(inf_status
->selected_level
));
1588 restore_inferior_status (inf_status
)
1589 struct inferior_status
*inf_status
;
1592 int level
= inf_status
->selected_level
;
1594 pc_changed
= inf_status
->pc_changed
;
1595 stop_signal
= inf_status
->stop_signal
;
1596 stop_pc
= inf_status
->stop_pc
;
1597 stop_frame_address
= inf_status
->stop_frame_address
;
1598 stop_step
= inf_status
->stop_step
;
1599 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
1600 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
1601 trap_expected
= inf_status
->trap_expected
;
1602 step_range_start
= inf_status
->step_range_start
;
1603 step_range_end
= inf_status
->step_range_end
;
1604 step_frame_address
= inf_status
->step_frame_address
;
1605 step_over_calls
= inf_status
->step_over_calls
;
1606 step_resume_break_address
= inf_status
->step_resume_break_address
;
1607 stop_after_trap
= inf_status
->stop_after_trap
;
1608 stop_soon_quietly
= inf_status
->stop_soon_quietly
;
1609 bpstat_clear (&stop_bpstat
);
1610 stop_bpstat
= inf_status
->stop_bpstat
;
1611 breakpoint_proceeded
= inf_status
->breakpoint_proceeded
;
1612 proceed_to_finish
= inf_status
->proceed_to_finish
;
1614 bcopy (inf_status
->stop_registers
, stop_registers
, REGISTER_BYTES
);
1616 /* The inferior can be gone if the user types "print exit(0)"
1617 (and perhaps other times). */
1618 if (target_has_stack
&& inf_status
->restore_stack_info
)
1620 fid
= find_relative_frame (get_current_frame (),
1624 FRAME_FP (fid
) != inf_status
->selected_frame_address
||
1628 /* I'm not sure this error message is a good idea. I have
1629 only seen it occur after "Can't continue previously
1630 requested operation" (we get called from do_cleanups), in
1631 which case it just adds insult to injury (one confusing
1632 error message after another. Besides which, does the
1633 user really care if we can't restore the previously
1635 fprintf (stderr
, "Unable to restore previously selected frame.\n");
1637 select_frame (get_current_frame (), 0);
1641 select_frame (fid
, inf_status
->selected_level
);
1647 _initialize_infrun ()
1651 add_info ("signals", signals_info
,
1652 "What debugger does when program gets various signals.\n\
1653 Specify a signal number as argument to print info on that signal only.");
1655 add_com ("handle", class_run
, handle_command
,
1656 "Specify how to handle a signal.\n\
1657 Args are signal number followed by flags.\n\
1658 Flags allowed are \"stop\", \"print\", \"pass\",\n\
1659 \"nostop\", \"noprint\" or \"nopass\".\n\
1660 Print means print a message if this signal happens.\n\
1661 Stop means reenter debugger if this signal happens (implies print).\n\
1662 Pass means let program see this signal; otherwise program doesn't know.\n\
1663 Pass and Stop may be combined.");
1665 for (i
= 0; i
< NSIG
; i
++)
1668 signal_print
[i
] = 1;
1669 signal_program
[i
] = 1;
1672 /* Signals caused by debugger's own actions
1673 should not be given to the program afterwards. */
1674 signal_program
[SIGTRAP
] = 0;
1675 signal_program
[SIGINT
] = 0;
1677 /* Signals that are not errors should not normally enter the debugger. */
1679 signal_stop
[SIGALRM
] = 0;
1680 signal_print
[SIGALRM
] = 0;
1681 #endif /* SIGALRM */
1683 signal_stop
[SIGVTALRM
] = 0;
1684 signal_print
[SIGVTALRM
] = 0;
1685 #endif /* SIGVTALRM */
1687 signal_stop
[SIGPROF
] = 0;
1688 signal_print
[SIGPROF
] = 0;
1689 #endif /* SIGPROF */
1691 signal_stop
[SIGCHLD
] = 0;
1692 signal_print
[SIGCHLD
] = 0;
1693 #endif /* SIGCHLD */
1695 signal_stop
[SIGCLD
] = 0;
1696 signal_print
[SIGCLD
] = 0;
1699 signal_stop
[SIGIO
] = 0;
1700 signal_print
[SIGIO
] = 0;
1703 signal_stop
[SIGURG
] = 0;
1704 signal_print
[SIGURG
] = 0;