1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
5 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
6 Software Foundation, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
31 #include "breakpoint.h"
35 #include "cli/cli-script.h"
37 #include "gdbthread.h"
48 /* Prototypes for local functions */
50 static void signals_info (char *, int);
52 static void handle_command (char *, int);
54 static void sig_print_info (enum target_signal
);
56 static void sig_print_header (void);
58 static void resume_cleanups (void *);
60 static int hook_stop_stub (void *);
62 static void delete_breakpoint_current_contents (void *);
64 static int restore_selected_frame (void *);
66 static void build_infrun (void);
68 static int follow_fork (void);
70 static void set_schedlock_func (char *args
, int from_tty
,
71 struct cmd_list_element
*c
);
73 struct execution_control_state
;
75 static int currently_stepping (struct execution_control_state
*ecs
);
77 static void xdb_handle_command (char *args
, int from_tty
);
79 static int prepare_to_proceed (void);
81 void _initialize_infrun (void);
83 int inferior_ignoring_startup_exec_events
= 0;
84 int inferior_ignoring_leading_exec_events
= 0;
86 /* When set, stop the 'step' command if we enter a function which has
87 no line number information. The normal behavior is that we step
88 over such function. */
89 int step_stop_if_no_debug
= 0;
91 /* In asynchronous mode, but simulating synchronous execution. */
93 int sync_execution
= 0;
95 /* wait_for_inferior and normal_stop use this to notify the user
96 when the inferior stopped in a different thread than it had been
99 static ptid_t previous_inferior_ptid
;
101 /* This is true for configurations that may follow through execl() and
102 similar functions. At present this is only true for HP-UX native. */
104 #ifndef MAY_FOLLOW_EXEC
105 #define MAY_FOLLOW_EXEC (0)
108 static int may_follow_exec
= MAY_FOLLOW_EXEC
;
110 /* If the program uses ELF-style shared libraries, then calls to
111 functions in shared libraries go through stubs, which live in a
112 table called the PLT (Procedure Linkage Table). The first time the
113 function is called, the stub sends control to the dynamic linker,
114 which looks up the function's real address, patches the stub so
115 that future calls will go directly to the function, and then passes
116 control to the function.
118 If we are stepping at the source level, we don't want to see any of
119 this --- we just want to skip over the stub and the dynamic linker.
120 The simple approach is to single-step until control leaves the
123 However, on some systems (e.g., Red Hat's 5.2 distribution) the
124 dynamic linker calls functions in the shared C library, so you
125 can't tell from the PC alone whether the dynamic linker is still
126 running. In this case, we use a step-resume breakpoint to get us
127 past the dynamic linker, as if we were using "next" to step over a
130 IN_SOLIB_DYNSYM_RESOLVE_CODE says whether we're in the dynamic
131 linker code or not. Normally, this means we single-step. However,
132 if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an
133 address where we can place a step-resume breakpoint to get past the
134 linker's symbol resolution function.
136 IN_SOLIB_DYNSYM_RESOLVE_CODE can generally be implemented in a
137 pretty portable way, by comparing the PC against the address ranges
138 of the dynamic linker's sections.
140 SKIP_SOLIB_RESOLVER is generally going to be system-specific, since
141 it depends on internal details of the dynamic linker. It's usually
142 not too hard to figure out where to put a breakpoint, but it
143 certainly isn't portable. SKIP_SOLIB_RESOLVER should do plenty of
144 sanity checking. If it can't figure things out, returning zero and
145 getting the (possibly confusing) stepping behavior is better than
146 signalling an error, which will obscure the change in the
149 #ifndef IN_SOLIB_DYNSYM_RESOLVE_CODE
150 #define IN_SOLIB_DYNSYM_RESOLVE_CODE(pc) 0
153 /* This function returns TRUE if pc is the address of an instruction
154 that lies within the dynamic linker (such as the event hook, or the
157 This function must be used only when a dynamic linker event has
158 been caught, and the inferior is being stepped out of the hook, or
159 undefined results are guaranteed. */
161 #ifndef SOLIB_IN_DYNAMIC_LINKER
162 #define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0
165 /* On MIPS16, a function that returns a floating point value may call
166 a library helper function to copy the return value to a floating point
167 register. The IGNORE_HELPER_CALL macro returns non-zero if we
168 should ignore (i.e. step over) this function call. */
169 #ifndef IGNORE_HELPER_CALL
170 #define IGNORE_HELPER_CALL(pc) 0
173 /* On some systems, the PC may be left pointing at an instruction that won't
174 actually be executed. This is usually indicated by a bit in the PSW. If
175 we find ourselves in such a state, then we step the target beyond the
176 nullified instruction before returning control to the user so as to avoid
179 #ifndef INSTRUCTION_NULLIFIED
180 #define INSTRUCTION_NULLIFIED 0
183 /* We can't step off a permanent breakpoint in the ordinary way, because we
184 can't remove it. Instead, we have to advance the PC to the next
185 instruction. This macro should expand to a pointer to a function that
186 does that, or zero if we have no such function. If we don't have a
187 definition for it, we have to report an error. */
188 #ifndef SKIP_PERMANENT_BREAKPOINT
189 #define SKIP_PERMANENT_BREAKPOINT (default_skip_permanent_breakpoint)
191 default_skip_permanent_breakpoint (void)
194 The program is stopped at a permanent breakpoint, but GDB does not know\n\
195 how to step past a permanent breakpoint on this architecture. Try using\n\
196 a command like `return' or `jump' to continue execution.");
201 /* Convert the #defines into values. This is temporary until wfi control
202 flow is completely sorted out. */
204 #ifndef HAVE_STEPPABLE_WATCHPOINT
205 #define HAVE_STEPPABLE_WATCHPOINT 0
207 #undef HAVE_STEPPABLE_WATCHPOINT
208 #define HAVE_STEPPABLE_WATCHPOINT 1
211 #ifndef CANNOT_STEP_HW_WATCHPOINTS
212 #define CANNOT_STEP_HW_WATCHPOINTS 0
214 #undef CANNOT_STEP_HW_WATCHPOINTS
215 #define CANNOT_STEP_HW_WATCHPOINTS 1
218 /* Tables of how to react to signals; the user sets them. */
220 static unsigned char *signal_stop
;
221 static unsigned char *signal_print
;
222 static unsigned char *signal_program
;
224 #define SET_SIGS(nsigs,sigs,flags) \
226 int signum = (nsigs); \
227 while (signum-- > 0) \
228 if ((sigs)[signum]) \
229 (flags)[signum] = 1; \
232 #define UNSET_SIGS(nsigs,sigs,flags) \
234 int signum = (nsigs); \
235 while (signum-- > 0) \
236 if ((sigs)[signum]) \
237 (flags)[signum] = 0; \
240 /* Value to pass to target_resume() to cause all threads to resume */
242 #define RESUME_ALL (pid_to_ptid (-1))
244 /* Command list pointer for the "stop" placeholder. */
246 static struct cmd_list_element
*stop_command
;
248 /* Nonzero if breakpoints are now inserted in the inferior. */
250 static int breakpoints_inserted
;
252 /* Function inferior was in as of last step command. */
254 static struct symbol
*step_start_function
;
256 /* Nonzero if we are expecting a trace trap and should proceed from it. */
258 static int trap_expected
;
261 /* Nonzero if we want to give control to the user when we're notified
262 of shared library events by the dynamic linker. */
263 static int stop_on_solib_events
;
267 /* Nonzero if the next time we try to continue the inferior, it will
268 step one instruction and generate a spurious trace trap.
269 This is used to compensate for a bug in HP-UX. */
271 static int trap_expected_after_continue
;
274 /* Nonzero means expecting a trace trap
275 and should stop the inferior and return silently when it happens. */
279 /* Nonzero means expecting a trap and caller will handle it themselves.
280 It is used after attach, due to attaching to a process;
281 when running in the shell before the child program has been exec'd;
282 and when running some kinds of remote stuff (FIXME?). */
284 enum stop_kind stop_soon
;
286 /* Nonzero if proceed is being used for a "finish" command or a similar
287 situation when stop_registers should be saved. */
289 int proceed_to_finish
;
291 /* Save register contents here when about to pop a stack dummy frame,
292 if-and-only-if proceed_to_finish is set.
293 Thus this contains the return value from the called function (assuming
294 values are returned in a register). */
296 struct regcache
*stop_registers
;
298 /* Nonzero if program stopped due to error trying to insert breakpoints. */
300 static int breakpoints_failed
;
302 /* Nonzero after stop if current stack frame should be printed. */
304 static int stop_print_frame
;
306 static struct breakpoint
*step_resume_breakpoint
= NULL
;
307 static struct breakpoint
*through_sigtramp_breakpoint
= NULL
;
309 /* On some platforms (e.g., HP-UX), hardware watchpoints have bad
310 interactions with an inferior that is running a kernel function
311 (aka, a system call or "syscall"). wait_for_inferior therefore
312 may have a need to know when the inferior is in a syscall. This
313 is a count of the number of inferior threads which are known to
314 currently be running in a syscall. */
315 static int number_of_threads_in_syscalls
;
317 /* This is a cached copy of the pid/waitstatus of the last event
318 returned by target_wait()/target_wait_hook(). This information is
319 returned by get_last_target_status(). */
320 static ptid_t target_last_wait_ptid
;
321 static struct target_waitstatus target_last_waitstatus
;
323 /* This is used to remember when a fork, vfork or exec event
324 was caught by a catchpoint, and thus the event is to be
325 followed at the next resume of the inferior, and not
329 enum target_waitkind kind
;
336 char *execd_pathname
;
340 static const char follow_fork_mode_child
[] = "child";
341 static const char follow_fork_mode_parent
[] = "parent";
343 static const char *follow_fork_mode_kind_names
[] = {
344 follow_fork_mode_child
,
345 follow_fork_mode_parent
,
349 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
355 int follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
357 return target_follow_fork (follow_child
);
361 follow_inferior_reset_breakpoints (void)
363 /* Was there a step_resume breakpoint? (There was if the user
364 did a "next" at the fork() call.) If so, explicitly reset its
367 step_resumes are a form of bp that are made to be per-thread.
368 Since we created the step_resume bp when the parent process
369 was being debugged, and now are switching to the child process,
370 from the breakpoint package's viewpoint, that's a switch of
371 "threads". We must update the bp's notion of which thread
372 it is for, or it'll be ignored when it triggers. */
374 if (step_resume_breakpoint
)
375 breakpoint_re_set_thread (step_resume_breakpoint
);
377 /* Reinsert all breakpoints in the child. The user may have set
378 breakpoints after catching the fork, in which case those
379 were never set in the child, but only in the parent. This makes
380 sure the inserted breakpoints match the breakpoint list. */
382 breakpoint_re_set ();
383 insert_breakpoints ();
386 /* EXECD_PATHNAME is assumed to be non-NULL. */
389 follow_exec (int pid
, char *execd_pathname
)
392 struct target_ops
*tgt
;
394 if (!may_follow_exec
)
397 /* This is an exec event that we actually wish to pay attention to.
398 Refresh our symbol table to the newly exec'd program, remove any
401 If there are breakpoints, they aren't really inserted now,
402 since the exec() transformed our inferior into a fresh set
405 We want to preserve symbolic breakpoints on the list, since
406 we have hopes that they can be reset after the new a.out's
407 symbol table is read.
409 However, any "raw" breakpoints must be removed from the list
410 (e.g., the solib bp's), since their address is probably invalid
413 And, we DON'T want to call delete_breakpoints() here, since
414 that may write the bp's "shadow contents" (the instruction
415 value that was overwritten witha TRAP instruction). Since
416 we now have a new a.out, those shadow contents aren't valid. */
417 update_breakpoints_after_exec ();
419 /* If there was one, it's gone now. We cannot truly step-to-next
420 statement through an exec(). */
421 step_resume_breakpoint
= NULL
;
422 step_range_start
= 0;
425 /* If there was one, it's gone now. */
426 through_sigtramp_breakpoint
= NULL
;
428 /* What is this a.out's name? */
429 printf_unfiltered ("Executing new program: %s\n", execd_pathname
);
431 /* We've followed the inferior through an exec. Therefore, the
432 inferior has essentially been killed & reborn. */
434 /* First collect the run target in effect. */
435 tgt
= find_run_target ();
436 /* If we can't find one, things are in a very strange state... */
438 error ("Could find run target to save before following exec");
440 gdb_flush (gdb_stdout
);
441 target_mourn_inferior ();
442 inferior_ptid
= pid_to_ptid (saved_pid
);
443 /* Because mourn_inferior resets inferior_ptid. */
446 /* That a.out is now the one to use. */
447 exec_file_attach (execd_pathname
, 0);
449 /* And also is where symbols can be found. */
450 symbol_file_add_main (execd_pathname
, 0);
452 /* Reset the shared library package. This ensures that we get
453 a shlib event when the child reaches "_start", at which point
454 the dld will have had a chance to initialize the child. */
455 #if defined(SOLIB_RESTART)
458 #ifdef SOLIB_CREATE_INFERIOR_HOOK
459 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
462 /* Reinsert all breakpoints. (Those which were symbolic have
463 been reset to the proper address in the new a.out, thanks
464 to symbol_file_command...) */
465 insert_breakpoints ();
467 /* The next resume of this inferior should bring it to the shlib
468 startup breakpoints. (If the user had also set bp's on
469 "main" from the old (parent) process, then they'll auto-
470 matically get reset there in the new process.) */
473 /* Non-zero if we just simulating a single-step. This is needed
474 because we cannot remove the breakpoints in the inferior process
475 until after the `wait' in `wait_for_inferior'. */
476 static int singlestep_breakpoints_inserted_p
= 0;
479 /* Things to clean up if we QUIT out of resume (). */
481 resume_cleanups (void *ignore
)
486 static const char schedlock_off
[] = "off";
487 static const char schedlock_on
[] = "on";
488 static const char schedlock_step
[] = "step";
489 static const char *scheduler_mode
= schedlock_off
;
490 static const char *scheduler_enums
[] = {
498 set_schedlock_func (char *args
, int from_tty
, struct cmd_list_element
*c
)
500 /* NOTE: cagney/2002-03-17: The add_show_from_set() function clones
501 the set command passed as a parameter. The clone operation will
502 include (BUG?) any ``set'' command callback, if present.
503 Commands like ``info set'' call all the ``show'' command
504 callbacks. Unfortunately, for ``show'' commands cloned from
505 ``set'', this includes callbacks belonging to ``set'' commands.
506 Making this worse, this only occures if add_show_from_set() is
507 called after add_cmd_sfunc() (BUG?). */
508 if (cmd_type (c
) == set_cmd
)
509 if (!target_can_lock_scheduler
)
511 scheduler_mode
= schedlock_off
;
512 error ("Target '%s' cannot support this command.", target_shortname
);
517 /* Resume the inferior, but allow a QUIT. This is useful if the user
518 wants to interrupt some lengthy single-stepping operation
519 (for child processes, the SIGINT goes to the inferior, and so
520 we get a SIGINT random_signal, but for remote debugging and perhaps
521 other targets, that's not true).
523 STEP nonzero if we should step (zero to continue instead).
524 SIG is the signal to give the inferior (zero for none). */
526 resume (int step
, enum target_signal sig
)
528 int should_resume
= 1;
529 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
532 /* FIXME: calling breakpoint_here_p (read_pc ()) three times! */
535 /* Some targets (e.g. Solaris x86) have a kernel bug when stepping
536 over an instruction that causes a page fault without triggering
537 a hardware watchpoint. The kernel properly notices that it shouldn't
538 stop, because the hardware watchpoint is not triggered, but it forgets
539 the step request and continues the program normally.
540 Work around the problem by removing hardware watchpoints if a step is
541 requested, GDB will check for a hardware watchpoint trigger after the
543 if (CANNOT_STEP_HW_WATCHPOINTS
&& step
&& breakpoints_inserted
)
544 remove_hw_watchpoints ();
547 /* Normally, by the time we reach `resume', the breakpoints are either
548 removed or inserted, as appropriate. The exception is if we're sitting
549 at a permanent breakpoint; we need to step over it, but permanent
550 breakpoints can't be removed. So we have to test for it here. */
551 if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here
)
552 SKIP_PERMANENT_BREAKPOINT ();
554 if (SOFTWARE_SINGLE_STEP_P () && step
)
556 /* Do it the hard way, w/temp breakpoints */
557 SOFTWARE_SINGLE_STEP (sig
, 1 /*insert-breakpoints */ );
558 /* ...and don't ask hardware to do it. */
560 /* and do not pull these breakpoints until after a `wait' in
561 `wait_for_inferior' */
562 singlestep_breakpoints_inserted_p
= 1;
565 /* Handle any optimized stores to the inferior NOW... */
566 #ifdef DO_DEFERRED_STORES
570 /* If there were any forks/vforks/execs that were caught and are
571 now to be followed, then do so. */
572 switch (pending_follow
.kind
)
574 case TARGET_WAITKIND_FORKED
:
575 case TARGET_WAITKIND_VFORKED
:
576 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
581 case TARGET_WAITKIND_EXECD
:
582 /* follow_exec is called as soon as the exec event is seen. */
583 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
590 /* Install inferior's terminal modes. */
591 target_terminal_inferior ();
597 resume_ptid
= RESUME_ALL
; /* Default */
599 if ((step
|| singlestep_breakpoints_inserted_p
) &&
600 !breakpoints_inserted
&& breakpoint_here_p (read_pc ()))
602 /* Stepping past a breakpoint without inserting breakpoints.
603 Make sure only the current thread gets to step, so that
604 other threads don't sneak past breakpoints while they are
607 resume_ptid
= inferior_ptid
;
610 if ((scheduler_mode
== schedlock_on
) ||
611 (scheduler_mode
== schedlock_step
&&
612 (step
|| singlestep_breakpoints_inserted_p
)))
614 /* User-settable 'scheduler' mode requires solo thread resume. */
615 resume_ptid
= inferior_ptid
;
618 if (CANNOT_STEP_BREAKPOINT
)
620 /* Most targets can step a breakpoint instruction, thus
621 executing it normally. But if this one cannot, just
622 continue and we will hit it anyway. */
623 if (step
&& breakpoints_inserted
&& breakpoint_here_p (read_pc ()))
626 target_resume (resume_ptid
, step
, sig
);
629 discard_cleanups (old_cleanups
);
633 /* Clear out all variables saying what to do when inferior is continued.
634 First do this, then set the ones you want, then call `proceed'. */
637 clear_proceed_status (void)
640 step_range_start
= 0;
642 step_frame_id
= null_frame_id
;
643 step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
645 stop_soon
= NO_STOP_QUIETLY
;
646 proceed_to_finish
= 0;
647 breakpoint_proceeded
= 1; /* We're about to proceed... */
649 /* Discard any remaining commands or status from previous stop. */
650 bpstat_clear (&stop_bpstat
);
653 /* This should be suitable for any targets that support threads. */
656 prepare_to_proceed (void)
659 struct target_waitstatus wait_status
;
661 /* Get the last target status returned by target_wait(). */
662 get_last_target_status (&wait_ptid
, &wait_status
);
664 /* Make sure we were stopped either at a breakpoint, or because
666 if (wait_status
.kind
!= TARGET_WAITKIND_STOPPED
667 || (wait_status
.value
.sig
!= TARGET_SIGNAL_TRAP
&&
668 wait_status
.value
.sig
!= TARGET_SIGNAL_INT
))
673 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
674 && !ptid_equal (inferior_ptid
, wait_ptid
))
676 /* Switched over from WAIT_PID. */
677 CORE_ADDR wait_pc
= read_pc_pid (wait_ptid
);
679 if (wait_pc
!= read_pc ())
681 /* Switch back to WAIT_PID thread. */
682 inferior_ptid
= wait_ptid
;
684 /* FIXME: This stuff came from switch_to_thread() in
685 thread.c (which should probably be a public function). */
686 flush_cached_frames ();
687 registers_changed ();
689 select_frame (get_current_frame ());
692 /* We return 1 to indicate that there is a breakpoint here,
693 so we need to step over it before continuing to avoid
694 hitting it straight away. */
695 if (breakpoint_here_p (wait_pc
))
703 /* Record the pc of the program the last time it stopped. This is
704 just used internally by wait_for_inferior, but need to be preserved
705 over calls to it and cleared when the inferior is started. */
706 static CORE_ADDR prev_pc
;
708 /* Basic routine for continuing the program in various fashions.
710 ADDR is the address to resume at, or -1 for resume where stopped.
711 SIGGNAL is the signal to give it, or 0 for none,
712 or -1 for act according to how it stopped.
713 STEP is nonzero if should trap after one instruction.
714 -1 means return after that and print nothing.
715 You should probably set various step_... variables
716 before calling here, if you are stepping.
718 You should call clear_proceed_status before calling proceed. */
721 proceed (CORE_ADDR addr
, enum target_signal siggnal
, int step
)
726 step_start_function
= find_pc_function (read_pc ());
730 if (addr
== (CORE_ADDR
) -1)
732 /* If there is a breakpoint at the address we will resume at,
733 step one instruction before inserting breakpoints
734 so that we do not stop right away (and report a second
735 hit at this breakpoint). */
737 if (read_pc () == stop_pc
&& breakpoint_here_p (read_pc ()))
740 #ifndef STEP_SKIPS_DELAY
741 #define STEP_SKIPS_DELAY(pc) (0)
742 #define STEP_SKIPS_DELAY_P (0)
744 /* Check breakpoint_here_p first, because breakpoint_here_p is fast
745 (it just checks internal GDB data structures) and STEP_SKIPS_DELAY
746 is slow (it needs to read memory from the target). */
747 if (STEP_SKIPS_DELAY_P
748 && breakpoint_here_p (read_pc () + 4)
749 && STEP_SKIPS_DELAY (read_pc ()))
757 /* In a multi-threaded task we may select another thread
758 and then continue or step.
760 But if the old thread was stopped at a breakpoint, it
761 will immediately cause another breakpoint stop without
762 any execution (i.e. it will report a breakpoint hit
763 incorrectly). So we must step over it first.
765 prepare_to_proceed checks the current thread against the thread
766 that reported the most recent event. If a step-over is required
767 it returns TRUE and sets the current thread to the old thread. */
768 if (prepare_to_proceed () && breakpoint_here_p (read_pc ()))
772 if (trap_expected_after_continue
)
774 /* If (step == 0), a trap will be automatically generated after
775 the first instruction is executed. Force step one
776 instruction to clear this condition. This should not occur
777 if step is nonzero, but it is harmless in that case. */
779 trap_expected_after_continue
= 0;
781 #endif /* HP_OS_BUG */
784 /* We will get a trace trap after one instruction.
785 Continue it automatically and insert breakpoints then. */
789 insert_breakpoints ();
790 /* If we get here there was no call to error() in
791 insert breakpoints -- so they were inserted. */
792 breakpoints_inserted
= 1;
795 if (siggnal
!= TARGET_SIGNAL_DEFAULT
)
796 stop_signal
= siggnal
;
797 /* If this signal should not be seen by program,
798 give it zero. Used for debugging signals. */
799 else if (!signal_program
[stop_signal
])
800 stop_signal
= TARGET_SIGNAL_0
;
802 annotate_starting ();
804 /* Make sure that output from GDB appears before output from the
806 gdb_flush (gdb_stdout
);
808 /* Refresh prev_pc value just prior to resuming. This used to be
809 done in stop_stepping, however, setting prev_pc there did not handle
810 scenarios such as inferior function calls or returning from
811 a function via the return command. In those cases, the prev_pc
812 value was not set properly for subsequent commands. The prev_pc value
813 is used to initialize the starting line number in the ecs. With an
814 invalid value, the gdb next command ends up stopping at the position
815 represented by the next line table entry past our start position.
816 On platforms that generate one line table entry per line, this
817 is not a problem. However, on the ia64, the compiler generates
818 extraneous line table entries that do not increase the line number.
819 When we issue the gdb next command on the ia64 after an inferior call
820 or a return command, we often end up a few instructions forward, still
821 within the original line we started.
823 An attempt was made to have init_execution_control_state () refresh
824 the prev_pc value before calculating the line number. This approach
825 did not work because on platforms that use ptrace, the pc register
826 cannot be read unless the inferior is stopped. At that point, we
827 are not guaranteed the inferior is stopped and so the read_pc ()
828 call can fail. Setting the prev_pc value here ensures the value is
829 updated correctly when the inferior is stopped. */
830 prev_pc
= read_pc ();
832 /* Resume inferior. */
833 resume (oneproc
|| step
|| bpstat_should_step (), stop_signal
);
835 /* Wait for it to stop (if not standalone)
836 and in any case decode why it stopped, and act accordingly. */
837 /* Do this only if we are not using the event loop, or if the target
838 does not support asynchronous execution. */
839 if (!event_loop_p
|| !target_can_async_p ())
841 wait_for_inferior ();
847 /* Start remote-debugging of a machine over a serial link. */
853 init_wait_for_inferior ();
854 stop_soon
= STOP_QUIETLY
;
857 /* Always go on waiting for the target, regardless of the mode. */
858 /* FIXME: cagney/1999-09-23: At present it isn't possible to
859 indicate to wait_for_inferior that a target should timeout if
860 nothing is returned (instead of just blocking). Because of this,
861 targets expecting an immediate response need to, internally, set
862 things up so that the target_wait() is forced to eventually
864 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
865 differentiate to its caller what the state of the target is after
866 the initial open has been performed. Here we're assuming that
867 the target has stopped. It should be possible to eventually have
868 target_open() return to the caller an indication that the target
869 is currently running and GDB state should be set to the same as
871 wait_for_inferior ();
875 /* Initialize static vars when a new inferior begins. */
878 init_wait_for_inferior (void)
880 /* These are meaningless until the first time through wait_for_inferior. */
884 trap_expected_after_continue
= 0;
886 breakpoints_inserted
= 0;
887 breakpoint_init_inferior (inf_starting
);
889 /* Don't confuse first call to proceed(). */
890 stop_signal
= TARGET_SIGNAL_0
;
892 /* The first resume is not following a fork/vfork/exec. */
893 pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
; /* I.e., none. */
895 /* See wait_for_inferior's handling of SYSCALL_ENTRY/RETURN events. */
896 number_of_threads_in_syscalls
= 0;
898 clear_proceed_status ();
902 delete_breakpoint_current_contents (void *arg
)
904 struct breakpoint
**breakpointp
= (struct breakpoint
**) arg
;
905 if (*breakpointp
!= NULL
)
907 delete_breakpoint (*breakpointp
);
912 /* This enum encodes possible reasons for doing a target_wait, so that
913 wfi can call target_wait in one place. (Ultimately the call will be
914 moved out of the infinite loop entirely.) */
918 infwait_normal_state
,
919 infwait_thread_hop_state
,
920 infwait_nullified_state
,
921 infwait_nonstep_watch_state
924 /* Why did the inferior stop? Used to print the appropriate messages
925 to the interface from within handle_inferior_event(). */
926 enum inferior_stop_reason
928 /* We don't know why. */
930 /* Step, next, nexti, stepi finished. */
932 /* Found breakpoint. */
934 /* Inferior terminated by signal. */
936 /* Inferior exited. */
938 /* Inferior received signal, and user asked to be notified. */
942 /* This structure contains what used to be local variables in
943 wait_for_inferior. Probably many of them can return to being
944 locals in handle_inferior_event. */
946 struct execution_control_state
948 struct target_waitstatus ws
;
949 struct target_waitstatus
*wp
;
952 CORE_ADDR stop_func_start
;
953 CORE_ADDR stop_func_end
;
954 char *stop_func_name
;
955 struct symtab_and_line sal
;
956 int remove_breakpoints_on_following_step
;
958 struct symtab
*current_symtab
;
959 int handling_longjmp
; /* FIXME */
961 ptid_t saved_inferior_ptid
;
963 int stepping_through_solib_after_catch
;
964 bpstat stepping_through_solib_catchpoints
;
965 int enable_hw_watchpoints_after_wait
;
966 int stepping_through_sigtramp
;
967 int new_thread_event
;
968 struct target_waitstatus tmpstatus
;
969 enum infwait_states infwait_state
;
974 void init_execution_control_state (struct execution_control_state
*ecs
);
976 static void handle_step_into_function (struct execution_control_state
*ecs
);
977 void handle_inferior_event (struct execution_control_state
*ecs
);
979 static void check_sigtramp2 (struct execution_control_state
*ecs
);
980 static void step_into_function (struct execution_control_state
*ecs
);
981 static void step_over_function (struct execution_control_state
*ecs
);
982 static void stop_stepping (struct execution_control_state
*ecs
);
983 static void prepare_to_wait (struct execution_control_state
*ecs
);
984 static void keep_going (struct execution_control_state
*ecs
);
985 static void print_stop_reason (enum inferior_stop_reason stop_reason
,
988 /* Wait for control to return from inferior to debugger.
989 If inferior gets a signal, we may decide to start it up again
990 instead of returning. That is why there is a loop in this function.
991 When this function actually returns it means the inferior
992 should be left stopped and GDB should read more commands. */
995 wait_for_inferior (void)
997 struct cleanup
*old_cleanups
;
998 struct execution_control_state ecss
;
999 struct execution_control_state
*ecs
;
1001 old_cleanups
= make_cleanup (delete_step_resume_breakpoint
,
1002 &step_resume_breakpoint
);
1003 make_cleanup (delete_breakpoint_current_contents
,
1004 &through_sigtramp_breakpoint
);
1006 /* wfi still stays in a loop, so it's OK just to take the address of
1007 a local to get the ecs pointer. */
1010 /* Fill in with reasonable starting values. */
1011 init_execution_control_state (ecs
);
1013 /* We'll update this if & when we switch to a new thread. */
1014 previous_inferior_ptid
= inferior_ptid
;
1016 overlay_cache_invalid
= 1;
1018 /* We have to invalidate the registers BEFORE calling target_wait
1019 because they can be loaded from the target while in target_wait.
1020 This makes remote debugging a bit more efficient for those
1021 targets that provide critical registers as part of their normal
1022 status mechanism. */
1024 registers_changed ();
1028 if (target_wait_hook
)
1029 ecs
->ptid
= target_wait_hook (ecs
->waiton_ptid
, ecs
->wp
);
1031 ecs
->ptid
= target_wait (ecs
->waiton_ptid
, ecs
->wp
);
1033 /* Now figure out what to do with the result of the result. */
1034 handle_inferior_event (ecs
);
1036 if (!ecs
->wait_some_more
)
1039 do_cleanups (old_cleanups
);
1042 /* Asynchronous version of wait_for_inferior. It is called by the
1043 event loop whenever a change of state is detected on the file
1044 descriptor corresponding to the target. It can be called more than
1045 once to complete a single execution command. In such cases we need
1046 to keep the state in a global variable ASYNC_ECSS. If it is the
1047 last time that this function is called for a single execution
1048 command, then report to the user that the inferior has stopped, and
1049 do the necessary cleanups. */
1051 struct execution_control_state async_ecss
;
1052 struct execution_control_state
*async_ecs
;
1055 fetch_inferior_event (void *client_data
)
1057 static struct cleanup
*old_cleanups
;
1059 async_ecs
= &async_ecss
;
1061 if (!async_ecs
->wait_some_more
)
1063 old_cleanups
= make_exec_cleanup (delete_step_resume_breakpoint
,
1064 &step_resume_breakpoint
);
1065 make_exec_cleanup (delete_breakpoint_current_contents
,
1066 &through_sigtramp_breakpoint
);
1068 /* Fill in with reasonable starting values. */
1069 init_execution_control_state (async_ecs
);
1071 /* We'll update this if & when we switch to a new thread. */
1072 previous_inferior_ptid
= inferior_ptid
;
1074 overlay_cache_invalid
= 1;
1076 /* We have to invalidate the registers BEFORE calling target_wait
1077 because they can be loaded from the target while in target_wait.
1078 This makes remote debugging a bit more efficient for those
1079 targets that provide critical registers as part of their normal
1080 status mechanism. */
1082 registers_changed ();
1085 if (target_wait_hook
)
1087 target_wait_hook (async_ecs
->waiton_ptid
, async_ecs
->wp
);
1089 async_ecs
->ptid
= target_wait (async_ecs
->waiton_ptid
, async_ecs
->wp
);
1091 /* Now figure out what to do with the result of the result. */
1092 handle_inferior_event (async_ecs
);
1094 if (!async_ecs
->wait_some_more
)
1096 /* Do only the cleanups that have been added by this
1097 function. Let the continuations for the commands do the rest,
1098 if there are any. */
1099 do_exec_cleanups (old_cleanups
);
1101 if (step_multi
&& stop_step
)
1102 inferior_event_handler (INF_EXEC_CONTINUE
, NULL
);
1104 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
1108 /* Prepare an execution control state for looping through a
1109 wait_for_inferior-type loop. */
1112 init_execution_control_state (struct execution_control_state
*ecs
)
1114 /* ecs->another_trap? */
1115 ecs
->random_signal
= 0;
1116 ecs
->remove_breakpoints_on_following_step
= 0;
1117 ecs
->handling_longjmp
= 0; /* FIXME */
1118 ecs
->update_step_sp
= 0;
1119 ecs
->stepping_through_solib_after_catch
= 0;
1120 ecs
->stepping_through_solib_catchpoints
= NULL
;
1121 ecs
->enable_hw_watchpoints_after_wait
= 0;
1122 ecs
->stepping_through_sigtramp
= 0;
1123 ecs
->sal
= find_pc_line (prev_pc
, 0);
1124 ecs
->current_line
= ecs
->sal
.line
;
1125 ecs
->current_symtab
= ecs
->sal
.symtab
;
1126 ecs
->infwait_state
= infwait_normal_state
;
1127 ecs
->waiton_ptid
= pid_to_ptid (-1);
1128 ecs
->wp
= &(ecs
->ws
);
1131 /* Call this function before setting step_resume_breakpoint, as a
1132 sanity check. There should never be more than one step-resume
1133 breakpoint per thread, so we should never be setting a new
1134 step_resume_breakpoint when one is already active. */
1136 check_for_old_step_resume_breakpoint (void)
1138 if (step_resume_breakpoint
)
1140 ("GDB bug: infrun.c (wait_for_inferior): dropping old step_resume breakpoint");
1143 /* Return the cached copy of the last pid/waitstatus returned by
1144 target_wait()/target_wait_hook(). The data is actually cached by
1145 handle_inferior_event(), which gets called immediately after
1146 target_wait()/target_wait_hook(). */
1149 get_last_target_status (ptid_t
*ptidp
, struct target_waitstatus
*status
)
1151 *ptidp
= target_last_wait_ptid
;
1152 *status
= target_last_waitstatus
;
1155 /* Switch thread contexts, maintaining "infrun state". */
1158 context_switch (struct execution_control_state
*ecs
)
1160 /* Caution: it may happen that the new thread (or the old one!)
1161 is not in the thread list. In this case we must not attempt
1162 to "switch context", or we run the risk that our context may
1163 be lost. This may happen as a result of the target module
1164 mishandling thread creation. */
1166 if (in_thread_list (inferior_ptid
) && in_thread_list (ecs
->ptid
))
1167 { /* Perform infrun state context switch: */
1168 /* Save infrun state for the old thread. */
1169 save_infrun_state (inferior_ptid
, prev_pc
,
1170 trap_expected
, step_resume_breakpoint
,
1171 through_sigtramp_breakpoint
, step_range_start
,
1172 step_range_end
, &step_frame_id
,
1173 ecs
->handling_longjmp
, ecs
->another_trap
,
1174 ecs
->stepping_through_solib_after_catch
,
1175 ecs
->stepping_through_solib_catchpoints
,
1176 ecs
->stepping_through_sigtramp
,
1177 ecs
->current_line
, ecs
->current_symtab
, step_sp
);
1179 /* Load infrun state for the new thread. */
1180 load_infrun_state (ecs
->ptid
, &prev_pc
,
1181 &trap_expected
, &step_resume_breakpoint
,
1182 &through_sigtramp_breakpoint
, &step_range_start
,
1183 &step_range_end
, &step_frame_id
,
1184 &ecs
->handling_longjmp
, &ecs
->another_trap
,
1185 &ecs
->stepping_through_solib_after_catch
,
1186 &ecs
->stepping_through_solib_catchpoints
,
1187 &ecs
->stepping_through_sigtramp
,
1188 &ecs
->current_line
, &ecs
->current_symtab
, &step_sp
);
1190 inferior_ptid
= ecs
->ptid
;
1193 /* Wrapper for PC_IN_SIGTRAMP that takes care of the need to find the
1196 In a classic example of "left hand VS right hand", "infrun.c" was
1197 trying to improve GDB's performance by caching the result of calls
1198 to calls to find_pc_partial_funtion, while at the same time
1199 find_pc_partial_function was also trying to ramp up performance by
1200 caching its most recent return value. The below makes the the
1201 function find_pc_partial_function solely responsibile for
1202 performance issues (the local cache that relied on a global
1203 variable - arrrggg - deleted).
1205 Using the testsuite and gcov, it was found that dropping the local
1206 "infrun.c" cache and instead relying on find_pc_partial_function
1207 increased the number of calls to 12000 (from 10000), but the number
1208 of times find_pc_partial_function's cache missed (this is what
1209 matters) was only increased by only 4 (to 3569). (A quick back of
1210 envelope caculation suggests that the extra 2000 function calls
1211 @1000 extra instructions per call make the 1 MIP VAX testsuite run
1212 take two extra seconds, oops :-)
1214 Long term, this function can be eliminated, replaced by the code:
1215 get_frame_type(current_frame()) == SIGTRAMP_FRAME (for new
1216 architectures this is very cheap). */
1219 pc_in_sigtramp (CORE_ADDR pc
)
1222 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
1223 return PC_IN_SIGTRAMP (pc
, name
);
1226 /* Handle the inferior event in the cases when we just stepped
1230 handle_step_into_function (struct execution_control_state
*ecs
)
1232 CORE_ADDR real_stop_pc
;
1234 if ((step_over_calls
== STEP_OVER_NONE
)
1235 || ((step_range_end
== 1)
1236 && in_prologue (prev_pc
, ecs
->stop_func_start
)))
1238 /* I presume that step_over_calls is only 0 when we're
1239 supposed to be stepping at the assembly language level
1240 ("stepi"). Just stop. */
1241 /* Also, maybe we just did a "nexti" inside a prolog,
1242 so we thought it was a subroutine call but it was not.
1243 Stop as well. FENN */
1245 print_stop_reason (END_STEPPING_RANGE
, 0);
1246 stop_stepping (ecs
);
1250 if (step_over_calls
== STEP_OVER_ALL
|| IGNORE_HELPER_CALL (stop_pc
))
1252 /* We're doing a "next". */
1254 if (pc_in_sigtramp (stop_pc
)
1255 && frame_id_inner (step_frame_id
,
1256 frame_id_build (read_sp (), 0)))
1257 /* We stepped out of a signal handler, and into its
1258 calling trampoline. This is misdetected as a
1259 subroutine call, but stepping over the signal
1260 trampoline isn't such a bad idea. In order to do that,
1261 we have to ignore the value in step_frame_id, since
1262 that doesn't represent the frame that'll reach when we
1263 return from the signal trampoline. Otherwise we'll
1264 probably continue to the end of the program. */
1265 step_frame_id
= null_frame_id
;
1267 step_over_function (ecs
);
1272 /* If we are in a function call trampoline (a stub between
1273 the calling routine and the real function), locate the real
1274 function. That's what tells us (a) whether we want to step
1275 into it at all, and (b) what prologue we want to run to
1276 the end of, if we do step into it. */
1277 real_stop_pc
= skip_language_trampoline (stop_pc
);
1278 if (real_stop_pc
== 0)
1279 real_stop_pc
= SKIP_TRAMPOLINE_CODE (stop_pc
);
1280 if (real_stop_pc
!= 0)
1281 ecs
->stop_func_start
= real_stop_pc
;
1283 /* If we have line number information for the function we
1284 are thinking of stepping into, step into it.
1286 If there are several symtabs at that PC (e.g. with include
1287 files), just want to know whether *any* of them have line
1288 numbers. find_pc_line handles this. */
1290 struct symtab_and_line tmp_sal
;
1292 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
1293 if (tmp_sal
.line
!= 0)
1295 step_into_function (ecs
);
1300 /* If we have no line number and the step-stop-if-no-debug
1301 is set, we stop the step so that the user has a chance to
1302 switch in assembly mode. */
1303 if (step_over_calls
== STEP_OVER_UNDEBUGGABLE
&& step_stop_if_no_debug
)
1306 print_stop_reason (END_STEPPING_RANGE
, 0);
1307 stop_stepping (ecs
);
1311 step_over_function (ecs
);
1316 /* Given an execution control state that has been freshly filled in
1317 by an event from the inferior, figure out what it means and take
1318 appropriate action. */
1321 handle_inferior_event (struct execution_control_state
*ecs
)
1323 /* NOTE: cagney/2003-03-28: If you're looking at this code and
1324 thinking that the variable stepped_after_stopped_by_watchpoint
1325 isn't used, then you're wrong! The macro STOPPED_BY_WATCHPOINT,
1326 defined in the file "config/pa/nm-hppah.h", accesses the variable
1327 indirectly. Mutter something rude about the HP merge. */
1328 int stepped_after_stopped_by_watchpoint
;
1329 int sw_single_step_trap_p
= 0;
1331 /* Cache the last pid/waitstatus. */
1332 target_last_wait_ptid
= ecs
->ptid
;
1333 target_last_waitstatus
= *ecs
->wp
;
1335 switch (ecs
->infwait_state
)
1337 case infwait_thread_hop_state
:
1338 /* Cancel the waiton_ptid. */
1339 ecs
->waiton_ptid
= pid_to_ptid (-1);
1340 /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event
1341 is serviced in this loop, below. */
1342 if (ecs
->enable_hw_watchpoints_after_wait
)
1344 TARGET_ENABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid
));
1345 ecs
->enable_hw_watchpoints_after_wait
= 0;
1347 stepped_after_stopped_by_watchpoint
= 0;
1350 case infwait_normal_state
:
1351 /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event
1352 is serviced in this loop, below. */
1353 if (ecs
->enable_hw_watchpoints_after_wait
)
1355 TARGET_ENABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid
));
1356 ecs
->enable_hw_watchpoints_after_wait
= 0;
1358 stepped_after_stopped_by_watchpoint
= 0;
1361 case infwait_nullified_state
:
1362 stepped_after_stopped_by_watchpoint
= 0;
1365 case infwait_nonstep_watch_state
:
1366 insert_breakpoints ();
1368 /* FIXME-maybe: is this cleaner than setting a flag? Does it
1369 handle things like signals arriving and other things happening
1370 in combination correctly? */
1371 stepped_after_stopped_by_watchpoint
= 1;
1375 internal_error (__FILE__
, __LINE__
, "bad switch");
1377 ecs
->infwait_state
= infwait_normal_state
;
1379 flush_cached_frames ();
1381 /* If it's a new process, add it to the thread database */
1383 ecs
->new_thread_event
= (!ptid_equal (ecs
->ptid
, inferior_ptid
)
1384 && !in_thread_list (ecs
->ptid
));
1386 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
1387 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
&& ecs
->new_thread_event
)
1389 add_thread (ecs
->ptid
);
1391 ui_out_text (uiout
, "[New ");
1392 ui_out_text (uiout
, target_pid_or_tid_to_str (ecs
->ptid
));
1393 ui_out_text (uiout
, "]\n");
1396 /* NOTE: This block is ONLY meant to be invoked in case of a
1397 "thread creation event"! If it is invoked for any other
1398 sort of event (such as a new thread landing on a breakpoint),
1399 the event will be discarded, which is almost certainly
1402 To avoid this, the low-level module (eg. target_wait)
1403 should call in_thread_list and add_thread, so that the
1404 new thread is known by the time we get here. */
1406 /* We may want to consider not doing a resume here in order
1407 to give the user a chance to play with the new thread.
1408 It might be good to make that a user-settable option. */
1410 /* At this point, all threads are stopped (happens
1411 automatically in either the OS or the native code).
1412 Therefore we need to continue all threads in order to
1415 target_resume (RESUME_ALL
, 0, TARGET_SIGNAL_0
);
1416 prepare_to_wait (ecs
);
1421 switch (ecs
->ws
.kind
)
1423 case TARGET_WAITKIND_LOADED
:
1424 /* Ignore gracefully during startup of the inferior, as it
1425 might be the shell which has just loaded some objects,
1426 otherwise add the symbols for the newly loaded objects. */
1428 if (stop_soon
== NO_STOP_QUIETLY
)
1430 /* Remove breakpoints, SOLIB_ADD might adjust
1431 breakpoint addresses via breakpoint_re_set. */
1432 if (breakpoints_inserted
)
1433 remove_breakpoints ();
1435 /* Check for any newly added shared libraries if we're
1436 supposed to be adding them automatically. Switch
1437 terminal for any messages produced by
1438 breakpoint_re_set. */
1439 target_terminal_ours_for_output ();
1440 /* NOTE: cagney/2003-11-25: Make certain that the target
1441 stack's section table is kept up-to-date. Architectures,
1442 (e.g., PPC64), use the section table to perform
1443 operations such as address => section name and hence
1444 require the table to contain all sections (including
1445 those found in shared libraries). */
1446 /* NOTE: cagney/2003-11-25: Pass current_target and not
1447 exec_ops to SOLIB_ADD. This is because current GDB is
1448 only tooled to propagate section_table changes out from
1449 the "current_target" (see target_resize_to_sections), and
1450 not up from the exec stratum. This, of course, isn't
1451 right. "infrun.c" should only interact with the
1452 exec/process stratum, instead relying on the target stack
1453 to propagate relevant changes (stop, section table
1454 changed, ...) up to other layers. */
1455 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
1456 target_terminal_inferior ();
1458 /* Reinsert breakpoints and continue. */
1459 if (breakpoints_inserted
)
1460 insert_breakpoints ();
1463 resume (0, TARGET_SIGNAL_0
);
1464 prepare_to_wait (ecs
);
1467 case TARGET_WAITKIND_SPURIOUS
:
1468 resume (0, TARGET_SIGNAL_0
);
1469 prepare_to_wait (ecs
);
1472 case TARGET_WAITKIND_EXITED
:
1473 target_terminal_ours (); /* Must do this before mourn anyway */
1474 print_stop_reason (EXITED
, ecs
->ws
.value
.integer
);
1476 /* Record the exit code in the convenience variable $_exitcode, so
1477 that the user can inspect this again later. */
1478 set_internalvar (lookup_internalvar ("_exitcode"),
1479 value_from_longest (builtin_type_int
,
1480 (LONGEST
) ecs
->ws
.value
.integer
));
1481 gdb_flush (gdb_stdout
);
1482 target_mourn_inferior ();
1483 singlestep_breakpoints_inserted_p
= 0; /*SOFTWARE_SINGLE_STEP_P() */
1484 stop_print_frame
= 0;
1485 stop_stepping (ecs
);
1488 case TARGET_WAITKIND_SIGNALLED
:
1489 stop_print_frame
= 0;
1490 stop_signal
= ecs
->ws
.value
.sig
;
1491 target_terminal_ours (); /* Must do this before mourn anyway */
1493 /* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't
1494 reach here unless the inferior is dead. However, for years
1495 target_kill() was called here, which hints that fatal signals aren't
1496 really fatal on some systems. If that's true, then some changes
1498 target_mourn_inferior ();
1500 print_stop_reason (SIGNAL_EXITED
, stop_signal
);
1501 singlestep_breakpoints_inserted_p
= 0; /*SOFTWARE_SINGLE_STEP_P() */
1502 stop_stepping (ecs
);
1505 /* The following are the only cases in which we keep going;
1506 the above cases end in a continue or goto. */
1507 case TARGET_WAITKIND_FORKED
:
1508 case TARGET_WAITKIND_VFORKED
:
1509 stop_signal
= TARGET_SIGNAL_TRAP
;
1510 pending_follow
.kind
= ecs
->ws
.kind
;
1512 pending_follow
.fork_event
.parent_pid
= PIDGET (ecs
->ptid
);
1513 pending_follow
.fork_event
.child_pid
= ecs
->ws
.value
.related_pid
;
1515 stop_pc
= read_pc ();
1517 /* Assume that catchpoints are not really software breakpoints. If
1518 some future target implements them using software breakpoints then
1519 that target is responsible for fudging DECR_PC_AFTER_BREAK. Thus
1520 we pass 1 for the NOT_A_SW_BREAKPOINT argument, so that
1521 bpstat_stop_status will not decrement the PC. */
1523 stop_bpstat
= bpstat_stop_status (&stop_pc
, 1);
1525 ecs
->random_signal
= !bpstat_explains_signal (stop_bpstat
);
1527 /* If no catchpoint triggered for this, then keep going. */
1528 if (ecs
->random_signal
)
1530 stop_signal
= TARGET_SIGNAL_0
;
1534 goto process_event_stop_test
;
1536 case TARGET_WAITKIND_EXECD
:
1537 stop_signal
= TARGET_SIGNAL_TRAP
;
1539 /* NOTE drow/2002-12-05: This code should be pushed down into the
1540 target_wait function. Until then following vfork on HP/UX 10.20
1541 is probably broken by this. Of course, it's broken anyway. */
1542 /* Is this a target which reports multiple exec events per actual
1543 call to exec()? (HP-UX using ptrace does, for example.) If so,
1544 ignore all but the last one. Just resume the exec'r, and wait
1545 for the next exec event. */
1546 if (inferior_ignoring_leading_exec_events
)
1548 inferior_ignoring_leading_exec_events
--;
1549 if (pending_follow
.kind
== TARGET_WAITKIND_VFORKED
)
1550 ENSURE_VFORKING_PARENT_REMAINS_STOPPED (pending_follow
.fork_event
.
1552 target_resume (ecs
->ptid
, 0, TARGET_SIGNAL_0
);
1553 prepare_to_wait (ecs
);
1556 inferior_ignoring_leading_exec_events
=
1557 target_reported_exec_events_per_exec_call () - 1;
1559 pending_follow
.execd_pathname
=
1560 savestring (ecs
->ws
.value
.execd_pathname
,
1561 strlen (ecs
->ws
.value
.execd_pathname
));
1563 /* This causes the eventpoints and symbol table to be reset. Must
1564 do this now, before trying to determine whether to stop. */
1565 follow_exec (PIDGET (inferior_ptid
), pending_follow
.execd_pathname
);
1566 xfree (pending_follow
.execd_pathname
);
1568 stop_pc
= read_pc_pid (ecs
->ptid
);
1569 ecs
->saved_inferior_ptid
= inferior_ptid
;
1570 inferior_ptid
= ecs
->ptid
;
1572 /* Assume that catchpoints are not really software breakpoints. If
1573 some future target implements them using software breakpoints then
1574 that target is responsible for fudging DECR_PC_AFTER_BREAK. Thus
1575 we pass 1 for the NOT_A_SW_BREAKPOINT argument, so that
1576 bpstat_stop_status will not decrement the PC. */
1578 stop_bpstat
= bpstat_stop_status (&stop_pc
, 1);
1580 ecs
->random_signal
= !bpstat_explains_signal (stop_bpstat
);
1581 inferior_ptid
= ecs
->saved_inferior_ptid
;
1583 /* If no catchpoint triggered for this, then keep going. */
1584 if (ecs
->random_signal
)
1586 stop_signal
= TARGET_SIGNAL_0
;
1590 goto process_event_stop_test
;
1592 /* These syscall events are returned on HP-UX, as part of its
1593 implementation of page-protection-based "hardware" watchpoints.
1594 HP-UX has unfortunate interactions between page-protections and
1595 some system calls. Our solution is to disable hardware watches
1596 when a system call is entered, and reenable them when the syscall
1597 completes. The downside of this is that we may miss the precise
1598 point at which a watched piece of memory is modified. "Oh well."
1600 Note that we may have multiple threads running, which may each
1601 enter syscalls at roughly the same time. Since we don't have a
1602 good notion currently of whether a watched piece of memory is
1603 thread-private, we'd best not have any page-protections active
1604 when any thread is in a syscall. Thus, we only want to reenable
1605 hardware watches when no threads are in a syscall.
1607 Also, be careful not to try to gather much state about a thread
1608 that's in a syscall. It's frequently a losing proposition. */
1609 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1610 number_of_threads_in_syscalls
++;
1611 if (number_of_threads_in_syscalls
== 1)
1613 TARGET_DISABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid
));
1615 resume (0, TARGET_SIGNAL_0
);
1616 prepare_to_wait (ecs
);
1619 /* Before examining the threads further, step this thread to
1620 get it entirely out of the syscall. (We get notice of the
1621 event when the thread is just on the verge of exiting a
1622 syscall. Stepping one instruction seems to get it back
1625 Note that although the logical place to reenable h/w watches
1626 is here, we cannot. We cannot reenable them before stepping
1627 the thread (this causes the next wait on the thread to hang).
1629 Nor can we enable them after stepping until we've done a wait.
1630 Thus, we simply set the flag ecs->enable_hw_watchpoints_after_wait
1631 here, which will be serviced immediately after the target
1633 case TARGET_WAITKIND_SYSCALL_RETURN
:
1634 target_resume (ecs
->ptid
, 1, TARGET_SIGNAL_0
);
1636 if (number_of_threads_in_syscalls
> 0)
1638 number_of_threads_in_syscalls
--;
1639 ecs
->enable_hw_watchpoints_after_wait
=
1640 (number_of_threads_in_syscalls
== 0);
1642 prepare_to_wait (ecs
);
1645 case TARGET_WAITKIND_STOPPED
:
1646 stop_signal
= ecs
->ws
.value
.sig
;
1649 /* We had an event in the inferior, but we are not interested
1650 in handling it at this level. The lower layers have already
1651 done what needs to be done, if anything.
1653 One of the possible circumstances for this is when the
1654 inferior produces output for the console. The inferior has
1655 not stopped, and we are ignoring the event. Another possible
1656 circumstance is any event which the lower level knows will be
1657 reported multiple times without an intervening resume. */
1658 case TARGET_WAITKIND_IGNORE
:
1659 prepare_to_wait (ecs
);
1663 /* We may want to consider not doing a resume here in order to give
1664 the user a chance to play with the new thread. It might be good
1665 to make that a user-settable option. */
1667 /* At this point, all threads are stopped (happens automatically in
1668 either the OS or the native code). Therefore we need to continue
1669 all threads in order to make progress. */
1670 if (ecs
->new_thread_event
)
1672 target_resume (RESUME_ALL
, 0, TARGET_SIGNAL_0
);
1673 prepare_to_wait (ecs
);
1677 stop_pc
= read_pc_pid (ecs
->ptid
);
1679 /* See if a thread hit a thread-specific breakpoint that was meant for
1680 another thread. If so, then step that thread past the breakpoint,
1683 if (stop_signal
== TARGET_SIGNAL_TRAP
)
1685 /* Check if a regular breakpoint has been hit before checking
1686 for a potential single step breakpoint. Otherwise, GDB will
1687 not see this breakpoint hit when stepping onto breakpoints. */
1688 if (breakpoints_inserted
1689 && breakpoint_here_p (stop_pc
- DECR_PC_AFTER_BREAK
))
1691 ecs
->random_signal
= 0;
1692 if (!breakpoint_thread_match (stop_pc
- DECR_PC_AFTER_BREAK
,
1697 /* Saw a breakpoint, but it was hit by the wrong thread.
1699 if (DECR_PC_AFTER_BREAK
)
1700 write_pc_pid (stop_pc
- DECR_PC_AFTER_BREAK
, ecs
->ptid
);
1702 remove_status
= remove_breakpoints ();
1703 /* Did we fail to remove breakpoints? If so, try
1704 to set the PC past the bp. (There's at least
1705 one situation in which we can fail to remove
1706 the bp's: On HP-UX's that use ttrace, we can't
1707 change the address space of a vforking child
1708 process until the child exits (well, okay, not
1709 then either :-) or execs. */
1710 if (remove_status
!= 0)
1712 /* FIXME! This is obviously non-portable! */
1713 write_pc_pid (stop_pc
- DECR_PC_AFTER_BREAK
+ 4, ecs
->ptid
);
1714 /* We need to restart all the threads now,
1715 * unles we're running in scheduler-locked mode.
1716 * Use currently_stepping to determine whether to
1719 /* FIXME MVS: is there any reason not to call resume()? */
1720 if (scheduler_mode
== schedlock_on
)
1721 target_resume (ecs
->ptid
,
1722 currently_stepping (ecs
), TARGET_SIGNAL_0
);
1724 target_resume (RESUME_ALL
,
1725 currently_stepping (ecs
), TARGET_SIGNAL_0
);
1726 prepare_to_wait (ecs
);
1731 breakpoints_inserted
= 0;
1732 if (!ptid_equal (inferior_ptid
, ecs
->ptid
))
1733 context_switch (ecs
);
1734 ecs
->waiton_ptid
= ecs
->ptid
;
1735 ecs
->wp
= &(ecs
->ws
);
1736 ecs
->another_trap
= 1;
1738 ecs
->infwait_state
= infwait_thread_hop_state
;
1740 registers_changed ();
1745 else if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p
)
1747 /* Readjust the stop_pc as it is off by DECR_PC_AFTER_BREAK
1748 compared to the value it would have if the system stepping
1749 capability was used. This allows the rest of the code in
1750 this function to use this address without having to worry
1751 whether software single step is in use or not. */
1752 if (DECR_PC_AFTER_BREAK
)
1754 stop_pc
-= DECR_PC_AFTER_BREAK
;
1755 write_pc_pid (stop_pc
, ecs
->ptid
);
1758 sw_single_step_trap_p
= 1;
1759 ecs
->random_signal
= 0;
1763 ecs
->random_signal
= 1;
1765 /* See if something interesting happened to the non-current thread. If
1766 so, then switch to that thread, and eventually give control back to
1769 Note that if there's any kind of pending follow (i.e., of a fork,
1770 vfork or exec), we don't want to do this now. Rather, we'll let
1771 the next resume handle it. */
1772 if (!ptid_equal (ecs
->ptid
, inferior_ptid
) &&
1773 (pending_follow
.kind
== TARGET_WAITKIND_SPURIOUS
))
1777 /* If it's a random signal for a non-current thread, notify user
1778 if he's expressed an interest. */
1779 if (ecs
->random_signal
&& signal_print
[stop_signal
])
1781 /* ??rehrauer: I don't understand the rationale for this code. If the
1782 inferior will stop as a result of this signal, then the act of handling
1783 the stop ought to print a message that's couches the stoppage in user
1784 terms, e.g., "Stopped for breakpoint/watchpoint". If the inferior
1785 won't stop as a result of the signal -- i.e., if the signal is merely
1786 a side-effect of something GDB's doing "under the covers" for the
1787 user, such as stepping threads over a breakpoint they shouldn't stop
1788 for -- then the message seems to be a serious annoyance at best.
1790 For now, remove the message altogether. */
1793 target_terminal_ours_for_output ();
1794 printf_filtered ("\nProgram received signal %s, %s.\n",
1795 target_signal_to_name (stop_signal
),
1796 target_signal_to_string (stop_signal
));
1797 gdb_flush (gdb_stdout
);
1801 /* If it's not SIGTRAP and not a signal we want to stop for, then
1802 continue the thread. */
1804 if (stop_signal
!= TARGET_SIGNAL_TRAP
&& !signal_stop
[stop_signal
])
1807 target_terminal_inferior ();
1809 /* Clear the signal if it should not be passed. */
1810 if (signal_program
[stop_signal
] == 0)
1811 stop_signal
= TARGET_SIGNAL_0
;
1813 target_resume (ecs
->ptid
, 0, stop_signal
);
1814 prepare_to_wait (ecs
);
1818 /* It's a SIGTRAP or a signal we're interested in. Switch threads,
1819 and fall into the rest of wait_for_inferior(). */
1821 context_switch (ecs
);
1824 context_hook (pid_to_thread_id (ecs
->ptid
));
1826 flush_cached_frames ();
1829 if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p
)
1831 /* Pull the single step breakpoints out of the target. */
1832 SOFTWARE_SINGLE_STEP (0, 0);
1833 singlestep_breakpoints_inserted_p
= 0;
1836 /* If PC is pointing at a nullified instruction, then step beyond
1837 it so that the user won't be confused when GDB appears to be ready
1840 /* if (INSTRUCTION_NULLIFIED && currently_stepping (ecs)) */
1841 if (INSTRUCTION_NULLIFIED
)
1843 registers_changed ();
1844 target_resume (ecs
->ptid
, 1, TARGET_SIGNAL_0
);
1846 /* We may have received a signal that we want to pass to
1847 the inferior; therefore, we must not clobber the waitstatus
1850 ecs
->infwait_state
= infwait_nullified_state
;
1851 ecs
->waiton_ptid
= ecs
->ptid
;
1852 ecs
->wp
= &(ecs
->tmpstatus
);
1853 prepare_to_wait (ecs
);
1857 /* It may not be necessary to disable the watchpoint to stop over
1858 it. For example, the PA can (with some kernel cooperation)
1859 single step over a watchpoint without disabling the watchpoint. */
1860 if (HAVE_STEPPABLE_WATCHPOINT
&& STOPPED_BY_WATCHPOINT (ecs
->ws
))
1863 prepare_to_wait (ecs
);
1867 /* It is far more common to need to disable a watchpoint to step
1868 the inferior over it. FIXME. What else might a debug
1869 register or page protection watchpoint scheme need here? */
1870 if (HAVE_NONSTEPPABLE_WATCHPOINT
&& STOPPED_BY_WATCHPOINT (ecs
->ws
))
1872 /* At this point, we are stopped at an instruction which has
1873 attempted to write to a piece of memory under control of
1874 a watchpoint. The instruction hasn't actually executed
1875 yet. If we were to evaluate the watchpoint expression
1876 now, we would get the old value, and therefore no change
1877 would seem to have occurred.
1879 In order to make watchpoints work `right', we really need
1880 to complete the memory write, and then evaluate the
1881 watchpoint expression. The following code does that by
1882 removing the watchpoint (actually, all watchpoints and
1883 breakpoints), single-stepping the target, re-inserting
1884 watchpoints, and then falling through to let normal
1885 single-step processing handle proceed. Since this
1886 includes evaluating watchpoints, things will come to a
1887 stop in the correct manner. */
1889 if (DECR_PC_AFTER_BREAK
)
1890 write_pc (stop_pc
- DECR_PC_AFTER_BREAK
);
1892 remove_breakpoints ();
1893 registers_changed ();
1894 target_resume (ecs
->ptid
, 1, TARGET_SIGNAL_0
); /* Single step */
1896 ecs
->waiton_ptid
= ecs
->ptid
;
1897 ecs
->wp
= &(ecs
->ws
);
1898 ecs
->infwait_state
= infwait_nonstep_watch_state
;
1899 prepare_to_wait (ecs
);
1903 /* It may be possible to simply continue after a watchpoint. */
1904 if (HAVE_CONTINUABLE_WATCHPOINT
)
1905 STOPPED_BY_WATCHPOINT (ecs
->ws
);
1907 ecs
->stop_func_start
= 0;
1908 ecs
->stop_func_end
= 0;
1909 ecs
->stop_func_name
= 0;
1910 /* Don't care about return value; stop_func_start and stop_func_name
1911 will both be 0 if it doesn't work. */
1912 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
1913 &ecs
->stop_func_start
, &ecs
->stop_func_end
);
1914 ecs
->stop_func_start
+= FUNCTION_START_OFFSET
;
1915 ecs
->another_trap
= 0;
1916 bpstat_clear (&stop_bpstat
);
1918 stop_stack_dummy
= 0;
1919 stop_print_frame
= 1;
1920 ecs
->random_signal
= 0;
1921 stopped_by_random_signal
= 0;
1922 breakpoints_failed
= 0;
1924 /* Look at the cause of the stop, and decide what to do.
1925 The alternatives are:
1926 1) break; to really stop and return to the debugger,
1927 2) drop through to start up again
1928 (set ecs->another_trap to 1 to single step once)
1929 3) set ecs->random_signal to 1, and the decision between 1 and 2
1930 will be made according to the signal handling tables. */
1932 /* First, distinguish signals caused by the debugger from signals
1933 that have to do with the program's own actions.
1934 Note that breakpoint insns may cause SIGTRAP or SIGILL
1935 or SIGEMT, depending on the operating system version.
1936 Here we detect when a SIGILL or SIGEMT is really a breakpoint
1937 and change it to SIGTRAP. */
1939 if (stop_signal
== TARGET_SIGNAL_TRAP
1940 || (breakpoints_inserted
&&
1941 (stop_signal
== TARGET_SIGNAL_ILL
1942 || stop_signal
== TARGET_SIGNAL_EMT
))
1943 || stop_soon
== STOP_QUIETLY
1944 || stop_soon
== STOP_QUIETLY_NO_SIGSTOP
)
1946 if (stop_signal
== TARGET_SIGNAL_TRAP
&& stop_after_trap
)
1948 stop_print_frame
= 0;
1949 stop_stepping (ecs
);
1953 /* This is originated from start_remote(), start_inferior() and
1954 shared libraries hook functions. */
1955 if (stop_soon
== STOP_QUIETLY
)
1957 stop_stepping (ecs
);
1961 /* This originates from attach_command(). We need to overwrite
1962 the stop_signal here, because some kernels don't ignore a
1963 SIGSTOP in a subsequent ptrace(PTRACE_SONT,SOGSTOP) call.
1964 See more comments in inferior.h. */
1965 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
)
1967 stop_stepping (ecs
);
1968 if (stop_signal
== TARGET_SIGNAL_STOP
)
1969 stop_signal
= TARGET_SIGNAL_0
;
1973 /* Don't even think about breakpoints
1974 if just proceeded over a breakpoint.
1976 However, if we are trying to proceed over a breakpoint
1977 and end up in sigtramp, then through_sigtramp_breakpoint
1978 will be set and we should check whether we've hit the
1980 if (stop_signal
== TARGET_SIGNAL_TRAP
&& trap_expected
1981 && through_sigtramp_breakpoint
== NULL
)
1982 bpstat_clear (&stop_bpstat
);
1985 /* See if there is a breakpoint at the current PC. */
1987 /* The second argument of bpstat_stop_status is meant to help
1988 distinguish between a breakpoint trap and a singlestep trap.
1989 This is only important on targets where DECR_PC_AFTER_BREAK
1990 is non-zero. The prev_pc test is meant to distinguish between
1991 singlestepping a trap instruction, and singlestepping thru a
1992 jump to the instruction following a trap instruction.
1994 Therefore, pass TRUE if our reason for stopping is
1995 something other than hitting a breakpoint. We do this by
1996 checking that either: we detected earlier a software single
1997 step trap or, 1) stepping is going on and 2) we didn't hit
1998 a breakpoint in a signal handler without an intervening stop
1999 in sigtramp, which is detected by a new stack pointer value
2000 below any usual function calling stack adjustments. */
2004 sw_single_step_trap_p
2005 || (currently_stepping (ecs
)
2006 && prev_pc
!= stop_pc
- DECR_PC_AFTER_BREAK
2008 && INNER_THAN (read_sp (), (step_sp
- 16)))));
2009 /* Following in case break condition called a
2011 stop_print_frame
= 1;
2014 /* NOTE: cagney/2003-03-29: These two checks for a random signal
2015 at one stage in the past included checks for an inferior
2016 function call's call dummy's return breakpoint. The original
2017 comment, that went with the test, read:
2019 ``End of a stack dummy. Some systems (e.g. Sony news) give
2020 another signal besides SIGTRAP, so check here as well as
2023 If someone ever tries to get get call dummys on a
2024 non-executable stack to work (where the target would stop
2025 with something like a SIGSEG), then those tests might need to
2026 be re-instated. Given, however, that the tests were only
2027 enabled when momentary breakpoints were not being used, I
2028 suspect that it won't be the case. */
2030 if (stop_signal
== TARGET_SIGNAL_TRAP
)
2032 = !(bpstat_explains_signal (stop_bpstat
)
2034 || (step_range_end
&& step_resume_breakpoint
== NULL
));
2037 ecs
->random_signal
= !bpstat_explains_signal (stop_bpstat
);
2038 if (!ecs
->random_signal
)
2039 stop_signal
= TARGET_SIGNAL_TRAP
;
2043 /* When we reach this point, we've pretty much decided
2044 that the reason for stopping must've been a random
2045 (unexpected) signal. */
2048 ecs
->random_signal
= 1;
2050 process_event_stop_test
:
2051 /* For the program's own signals, act according to
2052 the signal handling tables. */
2054 if (ecs
->random_signal
)
2056 /* Signal not for debugging purposes. */
2059 stopped_by_random_signal
= 1;
2061 if (signal_print
[stop_signal
])
2064 target_terminal_ours_for_output ();
2065 print_stop_reason (SIGNAL_RECEIVED
, stop_signal
);
2067 if (signal_stop
[stop_signal
])
2069 stop_stepping (ecs
);
2072 /* If not going to stop, give terminal back
2073 if we took it away. */
2075 target_terminal_inferior ();
2077 /* Clear the signal if it should not be passed. */
2078 if (signal_program
[stop_signal
] == 0)
2079 stop_signal
= TARGET_SIGNAL_0
;
2081 /* I'm not sure whether this needs to be check_sigtramp2 or
2082 whether it could/should be keep_going.
2084 This used to jump to step_over_function if we are stepping,
2087 Suppose the user does a `next' over a function call, and while
2088 that call is in progress, the inferior receives a signal for
2089 which GDB does not stop (i.e., signal_stop[SIG] is false). In
2090 that case, when we reach this point, there is already a
2091 step-resume breakpoint established, right where it should be:
2092 immediately after the function call the user is "next"-ing
2093 over. If we call step_over_function now, two bad things
2096 - we'll create a new breakpoint, at wherever the current
2097 frame's return address happens to be. That could be
2098 anywhere, depending on what function call happens to be on
2099 the top of the stack at that point. Point is, it's probably
2100 not where we need it.
2102 - the existing step-resume breakpoint (which is at the correct
2103 address) will get orphaned: step_resume_breakpoint will point
2104 to the new breakpoint, and the old step-resume breakpoint
2105 will never be cleaned up.
2107 The old behavior was meant to help HP-UX single-step out of
2108 sigtramps. It would place the new breakpoint at prev_pc, which
2109 was certainly wrong. I don't know the details there, so fixing
2110 this probably breaks that. As with anything else, it's up to
2111 the HP-UX maintainer to furnish a fix that doesn't break other
2112 platforms. --JimB, 20 May 1999 */
2113 check_sigtramp2 (ecs
);
2118 /* Handle cases caused by hitting a breakpoint. */
2120 CORE_ADDR jmp_buf_pc
;
2121 struct bpstat_what what
;
2123 what
= bpstat_what (stop_bpstat
);
2125 if (what
.call_dummy
)
2127 stop_stack_dummy
= 1;
2129 trap_expected_after_continue
= 1;
2133 switch (what
.main_action
)
2135 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
2136 /* If we hit the breakpoint at longjmp, disable it for the
2137 duration of this command. Then, install a temporary
2138 breakpoint at the target of the jmp_buf. */
2139 disable_longjmp_breakpoint ();
2140 remove_breakpoints ();
2141 breakpoints_inserted
= 0;
2142 if (!GET_LONGJMP_TARGET_P () || !GET_LONGJMP_TARGET (&jmp_buf_pc
))
2148 /* Need to blow away step-resume breakpoint, as it
2149 interferes with us */
2150 if (step_resume_breakpoint
!= NULL
)
2152 delete_step_resume_breakpoint (&step_resume_breakpoint
);
2154 /* Not sure whether we need to blow this away too, but probably
2155 it is like the step-resume breakpoint. */
2156 if (through_sigtramp_breakpoint
!= NULL
)
2158 delete_breakpoint (through_sigtramp_breakpoint
);
2159 through_sigtramp_breakpoint
= NULL
;
2163 /* FIXME - Need to implement nested temporary breakpoints */
2164 if (step_over_calls
> 0)
2165 set_longjmp_resume_breakpoint (jmp_buf_pc
, get_current_frame ());
2168 set_longjmp_resume_breakpoint (jmp_buf_pc
, null_frame_id
);
2169 ecs
->handling_longjmp
= 1; /* FIXME */
2173 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
2174 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
:
2175 remove_breakpoints ();
2176 breakpoints_inserted
= 0;
2178 /* FIXME - Need to implement nested temporary breakpoints */
2180 && (frame_id_inner (get_frame_id (get_current_frame ()),
2183 ecs
->another_trap
= 1;
2188 disable_longjmp_breakpoint ();
2189 ecs
->handling_longjmp
= 0; /* FIXME */
2190 if (what
.main_action
== BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
)
2192 /* else fallthrough */
2194 case BPSTAT_WHAT_SINGLE
:
2195 if (breakpoints_inserted
)
2197 remove_breakpoints ();
2199 breakpoints_inserted
= 0;
2200 ecs
->another_trap
= 1;
2201 /* Still need to check other stuff, at least the case
2202 where we are stepping and step out of the right range. */
2205 case BPSTAT_WHAT_STOP_NOISY
:
2206 stop_print_frame
= 1;
2208 /* We are about to nuke the step_resume_breakpoint and
2209 through_sigtramp_breakpoint via the cleanup chain, so
2210 no need to worry about it here. */
2212 stop_stepping (ecs
);
2215 case BPSTAT_WHAT_STOP_SILENT
:
2216 stop_print_frame
= 0;
2218 /* We are about to nuke the step_resume_breakpoint and
2219 through_sigtramp_breakpoint via the cleanup chain, so
2220 no need to worry about it here. */
2222 stop_stepping (ecs
);
2225 case BPSTAT_WHAT_STEP_RESUME
:
2226 /* This proably demands a more elegant solution, but, yeah
2229 This function's use of the simple variable
2230 step_resume_breakpoint doesn't seem to accomodate
2231 simultaneously active step-resume bp's, although the
2232 breakpoint list certainly can.
2234 If we reach here and step_resume_breakpoint is already
2235 NULL, then apparently we have multiple active
2236 step-resume bp's. We'll just delete the breakpoint we
2237 stopped at, and carry on.
2239 Correction: what the code currently does is delete a
2240 step-resume bp, but it makes no effort to ensure that
2241 the one deleted is the one currently stopped at. MVS */
2243 if (step_resume_breakpoint
== NULL
)
2245 step_resume_breakpoint
=
2246 bpstat_find_step_resume_breakpoint (stop_bpstat
);
2248 delete_step_resume_breakpoint (&step_resume_breakpoint
);
2251 case BPSTAT_WHAT_THROUGH_SIGTRAMP
:
2252 if (through_sigtramp_breakpoint
)
2253 delete_breakpoint (through_sigtramp_breakpoint
);
2254 through_sigtramp_breakpoint
= NULL
;
2256 /* If were waiting for a trap, hitting the step_resume_break
2257 doesn't count as getting it. */
2259 ecs
->another_trap
= 1;
2262 case BPSTAT_WHAT_CHECK_SHLIBS
:
2263 case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
:
2266 /* Remove breakpoints, we eventually want to step over the
2267 shlib event breakpoint, and SOLIB_ADD might adjust
2268 breakpoint addresses via breakpoint_re_set. */
2269 if (breakpoints_inserted
)
2270 remove_breakpoints ();
2271 breakpoints_inserted
= 0;
2273 /* Check for any newly added shared libraries if we're
2274 supposed to be adding them automatically. Switch
2275 terminal for any messages produced by
2276 breakpoint_re_set. */
2277 target_terminal_ours_for_output ();
2278 /* NOTE: cagney/2003-11-25: Make certain that the target
2279 stack's section table is kept up-to-date. Architectures,
2280 (e.g., PPC64), use the section table to perform
2281 operations such as address => section name and hence
2282 require the table to contain all sections (including
2283 those found in shared libraries). */
2284 /* NOTE: cagney/2003-11-25: Pass current_target and not
2285 exec_ops to SOLIB_ADD. This is because current GDB is
2286 only tooled to propagate section_table changes out from
2287 the "current_target" (see target_resize_to_sections), and
2288 not up from the exec stratum. This, of course, isn't
2289 right. "infrun.c" should only interact with the
2290 exec/process stratum, instead relying on the target stack
2291 to propagate relevant changes (stop, section table
2292 changed, ...) up to other layers. */
2293 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
2294 target_terminal_inferior ();
2296 /* Try to reenable shared library breakpoints, additional
2297 code segments in shared libraries might be mapped in now. */
2298 re_enable_breakpoints_in_shlibs ();
2300 /* If requested, stop when the dynamic linker notifies
2301 gdb of events. This allows the user to get control
2302 and place breakpoints in initializer routines for
2303 dynamically loaded objects (among other things). */
2304 if (stop_on_solib_events
)
2306 stop_stepping (ecs
);
2310 /* If we stopped due to an explicit catchpoint, then the
2311 (see above) call to SOLIB_ADD pulled in any symbols
2312 from a newly-loaded library, if appropriate.
2314 We do want the inferior to stop, but not where it is
2315 now, which is in the dynamic linker callback. Rather,
2316 we would like it stop in the user's program, just after
2317 the call that caused this catchpoint to trigger. That
2318 gives the user a more useful vantage from which to
2319 examine their program's state. */
2320 else if (what
.main_action
==
2321 BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
)
2323 /* ??rehrauer: If I could figure out how to get the
2324 right return PC from here, we could just set a temp
2325 breakpoint and resume. I'm not sure we can without
2326 cracking open the dld's shared libraries and sniffing
2327 their unwind tables and text/data ranges, and that's
2328 not a terribly portable notion.
2330 Until that time, we must step the inferior out of the
2331 dld callback, and also out of the dld itself (and any
2332 code or stubs in libdld.sl, such as "shl_load" and
2333 friends) until we reach non-dld code. At that point,
2334 we can stop stepping. */
2335 bpstat_get_triggered_catchpoints (stop_bpstat
,
2337 stepping_through_solib_catchpoints
);
2338 ecs
->stepping_through_solib_after_catch
= 1;
2340 /* Be sure to lift all breakpoints, so the inferior does
2341 actually step past this point... */
2342 ecs
->another_trap
= 1;
2347 /* We want to step over this breakpoint, then keep going. */
2348 ecs
->another_trap
= 1;
2355 case BPSTAT_WHAT_LAST
:
2356 /* Not a real code, but listed here to shut up gcc -Wall. */
2358 case BPSTAT_WHAT_KEEP_CHECKING
:
2363 /* We come here if we hit a breakpoint but should not
2364 stop for it. Possibly we also were stepping
2365 and should stop for that. So fall through and
2366 test for stepping. But, if not stepping,
2369 /* Are we stepping to get the inferior out of the dynamic
2370 linker's hook (and possibly the dld itself) after catching
2372 if (ecs
->stepping_through_solib_after_catch
)
2374 #if defined(SOLIB_ADD)
2375 /* Have we reached our destination? If not, keep going. */
2376 if (SOLIB_IN_DYNAMIC_LINKER (PIDGET (ecs
->ptid
), stop_pc
))
2378 ecs
->another_trap
= 1;
2383 /* Else, stop and report the catchpoint(s) whose triggering
2384 caused us to begin stepping. */
2385 ecs
->stepping_through_solib_after_catch
= 0;
2386 bpstat_clear (&stop_bpstat
);
2387 stop_bpstat
= bpstat_copy (ecs
->stepping_through_solib_catchpoints
);
2388 bpstat_clear (&ecs
->stepping_through_solib_catchpoints
);
2389 stop_print_frame
= 1;
2390 stop_stepping (ecs
);
2394 if (step_resume_breakpoint
)
2396 /* Having a step-resume breakpoint overrides anything
2397 else having to do with stepping commands until
2398 that breakpoint is reached. */
2399 /* I'm not sure whether this needs to be check_sigtramp2 or
2400 whether it could/should be keep_going. */
2401 check_sigtramp2 (ecs
);
2406 if (step_range_end
== 0)
2408 /* Likewise if we aren't even stepping. */
2409 /* I'm not sure whether this needs to be check_sigtramp2 or
2410 whether it could/should be keep_going. */
2411 check_sigtramp2 (ecs
);
2416 /* If stepping through a line, keep going if still within it.
2418 Note that step_range_end is the address of the first instruction
2419 beyond the step range, and NOT the address of the last instruction
2421 if (stop_pc
>= step_range_start
&& stop_pc
< step_range_end
)
2423 /* We might be doing a BPSTAT_WHAT_SINGLE and getting a signal.
2424 So definately need to check for sigtramp here. */
2425 check_sigtramp2 (ecs
);
2430 /* We stepped out of the stepping range. */
2432 /* If we are stepping at the source level and entered the runtime
2433 loader dynamic symbol resolution code, we keep on single stepping
2434 until we exit the run time loader code and reach the callee's
2436 if (step_over_calls
== STEP_OVER_UNDEBUGGABLE
2437 && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc
))
2439 CORE_ADDR pc_after_resolver
=
2440 gdbarch_skip_solib_resolver (current_gdbarch
, stop_pc
);
2442 if (pc_after_resolver
)
2444 /* Set up a step-resume breakpoint at the address
2445 indicated by SKIP_SOLIB_RESOLVER. */
2446 struct symtab_and_line sr_sal
;
2448 sr_sal
.pc
= pc_after_resolver
;
2450 check_for_old_step_resume_breakpoint ();
2451 step_resume_breakpoint
=
2452 set_momentary_breakpoint (sr_sal
, null_frame_id
, bp_step_resume
);
2453 if (breakpoints_inserted
)
2454 insert_breakpoints ();
2461 /* We can't update step_sp every time through the loop, because
2462 reading the stack pointer would slow down stepping too much.
2463 But we can update it every time we leave the step range. */
2464 ecs
->update_step_sp
= 1;
2466 /* Did we just take a signal? */
2467 if (pc_in_sigtramp (stop_pc
)
2468 && !pc_in_sigtramp (prev_pc
)
2469 && INNER_THAN (read_sp (), step_sp
))
2471 /* We've just taken a signal; go until we are back to
2472 the point where we took it and one more. */
2474 /* Note: The test above succeeds not only when we stepped
2475 into a signal handler, but also when we step past the last
2476 statement of a signal handler and end up in the return stub
2477 of the signal handler trampoline. To distinguish between
2478 these two cases, check that the frame is INNER_THAN the
2479 previous one below. pai/1997-09-11 */
2483 struct frame_id current_frame
= get_frame_id (get_current_frame ());
2485 if (frame_id_inner (current_frame
, step_frame_id
))
2487 /* We have just taken a signal; go until we are back to
2488 the point where we took it and one more. */
2490 /* This code is needed at least in the following case:
2491 The user types "next" and then a signal arrives (before
2492 the "next" is done). */
2494 /* Note that if we are stopped at a breakpoint, then we need
2495 the step_resume breakpoint to override any breakpoints at
2496 the same location, so that we will still step over the
2497 breakpoint even though the signal happened. */
2498 struct symtab_and_line sr_sal
;
2501 sr_sal
.symtab
= NULL
;
2503 sr_sal
.pc
= prev_pc
;
2504 /* We could probably be setting the frame to
2505 step_frame_id; I don't think anyone thought to try it. */
2506 check_for_old_step_resume_breakpoint ();
2507 step_resume_breakpoint
=
2508 set_momentary_breakpoint (sr_sal
, null_frame_id
, bp_step_resume
);
2509 if (breakpoints_inserted
)
2510 insert_breakpoints ();
2514 /* We just stepped out of a signal handler and into
2515 its calling trampoline.
2517 Normally, we'd call step_over_function from
2518 here, but for some reason GDB can't unwind the
2519 stack correctly to find the real PC for the point
2520 user code where the signal trampoline will return
2521 -- FRAME_SAVED_PC fails, at least on HP-UX 10.20.
2522 But signal trampolines are pretty small stubs of
2523 code, anyway, so it's OK instead to just
2524 single-step out. Note: assuming such trampolines
2525 don't exhibit recursion on any platform... */
2526 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
2527 &ecs
->stop_func_start
,
2528 &ecs
->stop_func_end
);
2529 /* Readjust stepping range */
2530 step_range_start
= ecs
->stop_func_start
;
2531 step_range_end
= ecs
->stop_func_end
;
2532 ecs
->stepping_through_sigtramp
= 1;
2537 /* If this is stepi or nexti, make sure that the stepping range
2538 gets us past that instruction. */
2539 if (step_range_end
== 1)
2540 /* FIXME: Does this run afoul of the code below which, if
2541 we step into the middle of a line, resets the stepping
2543 step_range_end
= (step_range_start
= prev_pc
) + 1;
2545 ecs
->remove_breakpoints_on_following_step
= 1;
2550 if (((stop_pc
== ecs
->stop_func_start
/* Quick test */
2551 || in_prologue (stop_pc
, ecs
->stop_func_start
))
2552 && !IN_SOLIB_RETURN_TRAMPOLINE (stop_pc
, ecs
->stop_func_name
))
2553 || IN_SOLIB_CALL_TRAMPOLINE (stop_pc
, ecs
->stop_func_name
)
2554 || ecs
->stop_func_name
== 0)
2556 /* It's a subroutine call. */
2557 handle_step_into_function (ecs
);
2561 /* We've wandered out of the step range. */
2563 ecs
->sal
= find_pc_line (stop_pc
, 0);
2565 if (step_range_end
== 1)
2567 /* It is stepi or nexti. We always want to stop stepping after
2570 print_stop_reason (END_STEPPING_RANGE
, 0);
2571 stop_stepping (ecs
);
2575 /* If we're in the return path from a shared library trampoline,
2576 we want to proceed through the trampoline when stepping. */
2577 if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc
, ecs
->stop_func_name
))
2579 /* Determine where this trampoline returns. */
2580 CORE_ADDR real_stop_pc
= SKIP_TRAMPOLINE_CODE (stop_pc
);
2582 /* Only proceed through if we know where it's going. */
2585 /* And put the step-breakpoint there and go until there. */
2586 struct symtab_and_line sr_sal
;
2588 init_sal (&sr_sal
); /* initialize to zeroes */
2589 sr_sal
.pc
= real_stop_pc
;
2590 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
2591 /* Do not specify what the fp should be when we stop
2592 since on some machines the prologue
2593 is where the new fp value is established. */
2594 check_for_old_step_resume_breakpoint ();
2595 step_resume_breakpoint
=
2596 set_momentary_breakpoint (sr_sal
, null_frame_id
, bp_step_resume
);
2597 if (breakpoints_inserted
)
2598 insert_breakpoints ();
2600 /* Restart without fiddling with the step ranges or
2607 if (ecs
->sal
.line
== 0)
2609 /* We have no line number information. That means to stop
2610 stepping (does this always happen right after one instruction,
2611 when we do "s" in a function with no line numbers,
2612 or can this happen as a result of a return or longjmp?). */
2614 print_stop_reason (END_STEPPING_RANGE
, 0);
2615 stop_stepping (ecs
);
2619 if ((stop_pc
== ecs
->sal
.pc
)
2620 && (ecs
->current_line
!= ecs
->sal
.line
2621 || ecs
->current_symtab
!= ecs
->sal
.symtab
))
2623 /* We are at the start of a different line. So stop. Note that
2624 we don't stop if we step into the middle of a different line.
2625 That is said to make things like for (;;) statements work
2628 print_stop_reason (END_STEPPING_RANGE
, 0);
2629 stop_stepping (ecs
);
2633 /* We aren't done stepping.
2635 Optimize by setting the stepping range to the line.
2636 (We might not be in the original line, but if we entered a
2637 new line in mid-statement, we continue stepping. This makes
2638 things like for(;;) statements work better.) */
2640 if (ecs
->stop_func_end
&& ecs
->sal
.end
>= ecs
->stop_func_end
)
2642 /* If this is the last line of the function, don't keep stepping
2643 (it would probably step us out of the function).
2644 This is particularly necessary for a one-line function,
2645 in which after skipping the prologue we better stop even though
2646 we will be in mid-line. */
2648 print_stop_reason (END_STEPPING_RANGE
, 0);
2649 stop_stepping (ecs
);
2652 step_range_start
= ecs
->sal
.pc
;
2653 step_range_end
= ecs
->sal
.end
;
2654 step_frame_id
= get_frame_id (get_current_frame ());
2655 ecs
->current_line
= ecs
->sal
.line
;
2656 ecs
->current_symtab
= ecs
->sal
.symtab
;
2658 /* In the case where we just stepped out of a function into the
2659 middle of a line of the caller, continue stepping, but
2660 step_frame_id must be modified to current frame */
2662 /* NOTE: cagney/2003-10-16: I think this frame ID inner test is too
2663 generous. It will trigger on things like a step into a frameless
2664 stackless leaf function. I think the logic should instead look
2665 at the unwound frame ID has that should give a more robust
2666 indication of what happened. */
2667 if (step
-ID
== current
-ID
)
2668 still stepping in same function
;
2669 else if (step
-ID
== unwind (current
-ID
))
2670 stepped into a function
;
2672 stepped out of a function
;
2673 /* Of course this assumes that the frame ID unwind code is robust
2674 and we're willing to introduce frame unwind logic into this
2675 function. Fortunately, those days are nearly upon us. */
2678 struct frame_id current_frame
= get_frame_id (get_current_frame ());
2679 if (!(frame_id_inner (current_frame
, step_frame_id
)))
2680 step_frame_id
= current_frame
;
2686 /* Are we in the middle of stepping? */
2689 currently_stepping (struct execution_control_state
*ecs
)
2691 return ((through_sigtramp_breakpoint
== NULL
2692 && !ecs
->handling_longjmp
2693 && ((step_range_end
&& step_resume_breakpoint
== NULL
)
2695 || ecs
->stepping_through_solib_after_catch
2696 || bpstat_should_step ());
2700 check_sigtramp2 (struct execution_control_state
*ecs
)
2703 && pc_in_sigtramp (stop_pc
)
2704 && !pc_in_sigtramp (prev_pc
)
2705 && INNER_THAN (read_sp (), step_sp
))
2707 /* What has happened here is that we have just stepped the
2708 inferior with a signal (because it is a signal which
2709 shouldn't make us stop), thus stepping into sigtramp.
2711 So we need to set a step_resume_break_address breakpoint and
2712 continue until we hit it, and then step. FIXME: This should
2713 be more enduring than a step_resume breakpoint; we should
2714 know that we will later need to keep going rather than
2715 re-hitting the breakpoint here (see the testsuite,
2716 gdb.base/signals.exp where it says "exceedingly difficult"). */
2718 struct symtab_and_line sr_sal
;
2720 init_sal (&sr_sal
); /* initialize to zeroes */
2721 sr_sal
.pc
= prev_pc
;
2722 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
2723 /* We perhaps could set the frame if we kept track of what the
2724 frame corresponding to prev_pc was. But we don't, so don't. */
2725 through_sigtramp_breakpoint
=
2726 set_momentary_breakpoint (sr_sal
, null_frame_id
, bp_through_sigtramp
);
2727 if (breakpoints_inserted
)
2728 insert_breakpoints ();
2730 ecs
->remove_breakpoints_on_following_step
= 1;
2731 ecs
->another_trap
= 1;
2735 /* Subroutine call with source code we should not step over. Do step
2736 to the first line of code in it. */
2739 step_into_function (struct execution_control_state
*ecs
)
2742 struct symtab_and_line sr_sal
;
2744 s
= find_pc_symtab (stop_pc
);
2745 if (s
&& s
->language
!= language_asm
)
2746 ecs
->stop_func_start
= SKIP_PROLOGUE (ecs
->stop_func_start
);
2748 ecs
->sal
= find_pc_line (ecs
->stop_func_start
, 0);
2749 /* Use the step_resume_break to step until the end of the prologue,
2750 even if that involves jumps (as it seems to on the vax under
2752 /* If the prologue ends in the middle of a source line, continue to
2753 the end of that source line (if it is still within the function).
2754 Otherwise, just go to end of prologue. */
2756 && ecs
->sal
.pc
!= ecs
->stop_func_start
2757 && ecs
->sal
.end
< ecs
->stop_func_end
)
2758 ecs
->stop_func_start
= ecs
->sal
.end
;
2760 /* Architectures which require breakpoint adjustment might not be able
2761 to place a breakpoint at the computed address. If so, the test
2762 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
2763 ecs->stop_func_start to an address at which a breakpoint may be
2764 legitimately placed.
2766 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
2767 made, GDB will enter an infinite loop when stepping through
2768 optimized code consisting of VLIW instructions which contain
2769 subinstructions corresponding to different source lines. On
2770 FR-V, it's not permitted to place a breakpoint on any but the
2771 first subinstruction of a VLIW instruction. When a breakpoint is
2772 set, GDB will adjust the breakpoint address to the beginning of
2773 the VLIW instruction. Thus, we need to make the corresponding
2774 adjustment here when computing the stop address. */
2776 if (gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
2778 ecs
->stop_func_start
2779 = gdbarch_adjust_breakpoint_address (current_gdbarch
,
2780 ecs
->stop_func_start
);
2783 if (ecs
->stop_func_start
== stop_pc
)
2785 /* We are already there: stop now. */
2787 print_stop_reason (END_STEPPING_RANGE
, 0);
2788 stop_stepping (ecs
);
2793 /* Put the step-breakpoint there and go until there. */
2794 init_sal (&sr_sal
); /* initialize to zeroes */
2795 sr_sal
.pc
= ecs
->stop_func_start
;
2796 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
2797 /* Do not specify what the fp should be when we stop since on
2798 some machines the prologue is where the new fp value is
2800 check_for_old_step_resume_breakpoint ();
2801 step_resume_breakpoint
=
2802 set_momentary_breakpoint (sr_sal
, null_frame_id
, bp_step_resume
);
2803 if (breakpoints_inserted
)
2804 insert_breakpoints ();
2806 /* And make sure stepping stops right away then. */
2807 step_range_end
= step_range_start
;
2812 /* We've just entered a callee, and we wish to resume until it returns
2813 to the caller. Setting a step_resume breakpoint on the return
2814 address will catch a return from the callee.
2816 However, if the callee is recursing, we want to be careful not to
2817 catch returns of those recursive calls, but only of THIS instance
2820 To do this, we set the step_resume bp's frame to our current
2821 caller's frame (step_frame_id, which is set by the "next" or
2822 "until" command, before execution begins). */
2825 step_over_function (struct execution_control_state
*ecs
)
2827 struct symtab_and_line sr_sal
;
2829 init_sal (&sr_sal
); /* initialize to zeros */
2831 /* NOTE: cagney/2003-04-06:
2833 At this point the equality get_frame_pc() == get_frame_func()
2834 should hold. This may make it possible for this code to tell the
2835 frame where it's function is, instead of the reverse. This would
2836 avoid the need to search for the frame's function, which can get
2837 very messy when there is no debug info available (look at the
2838 heuristic find pc start code found in targets like the MIPS). */
2840 /* NOTE: cagney/2003-04-06:
2842 The intent of DEPRECATED_SAVED_PC_AFTER_CALL was to:
2844 - provide a very light weight equivalent to frame_unwind_pc()
2845 (nee FRAME_SAVED_PC) that avoids the prologue analyzer
2847 - avoid handling the case where the PC hasn't been saved in the
2850 Unfortunately, not five lines further down, is a call to
2851 get_frame_id() and that is guarenteed to trigger the prologue
2854 The `correct fix' is for the prologe analyzer to handle the case
2855 where the prologue is incomplete (PC in prologue) and,
2856 consequently, the return pc has not yet been saved. It should be
2857 noted that the prologue analyzer needs to handle this case
2858 anyway: frameless leaf functions that don't save the return PC;
2859 single stepping through a prologue.
2861 The d10v handles all this by bailing out of the prologue analsis
2862 when it reaches the current instruction. */
2864 if (DEPRECATED_SAVED_PC_AFTER_CALL_P ())
2865 sr_sal
.pc
= ADDR_BITS_REMOVE (DEPRECATED_SAVED_PC_AFTER_CALL (get_current_frame ()));
2867 sr_sal
.pc
= ADDR_BITS_REMOVE (frame_pc_unwind (get_current_frame ()));
2868 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
2870 check_for_old_step_resume_breakpoint ();
2871 step_resume_breakpoint
=
2872 set_momentary_breakpoint (sr_sal
, get_frame_id (get_current_frame ()),
2875 if (frame_id_p (step_frame_id
)
2876 && !IN_SOLIB_DYNSYM_RESOLVE_CODE (sr_sal
.pc
))
2877 step_resume_breakpoint
->frame_id
= step_frame_id
;
2879 if (breakpoints_inserted
)
2880 insert_breakpoints ();
2884 stop_stepping (struct execution_control_state
*ecs
)
2886 /* Let callers know we don't want to wait for the inferior anymore. */
2887 ecs
->wait_some_more
= 0;
2890 /* This function handles various cases where we need to continue
2891 waiting for the inferior. */
2892 /* (Used to be the keep_going: label in the old wait_for_inferior) */
2895 keep_going (struct execution_control_state
*ecs
)
2897 /* Save the pc before execution, to compare with pc after stop. */
2898 prev_pc
= read_pc (); /* Might have been DECR_AFTER_BREAK */
2900 if (ecs
->update_step_sp
)
2901 step_sp
= read_sp ();
2902 ecs
->update_step_sp
= 0;
2904 /* If we did not do break;, it means we should keep running the
2905 inferior and not return to debugger. */
2907 if (trap_expected
&& stop_signal
!= TARGET_SIGNAL_TRAP
)
2909 /* We took a signal (which we are supposed to pass through to
2910 the inferior, else we'd have done a break above) and we
2911 haven't yet gotten our trap. Simply continue. */
2912 resume (currently_stepping (ecs
), stop_signal
);
2916 /* Either the trap was not expected, but we are continuing
2917 anyway (the user asked that this signal be passed to the
2920 The signal was SIGTRAP, e.g. it was our signal, but we
2921 decided we should resume from it.
2923 We're going to run this baby now!
2925 Insert breakpoints now, unless we are trying to one-proceed
2926 past a breakpoint. */
2927 /* If we've just finished a special step resume and we don't
2928 want to hit a breakpoint, pull em out. */
2929 if (step_resume_breakpoint
== NULL
2930 && through_sigtramp_breakpoint
== NULL
2931 && ecs
->remove_breakpoints_on_following_step
)
2933 ecs
->remove_breakpoints_on_following_step
= 0;
2934 remove_breakpoints ();
2935 breakpoints_inserted
= 0;
2937 else if (!breakpoints_inserted
&&
2938 (through_sigtramp_breakpoint
!= NULL
|| !ecs
->another_trap
))
2940 breakpoints_failed
= insert_breakpoints ();
2941 if (breakpoints_failed
)
2943 stop_stepping (ecs
);
2946 breakpoints_inserted
= 1;
2949 trap_expected
= ecs
->another_trap
;
2951 /* Do not deliver SIGNAL_TRAP (except when the user explicitly
2952 specifies that such a signal should be delivered to the
2955 Typically, this would occure when a user is debugging a
2956 target monitor on a simulator: the target monitor sets a
2957 breakpoint; the simulator encounters this break-point and
2958 halts the simulation handing control to GDB; GDB, noteing
2959 that the break-point isn't valid, returns control back to the
2960 simulator; the simulator then delivers the hardware
2961 equivalent of a SIGNAL_TRAP to the program being debugged. */
2963 if (stop_signal
== TARGET_SIGNAL_TRAP
&& !signal_program
[stop_signal
])
2964 stop_signal
= TARGET_SIGNAL_0
;
2967 resume (currently_stepping (ecs
), stop_signal
);
2970 prepare_to_wait (ecs
);
2973 /* This function normally comes after a resume, before
2974 handle_inferior_event exits. It takes care of any last bits of
2975 housekeeping, and sets the all-important wait_some_more flag. */
2978 prepare_to_wait (struct execution_control_state
*ecs
)
2980 if (ecs
->infwait_state
== infwait_normal_state
)
2982 overlay_cache_invalid
= 1;
2984 /* We have to invalidate the registers BEFORE calling
2985 target_wait because they can be loaded from the target while
2986 in target_wait. This makes remote debugging a bit more
2987 efficient for those targets that provide critical registers
2988 as part of their normal status mechanism. */
2990 registers_changed ();
2991 ecs
->waiton_ptid
= pid_to_ptid (-1);
2992 ecs
->wp
= &(ecs
->ws
);
2994 /* This is the old end of the while loop. Let everybody know we
2995 want to wait for the inferior some more and get called again
2997 ecs
->wait_some_more
= 1;
3000 /* Print why the inferior has stopped. We always print something when
3001 the inferior exits, or receives a signal. The rest of the cases are
3002 dealt with later on in normal_stop() and print_it_typical(). Ideally
3003 there should be a call to this function from handle_inferior_event()
3004 each time stop_stepping() is called.*/
3006 print_stop_reason (enum inferior_stop_reason stop_reason
, int stop_info
)
3008 switch (stop_reason
)
3011 /* We don't deal with these cases from handle_inferior_event()
3014 case END_STEPPING_RANGE
:
3015 /* We are done with a step/next/si/ni command. */
3016 /* For now print nothing. */
3017 /* Print a message only if not in the middle of doing a "step n"
3018 operation for n > 1 */
3019 if (!step_multi
|| !stop_step
)
3020 if (ui_out_is_mi_like_p (uiout
))
3021 ui_out_field_string (uiout
, "reason", "end-stepping-range");
3023 case BREAKPOINT_HIT
:
3024 /* We found a breakpoint. */
3025 /* For now print nothing. */
3028 /* The inferior was terminated by a signal. */
3029 annotate_signalled ();
3030 if (ui_out_is_mi_like_p (uiout
))
3031 ui_out_field_string (uiout
, "reason", "exited-signalled");
3032 ui_out_text (uiout
, "\nProgram terminated with signal ");
3033 annotate_signal_name ();
3034 ui_out_field_string (uiout
, "signal-name",
3035 target_signal_to_name (stop_info
));
3036 annotate_signal_name_end ();
3037 ui_out_text (uiout
, ", ");
3038 annotate_signal_string ();
3039 ui_out_field_string (uiout
, "signal-meaning",
3040 target_signal_to_string (stop_info
));
3041 annotate_signal_string_end ();
3042 ui_out_text (uiout
, ".\n");
3043 ui_out_text (uiout
, "The program no longer exists.\n");
3046 /* The inferior program is finished. */
3047 annotate_exited (stop_info
);
3050 if (ui_out_is_mi_like_p (uiout
))
3051 ui_out_field_string (uiout
, "reason", "exited");
3052 ui_out_text (uiout
, "\nProgram exited with code ");
3053 ui_out_field_fmt (uiout
, "exit-code", "0%o",
3054 (unsigned int) stop_info
);
3055 ui_out_text (uiout
, ".\n");
3059 if (ui_out_is_mi_like_p (uiout
))
3060 ui_out_field_string (uiout
, "reason", "exited-normally");
3061 ui_out_text (uiout
, "\nProgram exited normally.\n");
3064 case SIGNAL_RECEIVED
:
3065 /* Signal received. The signal table tells us to print about
3068 ui_out_text (uiout
, "\nProgram received signal ");
3069 annotate_signal_name ();
3070 if (ui_out_is_mi_like_p (uiout
))
3071 ui_out_field_string (uiout
, "reason", "signal-received");
3072 ui_out_field_string (uiout
, "signal-name",
3073 target_signal_to_name (stop_info
));
3074 annotate_signal_name_end ();
3075 ui_out_text (uiout
, ", ");
3076 annotate_signal_string ();
3077 ui_out_field_string (uiout
, "signal-meaning",
3078 target_signal_to_string (stop_info
));
3079 annotate_signal_string_end ();
3080 ui_out_text (uiout
, ".\n");
3083 internal_error (__FILE__
, __LINE__
,
3084 "print_stop_reason: unrecognized enum value");
3090 /* Here to return control to GDB when the inferior stops for real.
3091 Print appropriate messages, remove breakpoints, give terminal our modes.
3093 STOP_PRINT_FRAME nonzero means print the executing frame
3094 (pc, function, args, file, line number and line text).
3095 BREAKPOINTS_FAILED nonzero means stop was due to error
3096 attempting to insert breakpoints. */
3101 struct target_waitstatus last
;
3104 get_last_target_status (&last_ptid
, &last
);
3106 /* As with the notification of thread events, we want to delay
3107 notifying the user that we've switched thread context until
3108 the inferior actually stops.
3110 There's no point in saying anything if the inferior has exited.
3111 Note that SIGNALLED here means "exited with a signal", not
3112 "received a signal". */
3113 if (!ptid_equal (previous_inferior_ptid
, inferior_ptid
)
3114 && target_has_execution
3115 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
3116 && last
.kind
!= TARGET_WAITKIND_EXITED
)
3118 target_terminal_ours_for_output ();
3119 printf_filtered ("[Switching to %s]\n",
3120 target_pid_or_tid_to_str (inferior_ptid
));
3121 previous_inferior_ptid
= inferior_ptid
;
3124 /* Make sure that the current_frame's pc is correct. This
3125 is a correction for setting up the frame info before doing
3126 DECR_PC_AFTER_BREAK */
3127 if (target_has_execution
)
3128 /* FIXME: cagney/2002-12-06: Has the PC changed? Thanks to
3129 DECR_PC_AFTER_BREAK, the program counter can change. Ask the
3130 frame code to check for this and sort out any resultant mess.
3131 DECR_PC_AFTER_BREAK needs to just go away. */
3132 deprecated_update_frame_pc_hack (get_current_frame (), read_pc ());
3134 if (target_has_execution
&& breakpoints_inserted
)
3136 if (remove_breakpoints ())
3138 target_terminal_ours_for_output ();
3139 printf_filtered ("Cannot remove breakpoints because ");
3140 printf_filtered ("program is no longer writable.\n");
3141 printf_filtered ("It might be running in another process.\n");
3142 printf_filtered ("Further execution is probably impossible.\n");
3145 breakpoints_inserted
= 0;
3147 /* Delete the breakpoint we stopped at, if it wants to be deleted.
3148 Delete any breakpoint that is to be deleted at the next stop. */
3150 breakpoint_auto_delete (stop_bpstat
);
3152 /* If an auto-display called a function and that got a signal,
3153 delete that auto-display to avoid an infinite recursion. */
3155 if (stopped_by_random_signal
)
3156 disable_current_display ();
3158 /* Don't print a message if in the middle of doing a "step n"
3159 operation for n > 1 */
3160 if (step_multi
&& stop_step
)
3163 target_terminal_ours ();
3165 /* Look up the hook_stop and run it (CLI internally handles problem
3166 of stop_command's pre-hook not existing). */
3168 catch_errors (hook_stop_stub
, stop_command
,
3169 "Error while running hook_stop:\n", RETURN_MASK_ALL
);
3171 if (!target_has_stack
)
3177 /* Select innermost stack frame - i.e., current frame is frame 0,
3178 and current location is based on that.
3179 Don't do this on return from a stack dummy routine,
3180 or if the program has exited. */
3182 if (!stop_stack_dummy
)
3184 select_frame (get_current_frame ());
3186 /* Print current location without a level number, if
3187 we have changed functions or hit a breakpoint.
3188 Print source line if we have one.
3189 bpstat_print() contains the logic deciding in detail
3190 what to print, based on the event(s) that just occurred. */
3192 if (stop_print_frame
&& deprecated_selected_frame
)
3196 int do_frame_printing
= 1;
3198 bpstat_ret
= bpstat_print (stop_bpstat
);
3202 /* FIXME: cagney/2002-12-01: Given that a frame ID does
3203 (or should) carry around the function and does (or
3204 should) use that when doing a frame comparison. */
3206 && frame_id_eq (step_frame_id
,
3207 get_frame_id (get_current_frame ()))
3208 && step_start_function
== find_pc_function (stop_pc
))
3209 source_flag
= SRC_LINE
; /* finished step, just print source line */
3211 source_flag
= SRC_AND_LOC
; /* print location and source line */
3213 case PRINT_SRC_AND_LOC
:
3214 source_flag
= SRC_AND_LOC
; /* print location and source line */
3216 case PRINT_SRC_ONLY
:
3217 source_flag
= SRC_LINE
;
3220 source_flag
= SRC_LINE
; /* something bogus */
3221 do_frame_printing
= 0;
3224 internal_error (__FILE__
, __LINE__
, "Unknown value.");
3226 /* For mi, have the same behavior every time we stop:
3227 print everything but the source line. */
3228 if (ui_out_is_mi_like_p (uiout
))
3229 source_flag
= LOC_AND_ADDRESS
;
3231 if (ui_out_is_mi_like_p (uiout
))
3232 ui_out_field_int (uiout
, "thread-id",
3233 pid_to_thread_id (inferior_ptid
));
3234 /* The behavior of this routine with respect to the source
3236 SRC_LINE: Print only source line
3237 LOCATION: Print only location
3238 SRC_AND_LOC: Print location and source line */
3239 if (do_frame_printing
)
3240 print_stack_frame (deprecated_selected_frame
, -1, source_flag
);
3242 /* Display the auto-display expressions. */
3247 /* Save the function value return registers, if we care.
3248 We might be about to restore their previous contents. */
3249 if (proceed_to_finish
)
3250 /* NB: The copy goes through to the target picking up the value of
3251 all the registers. */
3252 regcache_cpy (stop_registers
, current_regcache
);
3254 if (stop_stack_dummy
)
3256 /* Pop the empty frame that contains the stack dummy. POP_FRAME
3257 ends with a setting of the current frame, so we can use that
3259 frame_pop (get_current_frame ());
3260 /* Set stop_pc to what it was before we called the function.
3261 Can't rely on restore_inferior_status because that only gets
3262 called if we don't stop in the called function. */
3263 stop_pc
= read_pc ();
3264 select_frame (get_current_frame ());
3268 annotate_stopped ();
3269 observer_notify_normal_stop ();
3273 hook_stop_stub (void *cmd
)
3275 execute_cmd_pre_hook ((struct cmd_list_element
*) cmd
);
3280 signal_stop_state (int signo
)
3282 return signal_stop
[signo
];
3286 signal_print_state (int signo
)
3288 return signal_print
[signo
];
3292 signal_pass_state (int signo
)
3294 return signal_program
[signo
];
3298 signal_stop_update (int signo
, int state
)
3300 int ret
= signal_stop
[signo
];
3301 signal_stop
[signo
] = state
;
3306 signal_print_update (int signo
, int state
)
3308 int ret
= signal_print
[signo
];
3309 signal_print
[signo
] = state
;
3314 signal_pass_update (int signo
, int state
)
3316 int ret
= signal_program
[signo
];
3317 signal_program
[signo
] = state
;
3322 sig_print_header (void)
3325 Signal Stop\tPrint\tPass to program\tDescription\n");
3329 sig_print_info (enum target_signal oursig
)
3331 char *name
= target_signal_to_name (oursig
);
3332 int name_padding
= 13 - strlen (name
);
3334 if (name_padding
<= 0)
3337 printf_filtered ("%s", name
);
3338 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
3339 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
3340 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
3341 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
3342 printf_filtered ("%s\n", target_signal_to_string (oursig
));
3345 /* Specify how various signals in the inferior should be handled. */
3348 handle_command (char *args
, int from_tty
)
3351 int digits
, wordlen
;
3352 int sigfirst
, signum
, siglast
;
3353 enum target_signal oursig
;
3356 unsigned char *sigs
;
3357 struct cleanup
*old_chain
;
3361 error_no_arg ("signal to handle");
3364 /* Allocate and zero an array of flags for which signals to handle. */
3366 nsigs
= (int) TARGET_SIGNAL_LAST
;
3367 sigs
= (unsigned char *) alloca (nsigs
);
3368 memset (sigs
, 0, nsigs
);
3370 /* Break the command line up into args. */
3372 argv
= buildargv (args
);
3377 old_chain
= make_cleanup_freeargv (argv
);
3379 /* Walk through the args, looking for signal oursigs, signal names, and
3380 actions. Signal numbers and signal names may be interspersed with
3381 actions, with the actions being performed for all signals cumulatively
3382 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
3384 while (*argv
!= NULL
)
3386 wordlen
= strlen (*argv
);
3387 for (digits
= 0; isdigit ((*argv
)[digits
]); digits
++)
3391 sigfirst
= siglast
= -1;
3393 if (wordlen
>= 1 && !strncmp (*argv
, "all", wordlen
))
3395 /* Apply action to all signals except those used by the
3396 debugger. Silently skip those. */
3399 siglast
= nsigs
- 1;
3401 else if (wordlen
>= 1 && !strncmp (*argv
, "stop", wordlen
))
3403 SET_SIGS (nsigs
, sigs
, signal_stop
);
3404 SET_SIGS (nsigs
, sigs
, signal_print
);
3406 else if (wordlen
>= 1 && !strncmp (*argv
, "ignore", wordlen
))
3408 UNSET_SIGS (nsigs
, sigs
, signal_program
);
3410 else if (wordlen
>= 2 && !strncmp (*argv
, "print", wordlen
))
3412 SET_SIGS (nsigs
, sigs
, signal_print
);
3414 else if (wordlen
>= 2 && !strncmp (*argv
, "pass", wordlen
))
3416 SET_SIGS (nsigs
, sigs
, signal_program
);
3418 else if (wordlen
>= 3 && !strncmp (*argv
, "nostop", wordlen
))
3420 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
3422 else if (wordlen
>= 3 && !strncmp (*argv
, "noignore", wordlen
))
3424 SET_SIGS (nsigs
, sigs
, signal_program
);
3426 else if (wordlen
>= 4 && !strncmp (*argv
, "noprint", wordlen
))
3428 UNSET_SIGS (nsigs
, sigs
, signal_print
);
3429 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
3431 else if (wordlen
>= 4 && !strncmp (*argv
, "nopass", wordlen
))
3433 UNSET_SIGS (nsigs
, sigs
, signal_program
);
3435 else if (digits
> 0)
3437 /* It is numeric. The numeric signal refers to our own
3438 internal signal numbering from target.h, not to host/target
3439 signal number. This is a feature; users really should be
3440 using symbolic names anyway, and the common ones like
3441 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
3443 sigfirst
= siglast
= (int)
3444 target_signal_from_command (atoi (*argv
));
3445 if ((*argv
)[digits
] == '-')
3448 target_signal_from_command (atoi ((*argv
) + digits
+ 1));
3450 if (sigfirst
> siglast
)
3452 /* Bet he didn't figure we'd think of this case... */
3460 oursig
= target_signal_from_name (*argv
);
3461 if (oursig
!= TARGET_SIGNAL_UNKNOWN
)
3463 sigfirst
= siglast
= (int) oursig
;
3467 /* Not a number and not a recognized flag word => complain. */
3468 error ("Unrecognized or ambiguous flag word: \"%s\".", *argv
);
3472 /* If any signal numbers or symbol names were found, set flags for
3473 which signals to apply actions to. */
3475 for (signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
3477 switch ((enum target_signal
) signum
)
3479 case TARGET_SIGNAL_TRAP
:
3480 case TARGET_SIGNAL_INT
:
3481 if (!allsigs
&& !sigs
[signum
])
3483 if (query ("%s is used by the debugger.\n\
3484 Are you sure you want to change it? ", target_signal_to_name ((enum target_signal
) signum
)))
3490 printf_unfiltered ("Not confirmed, unchanged.\n");
3491 gdb_flush (gdb_stdout
);
3495 case TARGET_SIGNAL_0
:
3496 case TARGET_SIGNAL_DEFAULT
:
3497 case TARGET_SIGNAL_UNKNOWN
:
3498 /* Make sure that "all" doesn't print these. */
3509 target_notice_signals (inferior_ptid
);
3513 /* Show the results. */
3514 sig_print_header ();
3515 for (signum
= 0; signum
< nsigs
; signum
++)
3519 sig_print_info (signum
);
3524 do_cleanups (old_chain
);
3528 xdb_handle_command (char *args
, int from_tty
)
3531 struct cleanup
*old_chain
;
3533 /* Break the command line up into args. */
3535 argv
= buildargv (args
);
3540 old_chain
= make_cleanup_freeargv (argv
);
3541 if (argv
[1] != (char *) NULL
)
3546 bufLen
= strlen (argv
[0]) + 20;
3547 argBuf
= (char *) xmalloc (bufLen
);
3551 enum target_signal oursig
;
3553 oursig
= target_signal_from_name (argv
[0]);
3554 memset (argBuf
, 0, bufLen
);
3555 if (strcmp (argv
[1], "Q") == 0)
3556 sprintf (argBuf
, "%s %s", argv
[0], "noprint");
3559 if (strcmp (argv
[1], "s") == 0)
3561 if (!signal_stop
[oursig
])
3562 sprintf (argBuf
, "%s %s", argv
[0], "stop");
3564 sprintf (argBuf
, "%s %s", argv
[0], "nostop");
3566 else if (strcmp (argv
[1], "i") == 0)
3568 if (!signal_program
[oursig
])
3569 sprintf (argBuf
, "%s %s", argv
[0], "pass");
3571 sprintf (argBuf
, "%s %s", argv
[0], "nopass");
3573 else if (strcmp (argv
[1], "r") == 0)
3575 if (!signal_print
[oursig
])
3576 sprintf (argBuf
, "%s %s", argv
[0], "print");
3578 sprintf (argBuf
, "%s %s", argv
[0], "noprint");
3584 handle_command (argBuf
, from_tty
);
3586 printf_filtered ("Invalid signal handling flag.\n");
3591 do_cleanups (old_chain
);
3594 /* Print current contents of the tables set by the handle command.
3595 It is possible we should just be printing signals actually used
3596 by the current target (but for things to work right when switching
3597 targets, all signals should be in the signal tables). */
3600 signals_info (char *signum_exp
, int from_tty
)
3602 enum target_signal oursig
;
3603 sig_print_header ();
3607 /* First see if this is a symbol name. */
3608 oursig
= target_signal_from_name (signum_exp
);
3609 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
3611 /* No, try numeric. */
3613 target_signal_from_command (parse_and_eval_long (signum_exp
));
3615 sig_print_info (oursig
);
3619 printf_filtered ("\n");
3620 /* These ugly casts brought to you by the native VAX compiler. */
3621 for (oursig
= TARGET_SIGNAL_FIRST
;
3622 (int) oursig
< (int) TARGET_SIGNAL_LAST
;
3623 oursig
= (enum target_signal
) ((int) oursig
+ 1))
3627 if (oursig
!= TARGET_SIGNAL_UNKNOWN
3628 && oursig
!= TARGET_SIGNAL_DEFAULT
&& oursig
!= TARGET_SIGNAL_0
)
3629 sig_print_info (oursig
);
3632 printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
3635 struct inferior_status
3637 enum target_signal stop_signal
;
3641 int stop_stack_dummy
;
3642 int stopped_by_random_signal
;
3644 CORE_ADDR step_range_start
;
3645 CORE_ADDR step_range_end
;
3646 struct frame_id step_frame_id
;
3647 enum step_over_calls_kind step_over_calls
;
3648 CORE_ADDR step_resume_break_address
;
3649 int stop_after_trap
;
3651 struct regcache
*stop_registers
;
3653 /* These are here because if call_function_by_hand has written some
3654 registers and then decides to call error(), we better not have changed
3656 struct regcache
*registers
;
3658 /* A frame unique identifier. */
3659 struct frame_id selected_frame_id
;
3661 int breakpoint_proceeded
;
3662 int restore_stack_info
;
3663 int proceed_to_finish
;
3667 write_inferior_status_register (struct inferior_status
*inf_status
, int regno
,
3670 int size
= DEPRECATED_REGISTER_RAW_SIZE (regno
);
3671 void *buf
= alloca (size
);
3672 store_signed_integer (buf
, size
, val
);
3673 regcache_raw_write (inf_status
->registers
, regno
, buf
);
3676 /* Save all of the information associated with the inferior<==>gdb
3677 connection. INF_STATUS is a pointer to a "struct inferior_status"
3678 (defined in inferior.h). */
3680 struct inferior_status
*
3681 save_inferior_status (int restore_stack_info
)
3683 struct inferior_status
*inf_status
= XMALLOC (struct inferior_status
);
3685 inf_status
->stop_signal
= stop_signal
;
3686 inf_status
->stop_pc
= stop_pc
;
3687 inf_status
->stop_step
= stop_step
;
3688 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
3689 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
3690 inf_status
->trap_expected
= trap_expected
;
3691 inf_status
->step_range_start
= step_range_start
;
3692 inf_status
->step_range_end
= step_range_end
;
3693 inf_status
->step_frame_id
= step_frame_id
;
3694 inf_status
->step_over_calls
= step_over_calls
;
3695 inf_status
->stop_after_trap
= stop_after_trap
;
3696 inf_status
->stop_soon
= stop_soon
;
3697 /* Save original bpstat chain here; replace it with copy of chain.
3698 If caller's caller is walking the chain, they'll be happier if we
3699 hand them back the original chain when restore_inferior_status is
3701 inf_status
->stop_bpstat
= stop_bpstat
;
3702 stop_bpstat
= bpstat_copy (stop_bpstat
);
3703 inf_status
->breakpoint_proceeded
= breakpoint_proceeded
;
3704 inf_status
->restore_stack_info
= restore_stack_info
;
3705 inf_status
->proceed_to_finish
= proceed_to_finish
;
3707 inf_status
->stop_registers
= regcache_dup_no_passthrough (stop_registers
);
3709 inf_status
->registers
= regcache_dup (current_regcache
);
3711 inf_status
->selected_frame_id
= get_frame_id (deprecated_selected_frame
);
3716 restore_selected_frame (void *args
)
3718 struct frame_id
*fid
= (struct frame_id
*) args
;
3719 struct frame_info
*frame
;
3721 frame
= frame_find_by_id (*fid
);
3723 /* If inf_status->selected_frame_id is NULL, there was no previously
3727 warning ("Unable to restore previously selected frame.\n");
3731 select_frame (frame
);
3737 restore_inferior_status (struct inferior_status
*inf_status
)
3739 stop_signal
= inf_status
->stop_signal
;
3740 stop_pc
= inf_status
->stop_pc
;
3741 stop_step
= inf_status
->stop_step
;
3742 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
3743 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
3744 trap_expected
= inf_status
->trap_expected
;
3745 step_range_start
= inf_status
->step_range_start
;
3746 step_range_end
= inf_status
->step_range_end
;
3747 step_frame_id
= inf_status
->step_frame_id
;
3748 step_over_calls
= inf_status
->step_over_calls
;
3749 stop_after_trap
= inf_status
->stop_after_trap
;
3750 stop_soon
= inf_status
->stop_soon
;
3751 bpstat_clear (&stop_bpstat
);
3752 stop_bpstat
= inf_status
->stop_bpstat
;
3753 breakpoint_proceeded
= inf_status
->breakpoint_proceeded
;
3754 proceed_to_finish
= inf_status
->proceed_to_finish
;
3756 /* FIXME: Is the restore of stop_registers always needed. */
3757 regcache_xfree (stop_registers
);
3758 stop_registers
= inf_status
->stop_registers
;
3760 /* The inferior can be gone if the user types "print exit(0)"
3761 (and perhaps other times). */
3762 if (target_has_execution
)
3763 /* NB: The register write goes through to the target. */
3764 regcache_cpy (current_regcache
, inf_status
->registers
);
3765 regcache_xfree (inf_status
->registers
);
3767 /* FIXME: If we are being called after stopping in a function which
3768 is called from gdb, we should not be trying to restore the
3769 selected frame; it just prints a spurious error message (The
3770 message is useful, however, in detecting bugs in gdb (like if gdb
3771 clobbers the stack)). In fact, should we be restoring the
3772 inferior status at all in that case? . */
3774 if (target_has_stack
&& inf_status
->restore_stack_info
)
3776 /* The point of catch_errors is that if the stack is clobbered,
3777 walking the stack might encounter a garbage pointer and
3778 error() trying to dereference it. */
3780 (restore_selected_frame
, &inf_status
->selected_frame_id
,
3781 "Unable to restore previously selected frame:\n",
3782 RETURN_MASK_ERROR
) == 0)
3783 /* Error in restoring the selected frame. Select the innermost
3785 select_frame (get_current_frame ());
3793 do_restore_inferior_status_cleanup (void *sts
)
3795 restore_inferior_status (sts
);
3799 make_cleanup_restore_inferior_status (struct inferior_status
*inf_status
)
3801 return make_cleanup (do_restore_inferior_status_cleanup
, inf_status
);
3805 discard_inferior_status (struct inferior_status
*inf_status
)
3807 /* See save_inferior_status for info on stop_bpstat. */
3808 bpstat_clear (&inf_status
->stop_bpstat
);
3809 regcache_xfree (inf_status
->registers
);
3810 regcache_xfree (inf_status
->stop_registers
);
3815 inferior_has_forked (int pid
, int *child_pid
)
3817 struct target_waitstatus last
;
3820 get_last_target_status (&last_ptid
, &last
);
3822 if (last
.kind
!= TARGET_WAITKIND_FORKED
)
3825 if (ptid_get_pid (last_ptid
) != pid
)
3828 *child_pid
= last
.value
.related_pid
;
3833 inferior_has_vforked (int pid
, int *child_pid
)
3835 struct target_waitstatus last
;
3838 get_last_target_status (&last_ptid
, &last
);
3840 if (last
.kind
!= TARGET_WAITKIND_VFORKED
)
3843 if (ptid_get_pid (last_ptid
) != pid
)
3846 *child_pid
= last
.value
.related_pid
;
3851 inferior_has_execd (int pid
, char **execd_pathname
)
3853 struct target_waitstatus last
;
3856 get_last_target_status (&last_ptid
, &last
);
3858 if (last
.kind
!= TARGET_WAITKIND_EXECD
)
3861 if (ptid_get_pid (last_ptid
) != pid
)
3864 *execd_pathname
= xstrdup (last
.value
.execd_pathname
);
3868 /* Oft used ptids */
3870 ptid_t minus_one_ptid
;
3872 /* Create a ptid given the necessary PID, LWP, and TID components. */
3875 ptid_build (int pid
, long lwp
, long tid
)
3885 /* Create a ptid from just a pid. */
3888 pid_to_ptid (int pid
)
3890 return ptid_build (pid
, 0, 0);
3893 /* Fetch the pid (process id) component from a ptid. */
3896 ptid_get_pid (ptid_t ptid
)
3901 /* Fetch the lwp (lightweight process) component from a ptid. */
3904 ptid_get_lwp (ptid_t ptid
)
3909 /* Fetch the tid (thread id) component from a ptid. */
3912 ptid_get_tid (ptid_t ptid
)
3917 /* ptid_equal() is used to test equality of two ptids. */
3920 ptid_equal (ptid_t ptid1
, ptid_t ptid2
)
3922 return (ptid1
.pid
== ptid2
.pid
&& ptid1
.lwp
== ptid2
.lwp
3923 && ptid1
.tid
== ptid2
.tid
);
3926 /* restore_inferior_ptid() will be used by the cleanup machinery
3927 to restore the inferior_ptid value saved in a call to
3928 save_inferior_ptid(). */
3931 restore_inferior_ptid (void *arg
)
3933 ptid_t
*saved_ptid_ptr
= arg
;
3934 inferior_ptid
= *saved_ptid_ptr
;
3938 /* Save the value of inferior_ptid so that it may be restored by a
3939 later call to do_cleanups(). Returns the struct cleanup pointer
3940 needed for later doing the cleanup. */
3943 save_inferior_ptid (void)
3945 ptid_t
*saved_ptid_ptr
;
3947 saved_ptid_ptr
= xmalloc (sizeof (ptid_t
));
3948 *saved_ptid_ptr
= inferior_ptid
;
3949 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
3956 stop_registers
= regcache_xmalloc (current_gdbarch
);
3960 _initialize_infrun (void)
3964 struct cmd_list_element
*c
;
3966 register_gdbarch_swap (&stop_registers
, sizeof (stop_registers
), NULL
);
3967 register_gdbarch_swap (NULL
, 0, build_infrun
);
3969 add_info ("signals", signals_info
,
3970 "What debugger does when program gets various signals.\n\
3971 Specify a signal as argument to print info on that signal only.");
3972 add_info_alias ("handle", "signals", 0);
3974 add_com ("handle", class_run
, handle_command
,
3975 concat ("Specify how to handle a signal.\n\
3976 Args are signals and actions to apply to those signals.\n\
3977 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
3978 from 1-15 are allowed for compatibility with old versions of GDB.\n\
3979 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
3980 The special arg \"all\" is recognized to mean all signals except those\n\
3981 used by the debugger, typically SIGTRAP and SIGINT.\n", "Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
3982 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
3983 Stop means reenter debugger if this signal happens (implies print).\n\
3984 Print means print a message if this signal happens.\n\
3985 Pass means let program see this signal; otherwise program doesn't know.\n\
3986 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
3987 Pass and Stop may be combined.", NULL
));
3990 add_com ("lz", class_info
, signals_info
,
3991 "What debugger does when program gets various signals.\n\
3992 Specify a signal as argument to print info on that signal only.");
3993 add_com ("z", class_run
, xdb_handle_command
,
3994 concat ("Specify how to handle a signal.\n\
3995 Args are signals and actions to apply to those signals.\n\
3996 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
3997 from 1-15 are allowed for compatibility with old versions of GDB.\n\
3998 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
3999 The special arg \"all\" is recognized to mean all signals except those\n\
4000 used by the debugger, typically SIGTRAP and SIGINT.\n", "Recognized actions include \"s\" (toggles between stop and nostop), \n\
4001 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
4002 nopass), \"Q\" (noprint)\n\
4003 Stop means reenter debugger if this signal happens (implies print).\n\
4004 Print means print a message if this signal happens.\n\
4005 Pass means let program see this signal; otherwise program doesn't know.\n\
4006 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
4007 Pass and Stop may be combined.", NULL
));
4012 add_cmd ("stop", class_obscure
, not_just_help_class_command
, "There is no `stop' command, but you can set a hook on `stop'.\n\
4013 This allows you to set a list of commands to be run each time execution\n\
4014 of the program stops.", &cmdlist
);
4016 numsigs
= (int) TARGET_SIGNAL_LAST
;
4017 signal_stop
= (unsigned char *) xmalloc (sizeof (signal_stop
[0]) * numsigs
);
4018 signal_print
= (unsigned char *)
4019 xmalloc (sizeof (signal_print
[0]) * numsigs
);
4020 signal_program
= (unsigned char *)
4021 xmalloc (sizeof (signal_program
[0]) * numsigs
);
4022 for (i
= 0; i
< numsigs
; i
++)
4025 signal_print
[i
] = 1;
4026 signal_program
[i
] = 1;
4029 /* Signals caused by debugger's own actions
4030 should not be given to the program afterwards. */
4031 signal_program
[TARGET_SIGNAL_TRAP
] = 0;
4032 signal_program
[TARGET_SIGNAL_INT
] = 0;
4034 /* Signals that are not errors should not normally enter the debugger. */
4035 signal_stop
[TARGET_SIGNAL_ALRM
] = 0;
4036 signal_print
[TARGET_SIGNAL_ALRM
] = 0;
4037 signal_stop
[TARGET_SIGNAL_VTALRM
] = 0;
4038 signal_print
[TARGET_SIGNAL_VTALRM
] = 0;
4039 signal_stop
[TARGET_SIGNAL_PROF
] = 0;
4040 signal_print
[TARGET_SIGNAL_PROF
] = 0;
4041 signal_stop
[TARGET_SIGNAL_CHLD
] = 0;
4042 signal_print
[TARGET_SIGNAL_CHLD
] = 0;
4043 signal_stop
[TARGET_SIGNAL_IO
] = 0;
4044 signal_print
[TARGET_SIGNAL_IO
] = 0;
4045 signal_stop
[TARGET_SIGNAL_POLL
] = 0;
4046 signal_print
[TARGET_SIGNAL_POLL
] = 0;
4047 signal_stop
[TARGET_SIGNAL_URG
] = 0;
4048 signal_print
[TARGET_SIGNAL_URG
] = 0;
4049 signal_stop
[TARGET_SIGNAL_WINCH
] = 0;
4050 signal_print
[TARGET_SIGNAL_WINCH
] = 0;
4052 /* These signals are used internally by user-level thread
4053 implementations. (See signal(5) on Solaris.) Like the above
4054 signals, a healthy program receives and handles them as part of
4055 its normal operation. */
4056 signal_stop
[TARGET_SIGNAL_LWP
] = 0;
4057 signal_print
[TARGET_SIGNAL_LWP
] = 0;
4058 signal_stop
[TARGET_SIGNAL_WAITING
] = 0;
4059 signal_print
[TARGET_SIGNAL_WAITING
] = 0;
4060 signal_stop
[TARGET_SIGNAL_CANCEL
] = 0;
4061 signal_print
[TARGET_SIGNAL_CANCEL
] = 0;
4065 (add_set_cmd ("stop-on-solib-events", class_support
, var_zinteger
,
4066 (char *) &stop_on_solib_events
,
4067 "Set stopping for shared library events.\n\
4068 If nonzero, gdb will give control to the user when the dynamic linker\n\
4069 notifies gdb of shared library events. The most common event of interest\n\
4070 to the user would be loading/unloading of a new library.\n", &setlist
), &showlist
);
4073 c
= add_set_enum_cmd ("follow-fork-mode",
4075 follow_fork_mode_kind_names
, &follow_fork_mode_string
,
4076 "Set debugger response to a program call of fork \
4078 A fork or vfork creates a new process. follow-fork-mode can be:\n\
4079 parent - the original process is debugged after a fork\n\
4080 child - the new process is debugged after a fork\n\
4081 The unfollowed process will continue to run.\n\
4082 By default, the debugger will follow the parent process.", &setlist
);
4083 add_show_from_set (c
, &showlist
);
4085 c
= add_set_enum_cmd ("scheduler-locking", class_run
, scheduler_enums
, /* array of string names */
4086 &scheduler_mode
, /* current mode */
4087 "Set mode for locking scheduler during execution.\n\
4088 off == no locking (threads may preempt at any time)\n\
4089 on == full locking (no thread except the current thread may run)\n\
4090 step == scheduler locked during every single-step operation.\n\
4091 In this mode, no other thread may run during a step command.\n\
4092 Other threads may run while stepping over a function call ('next').", &setlist
);
4094 set_cmd_sfunc (c
, set_schedlock_func
); /* traps on target vector */
4095 add_show_from_set (c
, &showlist
);
4097 c
= add_set_cmd ("step-mode", class_run
,
4098 var_boolean
, (char *) &step_stop_if_no_debug
,
4099 "Set mode of the step operation. When set, doing a step over a\n\
4100 function without debug line information will stop at the first\n\
4101 instruction of that function. Otherwise, the function is skipped and\n\
4102 the step command stops at a different source line.", &setlist
);
4103 add_show_from_set (c
, &showlist
);
4105 /* ptid initializations */
4106 null_ptid
= ptid_build (0, 0, 0);
4107 minus_one_ptid
= ptid_build (-1, 0, 0);
4108 inferior_ptid
= null_ptid
;
4109 target_last_wait_ptid
= minus_one_ptid
;