1 /* Target-struct-independent code to start (run) and stop an inferior process.
2 Copyright 1986-1989, 1991-2000 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., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
27 #include "breakpoint.h"
32 #include "gdbthread.h"
34 #include "symfile.h" /* for overlay functions */
39 /* Prototypes for local functions */
41 static void signals_info (char *, int);
43 static void handle_command (char *, int);
45 static void sig_print_info (enum target_signal
);
47 static void sig_print_header (void);
49 static void resume_cleanups (int);
51 static int hook_stop_stub (void *);
53 static void delete_breakpoint_current_contents (void *);
55 static void set_follow_fork_mode_command (char *arg
, int from_tty
,
56 struct cmd_list_element
* c
);
58 static struct inferior_status
*xmalloc_inferior_status (void);
60 static void free_inferior_status (struct inferior_status
*);
62 static int restore_selected_frame (void *);
64 static void build_infrun (void);
66 static void follow_inferior_fork (int parent_pid
, int child_pid
,
67 int has_forked
, int has_vforked
);
69 static void follow_fork (int parent_pid
, int child_pid
);
71 static void follow_vfork (int parent_pid
, int child_pid
);
73 static void set_schedlock_func (char *args
, int from_tty
,
74 struct cmd_list_element
* c
);
76 struct execution_control_state
;
78 static int currently_stepping (struct execution_control_state
*ecs
);
80 static void xdb_handle_command (char *args
, int from_tty
);
82 void _initialize_infrun (void);
84 int inferior_ignoring_startup_exec_events
= 0;
85 int inferior_ignoring_leading_exec_events
= 0;
87 /* In asynchronous mode, but simulating synchronous execution. */
89 int sync_execution
= 0;
91 /* wait_for_inferior and normal_stop use this to notify the user
92 when the inferior stopped in a different thread than it had been
95 static int previous_inferior_pid
;
97 /* This is true for configurations that may follow through execl() and
98 similar functions. At present this is only true for HP-UX native. */
100 #ifndef MAY_FOLLOW_EXEC
101 #define MAY_FOLLOW_EXEC (0)
104 static int may_follow_exec
= MAY_FOLLOW_EXEC
;
106 /* resume and wait_for_inferior use this to ensure that when
107 stepping over a hit breakpoint in a threaded application
108 only the thread that hit the breakpoint is stepped and the
109 other threads don't continue. This prevents having another
110 thread run past the breakpoint while it is temporarily
113 This is not thread-specific, so it isn't saved as part of
116 Versions of gdb which don't use the "step == this thread steps
117 and others continue" model but instead use the "step == this
118 thread steps and others wait" shouldn't do this. */
120 static int thread_step_needed
= 0;
122 /* This is true if thread_step_needed should actually be used. At
123 present this is only true for HP-UX native. */
125 #ifndef USE_THREAD_STEP_NEEDED
126 #define USE_THREAD_STEP_NEEDED (0)
129 static int use_thread_step_needed
= USE_THREAD_STEP_NEEDED
;
131 /* GET_LONGJMP_TARGET returns the PC at which longjmp() will resume the
132 program. It needs to examine the jmp_buf argument and extract the PC
133 from it. The return value is non-zero on success, zero otherwise. */
135 #ifndef GET_LONGJMP_TARGET
136 #define GET_LONGJMP_TARGET(PC_ADDR) 0
140 /* Some machines have trampoline code that sits between function callers
141 and the actual functions themselves. If this machine doesn't have
142 such things, disable their processing. */
144 #ifndef SKIP_TRAMPOLINE_CODE
145 #define SKIP_TRAMPOLINE_CODE(pc) 0
148 /* Dynamic function trampolines are similar to solib trampolines in that they
149 are between the caller and the callee. The difference is that when you
150 enter a dynamic trampoline, you can't determine the callee's address. Some
151 (usually complex) code needs to run in the dynamic trampoline to figure out
152 the callee's address. This macro is usually called twice. First, when we
153 enter the trampoline (looks like a normal function call at that point). It
154 should return the PC of a point within the trampoline where the callee's
155 address is known. Second, when we hit the breakpoint, this routine returns
156 the callee's address. At that point, things proceed as per a step resume
159 #ifndef DYNAMIC_TRAMPOLINE_NEXTPC
160 #define DYNAMIC_TRAMPOLINE_NEXTPC(pc) 0
163 /* If the program uses ELF-style shared libraries, then calls to
164 functions in shared libraries go through stubs, which live in a
165 table called the PLT (Procedure Linkage Table). The first time the
166 function is called, the stub sends control to the dynamic linker,
167 which looks up the function's real address, patches the stub so
168 that future calls will go directly to the function, and then passes
169 control to the function.
171 If we are stepping at the source level, we don't want to see any of
172 this --- we just want to skip over the stub and the dynamic linker.
173 The simple approach is to single-step until control leaves the
176 However, on some systems (e.g., Red Hat Linux 5.2) the dynamic
177 linker calls functions in the shared C library, so you can't tell
178 from the PC alone whether the dynamic linker is still running. In
179 this case, we use a step-resume breakpoint to get us past the
180 dynamic linker, as if we were using "next" to step over a function
183 IN_SOLIB_DYNSYM_RESOLVE_CODE says whether we're in the dynamic
184 linker code or not. Normally, this means we single-step. However,
185 if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an
186 address where we can place a step-resume breakpoint to get past the
187 linker's symbol resolution function.
189 IN_SOLIB_DYNSYM_RESOLVE_CODE can generally be implemented in a
190 pretty portable way, by comparing the PC against the address ranges
191 of the dynamic linker's sections.
193 SKIP_SOLIB_RESOLVER is generally going to be system-specific, since
194 it depends on internal details of the dynamic linker. It's usually
195 not too hard to figure out where to put a breakpoint, but it
196 certainly isn't portable. SKIP_SOLIB_RESOLVER should do plenty of
197 sanity checking. If it can't figure things out, returning zero and
198 getting the (possibly confusing) stepping behavior is better than
199 signalling an error, which will obscure the change in the
202 #ifndef IN_SOLIB_DYNSYM_RESOLVE_CODE
203 #define IN_SOLIB_DYNSYM_RESOLVE_CODE(pc) 0
206 #ifndef SKIP_SOLIB_RESOLVER
207 #define SKIP_SOLIB_RESOLVER(pc) 0
210 /* For SVR4 shared libraries, each call goes through a small piece of
211 trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates
212 to nonzero if we are current stopped in one of these. */
214 #ifndef IN_SOLIB_CALL_TRAMPOLINE
215 #define IN_SOLIB_CALL_TRAMPOLINE(pc,name) 0
218 /* In some shared library schemes, the return path from a shared library
219 call may need to go through a trampoline too. */
221 #ifndef IN_SOLIB_RETURN_TRAMPOLINE
222 #define IN_SOLIB_RETURN_TRAMPOLINE(pc,name) 0
225 /* This function returns TRUE if pc is the address of an instruction
226 that lies within the dynamic linker (such as the event hook, or the
229 This function must be used only when a dynamic linker event has
230 been caught, and the inferior is being stepped out of the hook, or
231 undefined results are guaranteed. */
233 #ifndef SOLIB_IN_DYNAMIC_LINKER
234 #define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0
237 /* On MIPS16, a function that returns a floating point value may call
238 a library helper function to copy the return value to a floating point
239 register. The IGNORE_HELPER_CALL macro returns non-zero if we
240 should ignore (i.e. step over) this function call. */
241 #ifndef IGNORE_HELPER_CALL
242 #define IGNORE_HELPER_CALL(pc) 0
245 /* On some systems, the PC may be left pointing at an instruction that won't
246 actually be executed. This is usually indicated by a bit in the PSW. If
247 we find ourselves in such a state, then we step the target beyond the
248 nullified instruction before returning control to the user so as to avoid
251 #ifndef INSTRUCTION_NULLIFIED
252 #define INSTRUCTION_NULLIFIED 0
255 /* We can't step off a permanent breakpoint in the ordinary way, because we
256 can't remove it. Instead, we have to advance the PC to the next
257 instruction. This macro should expand to a pointer to a function that
258 does that, or zero if we have no such function. If we don't have a
259 definition for it, we have to report an error. */
260 #ifndef SKIP_PERMANENT_BREAKPOINT
261 #define SKIP_PERMANENT_BREAKPOINT (default_skip_permanent_breakpoint)
263 default_skip_permanent_breakpoint (void)
266 fprintf_filtered (gdb_stderr
, "\
267 The program is stopped at a permanent breakpoint, but GDB does not know\n\
268 how to step past a permanent breakpoint on this architecture. Try using\n\
269 a command like `return' or `jump' to continue execution.\n");
270 return_to_top_level (RETURN_ERROR
);
275 /* Convert the #defines into values. This is temporary until wfi control
276 flow is completely sorted out. */
278 #ifndef HAVE_STEPPABLE_WATCHPOINT
279 #define HAVE_STEPPABLE_WATCHPOINT 0
281 #undef HAVE_STEPPABLE_WATCHPOINT
282 #define HAVE_STEPPABLE_WATCHPOINT 1
285 #ifndef HAVE_NONSTEPPABLE_WATCHPOINT
286 #define HAVE_NONSTEPPABLE_WATCHPOINT 0
288 #undef HAVE_NONSTEPPABLE_WATCHPOINT
289 #define HAVE_NONSTEPPABLE_WATCHPOINT 1
292 #ifndef HAVE_CONTINUABLE_WATCHPOINT
293 #define HAVE_CONTINUABLE_WATCHPOINT 0
295 #undef HAVE_CONTINUABLE_WATCHPOINT
296 #define HAVE_CONTINUABLE_WATCHPOINT 1
299 #ifndef CANNOT_STEP_HW_WATCHPOINTS
300 #define CANNOT_STEP_HW_WATCHPOINTS 0
302 #undef CANNOT_STEP_HW_WATCHPOINTS
303 #define CANNOT_STEP_HW_WATCHPOINTS 1
306 /* Tables of how to react to signals; the user sets them. */
308 static unsigned char *signal_stop
;
309 static unsigned char *signal_print
;
310 static unsigned char *signal_program
;
312 #define SET_SIGS(nsigs,sigs,flags) \
314 int signum = (nsigs); \
315 while (signum-- > 0) \
316 if ((sigs)[signum]) \
317 (flags)[signum] = 1; \
320 #define UNSET_SIGS(nsigs,sigs,flags) \
322 int signum = (nsigs); \
323 while (signum-- > 0) \
324 if ((sigs)[signum]) \
325 (flags)[signum] = 0; \
329 /* Command list pointer for the "stop" placeholder. */
331 static struct cmd_list_element
*stop_command
;
333 /* Nonzero if breakpoints are now inserted in the inferior. */
335 static int breakpoints_inserted
;
337 /* Function inferior was in as of last step command. */
339 static struct symbol
*step_start_function
;
341 /* Nonzero if we are expecting a trace trap and should proceed from it. */
343 static int trap_expected
;
346 /* Nonzero if we want to give control to the user when we're notified
347 of shared library events by the dynamic linker. */
348 static int stop_on_solib_events
;
352 /* Nonzero if the next time we try to continue the inferior, it will
353 step one instruction and generate a spurious trace trap.
354 This is used to compensate for a bug in HP-UX. */
356 static int trap_expected_after_continue
;
359 /* Nonzero means expecting a trace trap
360 and should stop the inferior and return silently when it happens. */
364 /* Nonzero means expecting a trap and caller will handle it themselves.
365 It is used after attach, due to attaching to a process;
366 when running in the shell before the child program has been exec'd;
367 and when running some kinds of remote stuff (FIXME?). */
369 int stop_soon_quietly
;
371 /* Nonzero if proceed is being used for a "finish" command or a similar
372 situation when stop_registers should be saved. */
374 int proceed_to_finish
;
376 /* Save register contents here when about to pop a stack dummy frame,
377 if-and-only-if proceed_to_finish is set.
378 Thus this contains the return value from the called function (assuming
379 values are returned in a register). */
381 char *stop_registers
;
383 /* Nonzero if program stopped due to error trying to insert breakpoints. */
385 static int breakpoints_failed
;
387 /* Nonzero after stop if current stack frame should be printed. */
389 static int stop_print_frame
;
391 static struct breakpoint
*step_resume_breakpoint
= NULL
;
392 static struct breakpoint
*through_sigtramp_breakpoint
= NULL
;
394 /* On some platforms (e.g., HP-UX), hardware watchpoints have bad
395 interactions with an inferior that is running a kernel function
396 (aka, a system call or "syscall"). wait_for_inferior therefore
397 may have a need to know when the inferior is in a syscall. This
398 is a count of the number of inferior threads which are known to
399 currently be running in a syscall. */
400 static int number_of_threads_in_syscalls
;
402 /* This is used to remember when a fork, vfork or exec event
403 was caught by a catchpoint, and thus the event is to be
404 followed at the next resume of the inferior, and not
408 enum target_waitkind kind
;
418 char *execd_pathname
;
422 /* Some platforms don't allow us to do anything meaningful with a
423 vforked child until it has exec'd. Vforked processes on such
424 platforms can only be followed after they've exec'd.
426 When this is set to 0, a vfork can be immediately followed,
427 and an exec can be followed merely as an exec. When this is
428 set to 1, a vfork event has been seen, but cannot be followed
429 until the exec is seen.
431 (In the latter case, inferior_pid is still the parent of the
432 vfork, and pending_follow.fork_event.child_pid is the child. The
433 appropriate process is followed, according to the setting of
434 follow-fork-mode.) */
435 static int follow_vfork_when_exec
;
437 static char *follow_fork_mode_kind_names
[] =
439 /* ??rehrauer: The "both" option is broken, by what may be a 10.20
440 kernel problem. It's also not terribly useful without a GUI to
441 help the user drive two debuggers. So for now, I'm disabling the
443 /* "parent", "child", "both", "ask" */
444 "parent", "child", "ask", NULL
447 static char *follow_fork_mode_string
= NULL
;
451 follow_inferior_fork (int parent_pid
, int child_pid
, int has_forked
,
454 int followed_parent
= 0;
455 int followed_child
= 0;
457 /* Which process did the user want us to follow? */
459 savestring (follow_fork_mode_string
, strlen (follow_fork_mode_string
));
461 /* Or, did the user not know, and want us to ask? */
462 if (STREQ (follow_fork_mode_string
, "ask"))
464 char requested_mode
[100];
467 error ("\"ask\" mode NYI");
468 follow_mode
= savestring (requested_mode
, strlen (requested_mode
));
471 /* If we're to be following the parent, then detach from child_pid.
472 We're already following the parent, so need do nothing explicit
474 if (STREQ (follow_mode
, "parent"))
478 /* We're already attached to the parent, by default. */
480 /* Before detaching from the child, remove all breakpoints from
481 it. (This won't actually modify the breakpoint list, but will
482 physically remove the breakpoints from the child.) */
483 if (!has_vforked
|| !follow_vfork_when_exec
)
485 detach_breakpoints (child_pid
);
486 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
487 SOLIB_REMOVE_INFERIOR_HOOK (child_pid
);
491 /* Detach from the child. */
494 target_require_detach (child_pid
, "", 1);
497 /* If we're to be following the child, then attach to it, detach
498 from inferior_pid, and set inferior_pid to child_pid. */
499 else if (STREQ (follow_mode
, "child"))
501 char child_pid_spelling
[100]; /* Arbitrary length. */
505 /* Before detaching from the parent, detach all breakpoints from
506 the child. But only if we're forking, or if we follow vforks
507 as soon as they happen. (If we're following vforks only when
508 the child has exec'd, then it's very wrong to try to write
509 back the "shadow contents" of inserted breakpoints now -- they
510 belong to the child's pre-exec'd a.out.) */
511 if (!has_vforked
|| !follow_vfork_when_exec
)
513 detach_breakpoints (child_pid
);
516 /* Before detaching from the parent, remove all breakpoints from it. */
517 remove_breakpoints ();
519 /* Also reset the solib inferior hook from the parent. */
520 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
521 SOLIB_REMOVE_INFERIOR_HOOK (inferior_pid
);
524 /* Detach from the parent. */
526 target_detach (NULL
, 1);
528 /* Attach to the child. */
529 inferior_pid
= child_pid
;
530 sprintf (child_pid_spelling
, "%d", child_pid
);
533 target_require_attach (child_pid_spelling
, 1);
535 /* Was there a step_resume breakpoint? (There was if the user
536 did a "next" at the fork() call.) If so, explicitly reset its
539 step_resumes are a form of bp that are made to be per-thread.
540 Since we created the step_resume bp when the parent process
541 was being debugged, and now are switching to the child process,
542 from the breakpoint package's viewpoint, that's a switch of
543 "threads". We must update the bp's notion of which thread
544 it is for, or it'll be ignored when it triggers... */
545 if (step_resume_breakpoint
&&
546 (!has_vforked
|| !follow_vfork_when_exec
))
547 breakpoint_re_set_thread (step_resume_breakpoint
);
549 /* Reinsert all breakpoints in the child. (The user may've set
550 breakpoints after catching the fork, in which case those
551 actually didn't get set in the child, but only in the parent.) */
552 if (!has_vforked
|| !follow_vfork_when_exec
)
554 breakpoint_re_set ();
555 insert_breakpoints ();
559 /* If we're to be following both parent and child, then fork ourselves,
560 and attach the debugger clone to the child. */
561 else if (STREQ (follow_mode
, "both"))
563 char pid_suffix
[100]; /* Arbitrary length. */
565 /* Clone ourselves to follow the child. This is the end of our
566 involvement with child_pid; our clone will take it from here... */
568 target_clone_and_follow_inferior (child_pid
, &followed_child
);
569 followed_parent
= !followed_child
;
571 /* We continue to follow the parent. To help distinguish the two
572 debuggers, though, both we and our clone will reset our prompts. */
573 sprintf (pid_suffix
, "[%d] ", inferior_pid
);
574 set_prompt (strcat (get_prompt (), pid_suffix
));
577 /* The parent and child of a vfork share the same address space.
578 Also, on some targets the order in which vfork and exec events
579 are received for parent in child requires some delicate handling
582 For instance, on ptrace-based HPUX we receive the child's vfork
583 event first, at which time the parent has been suspended by the
584 OS and is essentially untouchable until the child's exit or second
585 exec event arrives. At that time, the parent's vfork event is
586 delivered to us, and that's when we see and decide how to follow
587 the vfork. But to get to that point, we must continue the child
588 until it execs or exits. To do that smoothly, all breakpoints
589 must be removed from the child, in case there are any set between
590 the vfork() and exec() calls. But removing them from the child
591 also removes them from the parent, due to the shared-address-space
592 nature of a vfork'd parent and child. On HPUX, therefore, we must
593 take care to restore the bp's to the parent before we continue it.
594 Else, it's likely that we may not stop in the expected place. (The
595 worst scenario is when the user tries to step over a vfork() call;
596 the step-resume bp must be restored for the step to properly stop
597 in the parent after the call completes!)
599 Sequence of events, as reported to gdb from HPUX:
601 Parent Child Action for gdb to take
602 -------------------------------------------------------
603 1 VFORK Continue child
609 target_post_follow_vfork (parent_pid
,
615 pending_follow
.fork_event
.saw_parent_fork
= 0;
616 pending_follow
.fork_event
.saw_child_fork
= 0;
622 follow_fork (int parent_pid
, int child_pid
)
624 follow_inferior_fork (parent_pid
, child_pid
, 1, 0);
628 /* Forward declaration. */
629 static void follow_exec (int, char *);
632 follow_vfork (int parent_pid
, int child_pid
)
634 follow_inferior_fork (parent_pid
, child_pid
, 0, 1);
636 /* Did we follow the child? Had it exec'd before we saw the parent vfork? */
637 if (pending_follow
.fork_event
.saw_child_exec
&& (inferior_pid
== child_pid
))
639 pending_follow
.fork_event
.saw_child_exec
= 0;
640 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
641 follow_exec (inferior_pid
, pending_follow
.execd_pathname
);
642 free (pending_follow
.execd_pathname
);
647 follow_exec (int pid
, char *execd_pathname
)
650 struct target_ops
*tgt
;
652 if (!may_follow_exec
)
655 /* Did this exec() follow a vfork()? If so, we must follow the
656 vfork now too. Do it before following the exec. */
657 if (follow_vfork_when_exec
&&
658 (pending_follow
.kind
== TARGET_WAITKIND_VFORKED
))
660 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
661 follow_vfork (inferior_pid
, pending_follow
.fork_event
.child_pid
);
662 follow_vfork_when_exec
= 0;
663 saved_pid
= inferior_pid
;
665 /* Did we follow the parent? If so, we're done. If we followed
666 the child then we must also follow its exec(). */
667 if (inferior_pid
== pending_follow
.fork_event
.parent_pid
)
671 /* This is an exec event that we actually wish to pay attention to.
672 Refresh our symbol table to the newly exec'd program, remove any
675 If there are breakpoints, they aren't really inserted now,
676 since the exec() transformed our inferior into a fresh set
679 We want to preserve symbolic breakpoints on the list, since
680 we have hopes that they can be reset after the new a.out's
681 symbol table is read.
683 However, any "raw" breakpoints must be removed from the list
684 (e.g., the solib bp's), since their address is probably invalid
687 And, we DON'T want to call delete_breakpoints() here, since
688 that may write the bp's "shadow contents" (the instruction
689 value that was overwritten witha TRAP instruction). Since
690 we now have a new a.out, those shadow contents aren't valid. */
691 update_breakpoints_after_exec ();
693 /* If there was one, it's gone now. We cannot truly step-to-next
694 statement through an exec(). */
695 step_resume_breakpoint
= NULL
;
696 step_range_start
= 0;
699 /* If there was one, it's gone now. */
700 through_sigtramp_breakpoint
= NULL
;
702 /* What is this a.out's name? */
703 printf_unfiltered ("Executing new program: %s\n", execd_pathname
);
705 /* We've followed the inferior through an exec. Therefore, the
706 inferior has essentially been killed & reborn. */
708 /* First collect the run target in effect. */
709 tgt
= find_run_target ();
710 /* If we can't find one, things are in a very strange state... */
712 error ("Could find run target to save before following exec");
714 gdb_flush (gdb_stdout
);
715 target_mourn_inferior ();
716 inferior_pid
= saved_pid
; /* Because mourn_inferior resets inferior_pid. */
719 /* That a.out is now the one to use. */
720 exec_file_attach (execd_pathname
, 0);
722 /* And also is where symbols can be found. */
723 symbol_file_command (execd_pathname
, 0);
725 /* Reset the shared library package. This ensures that we get
726 a shlib event when the child reaches "_start", at which point
727 the dld will have had a chance to initialize the child. */
728 #if defined(SOLIB_RESTART)
731 #ifdef SOLIB_CREATE_INFERIOR_HOOK
732 SOLIB_CREATE_INFERIOR_HOOK (inferior_pid
);
735 /* Reinsert all breakpoints. (Those which were symbolic have
736 been reset to the proper address in the new a.out, thanks
737 to symbol_file_command...) */
738 insert_breakpoints ();
740 /* The next resume of this inferior should bring it to the shlib
741 startup breakpoints. (If the user had also set bp's on
742 "main" from the old (parent) process, then they'll auto-
743 matically get reset there in the new process.) */
746 /* Non-zero if we just simulating a single-step. This is needed
747 because we cannot remove the breakpoints in the inferior process
748 until after the `wait' in `wait_for_inferior'. */
749 static int singlestep_breakpoints_inserted_p
= 0;
752 /* Things to clean up if we QUIT out of resume (). */
755 resume_cleanups (int arg
)
760 static char schedlock_off
[] = "off";
761 static char schedlock_on
[] = "on";
762 static char schedlock_step
[] = "step";
763 static char *scheduler_mode
= schedlock_off
;
764 static char *scheduler_enums
[] =
773 set_schedlock_func (char *args
, int from_tty
, struct cmd_list_element
*c
)
775 if (c
->type
== set_cmd
)
776 if (!target_can_lock_scheduler
)
778 scheduler_mode
= schedlock_off
;
779 error ("Target '%s' cannot support this command.",
787 /* Resume the inferior, but allow a QUIT. This is useful if the user
788 wants to interrupt some lengthy single-stepping operation
789 (for child processes, the SIGINT goes to the inferior, and so
790 we get a SIGINT random_signal, but for remote debugging and perhaps
791 other targets, that's not true).
793 STEP nonzero if we should step (zero to continue instead).
794 SIG is the signal to give the inferior (zero for none). */
796 resume (int step
, enum target_signal sig
)
798 int should_resume
= 1;
799 struct cleanup
*old_cleanups
= make_cleanup ((make_cleanup_func
)
803 #ifdef CANNOT_STEP_BREAKPOINT
804 /* Most targets can step a breakpoint instruction, thus executing it
805 normally. But if this one cannot, just continue and we will hit
807 if (step
&& breakpoints_inserted
&& breakpoint_here_p (read_pc ()))
811 /* Some targets (e.g. Solaris x86) have a kernel bug when stepping
812 over an instruction that causes a page fault without triggering
813 a hardware watchpoint. The kernel properly notices that it shouldn't
814 stop, because the hardware watchpoint is not triggered, but it forgets
815 the step request and continues the program normally.
816 Work around the problem by removing hardware watchpoints if a step is
817 requested, GDB will check for a hardware watchpoint trigger after the
819 if (CANNOT_STEP_HW_WATCHPOINTS
&& step
&& breakpoints_inserted
)
820 remove_hw_watchpoints ();
823 /* Normally, by the time we reach `resume', the breakpoints are either
824 removed or inserted, as appropriate. The exception is if we're sitting
825 at a permanent breakpoint; we need to step over it, but permanent
826 breakpoints can't be removed. So we have to test for it here. */
827 if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here
)
828 SKIP_PERMANENT_BREAKPOINT ();
830 if (SOFTWARE_SINGLE_STEP_P
&& step
)
832 /* Do it the hard way, w/temp breakpoints */
833 SOFTWARE_SINGLE_STEP (sig
, 1 /*insert-breakpoints */ );
834 /* ...and don't ask hardware to do it. */
836 /* and do not pull these breakpoints until after a `wait' in
837 `wait_for_inferior' */
838 singlestep_breakpoints_inserted_p
= 1;
841 /* Handle any optimized stores to the inferior NOW... */
842 #ifdef DO_DEFERRED_STORES
846 /* If there were any forks/vforks/execs that were caught and are
847 now to be followed, then do so. */
848 switch (pending_follow
.kind
)
850 case (TARGET_WAITKIND_FORKED
):
851 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
852 follow_fork (inferior_pid
, pending_follow
.fork_event
.child_pid
);
855 case (TARGET_WAITKIND_VFORKED
):
857 int saw_child_exec
= pending_follow
.fork_event
.saw_child_exec
;
859 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
860 follow_vfork (inferior_pid
, pending_follow
.fork_event
.child_pid
);
862 /* Did we follow the child, but not yet see the child's exec event?
863 If so, then it actually ought to be waiting for us; we respond to
864 parent vfork events. We don't actually want to resume the child
865 in this situation; we want to just get its exec event. */
866 if (!saw_child_exec
&&
867 (inferior_pid
== pending_follow
.fork_event
.child_pid
))
872 case (TARGET_WAITKIND_EXECD
):
873 /* If we saw a vfork event but couldn't follow it until we saw
874 an exec, then now might be the time! */
875 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
876 /* follow_exec is called as soon as the exec event is seen. */
883 /* Install inferior's terminal modes. */
884 target_terminal_inferior ();
890 if (use_thread_step_needed
&& thread_step_needed
)
892 /* We stopped on a BPT instruction;
893 don't continue other threads and
894 just step this thread. */
895 thread_step_needed
= 0;
897 if (!breakpoint_here_p (read_pc ()))
899 /* Breakpoint deleted: ok to do regular resume
900 where all the threads either step or continue. */
907 warning ("Internal error, changing continue to step.");
908 remove_breakpoints ();
909 breakpoints_inserted
= 0;
913 resume_pid
= inferior_pid
;
918 /* Vanilla resume. */
919 if ((scheduler_mode
== schedlock_on
) ||
920 (scheduler_mode
== schedlock_step
&& step
!= 0))
921 resume_pid
= inferior_pid
;
925 target_resume (resume_pid
, step
, sig
);
928 discard_cleanups (old_cleanups
);
932 /* Clear out all variables saying what to do when inferior is continued.
933 First do this, then set the ones you want, then call `proceed'. */
936 clear_proceed_status (void)
939 step_range_start
= 0;
941 step_frame_address
= 0;
942 step_over_calls
= -1;
944 stop_soon_quietly
= 0;
945 proceed_to_finish
= 0;
946 breakpoint_proceeded
= 1; /* We're about to proceed... */
948 /* Discard any remaining commands or status from previous stop. */
949 bpstat_clear (&stop_bpstat
);
952 /* Basic routine for continuing the program in various fashions.
954 ADDR is the address to resume at, or -1 for resume where stopped.
955 SIGGNAL is the signal to give it, or 0 for none,
956 or -1 for act according to how it stopped.
957 STEP is nonzero if should trap after one instruction.
958 -1 means return after that and print nothing.
959 You should probably set various step_... variables
960 before calling here, if you are stepping.
962 You should call clear_proceed_status before calling proceed. */
965 proceed (CORE_ADDR addr
, enum target_signal siggnal
, int step
)
970 step_start_function
= find_pc_function (read_pc ());
974 if (addr
== (CORE_ADDR
) -1)
976 /* If there is a breakpoint at the address we will resume at,
977 step one instruction before inserting breakpoints
978 so that we do not stop right away (and report a second
979 hit at this breakpoint). */
981 if (read_pc () == stop_pc
&& breakpoint_here_p (read_pc ()))
984 #ifndef STEP_SKIPS_DELAY
985 #define STEP_SKIPS_DELAY(pc) (0)
986 #define STEP_SKIPS_DELAY_P (0)
988 /* Check breakpoint_here_p first, because breakpoint_here_p is fast
989 (it just checks internal GDB data structures) and STEP_SKIPS_DELAY
990 is slow (it needs to read memory from the target). */
991 if (STEP_SKIPS_DELAY_P
992 && breakpoint_here_p (read_pc () + 4)
993 && STEP_SKIPS_DELAY (read_pc ()))
1000 /* New address; we don't need to single-step a thread
1001 over a breakpoint we just hit, 'cause we aren't
1002 continuing from there.
1004 It's not worth worrying about the case where a user
1005 asks for a "jump" at the current PC--if they get the
1006 hiccup of re-hiting a hit breakpoint, what else do
1008 thread_step_needed
= 0;
1011 #ifdef PREPARE_TO_PROCEED
1012 /* In a multi-threaded task we may select another thread
1013 and then continue or step.
1015 But if the old thread was stopped at a breakpoint, it
1016 will immediately cause another breakpoint stop without
1017 any execution (i.e. it will report a breakpoint hit
1018 incorrectly). So we must step over it first.
1020 PREPARE_TO_PROCEED checks the current thread against the thread
1021 that reported the most recent event. If a step-over is required
1022 it returns TRUE and sets the current thread to the old thread. */
1023 if (PREPARE_TO_PROCEED (1) && breakpoint_here_p (read_pc ()))
1026 thread_step_needed
= 1;
1029 #endif /* PREPARE_TO_PROCEED */
1032 if (trap_expected_after_continue
)
1034 /* If (step == 0), a trap will be automatically generated after
1035 the first instruction is executed. Force step one
1036 instruction to clear this condition. This should not occur
1037 if step is nonzero, but it is harmless in that case. */
1039 trap_expected_after_continue
= 0;
1041 #endif /* HP_OS_BUG */
1044 /* We will get a trace trap after one instruction.
1045 Continue it automatically and insert breakpoints then. */
1049 int temp
= insert_breakpoints ();
1052 print_sys_errmsg ("insert_breakpoints", temp
);
1053 error ("Cannot insert breakpoints.\n\
1054 The same program may be running in another process,\n\
1055 or you may have requested too many hardware\n\
1056 breakpoints and/or watchpoints.\n");
1059 breakpoints_inserted
= 1;
1062 if (siggnal
!= TARGET_SIGNAL_DEFAULT
)
1063 stop_signal
= siggnal
;
1064 /* If this signal should not be seen by program,
1065 give it zero. Used for debugging signals. */
1066 else if (!signal_program
[stop_signal
])
1067 stop_signal
= TARGET_SIGNAL_0
;
1069 annotate_starting ();
1071 /* Make sure that output from GDB appears before output from the
1073 gdb_flush (gdb_stdout
);
1075 /* Resume inferior. */
1076 resume (oneproc
|| step
|| bpstat_should_step (), stop_signal
);
1078 /* Wait for it to stop (if not standalone)
1079 and in any case decode why it stopped, and act accordingly. */
1080 /* Do this only if we are not using the event loop, or if the target
1081 does not support asynchronous execution. */
1082 if (!event_loop_p
|| !target_can_async_p ())
1084 wait_for_inferior ();
1089 /* Record the pc and sp of the program the last time it stopped.
1090 These are just used internally by wait_for_inferior, but need
1091 to be preserved over calls to it and cleared when the inferior
1093 static CORE_ADDR prev_pc
;
1094 static CORE_ADDR prev_func_start
;
1095 static char *prev_func_name
;
1098 /* Start remote-debugging of a machine over a serial link. */
1103 init_thread_list ();
1104 init_wait_for_inferior ();
1105 stop_soon_quietly
= 1;
1108 /* Always go on waiting for the target, regardless of the mode. */
1109 /* FIXME: cagney/1999-09-23: At present it isn't possible to
1110 indicate th wait_for_inferior that a target should timeout if
1111 nothing is returned (instead of just blocking). Because of this,
1112 targets expecting an immediate response need to, internally, set
1113 things up so that the target_wait() is forced to eventually
1115 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
1116 differentiate to its caller what the state of the target is after
1117 the initial open has been performed. Here we're assuming that
1118 the target has stopped. It should be possible to eventually have
1119 target_open() return to the caller an indication that the target
1120 is currently running and GDB state should be set to the same as
1121 for an async run. */
1122 wait_for_inferior ();
1126 /* Initialize static vars when a new inferior begins. */
1129 init_wait_for_inferior (void)
1131 /* These are meaningless until the first time through wait_for_inferior. */
1133 prev_func_start
= 0;
1134 prev_func_name
= NULL
;
1137 trap_expected_after_continue
= 0;
1139 breakpoints_inserted
= 0;
1140 breakpoint_init_inferior (inf_starting
);
1142 /* Don't confuse first call to proceed(). */
1143 stop_signal
= TARGET_SIGNAL_0
;
1145 /* The first resume is not following a fork/vfork/exec. */
1146 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
; /* I.e., none. */
1147 pending_follow
.fork_event
.saw_parent_fork
= 0;
1148 pending_follow
.fork_event
.saw_child_fork
= 0;
1149 pending_follow
.fork_event
.saw_child_exec
= 0;
1151 /* See wait_for_inferior's handling of SYSCALL_ENTRY/RETURN events. */
1152 number_of_threads_in_syscalls
= 0;
1154 clear_proceed_status ();
1158 delete_breakpoint_current_contents (void *arg
)
1160 struct breakpoint
**breakpointp
= (struct breakpoint
**) arg
;
1161 if (*breakpointp
!= NULL
)
1163 delete_breakpoint (*breakpointp
);
1164 *breakpointp
= NULL
;
1168 /* This enum encodes possible reasons for doing a target_wait, so that
1169 wfi can call target_wait in one place. (Ultimately the call will be
1170 moved out of the infinite loop entirely.) */
1174 infwait_normal_state
,
1175 infwait_thread_hop_state
,
1176 infwait_nullified_state
,
1177 infwait_nonstep_watch_state
1180 /* Why did the inferior stop? Used to print the appropriate messages
1181 to the interface from within handle_inferior_event(). */
1182 enum inferior_stop_reason
1184 /* We don't know why. */
1186 /* Step, next, nexti, stepi finished. */
1188 /* Found breakpoint. */
1190 /* Inferior terminated by signal. */
1192 /* Inferior exited. */
1194 /* Inferior received signal, and user asked to be notified. */
1198 /* This structure contains what used to be local variables in
1199 wait_for_inferior. Probably many of them can return to being
1200 locals in handle_inferior_event. */
1202 struct execution_control_state
1204 struct target_waitstatus ws
;
1205 struct target_waitstatus
*wp
;
1208 CORE_ADDR stop_func_start
;
1209 CORE_ADDR stop_func_end
;
1210 char *stop_func_name
;
1211 struct symtab_and_line sal
;
1212 int remove_breakpoints_on_following_step
;
1214 struct symtab
*current_symtab
;
1215 int handling_longjmp
; /* FIXME */
1217 int saved_inferior_pid
;
1219 int stepping_through_solib_after_catch
;
1220 bpstat stepping_through_solib_catchpoints
;
1221 int enable_hw_watchpoints_after_wait
;
1222 int stepping_through_sigtramp
;
1223 int new_thread_event
;
1224 struct target_waitstatus tmpstatus
;
1225 enum infwait_states infwait_state
;
1230 void init_execution_control_state (struct execution_control_state
* ecs
);
1232 void handle_inferior_event (struct execution_control_state
* ecs
);
1234 static void check_sigtramp2 (struct execution_control_state
*ecs
);
1235 static void step_into_function (struct execution_control_state
*ecs
);
1236 static void step_over_function (struct execution_control_state
*ecs
);
1237 static void stop_stepping (struct execution_control_state
*ecs
);
1238 static void prepare_to_wait (struct execution_control_state
*ecs
);
1239 static void keep_going (struct execution_control_state
*ecs
);
1240 static void print_stop_reason (enum inferior_stop_reason stop_reason
, int stop_info
);
1242 /* Wait for control to return from inferior to debugger.
1243 If inferior gets a signal, we may decide to start it up again
1244 instead of returning. That is why there is a loop in this function.
1245 When this function actually returns it means the inferior
1246 should be left stopped and GDB should read more commands. */
1249 wait_for_inferior (void)
1251 struct cleanup
*old_cleanups
;
1252 struct execution_control_state ecss
;
1253 struct execution_control_state
*ecs
;
1255 old_cleanups
= make_cleanup (delete_breakpoint_current_contents
,
1256 &step_resume_breakpoint
);
1257 make_cleanup (delete_breakpoint_current_contents
,
1258 &through_sigtramp_breakpoint
);
1260 /* wfi still stays in a loop, so it's OK just to take the address of
1261 a local to get the ecs pointer. */
1264 /* Fill in with reasonable starting values. */
1265 init_execution_control_state (ecs
);
1267 thread_step_needed
= 0;
1269 /* We'll update this if & when we switch to a new thread. */
1270 previous_inferior_pid
= inferior_pid
;
1272 overlay_cache_invalid
= 1;
1274 /* We have to invalidate the registers BEFORE calling target_wait
1275 because they can be loaded from the target while in target_wait.
1276 This makes remote debugging a bit more efficient for those
1277 targets that provide critical registers as part of their normal
1278 status mechanism. */
1280 registers_changed ();
1284 if (target_wait_hook
)
1285 ecs
->pid
= target_wait_hook (ecs
->waiton_pid
, ecs
->wp
);
1287 ecs
->pid
= target_wait (ecs
->waiton_pid
, ecs
->wp
);
1289 /* Now figure out what to do with the result of the result. */
1290 handle_inferior_event (ecs
);
1292 if (!ecs
->wait_some_more
)
1295 do_cleanups (old_cleanups
);
1298 /* Asynchronous version of wait_for_inferior. It is called by the
1299 event loop whenever a change of state is detected on the file
1300 descriptor corresponding to the target. It can be called more than
1301 once to complete a single execution command. In such cases we need
1302 to keep the state in a global variable ASYNC_ECSS. If it is the
1303 last time that this function is called for a single execution
1304 command, then report to the user that the inferior has stopped, and
1305 do the necessary cleanups. */
1307 struct execution_control_state async_ecss
;
1308 struct execution_control_state
*async_ecs
;
1311 fetch_inferior_event (client_data
)
1314 static struct cleanup
*old_cleanups
;
1316 async_ecs
= &async_ecss
;
1318 if (!async_ecs
->wait_some_more
)
1320 old_cleanups
= make_exec_cleanup (delete_breakpoint_current_contents
,
1321 &step_resume_breakpoint
);
1322 make_exec_cleanup (delete_breakpoint_current_contents
,
1323 &through_sigtramp_breakpoint
);
1325 /* Fill in with reasonable starting values. */
1326 init_execution_control_state (async_ecs
);
1328 thread_step_needed
= 0;
1330 /* We'll update this if & when we switch to a new thread. */
1331 previous_inferior_pid
= inferior_pid
;
1333 overlay_cache_invalid
= 1;
1335 /* We have to invalidate the registers BEFORE calling target_wait
1336 because they can be loaded from the target while in target_wait.
1337 This makes remote debugging a bit more efficient for those
1338 targets that provide critical registers as part of their normal
1339 status mechanism. */
1341 registers_changed ();
1344 if (target_wait_hook
)
1345 async_ecs
->pid
= target_wait_hook (async_ecs
->waiton_pid
, async_ecs
->wp
);
1347 async_ecs
->pid
= target_wait (async_ecs
->waiton_pid
, async_ecs
->wp
);
1349 /* Now figure out what to do with the result of the result. */
1350 handle_inferior_event (async_ecs
);
1352 if (!async_ecs
->wait_some_more
)
1354 /* Do only the cleanups that have been added by this
1355 function. Let the continuations for the commands do the rest,
1356 if there are any. */
1357 do_exec_cleanups (old_cleanups
);
1359 if (step_multi
&& stop_step
)
1360 inferior_event_handler (INF_EXEC_CONTINUE
, NULL
);
1362 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
1366 /* Prepare an execution control state for looping through a
1367 wait_for_inferior-type loop. */
1370 init_execution_control_state (struct execution_control_state
*ecs
)
1372 /* ecs->another_trap? */
1373 ecs
->random_signal
= 0;
1374 ecs
->remove_breakpoints_on_following_step
= 0;
1375 ecs
->handling_longjmp
= 0; /* FIXME */
1376 ecs
->update_step_sp
= 0;
1377 ecs
->stepping_through_solib_after_catch
= 0;
1378 ecs
->stepping_through_solib_catchpoints
= NULL
;
1379 ecs
->enable_hw_watchpoints_after_wait
= 0;
1380 ecs
->stepping_through_sigtramp
= 0;
1381 ecs
->sal
= find_pc_line (prev_pc
, 0);
1382 ecs
->current_line
= ecs
->sal
.line
;
1383 ecs
->current_symtab
= ecs
->sal
.symtab
;
1384 ecs
->infwait_state
= infwait_normal_state
;
1385 ecs
->waiton_pid
= -1;
1386 ecs
->wp
= &(ecs
->ws
);
1389 /* Call this function before setting step_resume_breakpoint, as a
1390 sanity check. There should never be more than one step-resume
1391 breakpoint per thread, so we should never be setting a new
1392 step_resume_breakpoint when one is already active. */
1394 check_for_old_step_resume_breakpoint (void)
1396 if (step_resume_breakpoint
)
1397 warning ("GDB bug: infrun.c (wait_for_inferior): dropping old step_resume breakpoint");
1400 /* Given an execution control state that has been freshly filled in
1401 by an event from the inferior, figure out what it means and take
1402 appropriate action. */
1405 handle_inferior_event (struct execution_control_state
*ecs
)
1408 int stepped_after_stopped_by_watchpoint
;
1410 /* Keep this extra brace for now, minimizes diffs. */
1412 switch (ecs
->infwait_state
)
1414 case infwait_normal_state
:
1415 /* Since we've done a wait, we have a new event. Don't
1416 carry over any expectations about needing to step over a
1418 thread_step_needed
= 0;
1420 /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event
1421 is serviced in this loop, below. */
1422 if (ecs
->enable_hw_watchpoints_after_wait
)
1424 TARGET_ENABLE_HW_WATCHPOINTS (inferior_pid
);
1425 ecs
->enable_hw_watchpoints_after_wait
= 0;
1427 stepped_after_stopped_by_watchpoint
= 0;
1430 case infwait_thread_hop_state
:
1431 insert_breakpoints ();
1433 /* We need to restart all the threads now,
1434 * unles we're running in scheduler-locked mode.
1435 * FIXME: shouldn't we look at currently_stepping ()?
1437 if (scheduler_mode
== schedlock_on
)
1438 target_resume (ecs
->pid
, 0, TARGET_SIGNAL_0
);
1440 target_resume (-1, 0, TARGET_SIGNAL_0
);
1441 ecs
->infwait_state
= infwait_normal_state
;
1442 prepare_to_wait (ecs
);
1445 case infwait_nullified_state
:
1448 case infwait_nonstep_watch_state
:
1449 insert_breakpoints ();
1451 /* FIXME-maybe: is this cleaner than setting a flag? Does it
1452 handle things like signals arriving and other things happening
1453 in combination correctly? */
1454 stepped_after_stopped_by_watchpoint
= 1;
1457 ecs
->infwait_state
= infwait_normal_state
;
1459 flush_cached_frames ();
1461 /* If it's a new process, add it to the thread database */
1463 ecs
->new_thread_event
= ((ecs
->pid
!= inferior_pid
) && !in_thread_list (ecs
->pid
));
1465 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
1466 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
1467 && ecs
->new_thread_event
)
1469 add_thread (ecs
->pid
);
1472 ui_out_text (uiout
, "[New ");
1473 ui_out_text (uiout
, target_pid_or_tid_to_str (ecs
->pid
));
1474 ui_out_text (uiout
, "]\n");
1476 printf_filtered ("[New %s]\n", target_pid_or_tid_to_str (ecs
->pid
));
1480 /* NOTE: This block is ONLY meant to be invoked in case of a
1481 "thread creation event"! If it is invoked for any other
1482 sort of event (such as a new thread landing on a breakpoint),
1483 the event will be discarded, which is almost certainly
1486 To avoid this, the low-level module (eg. target_wait)
1487 should call in_thread_list and add_thread, so that the
1488 new thread is known by the time we get here. */
1490 /* We may want to consider not doing a resume here in order
1491 to give the user a chance to play with the new thread.
1492 It might be good to make that a user-settable option. */
1494 /* At this point, all threads are stopped (happens
1495 automatically in either the OS or the native code).
1496 Therefore we need to continue all threads in order to
1499 target_resume (-1, 0, TARGET_SIGNAL_0
);
1500 prepare_to_wait (ecs
);
1505 switch (ecs
->ws
.kind
)
1507 case TARGET_WAITKIND_LOADED
:
1508 /* Ignore gracefully during startup of the inferior, as it
1509 might be the shell which has just loaded some objects,
1510 otherwise add the symbols for the newly loaded objects. */
1512 if (!stop_soon_quietly
)
1514 /* Remove breakpoints, SOLIB_ADD might adjust
1515 breakpoint addresses via breakpoint_re_set. */
1516 if (breakpoints_inserted
)
1517 remove_breakpoints ();
1519 /* Check for any newly added shared libraries if we're
1520 supposed to be adding them automatically. */
1523 /* Switch terminal for any messages produced by
1524 breakpoint_re_set. */
1525 target_terminal_ours_for_output ();
1526 SOLIB_ADD (NULL
, 0, NULL
);
1527 target_terminal_inferior ();
1530 /* Reinsert breakpoints and continue. */
1531 if (breakpoints_inserted
)
1532 insert_breakpoints ();
1535 resume (0, TARGET_SIGNAL_0
);
1536 prepare_to_wait (ecs
);
1539 case TARGET_WAITKIND_SPURIOUS
:
1540 resume (0, TARGET_SIGNAL_0
);
1541 prepare_to_wait (ecs
);
1544 case TARGET_WAITKIND_EXITED
:
1545 target_terminal_ours (); /* Must do this before mourn anyway */
1546 print_stop_reason (EXITED
, ecs
->ws
.value
.integer
);
1548 /* Record the exit code in the convenience variable $_exitcode, so
1549 that the user can inspect this again later. */
1550 set_internalvar (lookup_internalvar ("_exitcode"),
1551 value_from_longest (builtin_type_int
,
1552 (LONGEST
) ecs
->ws
.value
.integer
));
1553 gdb_flush (gdb_stdout
);
1554 target_mourn_inferior ();
1555 singlestep_breakpoints_inserted_p
= 0; /*SOFTWARE_SINGLE_STEP_P */
1556 stop_print_frame
= 0;
1557 stop_stepping (ecs
);
1560 case TARGET_WAITKIND_SIGNALLED
:
1561 stop_print_frame
= 0;
1562 stop_signal
= ecs
->ws
.value
.sig
;
1563 target_terminal_ours (); /* Must do this before mourn anyway */
1565 /* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't
1566 reach here unless the inferior is dead. However, for years
1567 target_kill() was called here, which hints that fatal signals aren't
1568 really fatal on some systems. If that's true, then some changes
1570 target_mourn_inferior ();
1572 print_stop_reason (SIGNAL_EXITED
, stop_signal
);
1573 singlestep_breakpoints_inserted_p
= 0; /*SOFTWARE_SINGLE_STEP_P */
1574 stop_stepping (ecs
);
1577 /* The following are the only cases in which we keep going;
1578 the above cases end in a continue or goto. */
1579 case TARGET_WAITKIND_FORKED
:
1580 stop_signal
= TARGET_SIGNAL_TRAP
;
1581 pending_follow
.kind
= ecs
->ws
.kind
;
1583 /* Ignore fork events reported for the parent; we're only
1584 interested in reacting to forks of the child. Note that
1585 we expect the child's fork event to be available if we
1586 waited for it now. */
1587 if (inferior_pid
== ecs
->pid
)
1589 pending_follow
.fork_event
.saw_parent_fork
= 1;
1590 pending_follow
.fork_event
.parent_pid
= ecs
->pid
;
1591 pending_follow
.fork_event
.child_pid
= ecs
->ws
.value
.related_pid
;
1592 prepare_to_wait (ecs
);
1597 pending_follow
.fork_event
.saw_child_fork
= 1;
1598 pending_follow
.fork_event
.child_pid
= ecs
->pid
;
1599 pending_follow
.fork_event
.parent_pid
= ecs
->ws
.value
.related_pid
;
1602 stop_pc
= read_pc_pid (ecs
->pid
);
1603 ecs
->saved_inferior_pid
= inferior_pid
;
1604 inferior_pid
= ecs
->pid
;
1605 stop_bpstat
= bpstat_stop_status (&stop_pc
, currently_stepping (ecs
));
1606 ecs
->random_signal
= !bpstat_explains_signal (stop_bpstat
);
1607 inferior_pid
= ecs
->saved_inferior_pid
;
1608 goto process_event_stop_test
;
1610 /* If this a platform which doesn't allow a debugger to touch a
1611 vfork'd inferior until after it exec's, then we'd best keep
1612 our fingers entirely off the inferior, other than continuing
1613 it. This has the unfortunate side-effect that catchpoints
1614 of vforks will be ignored. But since the platform doesn't
1615 allow the inferior be touched at vfork time, there's really
1617 case TARGET_WAITKIND_VFORKED
:
1618 stop_signal
= TARGET_SIGNAL_TRAP
;
1619 pending_follow
.kind
= ecs
->ws
.kind
;
1621 /* Is this a vfork of the parent? If so, then give any
1622 vfork catchpoints a chance to trigger now. (It's
1623 dangerous to do so if the child canot be touched until
1624 it execs, and the child has not yet exec'd. We probably
1625 should warn the user to that effect when the catchpoint
1627 if (ecs
->pid
== inferior_pid
)
1629 pending_follow
.fork_event
.saw_parent_fork
= 1;
1630 pending_follow
.fork_event
.parent_pid
= ecs
->pid
;
1631 pending_follow
.fork_event
.child_pid
= ecs
->ws
.value
.related_pid
;
1634 /* If we've seen the child's vfork event but cannot really touch
1635 the child until it execs, then we must continue the child now.
1636 Else, give any vfork catchpoints a chance to trigger now. */
1639 pending_follow
.fork_event
.saw_child_fork
= 1;
1640 pending_follow
.fork_event
.child_pid
= ecs
->pid
;
1641 pending_follow
.fork_event
.parent_pid
= ecs
->ws
.value
.related_pid
;
1642 target_post_startup_inferior (pending_follow
.fork_event
.child_pid
);
1643 follow_vfork_when_exec
= !target_can_follow_vfork_prior_to_exec ();
1644 if (follow_vfork_when_exec
)
1646 target_resume (ecs
->pid
, 0, TARGET_SIGNAL_0
);
1647 prepare_to_wait (ecs
);
1652 stop_pc
= read_pc ();
1653 stop_bpstat
= bpstat_stop_status (&stop_pc
, currently_stepping (ecs
));
1654 ecs
->random_signal
= !bpstat_explains_signal (stop_bpstat
);
1655 goto process_event_stop_test
;
1657 case TARGET_WAITKIND_EXECD
:
1658 stop_signal
= TARGET_SIGNAL_TRAP
;
1660 /* Is this a target which reports multiple exec events per actual
1661 call to exec()? (HP-UX using ptrace does, for example.) If so,
1662 ignore all but the last one. Just resume the exec'r, and wait
1663 for the next exec event. */
1664 if (inferior_ignoring_leading_exec_events
)
1666 inferior_ignoring_leading_exec_events
--;
1667 if (pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1668 ENSURE_VFORKING_PARENT_REMAINS_STOPPED (pending_follow
.fork_event
.parent_pid
);
1669 target_resume (ecs
->pid
, 0, TARGET_SIGNAL_0
);
1670 prepare_to_wait (ecs
);
1673 inferior_ignoring_leading_exec_events
=
1674 target_reported_exec_events_per_exec_call () - 1;
1676 pending_follow
.execd_pathname
=
1677 savestring (ecs
->ws
.value
.execd_pathname
,
1678 strlen (ecs
->ws
.value
.execd_pathname
));
1680 /* Did inferior_pid exec, or did a (possibly not-yet-followed)
1681 child of a vfork exec?
1683 ??rehrauer: This is unabashedly an HP-UX specific thing. On
1684 HP-UX, events associated with a vforking inferior come in
1685 threes: a vfork event for the child (always first), followed
1686 a vfork event for the parent and an exec event for the child.
1687 The latter two can come in either order.
1689 If we get the parent vfork event first, life's good: We follow
1690 either the parent or child, and then the child's exec event is
1693 But if we get the child's exec event first, then we delay
1694 responding to it until we handle the parent's vfork. Because,
1695 otherwise we can't satisfy a "catch vfork". */
1696 if (pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1698 pending_follow
.fork_event
.saw_child_exec
= 1;
1700 /* On some targets, the child must be resumed before
1701 the parent vfork event is delivered. A single-step
1703 if (RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK ())
1704 target_resume (ecs
->pid
, 1, TARGET_SIGNAL_0
);
1705 /* We expect the parent vfork event to be available now. */
1706 prepare_to_wait (ecs
);
1710 /* This causes the eventpoints and symbol table to be reset. Must
1711 do this now, before trying to determine whether to stop. */
1712 follow_exec (inferior_pid
, pending_follow
.execd_pathname
);
1713 free (pending_follow
.execd_pathname
);
1715 stop_pc
= read_pc_pid (ecs
->pid
);
1716 ecs
->saved_inferior_pid
= inferior_pid
;
1717 inferior_pid
= ecs
->pid
;
1718 stop_bpstat
= bpstat_stop_status (&stop_pc
, currently_stepping (ecs
));
1719 ecs
->random_signal
= !bpstat_explains_signal (stop_bpstat
);
1720 inferior_pid
= ecs
->saved_inferior_pid
;
1721 goto process_event_stop_test
;
1723 /* These syscall events are returned on HP-UX, as part of its
1724 implementation of page-protection-based "hardware" watchpoints.
1725 HP-UX has unfortunate interactions between page-protections and
1726 some system calls. Our solution is to disable hardware watches
1727 when a system call is entered, and reenable them when the syscall
1728 completes. The downside of this is that we may miss the precise
1729 point at which a watched piece of memory is modified. "Oh well."
1731 Note that we may have multiple threads running, which may each
1732 enter syscalls at roughly the same time. Since we don't have a
1733 good notion currently of whether a watched piece of memory is
1734 thread-private, we'd best not have any page-protections active
1735 when any thread is in a syscall. Thus, we only want to reenable
1736 hardware watches when no threads are in a syscall.
1738 Also, be careful not to try to gather much state about a thread
1739 that's in a syscall. It's frequently a losing proposition. */
1740 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1741 number_of_threads_in_syscalls
++;
1742 if (number_of_threads_in_syscalls
== 1)
1744 TARGET_DISABLE_HW_WATCHPOINTS (inferior_pid
);
1746 resume (0, TARGET_SIGNAL_0
);
1747 prepare_to_wait (ecs
);
1750 /* Before examining the threads further, step this thread to
1751 get it entirely out of the syscall. (We get notice of the
1752 event when the thread is just on the verge of exiting a
1753 syscall. Stepping one instruction seems to get it back
1756 Note that although the logical place to reenable h/w watches
1757 is here, we cannot. We cannot reenable them before stepping
1758 the thread (this causes the next wait on the thread to hang).
1760 Nor can we enable them after stepping until we've done a wait.
1761 Thus, we simply set the flag ecs->enable_hw_watchpoints_after_wait
1762 here, which will be serviced immediately after the target
1764 case TARGET_WAITKIND_SYSCALL_RETURN
:
1765 target_resume (ecs
->pid
, 1, TARGET_SIGNAL_0
);
1767 if (number_of_threads_in_syscalls
> 0)
1769 number_of_threads_in_syscalls
--;
1770 ecs
->enable_hw_watchpoints_after_wait
=
1771 (number_of_threads_in_syscalls
== 0);
1773 prepare_to_wait (ecs
);
1776 case TARGET_WAITKIND_STOPPED
:
1777 stop_signal
= ecs
->ws
.value
.sig
;
1780 /* We had an event in the inferior, but we are not interested
1781 in handling it at this level. The lower layers have already
1782 done what needs to be done, if anything. This case can
1783 occur only when the target is async or extended-async. One
1784 of the circumstamces for this to happen is when the
1785 inferior produces output for the console. The inferior has
1786 not stopped, and we are ignoring the event. */
1787 case TARGET_WAITKIND_IGNORE
:
1788 ecs
->wait_some_more
= 1;
1792 /* We may want to consider not doing a resume here in order to give
1793 the user a chance to play with the new thread. It might be good
1794 to make that a user-settable option. */
1796 /* At this point, all threads are stopped (happens automatically in
1797 either the OS or the native code). Therefore we need to continue
1798 all threads in order to make progress. */
1799 if (ecs
->new_thread_event
)
1801 target_resume (-1, 0, TARGET_SIGNAL_0
);
1802 prepare_to_wait (ecs
);
1806 stop_pc
= read_pc_pid (ecs
->pid
);
1808 /* See if a thread hit a thread-specific breakpoint that was meant for
1809 another thread. If so, then step that thread past the breakpoint,
1812 if (stop_signal
== TARGET_SIGNAL_TRAP
)
1814 if (SOFTWARE_SINGLE_STEP_P
&& singlestep_breakpoints_inserted_p
)
1815 ecs
->random_signal
= 0;
1816 else if (breakpoints_inserted
1817 && breakpoint_here_p (stop_pc
- DECR_PC_AFTER_BREAK
))
1819 ecs
->random_signal
= 0;
1820 if (!breakpoint_thread_match (stop_pc
- DECR_PC_AFTER_BREAK
,
1825 /* Saw a breakpoint, but it was hit by the wrong thread.
1827 write_pc_pid (stop_pc
- DECR_PC_AFTER_BREAK
, ecs
->pid
);
1829 remove_status
= remove_breakpoints ();
1830 /* Did we fail to remove breakpoints? If so, try
1831 to set the PC past the bp. (There's at least
1832 one situation in which we can fail to remove
1833 the bp's: On HP-UX's that use ttrace, we can't
1834 change the address space of a vforking child
1835 process until the child exits (well, okay, not
1836 then either :-) or execs. */
1837 if (remove_status
!= 0)
1839 write_pc_pid (stop_pc
- DECR_PC_AFTER_BREAK
+ 4, ecs
->pid
);
1843 target_resume (ecs
->pid
, 1, TARGET_SIGNAL_0
);
1844 /* FIXME: What if a signal arrives instead of the
1845 single-step happening? */
1847 ecs
->waiton_pid
= ecs
->pid
;
1848 ecs
->wp
= &(ecs
->ws
);
1849 ecs
->infwait_state
= infwait_thread_hop_state
;
1850 prepare_to_wait (ecs
);
1854 /* We need to restart all the threads now,
1855 * unles we're running in scheduler-locked mode.
1856 * FIXME: shouldn't we look at currently_stepping ()?
1858 if (scheduler_mode
== schedlock_on
)
1859 target_resume (ecs
->pid
, 0, TARGET_SIGNAL_0
);
1861 target_resume (-1, 0, TARGET_SIGNAL_0
);
1862 prepare_to_wait (ecs
);
1867 /* This breakpoint matches--either it is the right
1868 thread or it's a generic breakpoint for all threads.
1869 Remember that we'll need to step just _this_ thread
1870 on any following user continuation! */
1871 thread_step_needed
= 1;
1876 ecs
->random_signal
= 1;
1878 /* See if something interesting happened to the non-current thread. If
1879 so, then switch to that thread, and eventually give control back to
1882 Note that if there's any kind of pending follow (i.e., of a fork,
1883 vfork or exec), we don't want to do this now. Rather, we'll let
1884 the next resume handle it. */
1885 if ((ecs
->pid
!= inferior_pid
) &&
1886 (pending_follow
.kind
== TARGET_WAITKIND_SPURIOUS
))
1890 /* If it's a random signal for a non-current thread, notify user
1891 if he's expressed an interest. */
1892 if (ecs
->random_signal
1893 && signal_print
[stop_signal
])
1895 /* ??rehrauer: I don't understand the rationale for this code. If the
1896 inferior will stop as a result of this signal, then the act of handling
1897 the stop ought to print a message that's couches the stoppage in user
1898 terms, e.g., "Stopped for breakpoint/watchpoint". If the inferior
1899 won't stop as a result of the signal -- i.e., if the signal is merely
1900 a side-effect of something GDB's doing "under the covers" for the
1901 user, such as stepping threads over a breakpoint they shouldn't stop
1902 for -- then the message seems to be a serious annoyance at best.
1904 For now, remove the message altogether. */
1907 target_terminal_ours_for_output ();
1908 printf_filtered ("\nProgram received signal %s, %s.\n",
1909 target_signal_to_name (stop_signal
),
1910 target_signal_to_string (stop_signal
));
1911 gdb_flush (gdb_stdout
);
1915 /* If it's not SIGTRAP and not a signal we want to stop for, then
1916 continue the thread. */
1918 if (stop_signal
!= TARGET_SIGNAL_TRAP
1919 && !signal_stop
[stop_signal
])
1922 target_terminal_inferior ();
1924 /* Clear the signal if it should not be passed. */
1925 if (signal_program
[stop_signal
] == 0)
1926 stop_signal
= TARGET_SIGNAL_0
;
1928 target_resume (ecs
->pid
, 0, stop_signal
);
1929 prepare_to_wait (ecs
);
1933 /* It's a SIGTRAP or a signal we're interested in. Switch threads,
1934 and fall into the rest of wait_for_inferior(). */
1936 /* Caution: it may happen that the new thread (or the old one!)
1937 is not in the thread list. In this case we must not attempt
1938 to "switch context", or we run the risk that our context may
1939 be lost. This may happen as a result of the target module
1940 mishandling thread creation. */
1942 if (in_thread_list (inferior_pid
) && in_thread_list (ecs
->pid
))
1943 { /* Perform infrun state context switch: */
1944 /* Save infrun state for the old thread. */
1945 save_infrun_state (inferior_pid
, prev_pc
,
1946 prev_func_start
, prev_func_name
,
1947 trap_expected
, step_resume_breakpoint
,
1948 through_sigtramp_breakpoint
,
1949 step_range_start
, step_range_end
,
1950 step_frame_address
, ecs
->handling_longjmp
,
1952 ecs
->stepping_through_solib_after_catch
,
1953 ecs
->stepping_through_solib_catchpoints
,
1954 ecs
->stepping_through_sigtramp
);
1956 /* Load infrun state for the new thread. */
1957 load_infrun_state (ecs
->pid
, &prev_pc
,
1958 &prev_func_start
, &prev_func_name
,
1959 &trap_expected
, &step_resume_breakpoint
,
1960 &through_sigtramp_breakpoint
,
1961 &step_range_start
, &step_range_end
,
1962 &step_frame_address
, &ecs
->handling_longjmp
,
1964 &ecs
->stepping_through_solib_after_catch
,
1965 &ecs
->stepping_through_solib_catchpoints
,
1966 &ecs
->stepping_through_sigtramp
);
1969 inferior_pid
= ecs
->pid
;
1972 context_hook (pid_to_thread_id (ecs
->pid
));
1974 flush_cached_frames ();
1977 if (SOFTWARE_SINGLE_STEP_P
&& singlestep_breakpoints_inserted_p
)
1979 /* Pull the single step breakpoints out of the target. */
1980 SOFTWARE_SINGLE_STEP (0, 0);
1981 singlestep_breakpoints_inserted_p
= 0;
1984 /* If PC is pointing at a nullified instruction, then step beyond
1985 it so that the user won't be confused when GDB appears to be ready
1988 /* if (INSTRUCTION_NULLIFIED && currently_stepping (ecs)) */
1989 if (INSTRUCTION_NULLIFIED
)
1991 registers_changed ();
1992 target_resume (ecs
->pid
, 1, TARGET_SIGNAL_0
);
1994 /* We may have received a signal that we want to pass to
1995 the inferior; therefore, we must not clobber the waitstatus
1998 ecs
->infwait_state
= infwait_nullified_state
;
1999 ecs
->waiton_pid
= ecs
->pid
;
2000 ecs
->wp
= &(ecs
->tmpstatus
);
2001 prepare_to_wait (ecs
);
2005 /* It may not be necessary to disable the watchpoint to stop over
2006 it. For example, the PA can (with some kernel cooperation)
2007 single step over a watchpoint without disabling the watchpoint. */
2008 if (HAVE_STEPPABLE_WATCHPOINT
&& STOPPED_BY_WATCHPOINT (ecs
->ws
))
2011 prepare_to_wait (ecs
);
2015 /* It is far more common to need to disable a watchpoint to step
2016 the inferior over it. FIXME. What else might a debug
2017 register or page protection watchpoint scheme need here? */
2018 if (HAVE_NONSTEPPABLE_WATCHPOINT
&& STOPPED_BY_WATCHPOINT (ecs
->ws
))
2020 /* At this point, we are stopped at an instruction which has
2021 attempted to write to a piece of memory under control of
2022 a watchpoint. The instruction hasn't actually executed
2023 yet. If we were to evaluate the watchpoint expression
2024 now, we would get the old value, and therefore no change
2025 would seem to have occurred.
2027 In order to make watchpoints work `right', we really need
2028 to complete the memory write, and then evaluate the
2029 watchpoint expression. The following code does that by
2030 removing the watchpoint (actually, all watchpoints and
2031 breakpoints), single-stepping the target, re-inserting
2032 watchpoints, and then falling through to let normal
2033 single-step processing handle proceed. Since this
2034 includes evaluating watchpoints, things will come to a
2035 stop in the correct manner. */
2037 write_pc (stop_pc
- DECR_PC_AFTER_BREAK
);
2039 remove_breakpoints ();
2040 registers_changed ();
2041 target_resume (ecs
->pid
, 1, TARGET_SIGNAL_0
); /* Single step */
2043 ecs
->waiton_pid
= ecs
->pid
;
2044 ecs
->wp
= &(ecs
->ws
);
2045 ecs
->infwait_state
= infwait_nonstep_watch_state
;
2046 prepare_to_wait (ecs
);
2050 /* It may be possible to simply continue after a watchpoint. */
2051 if (HAVE_CONTINUABLE_WATCHPOINT
)
2052 STOPPED_BY_WATCHPOINT (ecs
->ws
);
2054 ecs
->stop_func_start
= 0;
2055 ecs
->stop_func_end
= 0;
2056 ecs
->stop_func_name
= 0;
2057 /* Don't care about return value; stop_func_start and stop_func_name
2058 will both be 0 if it doesn't work. */
2059 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
2060 &ecs
->stop_func_start
, &ecs
->stop_func_end
);
2061 ecs
->stop_func_start
+= FUNCTION_START_OFFSET
;
2062 ecs
->another_trap
= 0;
2063 bpstat_clear (&stop_bpstat
);
2065 stop_stack_dummy
= 0;
2066 stop_print_frame
= 1;
2067 ecs
->random_signal
= 0;
2068 stopped_by_random_signal
= 0;
2069 breakpoints_failed
= 0;
2071 /* Look at the cause of the stop, and decide what to do.
2072 The alternatives are:
2073 1) break; to really stop and return to the debugger,
2074 2) drop through to start up again
2075 (set ecs->another_trap to 1 to single step once)
2076 3) set ecs->random_signal to 1, and the decision between 1 and 2
2077 will be made according to the signal handling tables. */
2079 /* First, distinguish signals caused by the debugger from signals
2080 that have to do with the program's own actions.
2081 Note that breakpoint insns may cause SIGTRAP or SIGILL
2082 or SIGEMT, depending on the operating system version.
2083 Here we detect when a SIGILL or SIGEMT is really a breakpoint
2084 and change it to SIGTRAP. */
2086 if (stop_signal
== TARGET_SIGNAL_TRAP
2087 || (breakpoints_inserted
&&
2088 (stop_signal
== TARGET_SIGNAL_ILL
2089 || stop_signal
== TARGET_SIGNAL_EMT
2091 || stop_soon_quietly
)
2093 if (stop_signal
== TARGET_SIGNAL_TRAP
&& stop_after_trap
)
2095 stop_print_frame
= 0;
2096 stop_stepping (ecs
);
2099 if (stop_soon_quietly
)
2101 stop_stepping (ecs
);
2105 /* Don't even think about breakpoints
2106 if just proceeded over a breakpoint.
2108 However, if we are trying to proceed over a breakpoint
2109 and end up in sigtramp, then through_sigtramp_breakpoint
2110 will be set and we should check whether we've hit the
2112 if (stop_signal
== TARGET_SIGNAL_TRAP
&& trap_expected
2113 && through_sigtramp_breakpoint
== NULL
)
2114 bpstat_clear (&stop_bpstat
);
2117 /* See if there is a breakpoint at the current PC. */
2118 stop_bpstat
= bpstat_stop_status
2120 /* Pass TRUE if our reason for stopping is something other
2121 than hitting a breakpoint. We do this by checking that
2122 1) stepping is going on and 2) we didn't hit a breakpoint
2123 in a signal handler without an intervening stop in
2124 sigtramp, which is detected by a new stack pointer value
2125 below any usual function calling stack adjustments. */
2126 (currently_stepping (ecs
)
2128 && INNER_THAN (read_sp (), (step_sp
- 16))))
2130 /* Following in case break condition called a
2132 stop_print_frame
= 1;
2135 if (stop_signal
== TARGET_SIGNAL_TRAP
)
2137 = !(bpstat_explains_signal (stop_bpstat
)
2139 || (!CALL_DUMMY_BREAKPOINT_OFFSET_P
2140 && PC_IN_CALL_DUMMY (stop_pc
, read_sp (),
2141 FRAME_FP (get_current_frame ())))
2142 || (step_range_end
&& step_resume_breakpoint
== NULL
));
2147 = !(bpstat_explains_signal (stop_bpstat
)
2148 /* End of a stack dummy. Some systems (e.g. Sony
2149 news) give another signal besides SIGTRAP, so
2150 check here as well as above. */
2151 || (!CALL_DUMMY_BREAKPOINT_OFFSET_P
2152 && PC_IN_CALL_DUMMY (stop_pc
, read_sp (),
2153 FRAME_FP (get_current_frame ())))
2155 if (!ecs
->random_signal
)
2156 stop_signal
= TARGET_SIGNAL_TRAP
;
2160 /* When we reach this point, we've pretty much decided
2161 that the reason for stopping must've been a random
2162 (unexpected) signal. */
2165 ecs
->random_signal
= 1;
2166 /* If a fork, vfork or exec event was seen, then there are two
2167 possible responses we can make:
2169 1. If a catchpoint triggers for the event (ecs->random_signal == 0),
2170 then we must stop now and issue a prompt. We will resume
2171 the inferior when the user tells us to.
2172 2. If no catchpoint triggers for the event (ecs->random_signal == 1),
2173 then we must resume the inferior now and keep checking.
2175 In either case, we must take appropriate steps to "follow" the
2176 the fork/vfork/exec when the inferior is resumed. For example,
2177 if follow-fork-mode is "child", then we must detach from the
2178 parent inferior and follow the new child inferior.
2180 In either case, setting pending_follow causes the next resume()
2181 to take the appropriate following action. */
2182 process_event_stop_test
:
2183 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
2185 if (ecs
->random_signal
) /* I.e., no catchpoint triggered for this. */
2188 stop_signal
= TARGET_SIGNAL_0
;
2193 else if (ecs
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
2195 if (ecs
->random_signal
) /* I.e., no catchpoint triggered for this. */
2197 stop_signal
= TARGET_SIGNAL_0
;
2202 else if (ecs
->ws
.kind
== TARGET_WAITKIND_EXECD
)
2204 pending_follow
.kind
= ecs
->ws
.kind
;
2205 if (ecs
->random_signal
) /* I.e., no catchpoint triggered for this. */
2208 stop_signal
= TARGET_SIGNAL_0
;
2214 /* For the program's own signals, act according to
2215 the signal handling tables. */
2217 if (ecs
->random_signal
)
2219 /* Signal not for debugging purposes. */
2222 stopped_by_random_signal
= 1;
2224 if (signal_print
[stop_signal
])
2227 target_terminal_ours_for_output ();
2228 print_stop_reason (SIGNAL_RECEIVED
, stop_signal
);
2230 if (signal_stop
[stop_signal
])
2232 stop_stepping (ecs
);
2235 /* If not going to stop, give terminal back
2236 if we took it away. */
2238 target_terminal_inferior ();
2240 /* Clear the signal if it should not be passed. */
2241 if (signal_program
[stop_signal
] == 0)
2242 stop_signal
= TARGET_SIGNAL_0
;
2244 /* I'm not sure whether this needs to be check_sigtramp2 or
2245 whether it could/should be keep_going.
2247 This used to jump to step_over_function if we are stepping,
2250 Suppose the user does a `next' over a function call, and while
2251 that call is in progress, the inferior receives a signal for
2252 which GDB does not stop (i.e., signal_stop[SIG] is false). In
2253 that case, when we reach this point, there is already a
2254 step-resume breakpoint established, right where it should be:
2255 immediately after the function call the user is "next"-ing
2256 over. If we call step_over_function now, two bad things
2259 - we'll create a new breakpoint, at wherever the current
2260 frame's return address happens to be. That could be
2261 anywhere, depending on what function call happens to be on
2262 the top of the stack at that point. Point is, it's probably
2263 not where we need it.
2265 - the existing step-resume breakpoint (which is at the correct
2266 address) will get orphaned: step_resume_breakpoint will point
2267 to the new breakpoint, and the old step-resume breakpoint
2268 will never be cleaned up.
2270 The old behavior was meant to help HP-UX single-step out of
2271 sigtramps. It would place the new breakpoint at prev_pc, which
2272 was certainly wrong. I don't know the details there, so fixing
2273 this probably breaks that. As with anything else, it's up to
2274 the HP-UX maintainer to furnish a fix that doesn't break other
2275 platforms. --JimB, 20 May 1999 */
2276 check_sigtramp2 (ecs
);
2279 /* Handle cases caused by hitting a breakpoint. */
2281 CORE_ADDR jmp_buf_pc
;
2282 struct bpstat_what what
;
2284 what
= bpstat_what (stop_bpstat
);
2286 if (what
.call_dummy
)
2288 stop_stack_dummy
= 1;
2290 trap_expected_after_continue
= 1;
2294 switch (what
.main_action
)
2296 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
2297 /* If we hit the breakpoint at longjmp, disable it for the
2298 duration of this command. Then, install a temporary
2299 breakpoint at the target of the jmp_buf. */
2300 disable_longjmp_breakpoint ();
2301 remove_breakpoints ();
2302 breakpoints_inserted
= 0;
2303 if (!GET_LONGJMP_TARGET (&jmp_buf_pc
))
2309 /* Need to blow away step-resume breakpoint, as it
2310 interferes with us */
2311 if (step_resume_breakpoint
!= NULL
)
2313 delete_breakpoint (step_resume_breakpoint
);
2314 step_resume_breakpoint
= NULL
;
2316 /* Not sure whether we need to blow this away too, but probably
2317 it is like the step-resume breakpoint. */
2318 if (through_sigtramp_breakpoint
!= NULL
)
2320 delete_breakpoint (through_sigtramp_breakpoint
);
2321 through_sigtramp_breakpoint
= NULL
;
2325 /* FIXME - Need to implement nested temporary breakpoints */
2326 if (step_over_calls
> 0)
2327 set_longjmp_resume_breakpoint (jmp_buf_pc
,
2328 get_current_frame ());
2331 set_longjmp_resume_breakpoint (jmp_buf_pc
, NULL
);
2332 ecs
->handling_longjmp
= 1; /* FIXME */
2336 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
2337 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
:
2338 remove_breakpoints ();
2339 breakpoints_inserted
= 0;
2341 /* FIXME - Need to implement nested temporary breakpoints */
2343 && (INNER_THAN (FRAME_FP (get_current_frame ()),
2344 step_frame_address
)))
2346 ecs
->another_trap
= 1;
2351 disable_longjmp_breakpoint ();
2352 ecs
->handling_longjmp
= 0; /* FIXME */
2353 if (what
.main_action
== BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
)
2355 /* else fallthrough */
2357 case BPSTAT_WHAT_SINGLE
:
2358 if (breakpoints_inserted
)
2360 thread_step_needed
= 1;
2361 remove_breakpoints ();
2363 breakpoints_inserted
= 0;
2364 ecs
->another_trap
= 1;
2365 /* Still need to check other stuff, at least the case
2366 where we are stepping and step out of the right range. */
2369 case BPSTAT_WHAT_STOP_NOISY
:
2370 stop_print_frame
= 1;
2372 /* We are about to nuke the step_resume_breakpoint and
2373 through_sigtramp_breakpoint via the cleanup chain, so
2374 no need to worry about it here. */
2376 stop_stepping (ecs
);
2379 case BPSTAT_WHAT_STOP_SILENT
:
2380 stop_print_frame
= 0;
2382 /* We are about to nuke the step_resume_breakpoint and
2383 through_sigtramp_breakpoint via the cleanup chain, so
2384 no need to worry about it here. */
2386 stop_stepping (ecs
);
2389 case BPSTAT_WHAT_STEP_RESUME
:
2390 /* This proably demands a more elegant solution, but, yeah
2393 This function's use of the simple variable
2394 step_resume_breakpoint doesn't seem to accomodate
2395 simultaneously active step-resume bp's, although the
2396 breakpoint list certainly can.
2398 If we reach here and step_resume_breakpoint is already
2399 NULL, then apparently we have multiple active
2400 step-resume bp's. We'll just delete the breakpoint we
2401 stopped at, and carry on.
2403 Correction: what the code currently does is delete a
2404 step-resume bp, but it makes no effort to ensure that
2405 the one deleted is the one currently stopped at. MVS */
2407 if (step_resume_breakpoint
== NULL
)
2409 step_resume_breakpoint
=
2410 bpstat_find_step_resume_breakpoint (stop_bpstat
);
2412 delete_breakpoint (step_resume_breakpoint
);
2413 step_resume_breakpoint
= NULL
;
2416 case BPSTAT_WHAT_THROUGH_SIGTRAMP
:
2417 if (through_sigtramp_breakpoint
)
2418 delete_breakpoint (through_sigtramp_breakpoint
);
2419 through_sigtramp_breakpoint
= NULL
;
2421 /* If were waiting for a trap, hitting the step_resume_break
2422 doesn't count as getting it. */
2424 ecs
->another_trap
= 1;
2427 case BPSTAT_WHAT_CHECK_SHLIBS
:
2428 case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
:
2431 /* Remove breakpoints, we eventually want to step over the
2432 shlib event breakpoint, and SOLIB_ADD might adjust
2433 breakpoint addresses via breakpoint_re_set. */
2434 if (breakpoints_inserted
)
2435 remove_breakpoints ();
2436 breakpoints_inserted
= 0;
2438 /* Check for any newly added shared libraries if we're
2439 supposed to be adding them automatically. */
2442 /* Switch terminal for any messages produced by
2443 breakpoint_re_set. */
2444 target_terminal_ours_for_output ();
2445 SOLIB_ADD (NULL
, 0, NULL
);
2446 target_terminal_inferior ();
2449 /* Try to reenable shared library breakpoints, additional
2450 code segments in shared libraries might be mapped in now. */
2451 re_enable_breakpoints_in_shlibs ();
2453 /* If requested, stop when the dynamic linker notifies
2454 gdb of events. This allows the user to get control
2455 and place breakpoints in initializer routines for
2456 dynamically loaded objects (among other things). */
2457 if (stop_on_solib_events
)
2459 stop_stepping (ecs
);
2463 /* If we stopped due to an explicit catchpoint, then the
2464 (see above) call to SOLIB_ADD pulled in any symbols
2465 from a newly-loaded library, if appropriate.
2467 We do want the inferior to stop, but not where it is
2468 now, which is in the dynamic linker callback. Rather,
2469 we would like it stop in the user's program, just after
2470 the call that caused this catchpoint to trigger. That
2471 gives the user a more useful vantage from which to
2472 examine their program's state. */
2473 else if (what
.main_action
== BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
)
2475 /* ??rehrauer: If I could figure out how to get the
2476 right return PC from here, we could just set a temp
2477 breakpoint and resume. I'm not sure we can without
2478 cracking open the dld's shared libraries and sniffing
2479 their unwind tables and text/data ranges, and that's
2480 not a terribly portable notion.
2482 Until that time, we must step the inferior out of the
2483 dld callback, and also out of the dld itself (and any
2484 code or stubs in libdld.sl, such as "shl_load" and
2485 friends) until we reach non-dld code. At that point,
2486 we can stop stepping. */
2487 bpstat_get_triggered_catchpoints (stop_bpstat
,
2488 &ecs
->stepping_through_solib_catchpoints
);
2489 ecs
->stepping_through_solib_after_catch
= 1;
2491 /* Be sure to lift all breakpoints, so the inferior does
2492 actually step past this point... */
2493 ecs
->another_trap
= 1;
2498 /* We want to step over this breakpoint, then keep going. */
2499 ecs
->another_trap
= 1;
2506 case BPSTAT_WHAT_LAST
:
2507 /* Not a real code, but listed here to shut up gcc -Wall. */
2509 case BPSTAT_WHAT_KEEP_CHECKING
:
2514 /* We come here if we hit a breakpoint but should not
2515 stop for it. Possibly we also were stepping
2516 and should stop for that. So fall through and
2517 test for stepping. But, if not stepping,
2520 /* Are we stepping to get the inferior out of the dynamic
2521 linker's hook (and possibly the dld itself) after catching
2523 if (ecs
->stepping_through_solib_after_catch
)
2525 #if defined(SOLIB_ADD)
2526 /* Have we reached our destination? If not, keep going. */
2527 if (SOLIB_IN_DYNAMIC_LINKER (ecs
->pid
, stop_pc
))
2529 ecs
->another_trap
= 1;
2534 /* Else, stop and report the catchpoint(s) whose triggering
2535 caused us to begin stepping. */
2536 ecs
->stepping_through_solib_after_catch
= 0;
2537 bpstat_clear (&stop_bpstat
);
2538 stop_bpstat
= bpstat_copy (ecs
->stepping_through_solib_catchpoints
);
2539 bpstat_clear (&ecs
->stepping_through_solib_catchpoints
);
2540 stop_print_frame
= 1;
2541 stop_stepping (ecs
);
2545 if (!CALL_DUMMY_BREAKPOINT_OFFSET_P
)
2547 /* This is the old way of detecting the end of the stack dummy.
2548 An architecture which defines CALL_DUMMY_BREAKPOINT_OFFSET gets
2549 handled above. As soon as we can test it on all of them, all
2550 architectures should define it. */
2552 /* If this is the breakpoint at the end of a stack dummy,
2553 just stop silently, unless the user was doing an si/ni, in which
2554 case she'd better know what she's doing. */
2556 if (CALL_DUMMY_HAS_COMPLETED (stop_pc
, read_sp (),
2557 FRAME_FP (get_current_frame ()))
2560 stop_print_frame
= 0;
2561 stop_stack_dummy
= 1;
2563 trap_expected_after_continue
= 1;
2565 stop_stepping (ecs
);
2570 if (step_resume_breakpoint
)
2572 /* Having a step-resume breakpoint overrides anything
2573 else having to do with stepping commands until
2574 that breakpoint is reached. */
2575 /* I'm not sure whether this needs to be check_sigtramp2 or
2576 whether it could/should be keep_going. */
2577 check_sigtramp2 (ecs
);
2582 if (step_range_end
== 0)
2584 /* Likewise if we aren't even stepping. */
2585 /* I'm not sure whether this needs to be check_sigtramp2 or
2586 whether it could/should be keep_going. */
2587 check_sigtramp2 (ecs
);
2592 /* If stepping through a line, keep going if still within it.
2594 Note that step_range_end is the address of the first instruction
2595 beyond the step range, and NOT the address of the last instruction
2597 if (stop_pc
>= step_range_start
2598 && stop_pc
< step_range_end
)
2600 /* We might be doing a BPSTAT_WHAT_SINGLE and getting a signal.
2601 So definately need to check for sigtramp here. */
2602 check_sigtramp2 (ecs
);
2607 /* We stepped out of the stepping range. */
2609 /* If we are stepping at the source level and entered the runtime
2610 loader dynamic symbol resolution code, we keep on single stepping
2611 until we exit the run time loader code and reach the callee's
2613 if (step_over_calls
< 0 && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc
))
2615 CORE_ADDR pc_after_resolver
= SKIP_SOLIB_RESOLVER (stop_pc
);
2617 if (pc_after_resolver
)
2619 /* Set up a step-resume breakpoint at the address
2620 indicated by SKIP_SOLIB_RESOLVER. */
2621 struct symtab_and_line sr_sal
;
2623 sr_sal
.pc
= pc_after_resolver
;
2625 check_for_old_step_resume_breakpoint ();
2626 step_resume_breakpoint
=
2627 set_momentary_breakpoint (sr_sal
, NULL
, bp_step_resume
);
2628 if (breakpoints_inserted
)
2629 insert_breakpoints ();
2636 /* We can't update step_sp every time through the loop, because
2637 reading the stack pointer would slow down stepping too much.
2638 But we can update it every time we leave the step range. */
2639 ecs
->update_step_sp
= 1;
2641 /* Did we just take a signal? */
2642 if (IN_SIGTRAMP (stop_pc
, ecs
->stop_func_name
)
2643 && !IN_SIGTRAMP (prev_pc
, prev_func_name
)
2644 && INNER_THAN (read_sp (), step_sp
))
2646 /* We've just taken a signal; go until we are back to
2647 the point where we took it and one more. */
2649 /* Note: The test above succeeds not only when we stepped
2650 into a signal handler, but also when we step past the last
2651 statement of a signal handler and end up in the return stub
2652 of the signal handler trampoline. To distinguish between
2653 these two cases, check that the frame is INNER_THAN the
2654 previous one below. pai/1997-09-11 */
2658 CORE_ADDR current_frame
= FRAME_FP (get_current_frame ());
2660 if (INNER_THAN (current_frame
, step_frame_address
))
2662 /* We have just taken a signal; go until we are back to
2663 the point where we took it and one more. */
2665 /* This code is needed at least in the following case:
2666 The user types "next" and then a signal arrives (before
2667 the "next" is done). */
2669 /* Note that if we are stopped at a breakpoint, then we need
2670 the step_resume breakpoint to override any breakpoints at
2671 the same location, so that we will still step over the
2672 breakpoint even though the signal happened. */
2673 struct symtab_and_line sr_sal
;
2676 sr_sal
.symtab
= NULL
;
2678 sr_sal
.pc
= prev_pc
;
2679 /* We could probably be setting the frame to
2680 step_frame_address; I don't think anyone thought to
2682 check_for_old_step_resume_breakpoint ();
2683 step_resume_breakpoint
=
2684 set_momentary_breakpoint (sr_sal
, NULL
, bp_step_resume
);
2685 if (breakpoints_inserted
)
2686 insert_breakpoints ();
2690 /* We just stepped out of a signal handler and into
2691 its calling trampoline.
2693 Normally, we'd call step_over_function from
2694 here, but for some reason GDB can't unwind the
2695 stack correctly to find the real PC for the point
2696 user code where the signal trampoline will return
2697 -- FRAME_SAVED_PC fails, at least on HP-UX 10.20.
2698 But signal trampolines are pretty small stubs of
2699 code, anyway, so it's OK instead to just
2700 single-step out. Note: assuming such trampolines
2701 don't exhibit recursion on any platform... */
2702 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
2703 &ecs
->stop_func_start
,
2704 &ecs
->stop_func_end
);
2705 /* Readjust stepping range */
2706 step_range_start
= ecs
->stop_func_start
;
2707 step_range_end
= ecs
->stop_func_end
;
2708 ecs
->stepping_through_sigtramp
= 1;
2713 /* If this is stepi or nexti, make sure that the stepping range
2714 gets us past that instruction. */
2715 if (step_range_end
== 1)
2716 /* FIXME: Does this run afoul of the code below which, if
2717 we step into the middle of a line, resets the stepping
2719 step_range_end
= (step_range_start
= prev_pc
) + 1;
2721 ecs
->remove_breakpoints_on_following_step
= 1;
2726 if (stop_pc
== ecs
->stop_func_start
/* Quick test */
2727 || (in_prologue (stop_pc
, ecs
->stop_func_start
) &&
2728 !IN_SOLIB_RETURN_TRAMPOLINE (stop_pc
, ecs
->stop_func_name
))
2729 || IN_SOLIB_CALL_TRAMPOLINE (stop_pc
, ecs
->stop_func_name
)
2730 || ecs
->stop_func_name
== 0)
2732 /* It's a subroutine call. */
2734 if (step_over_calls
== 0)
2736 /* I presume that step_over_calls is only 0 when we're
2737 supposed to be stepping at the assembly language level
2738 ("stepi"). Just stop. */
2740 print_stop_reason (END_STEPPING_RANGE
, 0);
2741 stop_stepping (ecs
);
2745 if (step_over_calls
> 0 || IGNORE_HELPER_CALL (stop_pc
))
2747 /* We're doing a "next". */
2748 step_over_function (ecs
);
2753 /* If we are in a function call trampoline (a stub between
2754 the calling routine and the real function), locate the real
2755 function. That's what tells us (a) whether we want to step
2756 into it at all, and (b) what prologue we want to run to
2757 the end of, if we do step into it. */
2758 tmp
= SKIP_TRAMPOLINE_CODE (stop_pc
);
2760 ecs
->stop_func_start
= tmp
;
2763 tmp
= DYNAMIC_TRAMPOLINE_NEXTPC (stop_pc
);
2766 struct symtab_and_line xxx
;
2767 /* Why isn't this s_a_l called "sr_sal", like all of the
2768 other s_a_l's where this code is duplicated? */
2769 INIT_SAL (&xxx
); /* initialize to zeroes */
2771 xxx
.section
= find_pc_overlay (xxx
.pc
);
2772 check_for_old_step_resume_breakpoint ();
2773 step_resume_breakpoint
=
2774 set_momentary_breakpoint (xxx
, NULL
, bp_step_resume
);
2775 insert_breakpoints ();
2781 /* If we have line number information for the function we
2782 are thinking of stepping into, step into it.
2784 If there are several symtabs at that PC (e.g. with include
2785 files), just want to know whether *any* of them have line
2786 numbers. find_pc_line handles this. */
2788 struct symtab_and_line tmp_sal
;
2790 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
2791 if (tmp_sal
.line
!= 0)
2793 step_into_function (ecs
);
2797 step_over_function (ecs
);
2803 /* We've wandered out of the step range. */
2805 ecs
->sal
= find_pc_line (stop_pc
, 0);
2807 if (step_range_end
== 1)
2809 /* It is stepi or nexti. We always want to stop stepping after
2812 print_stop_reason (END_STEPPING_RANGE
, 0);
2813 stop_stepping (ecs
);
2817 /* If we're in the return path from a shared library trampoline,
2818 we want to proceed through the trampoline when stepping. */
2819 if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc
, ecs
->stop_func_name
))
2823 /* Determine where this trampoline returns. */
2824 tmp
= SKIP_TRAMPOLINE_CODE (stop_pc
);
2826 /* Only proceed through if we know where it's going. */
2829 /* And put the step-breakpoint there and go until there. */
2830 struct symtab_and_line sr_sal
;
2832 INIT_SAL (&sr_sal
); /* initialize to zeroes */
2834 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
2835 /* Do not specify what the fp should be when we stop
2836 since on some machines the prologue
2837 is where the new fp value is established. */
2838 check_for_old_step_resume_breakpoint ();
2839 step_resume_breakpoint
=
2840 set_momentary_breakpoint (sr_sal
, NULL
, bp_step_resume
);
2841 if (breakpoints_inserted
)
2842 insert_breakpoints ();
2844 /* Restart without fiddling with the step ranges or
2851 if (ecs
->sal
.line
== 0)
2853 /* We have no line number information. That means to stop
2854 stepping (does this always happen right after one instruction,
2855 when we do "s" in a function with no line numbers,
2856 or can this happen as a result of a return or longjmp?). */
2858 print_stop_reason (END_STEPPING_RANGE
, 0);
2859 stop_stepping (ecs
);
2863 if ((stop_pc
== ecs
->sal
.pc
)
2864 && (ecs
->current_line
!= ecs
->sal
.line
|| ecs
->current_symtab
!= ecs
->sal
.symtab
))
2866 /* We are at the start of a different line. So stop. Note that
2867 we don't stop if we step into the middle of a different line.
2868 That is said to make things like for (;;) statements work
2871 print_stop_reason (END_STEPPING_RANGE
, 0);
2872 stop_stepping (ecs
);
2876 /* We aren't done stepping.
2878 Optimize by setting the stepping range to the line.
2879 (We might not be in the original line, but if we entered a
2880 new line in mid-statement, we continue stepping. This makes
2881 things like for(;;) statements work better.) */
2883 if (ecs
->stop_func_end
&& ecs
->sal
.end
>= ecs
->stop_func_end
)
2885 /* If this is the last line of the function, don't keep stepping
2886 (it would probably step us out of the function).
2887 This is particularly necessary for a one-line function,
2888 in which after skipping the prologue we better stop even though
2889 we will be in mid-line. */
2891 print_stop_reason (END_STEPPING_RANGE
, 0);
2892 stop_stepping (ecs
);
2895 step_range_start
= ecs
->sal
.pc
;
2896 step_range_end
= ecs
->sal
.end
;
2897 step_frame_address
= FRAME_FP (get_current_frame ());
2898 ecs
->current_line
= ecs
->sal
.line
;
2899 ecs
->current_symtab
= ecs
->sal
.symtab
;
2901 /* In the case where we just stepped out of a function into the middle
2902 of a line of the caller, continue stepping, but step_frame_address
2903 must be modified to current frame */
2905 CORE_ADDR current_frame
= FRAME_FP (get_current_frame ());
2906 if (!(INNER_THAN (current_frame
, step_frame_address
)))
2907 step_frame_address
= current_frame
;
2912 } /* extra brace, to preserve old indentation */
2915 /* Are we in the middle of stepping? */
2918 currently_stepping (struct execution_control_state
*ecs
)
2920 return ((through_sigtramp_breakpoint
== NULL
2921 && !ecs
->handling_longjmp
2922 && ((step_range_end
&& step_resume_breakpoint
== NULL
)
2924 || ecs
->stepping_through_solib_after_catch
2925 || bpstat_should_step ());
2929 check_sigtramp2 (struct execution_control_state
*ecs
)
2932 && IN_SIGTRAMP (stop_pc
, ecs
->stop_func_name
)
2933 && !IN_SIGTRAMP (prev_pc
, prev_func_name
)
2934 && INNER_THAN (read_sp (), step_sp
))
2936 /* What has happened here is that we have just stepped the
2937 inferior with a signal (because it is a signal which
2938 shouldn't make us stop), thus stepping into sigtramp.
2940 So we need to set a step_resume_break_address breakpoint and
2941 continue until we hit it, and then step. FIXME: This should
2942 be more enduring than a step_resume breakpoint; we should
2943 know that we will later need to keep going rather than
2944 re-hitting the breakpoint here (see the testsuite,
2945 gdb.base/signals.exp where it says "exceedingly difficult"). */
2947 struct symtab_and_line sr_sal
;
2949 INIT_SAL (&sr_sal
); /* initialize to zeroes */
2950 sr_sal
.pc
= prev_pc
;
2951 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
2952 /* We perhaps could set the frame if we kept track of what the
2953 frame corresponding to prev_pc was. But we don't, so don't. */
2954 through_sigtramp_breakpoint
=
2955 set_momentary_breakpoint (sr_sal
, NULL
, bp_through_sigtramp
);
2956 if (breakpoints_inserted
)
2957 insert_breakpoints ();
2959 ecs
->remove_breakpoints_on_following_step
= 1;
2960 ecs
->another_trap
= 1;
2964 /* Subroutine call with source code we should not step over. Do step
2965 to the first line of code in it. */
2968 step_into_function (struct execution_control_state
*ecs
)
2971 struct symtab_and_line sr_sal
;
2973 s
= find_pc_symtab (stop_pc
);
2974 if (s
&& s
->language
!= language_asm
)
2975 ecs
->stop_func_start
= SKIP_PROLOGUE (ecs
->stop_func_start
);
2977 ecs
->sal
= find_pc_line (ecs
->stop_func_start
, 0);
2978 /* Use the step_resume_break to step until the end of the prologue,
2979 even if that involves jumps (as it seems to on the vax under
2981 /* If the prologue ends in the middle of a source line, continue to
2982 the end of that source line (if it is still within the function).
2983 Otherwise, just go to end of prologue. */
2984 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2985 /* no, don't either. It skips any code that's legitimately on the
2989 && ecs
->sal
.pc
!= ecs
->stop_func_start
2990 && ecs
->sal
.end
< ecs
->stop_func_end
)
2991 ecs
->stop_func_start
= ecs
->sal
.end
;
2994 if (ecs
->stop_func_start
== stop_pc
)
2996 /* We are already there: stop now. */
2998 print_stop_reason (END_STEPPING_RANGE
, 0);
2999 stop_stepping (ecs
);
3004 /* Put the step-breakpoint there and go until there. */
3005 INIT_SAL (&sr_sal
); /* initialize to zeroes */
3006 sr_sal
.pc
= ecs
->stop_func_start
;
3007 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
3008 /* Do not specify what the fp should be when we stop since on
3009 some machines the prologue is where the new fp value is
3011 check_for_old_step_resume_breakpoint ();
3012 step_resume_breakpoint
=
3013 set_momentary_breakpoint (sr_sal
, NULL
, bp_step_resume
);
3014 if (breakpoints_inserted
)
3015 insert_breakpoints ();
3017 /* And make sure stepping stops right away then. */
3018 step_range_end
= step_range_start
;
3023 /* We've just entered a callee, and we wish to resume until it returns
3024 to the caller. Setting a step_resume breakpoint on the return
3025 address will catch a return from the callee.
3027 However, if the callee is recursing, we want to be careful not to
3028 catch returns of those recursive calls, but only of THIS instance
3031 To do this, we set the step_resume bp's frame to our current
3032 caller's frame (step_frame_address, which is set by the "next" or
3033 "until" command, before execution begins). */
3036 step_over_function (struct execution_control_state
*ecs
)
3038 struct symtab_and_line sr_sal
;
3040 INIT_SAL (&sr_sal
); /* initialize to zeros */
3041 sr_sal
.pc
= ADDR_BITS_REMOVE (SAVED_PC_AFTER_CALL (get_current_frame ()));
3042 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
3044 check_for_old_step_resume_breakpoint ();
3045 step_resume_breakpoint
=
3046 set_momentary_breakpoint (sr_sal
, get_current_frame (), bp_step_resume
);
3048 if (!IN_SOLIB_DYNSYM_RESOLVE_CODE (sr_sal
.pc
))
3049 step_resume_breakpoint
->frame
= step_frame_address
;
3051 if (breakpoints_inserted
)
3052 insert_breakpoints ();
3056 stop_stepping (struct execution_control_state
*ecs
)
3058 if (target_has_execution
)
3060 /* Are we stopping for a vfork event? We only stop when we see
3061 the child's event. However, we may not yet have seen the
3062 parent's event. And, inferior_pid is still set to the
3063 parent's pid, until we resume again and follow either the
3066 To ensure that we can really touch inferior_pid (aka, the
3067 parent process) -- which calls to functions like read_pc
3068 implicitly do -- wait on the parent if necessary. */
3069 if ((pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
3070 && !pending_follow
.fork_event
.saw_parent_fork
)
3076 if (target_wait_hook
)
3077 parent_pid
= target_wait_hook (-1, &(ecs
->ws
));
3079 parent_pid
= target_wait (-1, &(ecs
->ws
));
3081 while (parent_pid
!= inferior_pid
);
3084 /* Assuming the inferior still exists, set these up for next
3085 time, just like we did above if we didn't break out of the
3087 prev_pc
= read_pc ();
3088 prev_func_start
= ecs
->stop_func_start
;
3089 prev_func_name
= ecs
->stop_func_name
;
3092 /* Let callers know we don't want to wait for the inferior anymore. */
3093 ecs
->wait_some_more
= 0;
3096 /* This function handles various cases where we need to continue
3097 waiting for the inferior. */
3098 /* (Used to be the keep_going: label in the old wait_for_inferior) */
3101 keep_going (struct execution_control_state
*ecs
)
3103 /* ??rehrauer: ttrace on HP-UX theoretically allows one to debug a
3104 vforked child between its creation and subsequent exit or call to
3105 exec(). However, I had big problems in this rather creaky exec
3106 engine, getting that to work. The fundamental problem is that
3107 I'm trying to debug two processes via an engine that only
3108 understands a single process with possibly multiple threads.
3110 Hence, this spot is known to have problems when
3111 target_can_follow_vfork_prior_to_exec returns 1. */
3113 /* Save the pc before execution, to compare with pc after stop. */
3114 prev_pc
= read_pc (); /* Might have been DECR_AFTER_BREAK */
3115 prev_func_start
= ecs
->stop_func_start
; /* Ok, since if DECR_PC_AFTER
3116 BREAK is defined, the
3117 original pc would not have
3118 been at the start of a
3120 prev_func_name
= ecs
->stop_func_name
;
3122 if (ecs
->update_step_sp
)
3123 step_sp
= read_sp ();
3124 ecs
->update_step_sp
= 0;
3126 /* If we did not do break;, it means we should keep running the
3127 inferior and not return to debugger. */
3129 if (trap_expected
&& stop_signal
!= TARGET_SIGNAL_TRAP
)
3131 /* We took a signal (which we are supposed to pass through to
3132 the inferior, else we'd have done a break above) and we
3133 haven't yet gotten our trap. Simply continue. */
3134 resume (currently_stepping (ecs
), stop_signal
);
3138 /* Either the trap was not expected, but we are continuing
3139 anyway (the user asked that this signal be passed to the
3142 The signal was SIGTRAP, e.g. it was our signal, but we
3143 decided we should resume from it.
3145 We're going to run this baby now!
3147 Insert breakpoints now, unless we are trying to one-proceed
3148 past a breakpoint. */
3149 /* If we've just finished a special step resume and we don't
3150 want to hit a breakpoint, pull em out. */
3151 if (step_resume_breakpoint
== NULL
3152 && through_sigtramp_breakpoint
== NULL
3153 && ecs
->remove_breakpoints_on_following_step
)
3155 ecs
->remove_breakpoints_on_following_step
= 0;
3156 remove_breakpoints ();
3157 breakpoints_inserted
= 0;
3159 else if (!breakpoints_inserted
&&
3160 (through_sigtramp_breakpoint
!= NULL
|| !ecs
->another_trap
))
3162 breakpoints_failed
= insert_breakpoints ();
3163 if (breakpoints_failed
)
3165 stop_stepping (ecs
);
3168 breakpoints_inserted
= 1;
3171 trap_expected
= ecs
->another_trap
;
3173 /* Do not deliver SIGNAL_TRAP (except when the user explicitly
3174 specifies that such a signal should be delivered to the
3177 Typically, this would occure when a user is debugging a
3178 target monitor on a simulator: the target monitor sets a
3179 breakpoint; the simulator encounters this break-point and
3180 halts the simulation handing control to GDB; GDB, noteing
3181 that the break-point isn't valid, returns control back to the
3182 simulator; the simulator then delivers the hardware
3183 equivalent of a SIGNAL_TRAP to the program being debugged. */
3185 if (stop_signal
== TARGET_SIGNAL_TRAP
3186 && !signal_program
[stop_signal
])
3187 stop_signal
= TARGET_SIGNAL_0
;
3189 #ifdef SHIFT_INST_REGS
3190 /* I'm not sure when this following segment applies. I do know,
3191 now, that we shouldn't rewrite the regs when we were stopped
3192 by a random signal from the inferior process. */
3193 /* FIXME: Shouldn't this be based on the valid bit of the SXIP?
3194 (this is only used on the 88k). */
3196 if (!bpstat_explains_signal (stop_bpstat
)
3197 && (stop_signal
!= TARGET_SIGNAL_CHLD
)
3198 && !stopped_by_random_signal
)
3200 #endif /* SHIFT_INST_REGS */
3202 resume (currently_stepping (ecs
), stop_signal
);
3205 prepare_to_wait (ecs
);
3208 /* This function normally comes after a resume, before
3209 handle_inferior_event exits. It takes care of any last bits of
3210 housekeeping, and sets the all-important wait_some_more flag. */
3213 prepare_to_wait (struct execution_control_state
*ecs
)
3215 if (ecs
->infwait_state
== infwait_normal_state
)
3217 overlay_cache_invalid
= 1;
3219 /* We have to invalidate the registers BEFORE calling
3220 target_wait because they can be loaded from the target while
3221 in target_wait. This makes remote debugging a bit more
3222 efficient for those targets that provide critical registers
3223 as part of their normal status mechanism. */
3225 registers_changed ();
3226 ecs
->waiton_pid
= -1;
3227 ecs
->wp
= &(ecs
->ws
);
3229 /* This is the old end of the while loop. Let everybody know we
3230 want to wait for the inferior some more and get called again
3232 ecs
->wait_some_more
= 1;
3235 /* Print why the inferior has stopped. We always print something when
3236 the inferior exits, or receives a signal. The rest of the cases are
3237 dealt with later on in normal_stop() and print_it_typical(). Ideally
3238 there should be a call to this function from handle_inferior_event()
3239 each time stop_stepping() is called.*/
3241 print_stop_reason (enum inferior_stop_reason stop_reason
, int stop_info
)
3243 switch (stop_reason
)
3246 /* We don't deal with these cases from handle_inferior_event()
3249 case END_STEPPING_RANGE
:
3250 /* We are done with a step/next/si/ni command. */
3251 /* For now print nothing. */
3253 /* Print a message only if not in the middle of doing a "step n"
3254 operation for n > 1 */
3255 if (!step_multi
|| !stop_step
)
3256 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3257 ui_out_field_string (uiout
, "reason", "end-stepping-range");
3260 case BREAKPOINT_HIT
:
3261 /* We found a breakpoint. */
3262 /* For now print nothing. */
3265 /* The inferior was terminated by a signal. */
3267 annotate_signalled ();
3268 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3269 ui_out_field_string (uiout
, "reason", "exited-signalled");
3270 ui_out_text (uiout
, "\nProgram terminated with signal ");
3271 annotate_signal_name ();
3272 ui_out_field_string (uiout
, "signal-name", target_signal_to_name (stop_info
));
3273 annotate_signal_name_end ();
3274 ui_out_text (uiout
, ", ");
3275 annotate_signal_string ();
3276 ui_out_field_string (uiout
, "signal-meaning", target_signal_to_string (stop_info
));
3277 annotate_signal_string_end ();
3278 ui_out_text (uiout
, ".\n");
3279 ui_out_text (uiout
, "The program no longer exists.\n");
3281 annotate_signalled ();
3282 printf_filtered ("\nProgram terminated with signal ");
3283 annotate_signal_name ();
3284 printf_filtered ("%s", target_signal_to_name (stop_info
));
3285 annotate_signal_name_end ();
3286 printf_filtered (", ");
3287 annotate_signal_string ();
3288 printf_filtered ("%s", target_signal_to_string (stop_info
));
3289 annotate_signal_string_end ();
3290 printf_filtered (".\n");
3292 printf_filtered ("The program no longer exists.\n");
3293 gdb_flush (gdb_stdout
);
3297 /* The inferior program is finished. */
3299 annotate_exited (stop_info
);
3302 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3303 ui_out_field_string (uiout
, "reason", "exited");
3304 ui_out_text (uiout
, "\nProgram exited with code ");
3305 ui_out_field_fmt (uiout
, "exit-code", "0%o", (unsigned int) stop_info
);
3306 ui_out_text (uiout
, ".\n");
3310 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3311 ui_out_field_string (uiout
, "reason", "exited-normally");
3312 ui_out_text (uiout
, "\nProgram exited normally.\n");
3315 annotate_exited (stop_info
);
3317 printf_filtered ("\nProgram exited with code 0%o.\n",
3318 (unsigned int) stop_info
);
3320 printf_filtered ("\nProgram exited normally.\n");
3323 case SIGNAL_RECEIVED
:
3324 /* Signal received. The signal table tells us to print about
3328 ui_out_text (uiout
, "\nProgram received signal ");
3329 annotate_signal_name ();
3330 ui_out_field_string (uiout
, "signal-name", target_signal_to_name (stop_info
));
3331 annotate_signal_name_end ();
3332 ui_out_text (uiout
, ", ");
3333 annotate_signal_string ();
3334 ui_out_field_string (uiout
, "signal-meaning", target_signal_to_string (stop_info
));
3335 annotate_signal_string_end ();
3336 ui_out_text (uiout
, ".\n");
3339 printf_filtered ("\nProgram received signal ");
3340 annotate_signal_name ();
3341 printf_filtered ("%s", target_signal_to_name (stop_info
));
3342 annotate_signal_name_end ();
3343 printf_filtered (", ");
3344 annotate_signal_string ();
3345 printf_filtered ("%s", target_signal_to_string (stop_info
));
3346 annotate_signal_string_end ();
3347 printf_filtered (".\n");
3348 gdb_flush (gdb_stdout
);
3352 internal_error ("print_stop_reason: unrecognized enum value");
3358 /* Here to return control to GDB when the inferior stops for real.
3359 Print appropriate messages, remove breakpoints, give terminal our modes.
3361 STOP_PRINT_FRAME nonzero means print the executing frame
3362 (pc, function, args, file, line number and line text).
3363 BREAKPOINTS_FAILED nonzero means stop was due to error
3364 attempting to insert breakpoints. */
3369 /* As with the notification of thread events, we want to delay
3370 notifying the user that we've switched thread context until
3371 the inferior actually stops.
3373 (Note that there's no point in saying anything if the inferior
3375 if ((previous_inferior_pid
!= inferior_pid
)
3376 && target_has_execution
)
3378 target_terminal_ours_for_output ();
3379 printf_filtered ("[Switching to %s]\n",
3380 target_pid_or_tid_to_str (inferior_pid
));
3381 previous_inferior_pid
= inferior_pid
;
3384 /* Make sure that the current_frame's pc is correct. This
3385 is a correction for setting up the frame info before doing
3386 DECR_PC_AFTER_BREAK */
3387 if (target_has_execution
&& get_current_frame ())
3388 (get_current_frame ())->pc
= read_pc ();
3390 if (breakpoints_failed
)
3392 target_terminal_ours_for_output ();
3393 print_sys_errmsg ("While inserting breakpoints", breakpoints_failed
);
3394 printf_filtered ("Stopped; cannot insert breakpoints.\n\
3395 The same program may be running in another process,\n\
3396 or you may have requested too many hardware breakpoints\n\
3397 and/or watchpoints.\n");
3400 if (target_has_execution
&& breakpoints_inserted
)
3402 if (remove_breakpoints ())
3404 target_terminal_ours_for_output ();
3405 printf_filtered ("Cannot remove breakpoints because ");
3406 printf_filtered ("program is no longer writable.\n");
3407 printf_filtered ("It might be running in another process.\n");
3408 printf_filtered ("Further execution is probably impossible.\n");
3411 breakpoints_inserted
= 0;
3413 /* Delete the breakpoint we stopped at, if it wants to be deleted.
3414 Delete any breakpoint that is to be deleted at the next stop. */
3416 breakpoint_auto_delete (stop_bpstat
);
3418 /* If an auto-display called a function and that got a signal,
3419 delete that auto-display to avoid an infinite recursion. */
3421 if (stopped_by_random_signal
)
3422 disable_current_display ();
3424 /* Don't print a message if in the middle of doing a "step n"
3425 operation for n > 1 */
3426 if (step_multi
&& stop_step
)
3429 target_terminal_ours ();
3431 /* Look up the hook_stop and run it if it exists. */
3433 if (stop_command
&& stop_command
->hook
)
3435 catch_errors (hook_stop_stub
, stop_command
->hook
,
3436 "Error while running hook_stop:\n", RETURN_MASK_ALL
);
3439 if (!target_has_stack
)
3445 /* Select innermost stack frame - i.e., current frame is frame 0,
3446 and current location is based on that.
3447 Don't do this on return from a stack dummy routine,
3448 or if the program has exited. */
3450 if (!stop_stack_dummy
)
3452 select_frame (get_current_frame (), 0);
3454 /* Print current location without a level number, if
3455 we have changed functions or hit a breakpoint.
3456 Print source line if we have one.
3457 bpstat_print() contains the logic deciding in detail
3458 what to print, based on the event(s) that just occurred. */
3460 if (stop_print_frame
3465 int do_frame_printing
= 1;
3467 bpstat_ret
= bpstat_print (stop_bpstat
);
3472 && step_frame_address
== FRAME_FP (get_current_frame ())
3473 && step_start_function
== find_pc_function (stop_pc
))
3474 source_flag
= SRC_LINE
; /* finished step, just print source line */
3476 source_flag
= SRC_AND_LOC
; /* print location and source line */
3478 case PRINT_SRC_AND_LOC
:
3479 source_flag
= SRC_AND_LOC
; /* print location and source line */
3481 case PRINT_SRC_ONLY
:
3482 source_flag
= SRC_LINE
;
3485 do_frame_printing
= 0;
3488 internal_error ("Unknown value.");
3491 /* For mi, have the same behavior every time we stop:
3492 print everything but the source line. */
3493 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3494 source_flag
= LOC_AND_ADDRESS
;
3498 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3499 ui_out_field_int (uiout
, "thread-id", pid_to_thread_id (inferior_pid
));
3501 /* The behavior of this routine with respect to the source
3503 SRC_LINE: Print only source line
3504 LOCATION: Print only location
3505 SRC_AND_LOC: Print location and source line */
3506 if (do_frame_printing
)
3507 show_and_print_stack_frame (selected_frame
, -1, source_flag
);
3509 /* Display the auto-display expressions. */
3514 /* Save the function value return registers, if we care.
3515 We might be about to restore their previous contents. */
3516 if (proceed_to_finish
)
3517 read_register_bytes (0, stop_registers
, REGISTER_BYTES
);
3519 if (stop_stack_dummy
)
3521 /* Pop the empty frame that contains the stack dummy.
3522 POP_FRAME ends with a setting of the current frame, so we
3523 can use that next. */
3525 /* Set stop_pc to what it was before we called the function.
3526 Can't rely on restore_inferior_status because that only gets
3527 called if we don't stop in the called function. */
3528 stop_pc
= read_pc ();
3529 select_frame (get_current_frame (), 0);
3533 TUIDO (((TuiOpaqueFuncPtr
) tui_vCheckDataValues
, selected_frame
));
3536 annotate_stopped ();
3540 hook_stop_stub (void *cmd
)
3542 execute_user_command ((struct cmd_list_element
*) cmd
, 0);
3547 signal_stop_state (int signo
)
3549 return signal_stop
[signo
];
3553 signal_print_state (int signo
)
3555 return signal_print
[signo
];
3559 signal_pass_state (int signo
)
3561 return signal_program
[signo
];
3564 int signal_stop_update (signo
, state
)
3568 int ret
= signal_stop
[signo
];
3569 signal_stop
[signo
] = state
;
3573 int signal_print_update (signo
, state
)
3577 int ret
= signal_print
[signo
];
3578 signal_print
[signo
] = state
;
3582 int signal_pass_update (signo
, state
)
3586 int ret
= signal_program
[signo
];
3587 signal_program
[signo
] = state
;
3592 sig_print_header (void)
3595 Signal Stop\tPrint\tPass to program\tDescription\n");
3599 sig_print_info (enum target_signal oursig
)
3601 char *name
= target_signal_to_name (oursig
);
3602 int name_padding
= 13 - strlen (name
);
3604 if (name_padding
<= 0)
3607 printf_filtered ("%s", name
);
3608 printf_filtered ("%*.*s ", name_padding
, name_padding
,
3610 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
3611 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
3612 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
3613 printf_filtered ("%s\n", target_signal_to_string (oursig
));
3616 /* Specify how various signals in the inferior should be handled. */
3619 handle_command (char *args
, int from_tty
)
3622 int digits
, wordlen
;
3623 int sigfirst
, signum
, siglast
;
3624 enum target_signal oursig
;
3627 unsigned char *sigs
;
3628 struct cleanup
*old_chain
;
3632 error_no_arg ("signal to handle");
3635 /* Allocate and zero an array of flags for which signals to handle. */
3637 nsigs
= (int) TARGET_SIGNAL_LAST
;
3638 sigs
= (unsigned char *) alloca (nsigs
);
3639 memset (sigs
, 0, nsigs
);
3641 /* Break the command line up into args. */
3643 argv
= buildargv (args
);
3648 old_chain
= make_cleanup_freeargv (argv
);
3650 /* Walk through the args, looking for signal oursigs, signal names, and
3651 actions. Signal numbers and signal names may be interspersed with
3652 actions, with the actions being performed for all signals cumulatively
3653 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
3655 while (*argv
!= NULL
)
3657 wordlen
= strlen (*argv
);
3658 for (digits
= 0; isdigit ((*argv
)[digits
]); digits
++)
3662 sigfirst
= siglast
= -1;
3664 if (wordlen
>= 1 && !strncmp (*argv
, "all", wordlen
))
3666 /* Apply action to all signals except those used by the
3667 debugger. Silently skip those. */
3670 siglast
= nsigs
- 1;
3672 else if (wordlen
>= 1 && !strncmp (*argv
, "stop", wordlen
))
3674 SET_SIGS (nsigs
, sigs
, signal_stop
);
3675 SET_SIGS (nsigs
, sigs
, signal_print
);
3677 else if (wordlen
>= 1 && !strncmp (*argv
, "ignore", wordlen
))
3679 UNSET_SIGS (nsigs
, sigs
, signal_program
);
3681 else if (wordlen
>= 2 && !strncmp (*argv
, "print", wordlen
))
3683 SET_SIGS (nsigs
, sigs
, signal_print
);
3685 else if (wordlen
>= 2 && !strncmp (*argv
, "pass", wordlen
))
3687 SET_SIGS (nsigs
, sigs
, signal_program
);
3689 else if (wordlen
>= 3 && !strncmp (*argv
, "nostop", wordlen
))
3691 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
3693 else if (wordlen
>= 3 && !strncmp (*argv
, "noignore", wordlen
))
3695 SET_SIGS (nsigs
, sigs
, signal_program
);
3697 else if (wordlen
>= 4 && !strncmp (*argv
, "noprint", wordlen
))
3699 UNSET_SIGS (nsigs
, sigs
, signal_print
);
3700 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
3702 else if (wordlen
>= 4 && !strncmp (*argv
, "nopass", wordlen
))
3704 UNSET_SIGS (nsigs
, sigs
, signal_program
);
3706 else if (digits
> 0)
3708 /* It is numeric. The numeric signal refers to our own
3709 internal signal numbering from target.h, not to host/target
3710 signal number. This is a feature; users really should be
3711 using symbolic names anyway, and the common ones like
3712 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
3714 sigfirst
= siglast
= (int)
3715 target_signal_from_command (atoi (*argv
));
3716 if ((*argv
)[digits
] == '-')
3719 target_signal_from_command (atoi ((*argv
) + digits
+ 1));
3721 if (sigfirst
> siglast
)
3723 /* Bet he didn't figure we'd think of this case... */
3731 oursig
= target_signal_from_name (*argv
);
3732 if (oursig
!= TARGET_SIGNAL_UNKNOWN
)
3734 sigfirst
= siglast
= (int) oursig
;
3738 /* Not a number and not a recognized flag word => complain. */
3739 error ("Unrecognized or ambiguous flag word: \"%s\".", *argv
);
3743 /* If any signal numbers or symbol names were found, set flags for
3744 which signals to apply actions to. */
3746 for (signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
3748 switch ((enum target_signal
) signum
)
3750 case TARGET_SIGNAL_TRAP
:
3751 case TARGET_SIGNAL_INT
:
3752 if (!allsigs
&& !sigs
[signum
])
3754 if (query ("%s is used by the debugger.\n\
3755 Are you sure you want to change it? ",
3756 target_signal_to_name
3757 ((enum target_signal
) signum
)))
3763 printf_unfiltered ("Not confirmed, unchanged.\n");
3764 gdb_flush (gdb_stdout
);
3768 case TARGET_SIGNAL_0
:
3769 case TARGET_SIGNAL_DEFAULT
:
3770 case TARGET_SIGNAL_UNKNOWN
:
3771 /* Make sure that "all" doesn't print these. */
3782 target_notice_signals (inferior_pid
);
3786 /* Show the results. */
3787 sig_print_header ();
3788 for (signum
= 0; signum
< nsigs
; signum
++)
3792 sig_print_info (signum
);
3797 do_cleanups (old_chain
);
3801 xdb_handle_command (char *args
, int from_tty
)
3804 struct cleanup
*old_chain
;
3806 /* Break the command line up into args. */
3808 argv
= buildargv (args
);
3813 old_chain
= make_cleanup_freeargv (argv
);
3814 if (argv
[1] != (char *) NULL
)
3819 bufLen
= strlen (argv
[0]) + 20;
3820 argBuf
= (char *) xmalloc (bufLen
);
3824 enum target_signal oursig
;
3826 oursig
= target_signal_from_name (argv
[0]);
3827 memset (argBuf
, 0, bufLen
);
3828 if (strcmp (argv
[1], "Q") == 0)
3829 sprintf (argBuf
, "%s %s", argv
[0], "noprint");
3832 if (strcmp (argv
[1], "s") == 0)
3834 if (!signal_stop
[oursig
])
3835 sprintf (argBuf
, "%s %s", argv
[0], "stop");
3837 sprintf (argBuf
, "%s %s", argv
[0], "nostop");
3839 else if (strcmp (argv
[1], "i") == 0)
3841 if (!signal_program
[oursig
])
3842 sprintf (argBuf
, "%s %s", argv
[0], "pass");
3844 sprintf (argBuf
, "%s %s", argv
[0], "nopass");
3846 else if (strcmp (argv
[1], "r") == 0)
3848 if (!signal_print
[oursig
])
3849 sprintf (argBuf
, "%s %s", argv
[0], "print");
3851 sprintf (argBuf
, "%s %s", argv
[0], "noprint");
3857 handle_command (argBuf
, from_tty
);
3859 printf_filtered ("Invalid signal handling flag.\n");
3864 do_cleanups (old_chain
);
3867 /* Print current contents of the tables set by the handle command.
3868 It is possible we should just be printing signals actually used
3869 by the current target (but for things to work right when switching
3870 targets, all signals should be in the signal tables). */
3873 signals_info (char *signum_exp
, int from_tty
)
3875 enum target_signal oursig
;
3876 sig_print_header ();
3880 /* First see if this is a symbol name. */
3881 oursig
= target_signal_from_name (signum_exp
);
3882 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
3884 /* No, try numeric. */
3886 target_signal_from_command (parse_and_eval_address (signum_exp
));
3888 sig_print_info (oursig
);
3892 printf_filtered ("\n");
3893 /* These ugly casts brought to you by the native VAX compiler. */
3894 for (oursig
= TARGET_SIGNAL_FIRST
;
3895 (int) oursig
< (int) TARGET_SIGNAL_LAST
;
3896 oursig
= (enum target_signal
) ((int) oursig
+ 1))
3900 if (oursig
!= TARGET_SIGNAL_UNKNOWN
3901 && oursig
!= TARGET_SIGNAL_DEFAULT
3902 && oursig
!= TARGET_SIGNAL_0
)
3903 sig_print_info (oursig
);
3906 printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
3909 struct inferior_status
3911 enum target_signal stop_signal
;
3915 int stop_stack_dummy
;
3916 int stopped_by_random_signal
;
3918 CORE_ADDR step_range_start
;
3919 CORE_ADDR step_range_end
;
3920 CORE_ADDR step_frame_address
;
3921 int step_over_calls
;
3922 CORE_ADDR step_resume_break_address
;
3923 int stop_after_trap
;
3924 int stop_soon_quietly
;
3925 CORE_ADDR selected_frame_address
;
3926 char *stop_registers
;
3928 /* These are here because if call_function_by_hand has written some
3929 registers and then decides to call error(), we better not have changed
3934 int breakpoint_proceeded
;
3935 int restore_stack_info
;
3936 int proceed_to_finish
;
3939 static struct inferior_status
*
3940 xmalloc_inferior_status (void)
3942 struct inferior_status
*inf_status
;
3943 inf_status
= xmalloc (sizeof (struct inferior_status
));
3944 inf_status
->stop_registers
= xmalloc (REGISTER_BYTES
);
3945 inf_status
->registers
= xmalloc (REGISTER_BYTES
);
3950 free_inferior_status (struct inferior_status
*inf_status
)
3952 free (inf_status
->registers
);
3953 free (inf_status
->stop_registers
);
3958 write_inferior_status_register (struct inferior_status
*inf_status
, int regno
,
3961 int size
= REGISTER_RAW_SIZE (regno
);
3962 void *buf
= alloca (size
);
3963 store_signed_integer (buf
, size
, val
);
3964 memcpy (&inf_status
->registers
[REGISTER_BYTE (regno
)], buf
, size
);
3967 /* Save all of the information associated with the inferior<==>gdb
3968 connection. INF_STATUS is a pointer to a "struct inferior_status"
3969 (defined in inferior.h). */
3971 struct inferior_status
*
3972 save_inferior_status (int restore_stack_info
)
3974 struct inferior_status
*inf_status
= xmalloc_inferior_status ();
3976 inf_status
->stop_signal
= stop_signal
;
3977 inf_status
->stop_pc
= stop_pc
;
3978 inf_status
->stop_step
= stop_step
;
3979 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
3980 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
3981 inf_status
->trap_expected
= trap_expected
;
3982 inf_status
->step_range_start
= step_range_start
;
3983 inf_status
->step_range_end
= step_range_end
;
3984 inf_status
->step_frame_address
= step_frame_address
;
3985 inf_status
->step_over_calls
= step_over_calls
;
3986 inf_status
->stop_after_trap
= stop_after_trap
;
3987 inf_status
->stop_soon_quietly
= stop_soon_quietly
;
3988 /* Save original bpstat chain here; replace it with copy of chain.
3989 If caller's caller is walking the chain, they'll be happier if we
3990 hand them back the original chain when restore_inferior_status is
3992 inf_status
->stop_bpstat
= stop_bpstat
;
3993 stop_bpstat
= bpstat_copy (stop_bpstat
);
3994 inf_status
->breakpoint_proceeded
= breakpoint_proceeded
;
3995 inf_status
->restore_stack_info
= restore_stack_info
;
3996 inf_status
->proceed_to_finish
= proceed_to_finish
;
3998 memcpy (inf_status
->stop_registers
, stop_registers
, REGISTER_BYTES
);
4000 read_register_bytes (0, inf_status
->registers
, REGISTER_BYTES
);
4002 record_selected_frame (&(inf_status
->selected_frame_address
),
4003 &(inf_status
->selected_level
));
4007 struct restore_selected_frame_args
4009 CORE_ADDR frame_address
;
4014 restore_selected_frame (void *args
)
4016 struct restore_selected_frame_args
*fr
=
4017 (struct restore_selected_frame_args
*) args
;
4018 struct frame_info
*frame
;
4019 int level
= fr
->level
;
4021 frame
= find_relative_frame (get_current_frame (), &level
);
4023 /* If inf_status->selected_frame_address is NULL, there was no
4024 previously selected frame. */
4025 if (frame
== NULL
||
4026 /* FRAME_FP (frame) != fr->frame_address || */
4027 /* elz: deleted this check as a quick fix to the problem that
4028 for function called by hand gdb creates no internal frame
4029 structure and the real stack and gdb's idea of stack are
4030 different if nested calls by hands are made.
4032 mvs: this worries me. */
4035 warning ("Unable to restore previously selected frame.\n");
4039 select_frame (frame
, fr
->level
);
4045 restore_inferior_status (struct inferior_status
*inf_status
)
4047 stop_signal
= inf_status
->stop_signal
;
4048 stop_pc
= inf_status
->stop_pc
;
4049 stop_step
= inf_status
->stop_step
;
4050 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
4051 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
4052 trap_expected
= inf_status
->trap_expected
;
4053 step_range_start
= inf_status
->step_range_start
;
4054 step_range_end
= inf_status
->step_range_end
;
4055 step_frame_address
= inf_status
->step_frame_address
;
4056 step_over_calls
= inf_status
->step_over_calls
;
4057 stop_after_trap
= inf_status
->stop_after_trap
;
4058 stop_soon_quietly
= inf_status
->stop_soon_quietly
;
4059 bpstat_clear (&stop_bpstat
);
4060 stop_bpstat
= inf_status
->stop_bpstat
;
4061 breakpoint_proceeded
= inf_status
->breakpoint_proceeded
;
4062 proceed_to_finish
= inf_status
->proceed_to_finish
;
4064 /* FIXME: Is the restore of stop_registers always needed */
4065 memcpy (stop_registers
, inf_status
->stop_registers
, REGISTER_BYTES
);
4067 /* The inferior can be gone if the user types "print exit(0)"
4068 (and perhaps other times). */
4069 if (target_has_execution
)
4070 write_register_bytes (0, inf_status
->registers
, REGISTER_BYTES
);
4072 /* FIXME: If we are being called after stopping in a function which
4073 is called from gdb, we should not be trying to restore the
4074 selected frame; it just prints a spurious error message (The
4075 message is useful, however, in detecting bugs in gdb (like if gdb
4076 clobbers the stack)). In fact, should we be restoring the
4077 inferior status at all in that case? . */
4079 if (target_has_stack
&& inf_status
->restore_stack_info
)
4081 struct restore_selected_frame_args fr
;
4082 fr
.level
= inf_status
->selected_level
;
4083 fr
.frame_address
= inf_status
->selected_frame_address
;
4084 /* The point of catch_errors is that if the stack is clobbered,
4085 walking the stack might encounter a garbage pointer and error()
4086 trying to dereference it. */
4087 if (catch_errors (restore_selected_frame
, &fr
,
4088 "Unable to restore previously selected frame:\n",
4089 RETURN_MASK_ERROR
) == 0)
4090 /* Error in restoring the selected frame. Select the innermost
4094 select_frame (get_current_frame (), 0);
4098 free_inferior_status (inf_status
);
4102 discard_inferior_status (struct inferior_status
*inf_status
)
4104 /* See save_inferior_status for info on stop_bpstat. */
4105 bpstat_clear (&inf_status
->stop_bpstat
);
4106 free_inferior_status (inf_status
);
4110 set_follow_fork_mode_command (char *arg
, int from_tty
,
4111 struct cmd_list_element
*c
)
4113 if (!STREQ (arg
, "parent") &&
4114 !STREQ (arg
, "child") &&
4115 !STREQ (arg
, "both") &&
4116 !STREQ (arg
, "ask"))
4117 error ("follow-fork-mode must be one of \"parent\", \"child\", \"both\" or \"ask\".");
4119 if (follow_fork_mode_string
!= NULL
)
4120 free (follow_fork_mode_string
);
4121 follow_fork_mode_string
= savestring (arg
, strlen (arg
));
4127 stop_registers
= xmalloc (REGISTER_BYTES
);
4131 _initialize_infrun (void)
4134 register int numsigs
;
4135 struct cmd_list_element
*c
;
4139 register_gdbarch_swap (&stop_registers
, sizeof (stop_registers
), NULL
);
4140 register_gdbarch_swap (NULL
, 0, build_infrun
);
4142 add_info ("signals", signals_info
,
4143 "What debugger does when program gets various signals.\n\
4144 Specify a signal as argument to print info on that signal only.");
4145 add_info_alias ("handle", "signals", 0);
4147 add_com ("handle", class_run
, handle_command
,
4148 concat ("Specify how to handle a signal.\n\
4149 Args are signals and actions to apply to those signals.\n\
4150 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
4151 from 1-15 are allowed for compatibility with old versions of GDB.\n\
4152 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
4153 The special arg \"all\" is recognized to mean all signals except those\n\
4154 used by the debugger, typically SIGTRAP and SIGINT.\n",
4155 "Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
4156 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
4157 Stop means reenter debugger if this signal happens (implies print).\n\
4158 Print means print a message if this signal happens.\n\
4159 Pass means let program see this signal; otherwise program doesn't know.\n\
4160 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
4161 Pass and Stop may be combined.", NULL
));
4164 add_com ("lz", class_info
, signals_info
,
4165 "What debugger does when program gets various signals.\n\
4166 Specify a signal as argument to print info on that signal only.");
4167 add_com ("z", class_run
, xdb_handle_command
,
4168 concat ("Specify how to handle a signal.\n\
4169 Args are signals and actions to apply to those signals.\n\
4170 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
4171 from 1-15 are allowed for compatibility with old versions of GDB.\n\
4172 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
4173 The special arg \"all\" is recognized to mean all signals except those\n\
4174 used by the debugger, typically SIGTRAP and SIGINT.\n",
4175 "Recognized actions include \"s\" (toggles between stop and nostop), \n\
4176 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
4177 nopass), \"Q\" (noprint)\n\
4178 Stop means reenter debugger if this signal happens (implies print).\n\
4179 Print means print a message if this signal happens.\n\
4180 Pass means let program see this signal; otherwise program doesn't know.\n\
4181 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
4182 Pass and Stop may be combined.", NULL
));
4186 stop_command
= add_cmd ("stop", class_obscure
, not_just_help_class_command
,
4187 "There is no `stop' command, but you can set a hook on `stop'.\n\
4188 This allows you to set a list of commands to be run each time execution\n\
4189 of the program stops.", &cmdlist
);
4191 numsigs
= (int) TARGET_SIGNAL_LAST
;
4192 signal_stop
= (unsigned char *)
4193 xmalloc (sizeof (signal_stop
[0]) * numsigs
);
4194 signal_print
= (unsigned char *)
4195 xmalloc (sizeof (signal_print
[0]) * numsigs
);
4196 signal_program
= (unsigned char *)
4197 xmalloc (sizeof (signal_program
[0]) * numsigs
);
4198 for (i
= 0; i
< numsigs
; i
++)
4201 signal_print
[i
] = 1;
4202 signal_program
[i
] = 1;
4205 /* Signals caused by debugger's own actions
4206 should not be given to the program afterwards. */
4207 signal_program
[TARGET_SIGNAL_TRAP
] = 0;
4208 signal_program
[TARGET_SIGNAL_INT
] = 0;
4210 /* Signals that are not errors should not normally enter the debugger. */
4211 signal_stop
[TARGET_SIGNAL_ALRM
] = 0;
4212 signal_print
[TARGET_SIGNAL_ALRM
] = 0;
4213 signal_stop
[TARGET_SIGNAL_VTALRM
] = 0;
4214 signal_print
[TARGET_SIGNAL_VTALRM
] = 0;
4215 signal_stop
[TARGET_SIGNAL_PROF
] = 0;
4216 signal_print
[TARGET_SIGNAL_PROF
] = 0;
4217 signal_stop
[TARGET_SIGNAL_CHLD
] = 0;
4218 signal_print
[TARGET_SIGNAL_CHLD
] = 0;
4219 signal_stop
[TARGET_SIGNAL_IO
] = 0;
4220 signal_print
[TARGET_SIGNAL_IO
] = 0;
4221 signal_stop
[TARGET_SIGNAL_POLL
] = 0;
4222 signal_print
[TARGET_SIGNAL_POLL
] = 0;
4223 signal_stop
[TARGET_SIGNAL_URG
] = 0;
4224 signal_print
[TARGET_SIGNAL_URG
] = 0;
4225 signal_stop
[TARGET_SIGNAL_WINCH
] = 0;
4226 signal_print
[TARGET_SIGNAL_WINCH
] = 0;
4228 /* These signals are used internally by user-level thread
4229 implementations. (See signal(5) on Solaris.) Like the above
4230 signals, a healthy program receives and handles them as part of
4231 its normal operation. */
4232 signal_stop
[TARGET_SIGNAL_LWP
] = 0;
4233 signal_print
[TARGET_SIGNAL_LWP
] = 0;
4234 signal_stop
[TARGET_SIGNAL_WAITING
] = 0;
4235 signal_print
[TARGET_SIGNAL_WAITING
] = 0;
4236 signal_stop
[TARGET_SIGNAL_CANCEL
] = 0;
4237 signal_print
[TARGET_SIGNAL_CANCEL
] = 0;
4241 (add_set_cmd ("stop-on-solib-events", class_support
, var_zinteger
,
4242 (char *) &stop_on_solib_events
,
4243 "Set stopping for shared library events.\n\
4244 If nonzero, gdb will give control to the user when the dynamic linker\n\
4245 notifies gdb of shared library events. The most common event of interest\n\
4246 to the user would be loading/unloading of a new library.\n",
4251 c
= add_set_enum_cmd ("follow-fork-mode",
4253 follow_fork_mode_kind_names
,
4254 (char *) &follow_fork_mode_string
,
4255 /* ??rehrauer: The "both" option is broken, by what may be a 10.20
4256 kernel problem. It's also not terribly useful without a GUI to
4257 help the user drive two debuggers. So for now, I'm disabling
4258 the "both" option. */
4259 /* "Set debugger response to a program call of fork \
4261 A fork or vfork creates a new process. follow-fork-mode can be:\n\
4262 parent - the original process is debugged after a fork\n\
4263 child - the new process is debugged after a fork\n\
4264 both - both the parent and child are debugged after a fork\n\
4265 ask - the debugger will ask for one of the above choices\n\
4266 For \"both\", another copy of the debugger will be started to follow\n\
4267 the new child process. The original debugger will continue to follow\n\
4268 the original parent process. To distinguish their prompts, the\n\
4269 debugger copy's prompt will be changed.\n\
4270 For \"parent\" or \"child\", the unfollowed process will run free.\n\
4271 By default, the debugger will follow the parent process.",
4273 "Set debugger response to a program call of fork \
4275 A fork or vfork creates a new process. follow-fork-mode can be:\n\
4276 parent - the original process is debugged after a fork\n\
4277 child - the new process is debugged after a fork\n\
4278 ask - the debugger will ask for one of the above choices\n\
4279 For \"parent\" or \"child\", the unfollowed process will run free.\n\
4280 By default, the debugger will follow the parent process.",
4282 /* c->function.sfunc = ; */
4283 add_show_from_set (c
, &showlist
);
4285 set_follow_fork_mode_command ("parent", 0, NULL
);
4287 c
= add_set_enum_cmd ("scheduler-locking", class_run
,
4288 scheduler_enums
, /* array of string names */
4289 (char *) &scheduler_mode
, /* current mode */
4290 "Set mode for locking scheduler during execution.\n\
4291 off == no locking (threads may preempt at any time)\n\
4292 on == full locking (no thread except the current thread may run)\n\
4293 step == scheduler locked during every single-step operation.\n\
4294 In this mode, no other thread may run during a step command.\n\
4295 Other threads may run while stepping over a function call ('next').",
4298 c
->function
.sfunc
= set_schedlock_func
; /* traps on target vector */
4299 add_show_from_set (c
, &showlist
);