1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2014 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
31 #include "cli/cli-script.h"
33 #include "gdbthread.h"
45 #include "dictionary.h"
47 #include "mi/mi-common.h"
48 #include "event-top.h"
50 #include "record-full.h"
51 #include "inline-frame.h"
53 #include "tracepoint.h"
54 #include "continuations.h"
59 #include "completer.h"
60 #include "target-descriptions.h"
61 #include "target-dcache.h"
64 /* Prototypes for local functions */
66 static void signals_info (char *, int);
68 static void handle_command (char *, int);
70 static void sig_print_info (enum gdb_signal);
72 static void sig_print_header (void);
74 static void resume_cleanups (void *);
76 static int hook_stop_stub (void *);
78 static int restore_selected_frame (void *);
80 static int follow_fork (void);
82 static int follow_fork_inferior (int follow_child, int detach_fork);
84 static void follow_inferior_reset_breakpoints (void);
86 static void set_schedlock_func (char *args, int from_tty,
87 struct cmd_list_element *c);
89 static int currently_stepping (struct thread_info *tp);
91 static void xdb_handle_command (char *args, int from_tty);
93 void _initialize_infrun (void);
95 void nullify_last_target_wait_ptid (void);
97 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
99 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
101 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
103 /* When set, stop the 'step' command if we enter a function which has
104 no line number information. The normal behavior is that we step
105 over such function. */
106 int step_stop_if_no_debug = 0;
108 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
109 struct cmd_list_element *c, const char *value)
111 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
114 /* In asynchronous mode, but simulating synchronous execution. */
116 int sync_execution = 0;
118 /* proceed and normal_stop use this to notify the user when the
119 inferior stopped in a different thread than it had been running
122 static ptid_t previous_inferior_ptid;
124 /* If set (default for legacy reasons), when following a fork, GDB
125 will detach from one of the fork branches, child or parent.
126 Exactly which branch is detached depends on 'set follow-fork-mode'
129 static int detach_fork = 1;
131 int debug_displaced = 0;
133 show_debug_displaced (struct ui_file *file, int from_tty,
134 struct cmd_list_element *c, const char *value)
136 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
139 unsigned int debug_infrun = 0;
141 show_debug_infrun (struct ui_file *file, int from_tty,
142 struct cmd_list_element *c, const char *value)
144 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
148 /* Support for disabling address space randomization. */
150 int disable_randomization = 1;
153 show_disable_randomization (struct ui_file *file, int from_tty,
154 struct cmd_list_element *c, const char *value)
156 if (target_supports_disable_randomization ())
157 fprintf_filtered (file,
158 _("Disabling randomization of debuggee's "
159 "virtual address space is %s.\n"),
162 fputs_filtered (_("Disabling randomization of debuggee's "
163 "virtual address space is unsupported on\n"
164 "this platform.\n"), file);
168 set_disable_randomization (char *args, int from_tty,
169 struct cmd_list_element *c)
171 if (!target_supports_disable_randomization ())
172 error (_("Disabling randomization of debuggee's "
173 "virtual address space is unsupported on\n"
177 /* User interface for non-stop mode. */
180 static int non_stop_1 = 0;
183 set_non_stop (char *args, int from_tty,
184 struct cmd_list_element *c)
186 if (target_has_execution)
188 non_stop_1 = non_stop;
189 error (_("Cannot change this setting while the inferior is running."));
192 non_stop = non_stop_1;
196 show_non_stop (struct ui_file *file, int from_tty,
197 struct cmd_list_element *c, const char *value)
199 fprintf_filtered (file,
200 _("Controlling the inferior in non-stop mode is %s.\n"),
204 /* "Observer mode" is somewhat like a more extreme version of
205 non-stop, in which all GDB operations that might affect the
206 target's execution have been disabled. */
208 int observer_mode = 0;
209 static int observer_mode_1 = 0;
212 set_observer_mode (char *args, int from_tty,
213 struct cmd_list_element *c)
215 if (target_has_execution)
217 observer_mode_1 = observer_mode;
218 error (_("Cannot change this setting while the inferior is running."));
221 observer_mode = observer_mode_1;
223 may_write_registers = !observer_mode;
224 may_write_memory = !observer_mode;
225 may_insert_breakpoints = !observer_mode;
226 may_insert_tracepoints = !observer_mode;
227 /* We can insert fast tracepoints in or out of observer mode,
228 but enable them if we're going into this mode. */
230 may_insert_fast_tracepoints = 1;
231 may_stop = !observer_mode;
232 update_target_permissions ();
234 /* Going *into* observer mode we must force non-stop, then
235 going out we leave it that way. */
238 pagination_enabled = 0;
239 non_stop = non_stop_1 = 1;
243 printf_filtered (_("Observer mode is now %s.\n"),
244 (observer_mode ? "on" : "off"));
248 show_observer_mode (struct ui_file *file, int from_tty,
249 struct cmd_list_element *c, const char *value)
251 fprintf_filtered (file, _("Observer mode is %s.\n"), value);
254 /* This updates the value of observer mode based on changes in
255 permissions. Note that we are deliberately ignoring the values of
256 may-write-registers and may-write-memory, since the user may have
257 reason to enable these during a session, for instance to turn on a
258 debugging-related global. */
261 update_observer_mode (void)
265 newval = (!may_insert_breakpoints
266 && !may_insert_tracepoints
267 && may_insert_fast_tracepoints
271 /* Let the user know if things change. */
272 if (newval != observer_mode)
273 printf_filtered (_("Observer mode is now %s.\n"),
274 (newval ? "on" : "off"));
276 observer_mode = observer_mode_1 = newval;
279 /* Tables of how to react to signals; the user sets them. */
281 static unsigned char *signal_stop;
282 static unsigned char *signal_print;
283 static unsigned char *signal_program;
285 /* Table of signals that are registered with "catch signal". A
286 non-zero entry indicates that the signal is caught by some "catch
287 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
289 static unsigned char *signal_catch;
291 /* Table of signals that the target may silently handle.
292 This is automatically determined from the flags above,
293 and simply cached here. */
294 static unsigned char *signal_pass;
296 #define SET_SIGS(nsigs,sigs,flags) \
298 int signum = (nsigs); \
299 while (signum-- > 0) \
300 if ((sigs)[signum]) \
301 (flags)[signum] = 1; \
304 #define UNSET_SIGS(nsigs,sigs,flags) \
306 int signum = (nsigs); \
307 while (signum-- > 0) \
308 if ((sigs)[signum]) \
309 (flags)[signum] = 0; \
312 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
313 this function is to avoid exporting `signal_program'. */
316 update_signals_program_target (void)
318 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
321 /* Value to pass to target_resume() to cause all threads to resume. */
323 #define RESUME_ALL minus_one_ptid
325 /* Command list pointer for the "stop" placeholder. */
327 static struct cmd_list_element *stop_command;
329 /* Function inferior was in as of last step command. */
331 static struct symbol *step_start_function;
333 /* Nonzero if we want to give control to the user when we're notified
334 of shared library events by the dynamic linker. */
335 int stop_on_solib_events;
337 /* Enable or disable optional shared library event breakpoints
338 as appropriate when the above flag is changed. */
341 set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
343 update_solib_breakpoints ();
347 show_stop_on_solib_events (struct ui_file *file, int from_tty,
348 struct cmd_list_element *c, const char *value)
350 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
354 /* Nonzero means expecting a trace trap
355 and should stop the inferior and return silently when it happens. */
359 /* Save register contents here when executing a "finish" command or are
360 about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set.
361 Thus this contains the return value from the called function (assuming
362 values are returned in a register). */
364 struct regcache *stop_registers;
366 /* Nonzero after stop if current stack frame should be printed. */
368 static int stop_print_frame;
370 /* This is a cached copy of the pid/waitstatus of the last event
371 returned by target_wait()/deprecated_target_wait_hook(). This
372 information is returned by get_last_target_status(). */
373 static ptid_t target_last_wait_ptid;
374 static struct target_waitstatus target_last_waitstatus;
376 static void context_switch (ptid_t ptid);
378 void init_thread_stepping_state (struct thread_info *tss);
380 static void init_infwait_state (void);
382 static const char follow_fork_mode_child[] = "child";
383 static const char follow_fork_mode_parent[] = "parent";
385 static const char *const follow_fork_mode_kind_names[] = {
386 follow_fork_mode_child,
387 follow_fork_mode_parent,
391 static const char *follow_fork_mode_string = follow_fork_mode_parent;
393 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
394 struct cmd_list_element *c, const char *value)
396 fprintf_filtered (file,
397 _("Debugger response to a program "
398 "call of fork or vfork is \"%s\".\n"),
403 /* Handle changes to the inferior list based on the type of fork,
404 which process is being followed, and whether the other process
405 should be detached. On entry inferior_ptid must be the ptid of
406 the fork parent. At return inferior_ptid is the ptid of the
407 followed inferior. */
410 follow_fork_inferior (int follow_child, int detach_fork)
413 int parent_pid, child_pid;
415 has_vforked = (inferior_thread ()->pending_follow.kind
416 == TARGET_WAITKIND_VFORKED);
417 parent_pid = ptid_get_lwp (inferior_ptid);
419 parent_pid = ptid_get_pid (inferior_ptid);
421 = ptid_get_pid (inferior_thread ()->pending_follow.value.related_pid);
424 && !non_stop /* Non-stop always resumes both branches. */
425 && (!target_is_async_p () || sync_execution)
426 && !(follow_child || detach_fork || sched_multi))
428 /* The parent stays blocked inside the vfork syscall until the
429 child execs or exits. If we don't let the child run, then
430 the parent stays blocked. If we're telling the parent to run
431 in the foreground, the user will not be able to ctrl-c to get
432 back the terminal, effectively hanging the debug session. */
433 fprintf_filtered (gdb_stderr, _("\
434 Can not resume the parent process over vfork in the foreground while\n\
435 holding the child stopped. Try \"set detach-on-fork\" or \
436 \"set schedule-multiple\".\n"));
437 /* FIXME output string > 80 columns. */
443 /* Detach new forked process? */
446 struct cleanup *old_chain;
448 /* Before detaching from the child, remove all breakpoints
449 from it. If we forked, then this has already been taken
450 care of by infrun.c. If we vforked however, any
451 breakpoint inserted in the parent is visible in the
452 child, even those added while stopped in a vfork
453 catchpoint. This will remove the breakpoints from the
454 parent also, but they'll be reinserted below. */
457 /* Keep breakpoints list in sync. */
458 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
461 if (info_verbose || debug_infrun)
463 target_terminal_ours ();
464 fprintf_filtered (gdb_stdlog,
465 "Detaching after fork from "
466 "child process %d.\n",
472 struct inferior *parent_inf, *child_inf;
473 struct cleanup *old_chain;
475 /* Add process to GDB's tables. */
476 child_inf = add_inferior (child_pid);
478 parent_inf = current_inferior ();
479 child_inf->attach_flag = parent_inf->attach_flag;
480 copy_terminal_info (child_inf, parent_inf);
481 child_inf->gdbarch = parent_inf->gdbarch;
482 copy_inferior_target_desc_info (child_inf, parent_inf);
484 old_chain = save_inferior_ptid ();
485 save_current_program_space ();
487 inferior_ptid = ptid_build (child_pid, child_pid, 0);
488 add_thread (inferior_ptid);
489 child_inf->symfile_flags = SYMFILE_NO_READ;
491 /* If this is a vfork child, then the address-space is
492 shared with the parent. */
495 child_inf->pspace = parent_inf->pspace;
496 child_inf->aspace = parent_inf->aspace;
498 /* The parent will be frozen until the child is done
499 with the shared region. Keep track of the
501 child_inf->vfork_parent = parent_inf;
502 child_inf->pending_detach = 0;
503 parent_inf->vfork_child = child_inf;
504 parent_inf->pending_detach = 0;
508 child_inf->aspace = new_address_space ();
509 child_inf->pspace = add_program_space (child_inf->aspace);
510 child_inf->removable = 1;
511 set_current_program_space (child_inf->pspace);
512 clone_program_space (child_inf->pspace, parent_inf->pspace);
514 /* Let the shared library layer (e.g., solib-svr4) learn
515 about this new process, relocate the cloned exec, pull
516 in shared libraries, and install the solib event
517 breakpoint. If a "cloned-VM" event was propagated
518 better throughout the core, this wouldn't be
520 solib_create_inferior_hook (0);
523 do_cleanups (old_chain);
528 struct inferior *parent_inf;
530 parent_inf = current_inferior ();
532 /* If we detached from the child, then we have to be careful
533 to not insert breakpoints in the parent until the child
534 is done with the shared memory region. However, if we're
535 staying attached to the child, then we can and should
536 insert breakpoints, so that we can debug it. A
537 subsequent child exec or exit is enough to know when does
538 the child stops using the parent's address space. */
539 parent_inf->waiting_for_vfork_done = detach_fork;
540 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
545 /* Follow the child. */
546 struct inferior *parent_inf, *child_inf;
547 struct program_space *parent_pspace;
549 if (info_verbose || debug_infrun)
551 target_terminal_ours ();
553 fprintf_filtered (gdb_stdlog,
554 _("Attaching after process %d "
555 "vfork to child process %d.\n"),
556 parent_pid, child_pid);
558 fprintf_filtered (gdb_stdlog,
559 _("Attaching after process %d "
560 "fork to child process %d.\n"),
561 parent_pid, child_pid);
564 /* Add the new inferior first, so that the target_detach below
565 doesn't unpush the target. */
567 child_inf = add_inferior (child_pid);
569 parent_inf = current_inferior ();
570 child_inf->attach_flag = parent_inf->attach_flag;
571 copy_terminal_info (child_inf, parent_inf);
572 child_inf->gdbarch = parent_inf->gdbarch;
573 copy_inferior_target_desc_info (child_inf, parent_inf);
575 parent_pspace = parent_inf->pspace;
577 /* If we're vforking, we want to hold on to the parent until the
578 child exits or execs. At child exec or exit time we can
579 remove the old breakpoints from the parent and detach or
580 resume debugging it. Otherwise, detach the parent now; we'll
581 want to reuse it's program/address spaces, but we can't set
582 them to the child before removing breakpoints from the
583 parent, otherwise, the breakpoints module could decide to
584 remove breakpoints from the wrong process (since they'd be
585 assigned to the same address space). */
589 gdb_assert (child_inf->vfork_parent == NULL);
590 gdb_assert (parent_inf->vfork_child == NULL);
591 child_inf->vfork_parent = parent_inf;
592 child_inf->pending_detach = 0;
593 parent_inf->vfork_child = child_inf;
594 parent_inf->pending_detach = detach_fork;
595 parent_inf->waiting_for_vfork_done = 0;
597 else if (detach_fork)
598 target_detach (NULL, 0);
600 /* Note that the detach above makes PARENT_INF dangling. */
602 /* Add the child thread to the appropriate lists, and switch to
603 this new thread, before cloning the program space, and
604 informing the solib layer about this new process. */
606 inferior_ptid = ptid_build (child_pid, child_pid, 0);
607 add_thread (inferior_ptid);
609 /* If this is a vfork child, then the address-space is shared
610 with the parent. If we detached from the parent, then we can
611 reuse the parent's program/address spaces. */
612 if (has_vforked || detach_fork)
614 child_inf->pspace = parent_pspace;
615 child_inf->aspace = child_inf->pspace->aspace;
619 child_inf->aspace = new_address_space ();
620 child_inf->pspace = add_program_space (child_inf->aspace);
621 child_inf->removable = 1;
622 child_inf->symfile_flags = SYMFILE_NO_READ;
623 set_current_program_space (child_inf->pspace);
624 clone_program_space (child_inf->pspace, parent_pspace);
626 /* Let the shared library layer (e.g., solib-svr4) learn
627 about this new process, relocate the cloned exec, pull in
628 shared libraries, and install the solib event breakpoint.
629 If a "cloned-VM" event was propagated better throughout
630 the core, this wouldn't be required. */
631 solib_create_inferior_hook (0);
635 return target_follow_fork (follow_child, detach_fork);
638 /* Tell the target to follow the fork we're stopped at. Returns true
639 if the inferior should be resumed; false, if the target for some
640 reason decided it's best not to resume. */
645 int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
646 int should_resume = 1;
647 struct thread_info *tp;
649 /* Copy user stepping state to the new inferior thread. FIXME: the
650 followed fork child thread should have a copy of most of the
651 parent thread structure's run control related fields, not just these.
652 Initialized to avoid "may be used uninitialized" warnings from gcc. */
653 struct breakpoint *step_resume_breakpoint = NULL;
654 struct breakpoint *exception_resume_breakpoint = NULL;
655 CORE_ADDR step_range_start = 0;
656 CORE_ADDR step_range_end = 0;
657 struct frame_id step_frame_id = { 0 };
658 struct interp *command_interp = NULL;
663 struct target_waitstatus wait_status;
665 /* Get the last target status returned by target_wait(). */
666 get_last_target_status (&wait_ptid, &wait_status);
668 /* If not stopped at a fork event, then there's nothing else to
670 if (wait_status.kind != TARGET_WAITKIND_FORKED
671 && wait_status.kind != TARGET_WAITKIND_VFORKED)
674 /* Check if we switched over from WAIT_PTID, since the event was
676 if (!ptid_equal (wait_ptid, minus_one_ptid)
677 && !ptid_equal (inferior_ptid, wait_ptid))
679 /* We did. Switch back to WAIT_PTID thread, to tell the
680 target to follow it (in either direction). We'll
681 afterwards refuse to resume, and inform the user what
683 switch_to_thread (wait_ptid);
688 tp = inferior_thread ();
690 /* If there were any forks/vforks that were caught and are now to be
691 followed, then do so now. */
692 switch (tp->pending_follow.kind)
694 case TARGET_WAITKIND_FORKED:
695 case TARGET_WAITKIND_VFORKED:
697 ptid_t parent, child;
699 /* If the user did a next/step, etc, over a fork call,
700 preserve the stepping state in the fork child. */
701 if (follow_child && should_resume)
703 step_resume_breakpoint = clone_momentary_breakpoint
704 (tp->control.step_resume_breakpoint);
705 step_range_start = tp->control.step_range_start;
706 step_range_end = tp->control.step_range_end;
707 step_frame_id = tp->control.step_frame_id;
708 exception_resume_breakpoint
709 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
710 command_interp = tp->control.command_interp;
712 /* For now, delete the parent's sr breakpoint, otherwise,
713 parent/child sr breakpoints are considered duplicates,
714 and the child version will not be installed. Remove
715 this when the breakpoints module becomes aware of
716 inferiors and address spaces. */
717 delete_step_resume_breakpoint (tp);
718 tp->control.step_range_start = 0;
719 tp->control.step_range_end = 0;
720 tp->control.step_frame_id = null_frame_id;
721 delete_exception_resume_breakpoint (tp);
722 tp->control.command_interp = NULL;
725 parent = inferior_ptid;
726 child = tp->pending_follow.value.related_pid;
728 /* Set up inferior(s) as specified by the caller, and tell the
729 target to do whatever is necessary to follow either parent
731 if (follow_fork_inferior (follow_child, detach_fork))
733 /* Target refused to follow, or there's some other reason
734 we shouldn't resume. */
739 /* This pending follow fork event is now handled, one way
740 or another. The previous selected thread may be gone
741 from the lists by now, but if it is still around, need
742 to clear the pending follow request. */
743 tp = find_thread_ptid (parent);
745 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
747 /* This makes sure we don't try to apply the "Switched
748 over from WAIT_PID" logic above. */
749 nullify_last_target_wait_ptid ();
751 /* If we followed the child, switch to it... */
754 switch_to_thread (child);
756 /* ... and preserve the stepping state, in case the
757 user was stepping over the fork call. */
760 tp = inferior_thread ();
761 tp->control.step_resume_breakpoint
762 = step_resume_breakpoint;
763 tp->control.step_range_start = step_range_start;
764 tp->control.step_range_end = step_range_end;
765 tp->control.step_frame_id = step_frame_id;
766 tp->control.exception_resume_breakpoint
767 = exception_resume_breakpoint;
768 tp->control.command_interp = command_interp;
772 /* If we get here, it was because we're trying to
773 resume from a fork catchpoint, but, the user
774 has switched threads away from the thread that
775 forked. In that case, the resume command
776 issued is most likely not applicable to the
777 child, so just warn, and refuse to resume. */
778 warning (_("Not resuming: switched threads "
779 "before following fork child.\n"));
782 /* Reset breakpoints in the child as appropriate. */
783 follow_inferior_reset_breakpoints ();
786 switch_to_thread (parent);
790 case TARGET_WAITKIND_SPURIOUS:
791 /* Nothing to follow. */
794 internal_error (__FILE__, __LINE__,
795 "Unexpected pending_follow.kind %d\n",
796 tp->pending_follow.kind);
800 return should_resume;
804 follow_inferior_reset_breakpoints (void)
806 struct thread_info *tp = inferior_thread ();
808 /* Was there a step_resume breakpoint? (There was if the user
809 did a "next" at the fork() call.) If so, explicitly reset its
810 thread number. Cloned step_resume breakpoints are disabled on
811 creation, so enable it here now that it is associated with the
814 step_resumes are a form of bp that are made to be per-thread.
815 Since we created the step_resume bp when the parent process
816 was being debugged, and now are switching to the child process,
817 from the breakpoint package's viewpoint, that's a switch of
818 "threads". We must update the bp's notion of which thread
819 it is for, or it'll be ignored when it triggers. */
821 if (tp->control.step_resume_breakpoint)
823 breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
824 tp->control.step_resume_breakpoint->loc->enabled = 1;
827 /* Treat exception_resume breakpoints like step_resume breakpoints. */
828 if (tp->control.exception_resume_breakpoint)
830 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
831 tp->control.exception_resume_breakpoint->loc->enabled = 1;
834 /* Reinsert all breakpoints in the child. The user may have set
835 breakpoints after catching the fork, in which case those
836 were never set in the child, but only in the parent. This makes
837 sure the inserted breakpoints match the breakpoint list. */
839 breakpoint_re_set ();
840 insert_breakpoints ();
843 /* The child has exited or execed: resume threads of the parent the
844 user wanted to be executing. */
847 proceed_after_vfork_done (struct thread_info *thread,
850 int pid = * (int *) arg;
852 if (ptid_get_pid (thread->ptid) == pid
853 && is_running (thread->ptid)
854 && !is_executing (thread->ptid)
855 && !thread->stop_requested
856 && thread->suspend.stop_signal == GDB_SIGNAL_0)
859 fprintf_unfiltered (gdb_stdlog,
860 "infrun: resuming vfork parent thread %s\n",
861 target_pid_to_str (thread->ptid));
863 switch_to_thread (thread->ptid);
864 clear_proceed_status (0);
865 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
871 /* Called whenever we notice an exec or exit event, to handle
872 detaching or resuming a vfork parent. */
875 handle_vfork_child_exec_or_exit (int exec)
877 struct inferior *inf = current_inferior ();
879 if (inf->vfork_parent)
881 int resume_parent = -1;
883 /* This exec or exit marks the end of the shared memory region
884 between the parent and the child. If the user wanted to
885 detach from the parent, now is the time. */
887 if (inf->vfork_parent->pending_detach)
889 struct thread_info *tp;
890 struct cleanup *old_chain;
891 struct program_space *pspace;
892 struct address_space *aspace;
894 /* follow-fork child, detach-on-fork on. */
896 inf->vfork_parent->pending_detach = 0;
900 /* If we're handling a child exit, then inferior_ptid
901 points at the inferior's pid, not to a thread. */
902 old_chain = save_inferior_ptid ();
903 save_current_program_space ();
904 save_current_inferior ();
907 old_chain = save_current_space_and_thread ();
909 /* We're letting loose of the parent. */
910 tp = any_live_thread_of_process (inf->vfork_parent->pid);
911 switch_to_thread (tp->ptid);
913 /* We're about to detach from the parent, which implicitly
914 removes breakpoints from its address space. There's a
915 catch here: we want to reuse the spaces for the child,
916 but, parent/child are still sharing the pspace at this
917 point, although the exec in reality makes the kernel give
918 the child a fresh set of new pages. The problem here is
919 that the breakpoints module being unaware of this, would
920 likely chose the child process to write to the parent
921 address space. Swapping the child temporarily away from
922 the spaces has the desired effect. Yes, this is "sort
925 pspace = inf->pspace;
926 aspace = inf->aspace;
930 if (debug_infrun || info_verbose)
932 target_terminal_ours ();
935 fprintf_filtered (gdb_stdlog,
936 "Detaching vfork parent process "
937 "%d after child exec.\n",
938 inf->vfork_parent->pid);
940 fprintf_filtered (gdb_stdlog,
941 "Detaching vfork parent process "
942 "%d after child exit.\n",
943 inf->vfork_parent->pid);
946 target_detach (NULL, 0);
949 inf->pspace = pspace;
950 inf->aspace = aspace;
952 do_cleanups (old_chain);
956 /* We're staying attached to the parent, so, really give the
957 child a new address space. */
958 inf->pspace = add_program_space (maybe_new_address_space ());
959 inf->aspace = inf->pspace->aspace;
961 set_current_program_space (inf->pspace);
963 resume_parent = inf->vfork_parent->pid;
965 /* Break the bonds. */
966 inf->vfork_parent->vfork_child = NULL;
970 struct cleanup *old_chain;
971 struct program_space *pspace;
973 /* If this is a vfork child exiting, then the pspace and
974 aspaces were shared with the parent. Since we're
975 reporting the process exit, we'll be mourning all that is
976 found in the address space, and switching to null_ptid,
977 preparing to start a new inferior. But, since we don't
978 want to clobber the parent's address/program spaces, we
979 go ahead and create a new one for this exiting
982 /* Switch to null_ptid, so that clone_program_space doesn't want
983 to read the selected frame of a dead process. */
984 old_chain = save_inferior_ptid ();
985 inferior_ptid = null_ptid;
987 /* This inferior is dead, so avoid giving the breakpoints
988 module the option to write through to it (cloning a
989 program space resets breakpoints). */
992 pspace = add_program_space (maybe_new_address_space ());
993 set_current_program_space (pspace);
995 inf->symfile_flags = SYMFILE_NO_READ;
996 clone_program_space (pspace, inf->vfork_parent->pspace);
997 inf->pspace = pspace;
998 inf->aspace = pspace->aspace;
1000 /* Put back inferior_ptid. We'll continue mourning this
1002 do_cleanups (old_chain);
1004 resume_parent = inf->vfork_parent->pid;
1005 /* Break the bonds. */
1006 inf->vfork_parent->vfork_child = NULL;
1009 inf->vfork_parent = NULL;
1011 gdb_assert (current_program_space == inf->pspace);
1013 if (non_stop && resume_parent != -1)
1015 /* If the user wanted the parent to be running, let it go
1017 struct cleanup *old_chain = make_cleanup_restore_current_thread ();
1020 fprintf_unfiltered (gdb_stdlog,
1021 "infrun: resuming vfork parent process %d\n",
1024 iterate_over_threads (proceed_after_vfork_done, &resume_parent);
1026 do_cleanups (old_chain);
1031 /* Enum strings for "set|show follow-exec-mode". */
1033 static const char follow_exec_mode_new[] = "new";
1034 static const char follow_exec_mode_same[] = "same";
1035 static const char *const follow_exec_mode_names[] =
1037 follow_exec_mode_new,
1038 follow_exec_mode_same,
1042 static const char *follow_exec_mode_string = follow_exec_mode_same;
1044 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1045 struct cmd_list_element *c, const char *value)
1047 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
1050 /* EXECD_PATHNAME is assumed to be non-NULL. */
1053 follow_exec (ptid_t pid, char *execd_pathname)
1055 struct thread_info *th = inferior_thread ();
1056 struct inferior *inf = current_inferior ();
1058 /* This is an exec event that we actually wish to pay attention to.
1059 Refresh our symbol table to the newly exec'd program, remove any
1060 momentary bp's, etc.
1062 If there are breakpoints, they aren't really inserted now,
1063 since the exec() transformed our inferior into a fresh set
1066 We want to preserve symbolic breakpoints on the list, since
1067 we have hopes that they can be reset after the new a.out's
1068 symbol table is read.
1070 However, any "raw" breakpoints must be removed from the list
1071 (e.g., the solib bp's), since their address is probably invalid
1074 And, we DON'T want to call delete_breakpoints() here, since
1075 that may write the bp's "shadow contents" (the instruction
1076 value that was overwritten witha TRAP instruction). Since
1077 we now have a new a.out, those shadow contents aren't valid. */
1079 mark_breakpoints_out ();
1081 update_breakpoints_after_exec ();
1083 /* If there was one, it's gone now. We cannot truly step-to-next
1084 statement through an exec(). */
1085 th->control.step_resume_breakpoint = NULL;
1086 th->control.exception_resume_breakpoint = NULL;
1087 th->control.step_range_start = 0;
1088 th->control.step_range_end = 0;
1090 /* The target reports the exec event to the main thread, even if
1091 some other thread does the exec, and even if the main thread was
1092 already stopped --- if debugging in non-stop mode, it's possible
1093 the user had the main thread held stopped in the previous image
1094 --- release it now. This is the same behavior as step-over-exec
1095 with scheduler-locking on in all-stop mode. */
1096 th->stop_requested = 0;
1098 /* What is this a.out's name? */
1099 printf_unfiltered (_("%s is executing new program: %s\n"),
1100 target_pid_to_str (inferior_ptid),
1103 /* We've followed the inferior through an exec. Therefore, the
1104 inferior has essentially been killed & reborn. */
1106 gdb_flush (gdb_stdout);
1108 breakpoint_init_inferior (inf_execd);
1110 if (gdb_sysroot && *gdb_sysroot)
1112 char *name = alloca (strlen (gdb_sysroot)
1113 + strlen (execd_pathname)
1116 strcpy (name, gdb_sysroot);
1117 strcat (name, execd_pathname);
1118 execd_pathname = name;
1121 /* Reset the shared library package. This ensures that we get a
1122 shlib event when the child reaches "_start", at which point the
1123 dld will have had a chance to initialize the child. */
1124 /* Also, loading a symbol file below may trigger symbol lookups, and
1125 we don't want those to be satisfied by the libraries of the
1126 previous incarnation of this process. */
1127 no_shared_libraries (NULL, 0);
1129 if (follow_exec_mode_string == follow_exec_mode_new)
1131 struct program_space *pspace;
1133 /* The user wants to keep the old inferior and program spaces
1134 around. Create a new fresh one, and switch to it. */
1136 inf = add_inferior (current_inferior ()->pid);
1137 pspace = add_program_space (maybe_new_address_space ());
1138 inf->pspace = pspace;
1139 inf->aspace = pspace->aspace;
1141 exit_inferior_num_silent (current_inferior ()->num);
1143 set_current_inferior (inf);
1144 set_current_program_space (pspace);
1148 /* The old description may no longer be fit for the new image.
1149 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1150 old description; we'll read a new one below. No need to do
1151 this on "follow-exec-mode new", as the old inferior stays
1152 around (its description is later cleared/refetched on
1154 target_clear_description ();
1157 gdb_assert (current_program_space == inf->pspace);
1159 /* That a.out is now the one to use. */
1160 exec_file_attach (execd_pathname, 0);
1162 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1163 (Position Independent Executable) main symbol file will get applied by
1164 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1165 the breakpoints with the zero displacement. */
1167 symbol_file_add (execd_pathname,
1169 | SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET),
1172 if ((inf->symfile_flags & SYMFILE_NO_READ) == 0)
1173 set_initial_language ();
1175 /* If the target can specify a description, read it. Must do this
1176 after flipping to the new executable (because the target supplied
1177 description must be compatible with the executable's
1178 architecture, and the old executable may e.g., be 32-bit, while
1179 the new one 64-bit), and before anything involving memory or
1181 target_find_description ();
1183 solib_create_inferior_hook (0);
1185 jit_inferior_created_hook ();
1187 breakpoint_re_set ();
1189 /* Reinsert all breakpoints. (Those which were symbolic have
1190 been reset to the proper address in the new a.out, thanks
1191 to symbol_file_command...). */
1192 insert_breakpoints ();
1194 /* The next resume of this inferior should bring it to the shlib
1195 startup breakpoints. (If the user had also set bp's on
1196 "main" from the old (parent) process, then they'll auto-
1197 matically get reset there in the new process.). */
1200 /* Non-zero if we just simulating a single-step. This is needed
1201 because we cannot remove the breakpoints in the inferior process
1202 until after the `wait' in `wait_for_inferior'. */
1203 static int singlestep_breakpoints_inserted_p = 0;
1205 /* The thread we inserted single-step breakpoints for. */
1206 static ptid_t singlestep_ptid;
1208 /* PC when we started this single-step. */
1209 static CORE_ADDR singlestep_pc;
1211 /* Info about an instruction that is being stepped over. Invalid if
1214 struct step_over_info
1216 /* The instruction's address space. */
1217 struct address_space *aspace;
1219 /* The instruction's address. */
1223 /* The step-over info of the location that is being stepped over.
1225 Note that with async/breakpoint always-inserted mode, a user might
1226 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1227 being stepped over. As setting a new breakpoint inserts all
1228 breakpoints, we need to make sure the breakpoint being stepped over
1229 isn't inserted then. We do that by only clearing the step-over
1230 info when the step-over is actually finished (or aborted).
1232 Presently GDB can only step over one breakpoint at any given time.
1233 Given threads that can't run code in the same address space as the
1234 breakpoint's can't really miss the breakpoint, GDB could be taught
1235 to step-over at most one breakpoint per address space (so this info
1236 could move to the address space object if/when GDB is extended).
1237 The set of breakpoints being stepped over will normally be much
1238 smaller than the set of all breakpoints, so a flag in the
1239 breakpoint location structure would be wasteful. A separate list
1240 also saves complexity and run-time, as otherwise we'd have to go
1241 through all breakpoint locations clearing their flag whenever we
1242 start a new sequence. Similar considerations weigh against storing
1243 this info in the thread object. Plus, not all step overs actually
1244 have breakpoint locations -- e.g., stepping past a single-step
1245 breakpoint, or stepping to complete a non-continuable
1247 static struct step_over_info step_over_info;
1249 /* Record the address of the breakpoint/instruction we're currently
1253 set_step_over_info (struct address_space *aspace, CORE_ADDR address)
1255 step_over_info.aspace = aspace;
1256 step_over_info.address = address;
1259 /* Called when we're not longer stepping over a breakpoint / an
1260 instruction, so all breakpoints are free to be (re)inserted. */
1263 clear_step_over_info (void)
1265 step_over_info.aspace = NULL;
1266 step_over_info.address = 0;
1272 stepping_past_instruction_at (struct address_space *aspace,
1275 return (step_over_info.aspace != NULL
1276 && breakpoint_address_match (aspace, address,
1277 step_over_info.aspace,
1278 step_over_info.address));
1282 /* Displaced stepping. */
1284 /* In non-stop debugging mode, we must take special care to manage
1285 breakpoints properly; in particular, the traditional strategy for
1286 stepping a thread past a breakpoint it has hit is unsuitable.
1287 'Displaced stepping' is a tactic for stepping one thread past a
1288 breakpoint it has hit while ensuring that other threads running
1289 concurrently will hit the breakpoint as they should.
1291 The traditional way to step a thread T off a breakpoint in a
1292 multi-threaded program in all-stop mode is as follows:
1294 a0) Initially, all threads are stopped, and breakpoints are not
1296 a1) We single-step T, leaving breakpoints uninserted.
1297 a2) We insert breakpoints, and resume all threads.
1299 In non-stop debugging, however, this strategy is unsuitable: we
1300 don't want to have to stop all threads in the system in order to
1301 continue or step T past a breakpoint. Instead, we use displaced
1304 n0) Initially, T is stopped, other threads are running, and
1305 breakpoints are inserted.
1306 n1) We copy the instruction "under" the breakpoint to a separate
1307 location, outside the main code stream, making any adjustments
1308 to the instruction, register, and memory state as directed by
1310 n2) We single-step T over the instruction at its new location.
1311 n3) We adjust the resulting register and memory state as directed
1312 by T's architecture. This includes resetting T's PC to point
1313 back into the main instruction stream.
1316 This approach depends on the following gdbarch methods:
1318 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1319 indicate where to copy the instruction, and how much space must
1320 be reserved there. We use these in step n1.
1322 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1323 address, and makes any necessary adjustments to the instruction,
1324 register contents, and memory. We use this in step n1.
1326 - gdbarch_displaced_step_fixup adjusts registers and memory after
1327 we have successfuly single-stepped the instruction, to yield the
1328 same effect the instruction would have had if we had executed it
1329 at its original address. We use this in step n3.
1331 - gdbarch_displaced_step_free_closure provides cleanup.
1333 The gdbarch_displaced_step_copy_insn and
1334 gdbarch_displaced_step_fixup functions must be written so that
1335 copying an instruction with gdbarch_displaced_step_copy_insn,
1336 single-stepping across the copied instruction, and then applying
1337 gdbarch_displaced_insn_fixup should have the same effects on the
1338 thread's memory and registers as stepping the instruction in place
1339 would have. Exactly which responsibilities fall to the copy and
1340 which fall to the fixup is up to the author of those functions.
1342 See the comments in gdbarch.sh for details.
1344 Note that displaced stepping and software single-step cannot
1345 currently be used in combination, although with some care I think
1346 they could be made to. Software single-step works by placing
1347 breakpoints on all possible subsequent instructions; if the
1348 displaced instruction is a PC-relative jump, those breakpoints
1349 could fall in very strange places --- on pages that aren't
1350 executable, or at addresses that are not proper instruction
1351 boundaries. (We do generally let other threads run while we wait
1352 to hit the software single-step breakpoint, and they might
1353 encounter such a corrupted instruction.) One way to work around
1354 this would be to have gdbarch_displaced_step_copy_insn fully
1355 simulate the effect of PC-relative instructions (and return NULL)
1356 on architectures that use software single-stepping.
1358 In non-stop mode, we can have independent and simultaneous step
1359 requests, so more than one thread may need to simultaneously step
1360 over a breakpoint. The current implementation assumes there is
1361 only one scratch space per process. In this case, we have to
1362 serialize access to the scratch space. If thread A wants to step
1363 over a breakpoint, but we are currently waiting for some other
1364 thread to complete a displaced step, we leave thread A stopped and
1365 place it in the displaced_step_request_queue. Whenever a displaced
1366 step finishes, we pick the next thread in the queue and start a new
1367 displaced step operation on it. See displaced_step_prepare and
1368 displaced_step_fixup for details. */
1370 struct displaced_step_request
1373 struct displaced_step_request *next;
1376 /* Per-inferior displaced stepping state. */
1377 struct displaced_step_inferior_state
1379 /* Pointer to next in linked list. */
1380 struct displaced_step_inferior_state *next;
1382 /* The process this displaced step state refers to. */
1385 /* A queue of pending displaced stepping requests. One entry per
1386 thread that needs to do a displaced step. */
1387 struct displaced_step_request *step_request_queue;
1389 /* If this is not null_ptid, this is the thread carrying out a
1390 displaced single-step in process PID. This thread's state will
1391 require fixing up once it has completed its step. */
1394 /* The architecture the thread had when we stepped it. */
1395 struct gdbarch *step_gdbarch;
1397 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1398 for post-step cleanup. */
1399 struct displaced_step_closure *step_closure;
1401 /* The address of the original instruction, and the copy we
1403 CORE_ADDR step_original, step_copy;
1405 /* Saved contents of copy area. */
1406 gdb_byte *step_saved_copy;
1409 /* The list of states of processes involved in displaced stepping
1411 static struct displaced_step_inferior_state *displaced_step_inferior_states;
1413 /* Get the displaced stepping state of process PID. */
1415 static struct displaced_step_inferior_state *
1416 get_displaced_stepping_state (int pid)
1418 struct displaced_step_inferior_state *state;
1420 for (state = displaced_step_inferior_states;
1422 state = state->next)
1423 if (state->pid == pid)
1429 /* Add a new displaced stepping state for process PID to the displaced
1430 stepping state list, or return a pointer to an already existing
1431 entry, if it already exists. Never returns NULL. */
1433 static struct displaced_step_inferior_state *
1434 add_displaced_stepping_state (int pid)
1436 struct displaced_step_inferior_state *state;
1438 for (state = displaced_step_inferior_states;
1440 state = state->next)
1441 if (state->pid == pid)
1444 state = xcalloc (1, sizeof (*state));
1446 state->next = displaced_step_inferior_states;
1447 displaced_step_inferior_states = state;
1452 /* If inferior is in displaced stepping, and ADDR equals to starting address
1453 of copy area, return corresponding displaced_step_closure. Otherwise,
1456 struct displaced_step_closure*
1457 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1459 struct displaced_step_inferior_state *displaced
1460 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1462 /* If checking the mode of displaced instruction in copy area. */
1463 if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1464 && (displaced->step_copy == addr))
1465 return displaced->step_closure;
1470 /* Remove the displaced stepping state of process PID. */
1473 remove_displaced_stepping_state (int pid)
1475 struct displaced_step_inferior_state *it, **prev_next_p;
1477 gdb_assert (pid != 0);
1479 it = displaced_step_inferior_states;
1480 prev_next_p = &displaced_step_inferior_states;
1485 *prev_next_p = it->next;
1490 prev_next_p = &it->next;
1496 infrun_inferior_exit (struct inferior *inf)
1498 remove_displaced_stepping_state (inf->pid);
1501 /* If ON, and the architecture supports it, GDB will use displaced
1502 stepping to step over breakpoints. If OFF, or if the architecture
1503 doesn't support it, GDB will instead use the traditional
1504 hold-and-step approach. If AUTO (which is the default), GDB will
1505 decide which technique to use to step over breakpoints depending on
1506 which of all-stop or non-stop mode is active --- displaced stepping
1507 in non-stop mode; hold-and-step in all-stop mode. */
1509 static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
1512 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1513 struct cmd_list_element *c,
1516 if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1517 fprintf_filtered (file,
1518 _("Debugger's willingness to use displaced stepping "
1519 "to step over breakpoints is %s (currently %s).\n"),
1520 value, non_stop ? "on" : "off");
1522 fprintf_filtered (file,
1523 _("Debugger's willingness to use displaced stepping "
1524 "to step over breakpoints is %s.\n"), value);
1527 /* Return non-zero if displaced stepping can/should be used to step
1528 over breakpoints. */
1531 use_displaced_stepping (struct gdbarch *gdbarch)
1533 return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO && non_stop)
1534 || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1535 && gdbarch_displaced_step_copy_insn_p (gdbarch)
1536 && find_record_target () == NULL);
1539 /* Clean out any stray displaced stepping state. */
1541 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1543 /* Indicate that there is no cleanup pending. */
1544 displaced->step_ptid = null_ptid;
1546 if (displaced->step_closure)
1548 gdbarch_displaced_step_free_closure (displaced->step_gdbarch,
1549 displaced->step_closure);
1550 displaced->step_closure = NULL;
1555 displaced_step_clear_cleanup (void *arg)
1557 struct displaced_step_inferior_state *state = arg;
1559 displaced_step_clear (state);
1562 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1564 displaced_step_dump_bytes (struct ui_file *file,
1565 const gdb_byte *buf,
1570 for (i = 0; i < len; i++)
1571 fprintf_unfiltered (file, "%02x ", buf[i]);
1572 fputs_unfiltered ("\n", file);
1575 /* Prepare to single-step, using displaced stepping.
1577 Note that we cannot use displaced stepping when we have a signal to
1578 deliver. If we have a signal to deliver and an instruction to step
1579 over, then after the step, there will be no indication from the
1580 target whether the thread entered a signal handler or ignored the
1581 signal and stepped over the instruction successfully --- both cases
1582 result in a simple SIGTRAP. In the first case we mustn't do a
1583 fixup, and in the second case we must --- but we can't tell which.
1584 Comments in the code for 'random signals' in handle_inferior_event
1585 explain how we handle this case instead.
1587 Returns 1 if preparing was successful -- this thread is going to be
1588 stepped now; or 0 if displaced stepping this thread got queued. */
1590 displaced_step_prepare (ptid_t ptid)
1592 struct cleanup *old_cleanups, *ignore_cleanups;
1593 struct thread_info *tp = find_thread_ptid (ptid);
1594 struct regcache *regcache = get_thread_regcache (ptid);
1595 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1596 CORE_ADDR original, copy;
1598 struct displaced_step_closure *closure;
1599 struct displaced_step_inferior_state *displaced;
1602 /* We should never reach this function if the architecture does not
1603 support displaced stepping. */
1604 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1606 /* Disable range stepping while executing in the scratch pad. We
1607 want a single-step even if executing the displaced instruction in
1608 the scratch buffer lands within the stepping range (e.g., a
1610 tp->control.may_range_step = 0;
1612 /* We have to displaced step one thread at a time, as we only have
1613 access to a single scratch space per inferior. */
1615 displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1617 if (!ptid_equal (displaced->step_ptid, null_ptid))
1619 /* Already waiting for a displaced step to finish. Defer this
1620 request and place in queue. */
1621 struct displaced_step_request *req, *new_req;
1623 if (debug_displaced)
1624 fprintf_unfiltered (gdb_stdlog,
1625 "displaced: defering step of %s\n",
1626 target_pid_to_str (ptid));
1628 new_req = xmalloc (sizeof (*new_req));
1629 new_req->ptid = ptid;
1630 new_req->next = NULL;
1632 if (displaced->step_request_queue)
1634 for (req = displaced->step_request_queue;
1638 req->next = new_req;
1641 displaced->step_request_queue = new_req;
1647 if (debug_displaced)
1648 fprintf_unfiltered (gdb_stdlog,
1649 "displaced: stepping %s now\n",
1650 target_pid_to_str (ptid));
1653 displaced_step_clear (displaced);
1655 old_cleanups = save_inferior_ptid ();
1656 inferior_ptid = ptid;
1658 original = regcache_read_pc (regcache);
1660 copy = gdbarch_displaced_step_location (gdbarch);
1661 len = gdbarch_max_insn_length (gdbarch);
1663 /* Save the original contents of the copy area. */
1664 displaced->step_saved_copy = xmalloc (len);
1665 ignore_cleanups = make_cleanup (free_current_contents,
1666 &displaced->step_saved_copy);
1667 status = target_read_memory (copy, displaced->step_saved_copy, len);
1669 throw_error (MEMORY_ERROR,
1670 _("Error accessing memory address %s (%s) for "
1671 "displaced-stepping scratch space."),
1672 paddress (gdbarch, copy), safe_strerror (status));
1673 if (debug_displaced)
1675 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1676 paddress (gdbarch, copy));
1677 displaced_step_dump_bytes (gdb_stdlog,
1678 displaced->step_saved_copy,
1682 closure = gdbarch_displaced_step_copy_insn (gdbarch,
1683 original, copy, regcache);
1685 /* We don't support the fully-simulated case at present. */
1686 gdb_assert (closure);
1688 /* Save the information we need to fix things up if the step
1690 displaced->step_ptid = ptid;
1691 displaced->step_gdbarch = gdbarch;
1692 displaced->step_closure = closure;
1693 displaced->step_original = original;
1694 displaced->step_copy = copy;
1696 make_cleanup (displaced_step_clear_cleanup, displaced);
1698 /* Resume execution at the copy. */
1699 regcache_write_pc (regcache, copy);
1701 discard_cleanups (ignore_cleanups);
1703 do_cleanups (old_cleanups);
1705 if (debug_displaced)
1706 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1707 paddress (gdbarch, copy));
1713 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1714 const gdb_byte *myaddr, int len)
1716 struct cleanup *ptid_cleanup = save_inferior_ptid ();
1718 inferior_ptid = ptid;
1719 write_memory (memaddr, myaddr, len);
1720 do_cleanups (ptid_cleanup);
1723 /* Restore the contents of the copy area for thread PTID. */
1726 displaced_step_restore (struct displaced_step_inferior_state *displaced,
1729 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1731 write_memory_ptid (ptid, displaced->step_copy,
1732 displaced->step_saved_copy, len);
1733 if (debug_displaced)
1734 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1735 target_pid_to_str (ptid),
1736 paddress (displaced->step_gdbarch,
1737 displaced->step_copy));
1741 displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
1743 struct cleanup *old_cleanups;
1744 struct displaced_step_inferior_state *displaced
1745 = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1747 /* Was any thread of this process doing a displaced step? */
1748 if (displaced == NULL)
1751 /* Was this event for the pid we displaced? */
1752 if (ptid_equal (displaced->step_ptid, null_ptid)
1753 || ! ptid_equal (displaced->step_ptid, event_ptid))
1756 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1758 displaced_step_restore (displaced, displaced->step_ptid);
1760 /* Did the instruction complete successfully? */
1761 if (signal == GDB_SIGNAL_TRAP)
1763 /* Fix up the resulting state. */
1764 gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1765 displaced->step_closure,
1766 displaced->step_original,
1767 displaced->step_copy,
1768 get_thread_regcache (displaced->step_ptid));
1772 /* Since the instruction didn't complete, all we can do is
1774 struct regcache *regcache = get_thread_regcache (event_ptid);
1775 CORE_ADDR pc = regcache_read_pc (regcache);
1777 pc = displaced->step_original + (pc - displaced->step_copy);
1778 regcache_write_pc (regcache, pc);
1781 do_cleanups (old_cleanups);
1783 displaced->step_ptid = null_ptid;
1785 /* Are there any pending displaced stepping requests? If so, run
1786 one now. Leave the state object around, since we're likely to
1787 need it again soon. */
1788 while (displaced->step_request_queue)
1790 struct displaced_step_request *head;
1792 struct regcache *regcache;
1793 struct gdbarch *gdbarch;
1794 CORE_ADDR actual_pc;
1795 struct address_space *aspace;
1797 head = displaced->step_request_queue;
1799 displaced->step_request_queue = head->next;
1802 context_switch (ptid);
1804 regcache = get_thread_regcache (ptid);
1805 actual_pc = regcache_read_pc (regcache);
1806 aspace = get_regcache_aspace (regcache);
1808 if (breakpoint_here_p (aspace, actual_pc))
1810 if (debug_displaced)
1811 fprintf_unfiltered (gdb_stdlog,
1812 "displaced: stepping queued %s now\n",
1813 target_pid_to_str (ptid));
1815 displaced_step_prepare (ptid);
1817 gdbarch = get_regcache_arch (regcache);
1819 if (debug_displaced)
1821 CORE_ADDR actual_pc = regcache_read_pc (regcache);
1824 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1825 paddress (gdbarch, actual_pc));
1826 read_memory (actual_pc, buf, sizeof (buf));
1827 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1830 if (gdbarch_displaced_step_hw_singlestep (gdbarch,
1831 displaced->step_closure))
1832 target_resume (ptid, 1, GDB_SIGNAL_0);
1834 target_resume (ptid, 0, GDB_SIGNAL_0);
1836 /* Done, we're stepping a thread. */
1842 struct thread_info *tp = inferior_thread ();
1844 /* The breakpoint we were sitting under has since been
1846 tp->control.trap_expected = 0;
1848 /* Go back to what we were trying to do. */
1849 step = currently_stepping (tp);
1851 if (debug_displaced)
1852 fprintf_unfiltered (gdb_stdlog,
1853 "displaced: breakpoint is gone: %s, step(%d)\n",
1854 target_pid_to_str (tp->ptid), step);
1856 target_resume (ptid, step, GDB_SIGNAL_0);
1857 tp->suspend.stop_signal = GDB_SIGNAL_0;
1859 /* This request was discarded. See if there's any other
1860 thread waiting for its turn. */
1865 /* Update global variables holding ptids to hold NEW_PTID if they were
1866 holding OLD_PTID. */
1868 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
1870 struct displaced_step_request *it;
1871 struct displaced_step_inferior_state *displaced;
1873 if (ptid_equal (inferior_ptid, old_ptid))
1874 inferior_ptid = new_ptid;
1876 if (ptid_equal (singlestep_ptid, old_ptid))
1877 singlestep_ptid = new_ptid;
1879 for (displaced = displaced_step_inferior_states;
1881 displaced = displaced->next)
1883 if (ptid_equal (displaced->step_ptid, old_ptid))
1884 displaced->step_ptid = new_ptid;
1886 for (it = displaced->step_request_queue; it; it = it->next)
1887 if (ptid_equal (it->ptid, old_ptid))
1888 it->ptid = new_ptid;
1895 /* Things to clean up if we QUIT out of resume (). */
1897 resume_cleanups (void *ignore)
1902 static const char schedlock_off[] = "off";
1903 static const char schedlock_on[] = "on";
1904 static const char schedlock_step[] = "step";
1905 static const char *const scheduler_enums[] = {
1911 static const char *scheduler_mode = schedlock_off;
1913 show_scheduler_mode (struct ui_file *file, int from_tty,
1914 struct cmd_list_element *c, const char *value)
1916 fprintf_filtered (file,
1917 _("Mode for locking scheduler "
1918 "during execution is \"%s\".\n"),
1923 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
1925 if (!target_can_lock_scheduler)
1927 scheduler_mode = schedlock_off;
1928 error (_("Target '%s' cannot support this command."), target_shortname);
1932 /* True if execution commands resume all threads of all processes by
1933 default; otherwise, resume only threads of the current inferior
1935 int sched_multi = 0;
1937 /* Try to setup for software single stepping over the specified location.
1938 Return 1 if target_resume() should use hardware single step.
1940 GDBARCH the current gdbarch.
1941 PC the location to step over. */
1944 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
1948 if (execution_direction == EXEC_FORWARD
1949 && gdbarch_software_single_step_p (gdbarch)
1950 && gdbarch_software_single_step (gdbarch, get_current_frame ()))
1953 /* Do not pull these breakpoints until after a `wait' in
1954 `wait_for_inferior'. */
1955 singlestep_breakpoints_inserted_p = 1;
1956 singlestep_ptid = inferior_ptid;
1963 user_visible_resume_ptid (int step)
1965 /* By default, resume all threads of all processes. */
1966 ptid_t resume_ptid = RESUME_ALL;
1968 /* Maybe resume only all threads of the current process. */
1969 if (!sched_multi && target_supports_multi_process ())
1971 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1974 /* Maybe resume a single thread after all. */
1977 /* With non-stop mode on, threads are always handled
1979 resume_ptid = inferior_ptid;
1981 else if ((scheduler_mode == schedlock_on)
1982 || (scheduler_mode == schedlock_step && step))
1984 /* User-settable 'scheduler' mode requires solo thread resume. */
1985 resume_ptid = inferior_ptid;
1988 /* We may actually resume fewer threads at first, e.g., if a thread
1989 is stopped at a breakpoint that needs stepping-off, but that
1990 should not be visible to the user/frontend, and neither should
1991 the frontend/user be allowed to proceed any of the threads that
1992 happen to be stopped for internal run control handling, if a
1993 previous command wanted them resumed. */
1997 /* Resume the inferior, but allow a QUIT. This is useful if the user
1998 wants to interrupt some lengthy single-stepping operation
1999 (for child processes, the SIGINT goes to the inferior, and so
2000 we get a SIGINT random_signal, but for remote debugging and perhaps
2001 other targets, that's not true).
2003 STEP nonzero if we should step (zero to continue instead).
2004 SIG is the signal to give the inferior (zero for none). */
2006 resume (int step, enum gdb_signal sig)
2008 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
2009 struct regcache *regcache = get_current_regcache ();
2010 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2011 struct thread_info *tp = inferior_thread ();
2012 CORE_ADDR pc = regcache_read_pc (regcache);
2013 struct address_space *aspace = get_regcache_aspace (regcache);
2015 /* From here on, this represents the caller's step vs continue
2016 request, while STEP represents what we'll actually request the
2017 target to do. STEP can decay from a step to a continue, if e.g.,
2018 we need to implement single-stepping with breakpoints (software
2019 single-step). When deciding whether "set scheduler-locking step"
2020 applies, it's the callers intention that counts. */
2021 const int entry_step = step;
2025 if (current_inferior ()->waiting_for_vfork_done)
2027 /* Don't try to single-step a vfork parent that is waiting for
2028 the child to get out of the shared memory region (by exec'ing
2029 or exiting). This is particularly important on software
2030 single-step archs, as the child process would trip on the
2031 software single step breakpoint inserted for the parent
2032 process. Since the parent will not actually execute any
2033 instruction until the child is out of the shared region (such
2034 are vfork's semantics), it is safe to simply continue it.
2035 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2036 the parent, and tell it to `keep_going', which automatically
2037 re-sets it stepping. */
2039 fprintf_unfiltered (gdb_stdlog,
2040 "infrun: resume : clear step\n");
2045 fprintf_unfiltered (gdb_stdlog,
2046 "infrun: resume (step=%d, signal=%s), "
2047 "trap_expected=%d, current thread [%s] at %s\n",
2048 step, gdb_signal_to_symbol_string (sig),
2049 tp->control.trap_expected,
2050 target_pid_to_str (inferior_ptid),
2051 paddress (gdbarch, pc));
2053 /* Normally, by the time we reach `resume', the breakpoints are either
2054 removed or inserted, as appropriate. The exception is if we're sitting
2055 at a permanent breakpoint; we need to step over it, but permanent
2056 breakpoints can't be removed. So we have to test for it here. */
2057 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
2059 if (gdbarch_skip_permanent_breakpoint_p (gdbarch))
2060 gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2063 The program is stopped at a permanent breakpoint, but GDB does not know\n\
2064 how to step past a permanent breakpoint on this architecture. Try using\n\
2065 a command like `return' or `jump' to continue execution."));
2068 /* If we have a breakpoint to step over, make sure to do a single
2069 step only. Same if we have software watchpoints. */
2070 if (tp->control.trap_expected || bpstat_should_step ())
2071 tp->control.may_range_step = 0;
2073 /* If enabled, step over breakpoints by executing a copy of the
2074 instruction at a different address.
2076 We can't use displaced stepping when we have a signal to deliver;
2077 the comments for displaced_step_prepare explain why. The
2078 comments in the handle_inferior event for dealing with 'random
2079 signals' explain what we do instead.
2081 We can't use displaced stepping when we are waiting for vfork_done
2082 event, displaced stepping breaks the vfork child similarly as single
2083 step software breakpoint. */
2084 if (use_displaced_stepping (gdbarch)
2085 && (tp->control.trap_expected
2086 || (step && gdbarch_software_single_step_p (gdbarch)))
2087 && sig == GDB_SIGNAL_0
2088 && !current_inferior ()->waiting_for_vfork_done)
2090 struct displaced_step_inferior_state *displaced;
2092 if (!displaced_step_prepare (inferior_ptid))
2094 /* Got placed in displaced stepping queue. Will be resumed
2095 later when all the currently queued displaced stepping
2096 requests finish. The thread is not executing at this
2097 point, and the call to set_executing will be made later.
2098 But we need to call set_running here, since from the
2099 user/frontend's point of view, threads were set running.
2100 Unless we're calling an inferior function, as in that
2101 case we pretend the inferior doesn't run at all. */
2102 if (!tp->control.in_infcall)
2103 set_running (user_visible_resume_ptid (entry_step), 1);
2104 discard_cleanups (old_cleanups);
2108 /* Update pc to reflect the new address from which we will execute
2109 instructions due to displaced stepping. */
2110 pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
2112 displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
2113 step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2114 displaced->step_closure);
2117 /* Do we need to do it the hard way, w/temp breakpoints? */
2119 step = maybe_software_singlestep (gdbarch, pc);
2121 /* Currently, our software single-step implementation leads to different
2122 results than hardware single-stepping in one situation: when stepping
2123 into delivering a signal which has an associated signal handler,
2124 hardware single-step will stop at the first instruction of the handler,
2125 while software single-step will simply skip execution of the handler.
2127 For now, this difference in behavior is accepted since there is no
2128 easy way to actually implement single-stepping into a signal handler
2129 without kernel support.
2131 However, there is one scenario where this difference leads to follow-on
2132 problems: if we're stepping off a breakpoint by removing all breakpoints
2133 and then single-stepping. In this case, the software single-step
2134 behavior means that even if there is a *breakpoint* in the signal
2135 handler, GDB still would not stop.
2137 Fortunately, we can at least fix this particular issue. We detect
2138 here the case where we are about to deliver a signal while software
2139 single-stepping with breakpoints removed. In this situation, we
2140 revert the decisions to remove all breakpoints and insert single-
2141 step breakpoints, and instead we install a step-resume breakpoint
2142 at the current address, deliver the signal without stepping, and
2143 once we arrive back at the step-resume breakpoint, actually step
2144 over the breakpoint we originally wanted to step over. */
2145 if (singlestep_breakpoints_inserted_p
2146 && tp->control.trap_expected && sig != GDB_SIGNAL_0)
2148 /* If we have nested signals or a pending signal is delivered
2149 immediately after a handler returns, might might already have
2150 a step-resume breakpoint set on the earlier handler. We cannot
2151 set another step-resume breakpoint; just continue on until the
2152 original breakpoint is hit. */
2153 if (tp->control.step_resume_breakpoint == NULL)
2155 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2156 tp->step_after_step_resume_breakpoint = 1;
2159 remove_single_step_breakpoints ();
2160 singlestep_breakpoints_inserted_p = 0;
2162 clear_step_over_info ();
2163 tp->control.trap_expected = 0;
2165 insert_breakpoints ();
2168 /* If STEP is set, it's a request to use hardware stepping
2169 facilities. But in that case, we should never
2170 use singlestep breakpoint. */
2171 gdb_assert (!(singlestep_breakpoints_inserted_p && step));
2173 /* Decide the set of threads to ask the target to resume. Start
2174 by assuming everything will be resumed, than narrow the set
2175 by applying increasingly restricting conditions. */
2176 resume_ptid = user_visible_resume_ptid (entry_step);
2178 /* Even if RESUME_PTID is a wildcard, and we end up resuming less
2179 (e.g., we might need to step over a breakpoint), from the
2180 user/frontend's point of view, all threads in RESUME_PTID are now
2181 running. Unless we're calling an inferior function, as in that
2182 case pretend we inferior doesn't run at all. */
2183 if (!tp->control.in_infcall)
2184 set_running (resume_ptid, 1);
2186 /* Maybe resume a single thread after all. */
2187 if ((step || singlestep_breakpoints_inserted_p)
2188 && tp->control.trap_expected)
2190 /* We're allowing a thread to run past a breakpoint it has
2191 hit, by single-stepping the thread with the breakpoint
2192 removed. In which case, we need to single-step only this
2193 thread, and keep others stopped, as they can miss this
2194 breakpoint if allowed to run. */
2195 resume_ptid = inferior_ptid;
2198 if (gdbarch_cannot_step_breakpoint (gdbarch))
2200 /* Most targets can step a breakpoint instruction, thus
2201 executing it normally. But if this one cannot, just
2202 continue and we will hit it anyway. */
2203 if (step && breakpoint_inserted_here_p (aspace, pc))
2208 && use_displaced_stepping (gdbarch)
2209 && tp->control.trap_expected)
2211 struct regcache *resume_regcache = get_thread_regcache (resume_ptid);
2212 struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
2213 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2216 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2217 paddress (resume_gdbarch, actual_pc));
2218 read_memory (actual_pc, buf, sizeof (buf));
2219 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2222 if (tp->control.may_range_step)
2224 /* If we're resuming a thread with the PC out of the step
2225 range, then we're doing some nested/finer run control
2226 operation, like stepping the thread out of the dynamic
2227 linker or the displaced stepping scratch pad. We
2228 shouldn't have allowed a range step then. */
2229 gdb_assert (pc_in_thread_step_range (pc, tp));
2232 /* Install inferior's terminal modes. */
2233 target_terminal_inferior ();
2235 /* Avoid confusing the next resume, if the next stop/resume
2236 happens to apply to another thread. */
2237 tp->suspend.stop_signal = GDB_SIGNAL_0;
2239 /* Advise target which signals may be handled silently. If we have
2240 removed breakpoints because we are stepping over one (which can
2241 happen only if we are not using displaced stepping), we need to
2242 receive all signals to avoid accidentally skipping a breakpoint
2243 during execution of a signal handler. */
2244 if ((step || singlestep_breakpoints_inserted_p)
2245 && tp->control.trap_expected
2246 && !use_displaced_stepping (gdbarch))
2247 target_pass_signals (0, NULL);
2249 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2251 target_resume (resume_ptid, step, sig);
2253 discard_cleanups (old_cleanups);
2258 /* Clear out all variables saying what to do when inferior is continued.
2259 First do this, then set the ones you want, then call `proceed'. */
2262 clear_proceed_status_thread (struct thread_info *tp)
2265 fprintf_unfiltered (gdb_stdlog,
2266 "infrun: clear_proceed_status_thread (%s)\n",
2267 target_pid_to_str (tp->ptid));
2269 /* If this signal should not be seen by program, give it zero.
2270 Used for debugging signals. */
2271 if (!signal_pass_state (tp->suspend.stop_signal))
2272 tp->suspend.stop_signal = GDB_SIGNAL_0;
2274 tp->control.trap_expected = 0;
2275 tp->control.step_range_start = 0;
2276 tp->control.step_range_end = 0;
2277 tp->control.may_range_step = 0;
2278 tp->control.step_frame_id = null_frame_id;
2279 tp->control.step_stack_frame_id = null_frame_id;
2280 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
2281 tp->stop_requested = 0;
2283 tp->control.stop_step = 0;
2285 tp->control.proceed_to_finish = 0;
2287 tp->control.command_interp = NULL;
2289 /* Discard any remaining commands or status from previous stop. */
2290 bpstat_clear (&tp->control.stop_bpstat);
2294 clear_proceed_status (int step)
2298 struct thread_info *tp;
2301 resume_ptid = user_visible_resume_ptid (step);
2303 /* In all-stop mode, delete the per-thread status of all threads
2304 we're about to resume, implicitly and explicitly. */
2305 ALL_NON_EXITED_THREADS (tp)
2307 if (!ptid_match (tp->ptid, resume_ptid))
2309 clear_proceed_status_thread (tp);
2313 if (!ptid_equal (inferior_ptid, null_ptid))
2315 struct inferior *inferior;
2319 /* If in non-stop mode, only delete the per-thread status of
2320 the current thread. */
2321 clear_proceed_status_thread (inferior_thread ());
2324 inferior = current_inferior ();
2325 inferior->control.stop_soon = NO_STOP_QUIETLY;
2328 stop_after_trap = 0;
2330 clear_step_over_info ();
2332 observer_notify_about_to_proceed ();
2336 regcache_xfree (stop_registers);
2337 stop_registers = NULL;
2341 /* Returns true if TP is still stopped at a breakpoint that needs
2342 stepping-over in order to make progress. If the breakpoint is gone
2343 meanwhile, we can skip the whole step-over dance. */
2346 thread_still_needs_step_over (struct thread_info *tp)
2348 if (tp->stepping_over_breakpoint)
2350 struct regcache *regcache = get_thread_regcache (tp->ptid);
2352 if (breakpoint_here_p (get_regcache_aspace (regcache),
2353 regcache_read_pc (regcache)))
2356 tp->stepping_over_breakpoint = 0;
2362 /* Returns true if scheduler locking applies. STEP indicates whether
2363 we're about to do a step/next-like command to a thread. */
2366 schedlock_applies (int step)
2368 return (scheduler_mode == schedlock_on
2369 || (scheduler_mode == schedlock_step
2373 /* Look a thread other than EXCEPT that has previously reported a
2374 breakpoint event, and thus needs a step-over in order to make
2375 progress. Returns NULL is none is found. STEP indicates whether
2376 we're about to step the current thread, in order to decide whether
2377 "set scheduler-locking step" applies. */
2379 static struct thread_info *
2380 find_thread_needs_step_over (int step, struct thread_info *except)
2382 struct thread_info *tp, *current;
2384 /* With non-stop mode on, threads are always handled individually. */
2385 gdb_assert (! non_stop);
2387 current = inferior_thread ();
2389 /* If scheduler locking applies, we can avoid iterating over all
2391 if (schedlock_applies (step))
2393 if (except != current
2394 && thread_still_needs_step_over (current))
2400 ALL_NON_EXITED_THREADS (tp)
2402 /* Ignore the EXCEPT thread. */
2405 /* Ignore threads of processes we're not resuming. */
2407 && ptid_get_pid (tp->ptid) != ptid_get_pid (inferior_ptid))
2410 if (thread_still_needs_step_over (tp))
2417 /* Basic routine for continuing the program in various fashions.
2419 ADDR is the address to resume at, or -1 for resume where stopped.
2420 SIGGNAL is the signal to give it, or 0 for none,
2421 or -1 for act according to how it stopped.
2422 STEP is nonzero if should trap after one instruction.
2423 -1 means return after that and print nothing.
2424 You should probably set various step_... variables
2425 before calling here, if you are stepping.
2427 You should call clear_proceed_status before calling proceed. */
2430 proceed (CORE_ADDR addr, enum gdb_signal siggnal, int step)
2432 struct regcache *regcache;
2433 struct gdbarch *gdbarch;
2434 struct thread_info *tp;
2436 struct address_space *aspace;
2438 /* If we're stopped at a fork/vfork, follow the branch set by the
2439 "set follow-fork-mode" command; otherwise, we'll just proceed
2440 resuming the current thread. */
2441 if (!follow_fork ())
2443 /* The target for some reason decided not to resume. */
2445 if (target_can_async_p ())
2446 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2450 /* We'll update this if & when we switch to a new thread. */
2451 previous_inferior_ptid = inferior_ptid;
2453 regcache = get_current_regcache ();
2454 gdbarch = get_regcache_arch (regcache);
2455 aspace = get_regcache_aspace (regcache);
2456 pc = regcache_read_pc (regcache);
2457 tp = inferior_thread ();
2460 step_start_function = find_pc_function (pc);
2462 stop_after_trap = 1;
2464 /* Fill in with reasonable starting values. */
2465 init_thread_stepping_state (tp);
2467 if (addr == (CORE_ADDR) -1)
2469 if (pc == stop_pc && breakpoint_here_p (aspace, pc)
2470 && execution_direction != EXEC_REVERSE)
2471 /* There is a breakpoint at the address we will resume at,
2472 step one instruction before inserting breakpoints so that
2473 we do not stop right away (and report a second hit at this
2476 Note, we don't do this in reverse, because we won't
2477 actually be executing the breakpoint insn anyway.
2478 We'll be (un-)executing the previous instruction. */
2479 tp->stepping_over_breakpoint = 1;
2480 else if (gdbarch_single_step_through_delay_p (gdbarch)
2481 && gdbarch_single_step_through_delay (gdbarch,
2482 get_current_frame ()))
2483 /* We stepped onto an instruction that needs to be stepped
2484 again before re-inserting the breakpoint, do so. */
2485 tp->stepping_over_breakpoint = 1;
2489 regcache_write_pc (regcache, addr);
2492 if (siggnal != GDB_SIGNAL_DEFAULT)
2493 tp->suspend.stop_signal = siggnal;
2495 /* Record the interpreter that issued the execution command that
2496 caused this thread to resume. If the top level interpreter is
2497 MI/async, and the execution command was a CLI command
2498 (next/step/etc.), we'll want to print stop event output to the MI
2499 console channel (the stepped-to line, etc.), as if the user
2500 entered the execution command on a real GDB console. */
2501 inferior_thread ()->control.command_interp = command_interp ();
2504 fprintf_unfiltered (gdb_stdlog,
2505 "infrun: proceed (addr=%s, signal=%s, step=%d)\n",
2506 paddress (gdbarch, addr),
2507 gdb_signal_to_symbol_string (siggnal), step);
2510 /* In non-stop, each thread is handled individually. The context
2511 must already be set to the right thread here. */
2515 struct thread_info *step_over;
2517 /* In a multi-threaded task we may select another thread and
2518 then continue or step.
2520 But if the old thread was stopped at a breakpoint, it will
2521 immediately cause another breakpoint stop without any
2522 execution (i.e. it will report a breakpoint hit incorrectly).
2523 So we must step over it first.
2525 Look for a thread other than the current (TP) that reported a
2526 breakpoint hit and hasn't been resumed yet since. */
2527 step_over = find_thread_needs_step_over (step, tp);
2528 if (step_over != NULL)
2531 fprintf_unfiltered (gdb_stdlog,
2532 "infrun: need to step-over [%s] first\n",
2533 target_pid_to_str (step_over->ptid));
2535 /* Store the prev_pc for the stepping thread too, needed by
2536 switch_back_to_stepping thread. */
2537 tp->prev_pc = regcache_read_pc (get_current_regcache ());
2538 switch_to_thread (step_over->ptid);
2543 /* If we need to step over a breakpoint, and we're not using
2544 displaced stepping to do so, insert all breakpoints (watchpoints,
2545 etc.) but the one we're stepping over, step one instruction, and
2546 then re-insert the breakpoint when that step is finished. */
2547 if (tp->stepping_over_breakpoint && !use_displaced_stepping (gdbarch))
2549 struct regcache *regcache = get_current_regcache ();
2551 set_step_over_info (get_regcache_aspace (regcache),
2552 regcache_read_pc (regcache));
2555 clear_step_over_info ();
2557 insert_breakpoints ();
2559 tp->control.trap_expected = tp->stepping_over_breakpoint;
2561 annotate_starting ();
2563 /* Make sure that output from GDB appears before output from the
2565 gdb_flush (gdb_stdout);
2567 /* Refresh prev_pc value just prior to resuming. This used to be
2568 done in stop_waiting, however, setting prev_pc there did not handle
2569 scenarios such as inferior function calls or returning from
2570 a function via the return command. In those cases, the prev_pc
2571 value was not set properly for subsequent commands. The prev_pc value
2572 is used to initialize the starting line number in the ecs. With an
2573 invalid value, the gdb next command ends up stopping at the position
2574 represented by the next line table entry past our start position.
2575 On platforms that generate one line table entry per line, this
2576 is not a problem. However, on the ia64, the compiler generates
2577 extraneous line table entries that do not increase the line number.
2578 When we issue the gdb next command on the ia64 after an inferior call
2579 or a return command, we often end up a few instructions forward, still
2580 within the original line we started.
2582 An attempt was made to refresh the prev_pc at the same time the
2583 execution_control_state is initialized (for instance, just before
2584 waiting for an inferior event). But this approach did not work
2585 because of platforms that use ptrace, where the pc register cannot
2586 be read unless the inferior is stopped. At that point, we are not
2587 guaranteed the inferior is stopped and so the regcache_read_pc() call
2588 can fail. Setting the prev_pc value here ensures the value is updated
2589 correctly when the inferior is stopped. */
2590 tp->prev_pc = regcache_read_pc (get_current_regcache ());
2592 /* Reset to normal state. */
2593 init_infwait_state ();
2595 /* Resume inferior. */
2596 resume (tp->control.trap_expected || step || bpstat_should_step (),
2597 tp->suspend.stop_signal);
2599 /* Wait for it to stop (if not standalone)
2600 and in any case decode why it stopped, and act accordingly. */
2601 /* Do this only if we are not using the event loop, or if the target
2602 does not support asynchronous execution. */
2603 if (!target_can_async_p ())
2605 wait_for_inferior ();
2611 /* Start remote-debugging of a machine over a serial link. */
2614 start_remote (int from_tty)
2616 struct inferior *inferior;
2618 inferior = current_inferior ();
2619 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2621 /* Always go on waiting for the target, regardless of the mode. */
2622 /* FIXME: cagney/1999-09-23: At present it isn't possible to
2623 indicate to wait_for_inferior that a target should timeout if
2624 nothing is returned (instead of just blocking). Because of this,
2625 targets expecting an immediate response need to, internally, set
2626 things up so that the target_wait() is forced to eventually
2628 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
2629 differentiate to its caller what the state of the target is after
2630 the initial open has been performed. Here we're assuming that
2631 the target has stopped. It should be possible to eventually have
2632 target_open() return to the caller an indication that the target
2633 is currently running and GDB state should be set to the same as
2634 for an async run. */
2635 wait_for_inferior ();
2637 /* Now that the inferior has stopped, do any bookkeeping like
2638 loading shared libraries. We want to do this before normal_stop,
2639 so that the displayed frame is up to date. */
2640 post_create_inferior (¤t_target, from_tty);
2645 /* Initialize static vars when a new inferior begins. */
2648 init_wait_for_inferior (void)
2650 /* These are meaningless until the first time through wait_for_inferior. */
2652 breakpoint_init_inferior (inf_starting);
2654 clear_proceed_status (0);
2656 target_last_wait_ptid = minus_one_ptid;
2658 previous_inferior_ptid = inferior_ptid;
2659 init_infwait_state ();
2661 /* Discard any skipped inlined frames. */
2662 clear_inline_frame_state (minus_one_ptid);
2664 singlestep_ptid = null_ptid;
2669 /* This enum encodes possible reasons for doing a target_wait, so that
2670 wfi can call target_wait in one place. (Ultimately the call will be
2671 moved out of the infinite loop entirely.) */
2675 infwait_normal_state,
2676 infwait_step_watch_state,
2677 infwait_nonstep_watch_state
2680 /* The PTID we'll do a target_wait on.*/
2683 /* Current inferior wait state. */
2684 static enum infwait_states infwait_state;
2686 /* Data to be passed around while handling an event. This data is
2687 discarded between events. */
2688 struct execution_control_state
2691 /* The thread that got the event, if this was a thread event; NULL
2693 struct thread_info *event_thread;
2695 struct target_waitstatus ws;
2696 int stop_func_filled_in;
2697 CORE_ADDR stop_func_start;
2698 CORE_ADDR stop_func_end;
2699 const char *stop_func_name;
2702 /* We were in infwait_step_watch_state or
2703 infwait_nonstep_watch_state state, and the thread reported an
2705 int stepped_after_stopped_by_watchpoint;
2707 /* True if the event thread hit the single-step breakpoint of
2708 another thread. Thus the event doesn't cause a stop, the thread
2709 needs to be single-stepped past the single-step breakpoint before
2710 we can switch back to the original stepping thread. */
2711 int hit_singlestep_breakpoint;
2714 static void handle_inferior_event (struct execution_control_state *ecs);
2716 static void handle_step_into_function (struct gdbarch *gdbarch,
2717 struct execution_control_state *ecs);
2718 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
2719 struct execution_control_state *ecs);
2720 static void handle_signal_stop (struct execution_control_state *ecs);
2721 static void check_exception_resume (struct execution_control_state *,
2722 struct frame_info *);
2724 static void end_stepping_range (struct execution_control_state *ecs);
2725 static void stop_waiting (struct execution_control_state *ecs);
2726 static void prepare_to_wait (struct execution_control_state *ecs);
2727 static void keep_going (struct execution_control_state *ecs);
2728 static void process_event_stop_test (struct execution_control_state *ecs);
2729 static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
2731 /* Callback for iterate over threads. If the thread is stopped, but
2732 the user/frontend doesn't know about that yet, go through
2733 normal_stop, as if the thread had just stopped now. ARG points at
2734 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
2735 ptid_is_pid(PTID) is true, applies to all threads of the process
2736 pointed at by PTID. Otherwise, apply only to the thread pointed by
2740 infrun_thread_stop_requested_callback (struct thread_info *info, void *arg)
2742 ptid_t ptid = * (ptid_t *) arg;
2744 if ((ptid_equal (info->ptid, ptid)
2745 || ptid_equal (minus_one_ptid, ptid)
2746 || (ptid_is_pid (ptid)
2747 && ptid_get_pid (ptid) == ptid_get_pid (info->ptid)))
2748 && is_running (info->ptid)
2749 && !is_executing (info->ptid))
2751 struct cleanup *old_chain;
2752 struct execution_control_state ecss;
2753 struct execution_control_state *ecs = &ecss;
2755 memset (ecs, 0, sizeof (*ecs));
2757 old_chain = make_cleanup_restore_current_thread ();
2759 overlay_cache_invalid = 1;
2760 /* Flush target cache before starting to handle each event.
2761 Target was running and cache could be stale. This is just a
2762 heuristic. Running threads may modify target memory, but we
2763 don't get any event. */
2764 target_dcache_invalidate ();
2766 /* Go through handle_inferior_event/normal_stop, so we always
2767 have consistent output as if the stop event had been
2769 ecs->ptid = info->ptid;
2770 ecs->event_thread = find_thread_ptid (info->ptid);
2771 ecs->ws.kind = TARGET_WAITKIND_STOPPED;
2772 ecs->ws.value.sig = GDB_SIGNAL_0;
2774 handle_inferior_event (ecs);
2776 if (!ecs->wait_some_more)
2778 struct thread_info *tp;
2782 /* Finish off the continuations. */
2783 tp = inferior_thread ();
2784 do_all_intermediate_continuations_thread (tp, 1);
2785 do_all_continuations_thread (tp, 1);
2788 do_cleanups (old_chain);
2794 /* This function is attached as a "thread_stop_requested" observer.
2795 Cleanup local state that assumed the PTID was to be resumed, and
2796 report the stop to the frontend. */
2799 infrun_thread_stop_requested (ptid_t ptid)
2801 struct displaced_step_inferior_state *displaced;
2803 /* PTID was requested to stop. Remove it from the displaced
2804 stepping queue, so we don't try to resume it automatically. */
2806 for (displaced = displaced_step_inferior_states;
2808 displaced = displaced->next)
2810 struct displaced_step_request *it, **prev_next_p;
2812 it = displaced->step_request_queue;
2813 prev_next_p = &displaced->step_request_queue;
2816 if (ptid_match (it->ptid, ptid))
2818 *prev_next_p = it->next;
2824 prev_next_p = &it->next;
2831 iterate_over_threads (infrun_thread_stop_requested_callback, &ptid);
2835 infrun_thread_thread_exit (struct thread_info *tp, int silent)
2837 if (ptid_equal (target_last_wait_ptid, tp->ptid))
2838 nullify_last_target_wait_ptid ();
2841 /* Callback for iterate_over_threads. */
2844 delete_step_resume_breakpoint_callback (struct thread_info *info, void *data)
2846 if (is_exited (info->ptid))
2849 delete_step_resume_breakpoint (info);
2850 delete_exception_resume_breakpoint (info);
2854 /* In all-stop, delete the step resume breakpoint of any thread that
2855 had one. In non-stop, delete the step resume breakpoint of the
2856 thread that just stopped. */
2859 delete_step_thread_step_resume_breakpoint (void)
2861 if (!target_has_execution
2862 || ptid_equal (inferior_ptid, null_ptid))
2863 /* If the inferior has exited, we have already deleted the step
2864 resume breakpoints out of GDB's lists. */
2869 /* If in non-stop mode, only delete the step-resume or
2870 longjmp-resume breakpoint of the thread that just stopped
2872 struct thread_info *tp = inferior_thread ();
2874 delete_step_resume_breakpoint (tp);
2875 delete_exception_resume_breakpoint (tp);
2878 /* In all-stop mode, delete all step-resume and longjmp-resume
2879 breakpoints of any thread that had them. */
2880 iterate_over_threads (delete_step_resume_breakpoint_callback, NULL);
2883 /* A cleanup wrapper. */
2886 delete_step_thread_step_resume_breakpoint_cleanup (void *arg)
2888 delete_step_thread_step_resume_breakpoint ();
2891 /* Pretty print the results of target_wait, for debugging purposes. */
2894 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
2895 const struct target_waitstatus *ws)
2897 char *status_string = target_waitstatus_to_string (ws);
2898 struct ui_file *tmp_stream = mem_fileopen ();
2901 /* The text is split over several lines because it was getting too long.
2902 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
2903 output as a unit; we want only one timestamp printed if debug_timestamp
2906 fprintf_unfiltered (tmp_stream,
2907 "infrun: target_wait (%d", ptid_get_pid (waiton_ptid));
2908 if (ptid_get_pid (waiton_ptid) != -1)
2909 fprintf_unfiltered (tmp_stream,
2910 " [%s]", target_pid_to_str (waiton_ptid));
2911 fprintf_unfiltered (tmp_stream, ", status) =\n");
2912 fprintf_unfiltered (tmp_stream,
2913 "infrun: %d [%s],\n",
2914 ptid_get_pid (result_ptid),
2915 target_pid_to_str (result_ptid));
2916 fprintf_unfiltered (tmp_stream,
2920 text = ui_file_xstrdup (tmp_stream, NULL);
2922 /* This uses %s in part to handle %'s in the text, but also to avoid
2923 a gcc error: the format attribute requires a string literal. */
2924 fprintf_unfiltered (gdb_stdlog, "%s", text);
2926 xfree (status_string);
2928 ui_file_delete (tmp_stream);
2931 /* Prepare and stabilize the inferior for detaching it. E.g.,
2932 detaching while a thread is displaced stepping is a recipe for
2933 crashing it, as nothing would readjust the PC out of the scratch
2937 prepare_for_detach (void)
2939 struct inferior *inf = current_inferior ();
2940 ptid_t pid_ptid = pid_to_ptid (inf->pid);
2941 struct cleanup *old_chain_1;
2942 struct displaced_step_inferior_state *displaced;
2944 displaced = get_displaced_stepping_state (inf->pid);
2946 /* Is any thread of this process displaced stepping? If not,
2947 there's nothing else to do. */
2948 if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
2952 fprintf_unfiltered (gdb_stdlog,
2953 "displaced-stepping in-process while detaching");
2955 old_chain_1 = make_cleanup_restore_integer (&inf->detaching);
2958 while (!ptid_equal (displaced->step_ptid, null_ptid))
2960 struct cleanup *old_chain_2;
2961 struct execution_control_state ecss;
2962 struct execution_control_state *ecs;
2965 memset (ecs, 0, sizeof (*ecs));
2967 overlay_cache_invalid = 1;
2968 /* Flush target cache before starting to handle each event.
2969 Target was running and cache could be stale. This is just a
2970 heuristic. Running threads may modify target memory, but we
2971 don't get any event. */
2972 target_dcache_invalidate ();
2974 if (deprecated_target_wait_hook)
2975 ecs->ptid = deprecated_target_wait_hook (pid_ptid, &ecs->ws, 0);
2977 ecs->ptid = target_wait (pid_ptid, &ecs->ws, 0);
2980 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
2982 /* If an error happens while handling the event, propagate GDB's
2983 knowledge of the executing state to the frontend/user running
2985 old_chain_2 = make_cleanup (finish_thread_state_cleanup,
2988 /* Now figure out what to do with the result of the result. */
2989 handle_inferior_event (ecs);
2991 /* No error, don't finish the state yet. */
2992 discard_cleanups (old_chain_2);
2994 /* Breakpoints and watchpoints are not installed on the target
2995 at this point, and signals are passed directly to the
2996 inferior, so this must mean the process is gone. */
2997 if (!ecs->wait_some_more)
2999 discard_cleanups (old_chain_1);
3000 error (_("Program exited while detaching"));
3004 discard_cleanups (old_chain_1);
3007 /* Wait for control to return from inferior to debugger.
3009 If inferior gets a signal, we may decide to start it up again
3010 instead of returning. That is why there is a loop in this function.
3011 When this function actually returns it means the inferior
3012 should be left stopped and GDB should read more commands. */
3015 wait_for_inferior (void)
3017 struct cleanup *old_cleanups;
3021 (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3024 make_cleanup (delete_step_thread_step_resume_breakpoint_cleanup, NULL);
3028 struct execution_control_state ecss;
3029 struct execution_control_state *ecs = &ecss;
3030 struct cleanup *old_chain;
3032 memset (ecs, 0, sizeof (*ecs));
3034 overlay_cache_invalid = 1;
3036 /* Flush target cache before starting to handle each event.
3037 Target was running and cache could be stale. This is just a
3038 heuristic. Running threads may modify target memory, but we
3039 don't get any event. */
3040 target_dcache_invalidate ();
3042 if (deprecated_target_wait_hook)
3043 ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0);
3045 ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0);
3048 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3050 /* If an error happens while handling the event, propagate GDB's
3051 knowledge of the executing state to the frontend/user running
3053 old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3055 /* Now figure out what to do with the result of the result. */
3056 handle_inferior_event (ecs);
3058 /* No error, don't finish the state yet. */
3059 discard_cleanups (old_chain);
3061 if (!ecs->wait_some_more)
3065 do_cleanups (old_cleanups);
3068 /* Asynchronous version of wait_for_inferior. It is called by the
3069 event loop whenever a change of state is detected on the file
3070 descriptor corresponding to the target. It can be called more than
3071 once to complete a single execution command. In such cases we need
3072 to keep the state in a global variable ECSS. If it is the last time
3073 that this function is called for a single execution command, then
3074 report to the user that the inferior has stopped, and do the
3075 necessary cleanups. */
3078 fetch_inferior_event (void *client_data)
3080 struct execution_control_state ecss;
3081 struct execution_control_state *ecs = &ecss;
3082 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3083 struct cleanup *ts_old_chain;
3084 int was_sync = sync_execution;
3087 memset (ecs, 0, sizeof (*ecs));
3089 /* We're handling a live event, so make sure we're doing live
3090 debugging. If we're looking at traceframes while the target is
3091 running, we're going to need to get back to that mode after
3092 handling the event. */
3095 make_cleanup_restore_current_traceframe ();
3096 set_current_traceframe (-1);
3100 /* In non-stop mode, the user/frontend should not notice a thread
3101 switch due to internal events. Make sure we reverse to the
3102 user selected thread and frame after handling the event and
3103 running any breakpoint commands. */
3104 make_cleanup_restore_current_thread ();
3106 overlay_cache_invalid = 1;
3107 /* Flush target cache before starting to handle each event. Target
3108 was running and cache could be stale. This is just a heuristic.
3109 Running threads may modify target memory, but we don't get any
3111 target_dcache_invalidate ();
3113 make_cleanup_restore_integer (&execution_direction);
3114 execution_direction = target_execution_direction ();
3116 if (deprecated_target_wait_hook)
3118 deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
3120 ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
3123 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3125 /* If an error happens while handling the event, propagate GDB's
3126 knowledge of the executing state to the frontend/user running
3129 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3131 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
3133 /* Get executed before make_cleanup_restore_current_thread above to apply
3134 still for the thread which has thrown the exception. */
3135 make_bpstat_clear_actions_cleanup ();
3137 /* Now figure out what to do with the result of the result. */
3138 handle_inferior_event (ecs);
3140 if (!ecs->wait_some_more)
3142 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
3144 delete_step_thread_step_resume_breakpoint ();
3146 /* We may not find an inferior if this was a process exit. */
3147 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3150 if (target_has_execution
3151 && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED
3152 && ecs->ws.kind != TARGET_WAITKIND_EXITED
3153 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3154 && ecs->event_thread->step_multi
3155 && ecs->event_thread->control.stop_step)
3156 inferior_event_handler (INF_EXEC_CONTINUE, NULL);
3159 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3164 /* No error, don't finish the thread states yet. */
3165 discard_cleanups (ts_old_chain);
3167 /* Revert thread and frame. */
3168 do_cleanups (old_chain);
3170 /* If the inferior was in sync execution mode, and now isn't,
3171 restore the prompt (a synchronous execution command has finished,
3172 and we're ready for input). */
3173 if (interpreter_async && was_sync && !sync_execution)
3174 observer_notify_sync_execution_done ();
3178 && exec_done_display_p
3179 && (ptid_equal (inferior_ptid, null_ptid)
3180 || !is_running (inferior_ptid)))
3181 printf_unfiltered (_("completed.\n"));
3184 /* Record the frame and location we're currently stepping through. */
3186 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3188 struct thread_info *tp = inferior_thread ();
3190 tp->control.step_frame_id = get_frame_id (frame);
3191 tp->control.step_stack_frame_id = get_stack_frame_id (frame);
3193 tp->current_symtab = sal.symtab;
3194 tp->current_line = sal.line;
3197 /* Clear context switchable stepping state. */
3200 init_thread_stepping_state (struct thread_info *tss)
3202 tss->stepping_over_breakpoint = 0;
3203 tss->step_after_step_resume_breakpoint = 0;
3206 /* Set the cached copy of the last ptid/waitstatus. */
3209 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
3211 target_last_wait_ptid = ptid;
3212 target_last_waitstatus = status;
3215 /* Return the cached copy of the last pid/waitstatus returned by
3216 target_wait()/deprecated_target_wait_hook(). The data is actually
3217 cached by handle_inferior_event(), which gets called immediately
3218 after target_wait()/deprecated_target_wait_hook(). */
3221 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
3223 *ptidp = target_last_wait_ptid;
3224 *status = target_last_waitstatus;
3228 nullify_last_target_wait_ptid (void)
3230 target_last_wait_ptid = minus_one_ptid;
3233 /* Switch thread contexts. */
3236 context_switch (ptid_t ptid)
3238 if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
3240 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
3241 target_pid_to_str (inferior_ptid));
3242 fprintf_unfiltered (gdb_stdlog, "to %s\n",
3243 target_pid_to_str (ptid));
3246 switch_to_thread (ptid);
3250 adjust_pc_after_break (struct execution_control_state *ecs)
3252 struct regcache *regcache;
3253 struct gdbarch *gdbarch;
3254 struct address_space *aspace;
3255 CORE_ADDR breakpoint_pc, decr_pc;
3257 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
3258 we aren't, just return.
3260 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3261 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
3262 implemented by software breakpoints should be handled through the normal
3265 NOTE drow/2004-01-31: On some targets, breakpoints may generate
3266 different signals (SIGILL or SIGEMT for instance), but it is less
3267 clear where the PC is pointing afterwards. It may not match
3268 gdbarch_decr_pc_after_break. I don't know any specific target that
3269 generates these signals at breakpoints (the code has been in GDB since at
3270 least 1992) so I can not guess how to handle them here.
3272 In earlier versions of GDB, a target with
3273 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3274 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
3275 target with both of these set in GDB history, and it seems unlikely to be
3276 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
3278 if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
3281 if (ecs->ws.value.sig != GDB_SIGNAL_TRAP)
3284 /* In reverse execution, when a breakpoint is hit, the instruction
3285 under it has already been de-executed. The reported PC always
3286 points at the breakpoint address, so adjusting it further would
3287 be wrong. E.g., consider this case on a decr_pc_after_break == 1
3290 B1 0x08000000 : INSN1
3291 B2 0x08000001 : INSN2
3293 PC -> 0x08000003 : INSN4
3295 Say you're stopped at 0x08000003 as above. Reverse continuing
3296 from that point should hit B2 as below. Reading the PC when the
3297 SIGTRAP is reported should read 0x08000001 and INSN2 should have
3298 been de-executed already.
3300 B1 0x08000000 : INSN1
3301 B2 PC -> 0x08000001 : INSN2
3305 We can't apply the same logic as for forward execution, because
3306 we would wrongly adjust the PC to 0x08000000, since there's a
3307 breakpoint at PC - 1. We'd then report a hit on B1, although
3308 INSN1 hadn't been de-executed yet. Doing nothing is the correct
3310 if (execution_direction == EXEC_REVERSE)
3313 /* If this target does not decrement the PC after breakpoints, then
3314 we have nothing to do. */
3315 regcache = get_thread_regcache (ecs->ptid);
3316 gdbarch = get_regcache_arch (regcache);
3318 decr_pc = target_decr_pc_after_break (gdbarch);
3322 aspace = get_regcache_aspace (regcache);
3324 /* Find the location where (if we've hit a breakpoint) the
3325 breakpoint would be. */
3326 breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
3328 /* Check whether there actually is a software breakpoint inserted at
3331 If in non-stop mode, a race condition is possible where we've
3332 removed a breakpoint, but stop events for that breakpoint were
3333 already queued and arrive later. To suppress those spurious
3334 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
3335 and retire them after a number of stop events are reported. */
3336 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
3337 || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
3339 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
3341 if (record_full_is_used ())
3342 record_full_gdb_operation_disable_set ();
3344 /* When using hardware single-step, a SIGTRAP is reported for both
3345 a completed single-step and a software breakpoint. Need to
3346 differentiate between the two, as the latter needs adjusting
3347 but the former does not.
3349 The SIGTRAP can be due to a completed hardware single-step only if
3350 - we didn't insert software single-step breakpoints
3351 - the thread to be examined is still the current thread
3352 - this thread is currently being stepped
3354 If any of these events did not occur, we must have stopped due
3355 to hitting a software breakpoint, and have to back up to the
3358 As a special case, we could have hardware single-stepped a
3359 software breakpoint. In this case (prev_pc == breakpoint_pc),
3360 we also need to back up to the breakpoint address. */
3362 if (singlestep_breakpoints_inserted_p
3363 || !ptid_equal (ecs->ptid, inferior_ptid)
3364 || !currently_stepping (ecs->event_thread)
3365 || ecs->event_thread->prev_pc == breakpoint_pc)
3366 regcache_write_pc (regcache, breakpoint_pc);
3368 do_cleanups (old_cleanups);
3373 init_infwait_state (void)
3375 waiton_ptid = pid_to_ptid (-1);
3376 infwait_state = infwait_normal_state;
3380 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
3382 for (frame = get_prev_frame (frame);
3384 frame = get_prev_frame (frame))
3386 if (frame_id_eq (get_frame_id (frame), step_frame_id))
3388 if (get_frame_type (frame) != INLINE_FRAME)
3395 /* Auxiliary function that handles syscall entry/return events.
3396 It returns 1 if the inferior should keep going (and GDB
3397 should ignore the event), or 0 if the event deserves to be
3401 handle_syscall_event (struct execution_control_state *ecs)
3403 struct regcache *regcache;
3406 if (!ptid_equal (ecs->ptid, inferior_ptid))
3407 context_switch (ecs->ptid);
3409 regcache = get_thread_regcache (ecs->ptid);
3410 syscall_number = ecs->ws.value.syscall_number;
3411 stop_pc = regcache_read_pc (regcache);
3413 if (catch_syscall_enabled () > 0
3414 && catching_syscall_number (syscall_number) > 0)
3417 fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
3420 ecs->event_thread->control.stop_bpstat
3421 = bpstat_stop_status (get_regcache_aspace (regcache),
3422 stop_pc, ecs->ptid, &ecs->ws);
3424 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3426 /* Catchpoint hit. */
3431 /* If no catchpoint triggered for this, then keep going. */
3436 /* Lazily fill in the execution_control_state's stop_func_* fields. */
3439 fill_in_stop_func (struct gdbarch *gdbarch,
3440 struct execution_control_state *ecs)
3442 if (!ecs->stop_func_filled_in)
3444 /* Don't care about return value; stop_func_start and stop_func_name
3445 will both be 0 if it doesn't work. */
3446 find_pc_partial_function (stop_pc, &ecs->stop_func_name,
3447 &ecs->stop_func_start, &ecs->stop_func_end);
3448 ecs->stop_func_start
3449 += gdbarch_deprecated_function_start_offset (gdbarch);
3451 if (gdbarch_skip_entrypoint_p (gdbarch))
3452 ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
3453 ecs->stop_func_start);
3455 ecs->stop_func_filled_in = 1;
3460 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
3462 static enum stop_kind
3463 get_inferior_stop_soon (ptid_t ptid)
3465 struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
3467 gdb_assert (inf != NULL);
3468 return inf->control.stop_soon;
3471 /* Given an execution control state that has been freshly filled in by
3472 an event from the inferior, figure out what it means and take
3475 The alternatives are:
3477 1) stop_waiting and return; to really stop and return to the
3480 2) keep_going and return; to wait for the next event (set
3481 ecs->event_thread->stepping_over_breakpoint to 1 to single step
3485 handle_inferior_event (struct execution_control_state *ecs)
3487 enum stop_kind stop_soon;
3489 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
3491 /* We had an event in the inferior, but we are not interested in
3492 handling it at this level. The lower layers have already
3493 done what needs to be done, if anything.
3495 One of the possible circumstances for this is when the
3496 inferior produces output for the console. The inferior has
3497 not stopped, and we are ignoring the event. Another possible
3498 circumstance is any event which the lower level knows will be
3499 reported multiple times without an intervening resume. */
3501 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
3502 prepare_to_wait (ecs);
3506 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
3507 && target_can_async_p () && !sync_execution)
3509 /* There were no unwaited-for children left in the target, but,
3510 we're not synchronously waiting for events either. Just
3511 ignore. Otherwise, if we were running a synchronous
3512 execution command, we need to cancel it and give the user
3513 back the terminal. */
3515 fprintf_unfiltered (gdb_stdlog,
3516 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
3517 prepare_to_wait (ecs);
3521 /* Cache the last pid/waitstatus. */
3522 set_last_target_status (ecs->ptid, ecs->ws);
3524 /* Always clear state belonging to the previous time we stopped. */
3525 stop_stack_dummy = STOP_NONE;
3527 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
3529 /* No unwaited-for children left. IOW, all resumed children
3532 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
3534 stop_print_frame = 0;
3539 if (ecs->ws.kind != TARGET_WAITKIND_EXITED
3540 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
3542 ecs->event_thread = find_thread_ptid (ecs->ptid);
3543 /* If it's a new thread, add it to the thread database. */
3544 if (ecs->event_thread == NULL)
3545 ecs->event_thread = add_thread (ecs->ptid);
3547 /* Disable range stepping. If the next step request could use a
3548 range, this will be end up re-enabled then. */
3549 ecs->event_thread->control.may_range_step = 0;
3552 /* Dependent on valid ECS->EVENT_THREAD. */
3553 adjust_pc_after_break (ecs);
3555 /* Dependent on the current PC value modified by adjust_pc_after_break. */
3556 reinit_frame_cache ();
3558 breakpoint_retire_moribund ();
3560 /* First, distinguish signals caused by the debugger from signals
3561 that have to do with the program's own actions. Note that
3562 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
3563 on the operating system version. Here we detect when a SIGILL or
3564 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
3565 something similar for SIGSEGV, since a SIGSEGV will be generated
3566 when we're trying to execute a breakpoint instruction on a
3567 non-executable stack. This happens for call dummy breakpoints
3568 for architectures like SPARC that place call dummies on the
3570 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
3571 && (ecs->ws.value.sig == GDB_SIGNAL_ILL
3572 || ecs->ws.value.sig == GDB_SIGNAL_SEGV
3573 || ecs->ws.value.sig == GDB_SIGNAL_EMT))
3575 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3577 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache),
3578 regcache_read_pc (regcache)))
3581 fprintf_unfiltered (gdb_stdlog,
3582 "infrun: Treating signal as SIGTRAP\n");
3583 ecs->ws.value.sig = GDB_SIGNAL_TRAP;
3587 /* Mark the non-executing threads accordingly. In all-stop, all
3588 threads of all processes are stopped when we get any event
3589 reported. In non-stop mode, only the event thread stops. If
3590 we're handling a process exit in non-stop mode, there's nothing
3591 to do, as threads of the dead process are gone, and threads of
3592 any other process were left running. */
3594 set_executing (minus_one_ptid, 0);
3595 else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3596 && ecs->ws.kind != TARGET_WAITKIND_EXITED)
3597 set_executing (ecs->ptid, 0);
3599 switch (infwait_state)
3601 case infwait_normal_state:
3603 fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n");
3606 case infwait_step_watch_state:
3608 fprintf_unfiltered (gdb_stdlog,
3609 "infrun: infwait_step_watch_state\n");
3611 ecs->stepped_after_stopped_by_watchpoint = 1;
3614 case infwait_nonstep_watch_state:
3616 fprintf_unfiltered (gdb_stdlog,
3617 "infrun: infwait_nonstep_watch_state\n");
3618 insert_breakpoints ();
3620 /* FIXME-maybe: is this cleaner than setting a flag? Does it
3621 handle things like signals arriving and other things happening
3622 in combination correctly? */
3623 ecs->stepped_after_stopped_by_watchpoint = 1;
3627 internal_error (__FILE__, __LINE__, _("bad switch"));
3630 infwait_state = infwait_normal_state;
3631 waiton_ptid = pid_to_ptid (-1);
3633 switch (ecs->ws.kind)
3635 case TARGET_WAITKIND_LOADED:
3637 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
3638 if (!ptid_equal (ecs->ptid, inferior_ptid))
3639 context_switch (ecs->ptid);
3640 /* Ignore gracefully during startup of the inferior, as it might
3641 be the shell which has just loaded some objects, otherwise
3642 add the symbols for the newly loaded objects. Also ignore at
3643 the beginning of an attach or remote session; we will query
3644 the full list of libraries once the connection is
3647 stop_soon = get_inferior_stop_soon (ecs->ptid);
3648 if (stop_soon == NO_STOP_QUIETLY)
3650 struct regcache *regcache;
3652 regcache = get_thread_regcache (ecs->ptid);
3654 handle_solib_event ();
3656 ecs->event_thread->control.stop_bpstat
3657 = bpstat_stop_status (get_regcache_aspace (regcache),
3658 stop_pc, ecs->ptid, &ecs->ws);
3660 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3662 /* A catchpoint triggered. */
3663 process_event_stop_test (ecs);
3667 /* If requested, stop when the dynamic linker notifies
3668 gdb of events. This allows the user to get control
3669 and place breakpoints in initializer routines for
3670 dynamically loaded objects (among other things). */
3671 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3672 if (stop_on_solib_events)
3674 /* Make sure we print "Stopped due to solib-event" in
3676 stop_print_frame = 1;
3683 /* If we are skipping through a shell, or through shared library
3684 loading that we aren't interested in, resume the program. If
3685 we're running the program normally, also resume. */
3686 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
3688 /* Loading of shared libraries might have changed breakpoint
3689 addresses. Make sure new breakpoints are inserted. */
3690 if (stop_soon == NO_STOP_QUIETLY)
3691 insert_breakpoints ();
3692 resume (0, GDB_SIGNAL_0);
3693 prepare_to_wait (ecs);
3697 /* But stop if we're attaching or setting up a remote
3699 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
3700 || stop_soon == STOP_QUIETLY_REMOTE)
3703 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
3708 internal_error (__FILE__, __LINE__,
3709 _("unhandled stop_soon: %d"), (int) stop_soon);
3711 case TARGET_WAITKIND_SPURIOUS:
3713 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
3714 if (!ptid_equal (ecs->ptid, inferior_ptid))
3715 context_switch (ecs->ptid);
3716 resume (0, GDB_SIGNAL_0);
3717 prepare_to_wait (ecs);
3720 case TARGET_WAITKIND_EXITED:
3721 case TARGET_WAITKIND_SIGNALLED:
3724 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3725 fprintf_unfiltered (gdb_stdlog,
3726 "infrun: TARGET_WAITKIND_EXITED\n");
3728 fprintf_unfiltered (gdb_stdlog,
3729 "infrun: TARGET_WAITKIND_SIGNALLED\n");
3732 inferior_ptid = ecs->ptid;
3733 set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid)));
3734 set_current_program_space (current_inferior ()->pspace);
3735 handle_vfork_child_exec_or_exit (0);
3736 target_terminal_ours (); /* Must do this before mourn anyway. */
3738 /* Clearing any previous state of convenience variables. */
3739 clear_exit_convenience_vars ();
3741 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3743 /* Record the exit code in the convenience variable $_exitcode, so
3744 that the user can inspect this again later. */
3745 set_internalvar_integer (lookup_internalvar ("_exitcode"),
3746 (LONGEST) ecs->ws.value.integer);
3748 /* Also record this in the inferior itself. */
3749 current_inferior ()->has_exit_code = 1;
3750 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
3752 /* Support the --return-child-result option. */
3753 return_child_result_value = ecs->ws.value.integer;
3755 observer_notify_exited (ecs->ws.value.integer);
3759 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3760 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3762 if (gdbarch_gdb_signal_to_target_p (gdbarch))
3764 /* Set the value of the internal variable $_exitsignal,
3765 which holds the signal uncaught by the inferior. */
3766 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
3767 gdbarch_gdb_signal_to_target (gdbarch,
3768 ecs->ws.value.sig));
3772 /* We don't have access to the target's method used for
3773 converting between signal numbers (GDB's internal
3774 representation <-> target's representation).
3775 Therefore, we cannot do a good job at displaying this
3776 information to the user. It's better to just warn
3777 her about it (if infrun debugging is enabled), and
3780 fprintf_filtered (gdb_stdlog, _("\
3781 Cannot fill $_exitsignal with the correct signal number.\n"));
3784 observer_notify_signal_exited (ecs->ws.value.sig);
3787 gdb_flush (gdb_stdout);
3788 target_mourn_inferior ();
3789 singlestep_breakpoints_inserted_p = 0;
3790 cancel_single_step_breakpoints ();
3791 stop_print_frame = 0;
3795 /* The following are the only cases in which we keep going;
3796 the above cases end in a continue or goto. */
3797 case TARGET_WAITKIND_FORKED:
3798 case TARGET_WAITKIND_VFORKED:
3801 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3802 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
3804 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
3807 /* Check whether the inferior is displaced stepping. */
3809 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3810 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3811 struct displaced_step_inferior_state *displaced
3812 = get_displaced_stepping_state (ptid_get_pid (ecs->ptid));
3814 /* If checking displaced stepping is supported, and thread
3815 ecs->ptid is displaced stepping. */
3816 if (displaced && ptid_equal (displaced->step_ptid, ecs->ptid))
3818 struct inferior *parent_inf
3819 = find_inferior_pid (ptid_get_pid (ecs->ptid));
3820 struct regcache *child_regcache;
3821 CORE_ADDR parent_pc;
3823 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
3824 indicating that the displaced stepping of syscall instruction
3825 has been done. Perform cleanup for parent process here. Note
3826 that this operation also cleans up the child process for vfork,
3827 because their pages are shared. */
3828 displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
3830 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3832 /* Restore scratch pad for child process. */
3833 displaced_step_restore (displaced, ecs->ws.value.related_pid);
3836 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
3837 the child's PC is also within the scratchpad. Set the child's PC
3838 to the parent's PC value, which has already been fixed up.
3839 FIXME: we use the parent's aspace here, although we're touching
3840 the child, because the child hasn't been added to the inferior
3841 list yet at this point. */
3844 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
3846 parent_inf->aspace);
3847 /* Read PC value of parent process. */
3848 parent_pc = regcache_read_pc (regcache);
3850 if (debug_displaced)
3851 fprintf_unfiltered (gdb_stdlog,
3852 "displaced: write child pc from %s to %s\n",
3854 regcache_read_pc (child_regcache)),
3855 paddress (gdbarch, parent_pc));
3857 regcache_write_pc (child_regcache, parent_pc);
3861 if (!ptid_equal (ecs->ptid, inferior_ptid))
3862 context_switch (ecs->ptid);
3864 /* Immediately detach breakpoints from the child before there's
3865 any chance of letting the user delete breakpoints from the
3866 breakpoint lists. If we don't do this early, it's easy to
3867 leave left over traps in the child, vis: "break foo; catch
3868 fork; c; <fork>; del; c; <child calls foo>". We only follow
3869 the fork on the last `continue', and by that time the
3870 breakpoint at "foo" is long gone from the breakpoint table.
3871 If we vforked, then we don't need to unpatch here, since both
3872 parent and child are sharing the same memory pages; we'll
3873 need to unpatch at follow/detach time instead to be certain
3874 that new breakpoints added between catchpoint hit time and
3875 vfork follow are detached. */
3876 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
3878 /* This won't actually modify the breakpoint list, but will
3879 physically remove the breakpoints from the child. */
3880 detach_breakpoints (ecs->ws.value.related_pid);
3883 if (singlestep_breakpoints_inserted_p)
3885 /* Pull the single step breakpoints out of the target. */
3886 remove_single_step_breakpoints ();
3887 singlestep_breakpoints_inserted_p = 0;
3890 /* In case the event is caught by a catchpoint, remember that
3891 the event is to be followed at the next resume of the thread,
3892 and not immediately. */
3893 ecs->event_thread->pending_follow = ecs->ws;
3895 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3897 ecs->event_thread->control.stop_bpstat
3898 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3899 stop_pc, ecs->ptid, &ecs->ws);
3901 /* If no catchpoint triggered for this, then keep going. Note
3902 that we're interested in knowing the bpstat actually causes a
3903 stop, not just if it may explain the signal. Software
3904 watchpoints, for example, always appear in the bpstat. */
3905 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3911 = (follow_fork_mode_string == follow_fork_mode_child);
3913 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3915 should_resume = follow_fork ();
3918 child = ecs->ws.value.related_pid;
3920 /* In non-stop mode, also resume the other branch. */
3921 if (non_stop && !detach_fork)
3924 switch_to_thread (parent);
3926 switch_to_thread (child);
3928 ecs->event_thread = inferior_thread ();
3929 ecs->ptid = inferior_ptid;
3934 switch_to_thread (child);
3936 switch_to_thread (parent);
3938 ecs->event_thread = inferior_thread ();
3939 ecs->ptid = inferior_ptid;
3947 process_event_stop_test (ecs);
3950 case TARGET_WAITKIND_VFORK_DONE:
3951 /* Done with the shared memory region. Re-insert breakpoints in
3952 the parent, and keep going. */
3955 fprintf_unfiltered (gdb_stdlog,
3956 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
3958 if (!ptid_equal (ecs->ptid, inferior_ptid))
3959 context_switch (ecs->ptid);
3961 current_inferior ()->waiting_for_vfork_done = 0;
3962 current_inferior ()->pspace->breakpoints_not_allowed = 0;
3963 /* This also takes care of reinserting breakpoints in the
3964 previously locked inferior. */
3968 case TARGET_WAITKIND_EXECD:
3970 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
3972 if (!ptid_equal (ecs->ptid, inferior_ptid))
3973 context_switch (ecs->ptid);
3975 singlestep_breakpoints_inserted_p = 0;
3976 cancel_single_step_breakpoints ();
3978 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3980 /* Do whatever is necessary to the parent branch of the vfork. */
3981 handle_vfork_child_exec_or_exit (1);
3983 /* This causes the eventpoints and symbol table to be reset.
3984 Must do this now, before trying to determine whether to
3986 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
3988 ecs->event_thread->control.stop_bpstat
3989 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3990 stop_pc, ecs->ptid, &ecs->ws);
3992 /* Note that this may be referenced from inside
3993 bpstat_stop_status above, through inferior_has_execd. */
3994 xfree (ecs->ws.value.execd_pathname);
3995 ecs->ws.value.execd_pathname = NULL;
3997 /* If no catchpoint triggered for this, then keep going. */
3998 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4000 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4004 process_event_stop_test (ecs);
4007 /* Be careful not to try to gather much state about a thread
4008 that's in a syscall. It's frequently a losing proposition. */
4009 case TARGET_WAITKIND_SYSCALL_ENTRY:
4011 fprintf_unfiltered (gdb_stdlog,
4012 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
4013 /* Getting the current syscall number. */
4014 if (handle_syscall_event (ecs) == 0)
4015 process_event_stop_test (ecs);
4018 /* Before examining the threads further, step this thread to
4019 get it entirely out of the syscall. (We get notice of the
4020 event when the thread is just on the verge of exiting a
4021 syscall. Stepping one instruction seems to get it back
4023 case TARGET_WAITKIND_SYSCALL_RETURN:
4025 fprintf_unfiltered (gdb_stdlog,
4026 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
4027 if (handle_syscall_event (ecs) == 0)
4028 process_event_stop_test (ecs);
4031 case TARGET_WAITKIND_STOPPED:
4033 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
4034 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
4035 handle_signal_stop (ecs);
4038 case TARGET_WAITKIND_NO_HISTORY:
4040 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
4041 /* Reverse execution: target ran out of history info. */
4043 /* Pull the single step breakpoints out of the target. */
4044 if (singlestep_breakpoints_inserted_p)
4046 if (!ptid_equal (ecs->ptid, inferior_ptid))
4047 context_switch (ecs->ptid);
4048 remove_single_step_breakpoints ();
4049 singlestep_breakpoints_inserted_p = 0;
4051 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
4052 observer_notify_no_history ();
4058 /* Come here when the program has stopped with a signal. */
4061 handle_signal_stop (struct execution_control_state *ecs)
4063 struct frame_info *frame;
4064 struct gdbarch *gdbarch;
4065 int stopped_by_watchpoint;
4066 enum stop_kind stop_soon;
4069 gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
4071 /* Do we need to clean up the state of a thread that has
4072 completed a displaced single-step? (Doing so usually affects
4073 the PC, so do it here, before we set stop_pc.) */
4074 displaced_step_fixup (ecs->ptid,
4075 ecs->event_thread->suspend.stop_signal);
4077 /* If we either finished a single-step or hit a breakpoint, but
4078 the user wanted this thread to be stopped, pretend we got a
4079 SIG0 (generic unsignaled stop). */
4080 if (ecs->event_thread->stop_requested
4081 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
4082 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4084 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
4088 struct regcache *regcache = get_thread_regcache (ecs->ptid);
4089 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4090 struct cleanup *old_chain = save_inferior_ptid ();
4092 inferior_ptid = ecs->ptid;
4094 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
4095 paddress (gdbarch, stop_pc));
4096 if (target_stopped_by_watchpoint ())
4100 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
4102 if (target_stopped_data_address (¤t_target, &addr))
4103 fprintf_unfiltered (gdb_stdlog,
4104 "infrun: stopped data address = %s\n",
4105 paddress (gdbarch, addr));
4107 fprintf_unfiltered (gdb_stdlog,
4108 "infrun: (no data address available)\n");
4111 do_cleanups (old_chain);
4114 /* This is originated from start_remote(), start_inferior() and
4115 shared libraries hook functions. */
4116 stop_soon = get_inferior_stop_soon (ecs->ptid);
4117 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
4119 if (!ptid_equal (ecs->ptid, inferior_ptid))
4120 context_switch (ecs->ptid);
4122 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
4123 stop_print_frame = 1;
4128 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4131 if (!ptid_equal (ecs->ptid, inferior_ptid))
4132 context_switch (ecs->ptid);
4134 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
4135 stop_print_frame = 0;
4140 /* This originates from attach_command(). We need to overwrite
4141 the stop_signal here, because some kernels don't ignore a
4142 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
4143 See more comments in inferior.h. On the other hand, if we
4144 get a non-SIGSTOP, report it to the user - assume the backend
4145 will handle the SIGSTOP if it should show up later.
4147 Also consider that the attach is complete when we see a
4148 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
4149 target extended-remote report it instead of a SIGSTOP
4150 (e.g. gdbserver). We already rely on SIGTRAP being our
4151 signal, so this is no exception.
4153 Also consider that the attach is complete when we see a
4154 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
4155 the target to stop all threads of the inferior, in case the
4156 low level attach operation doesn't stop them implicitly. If
4157 they weren't stopped implicitly, then the stub will report a
4158 GDB_SIGNAL_0, meaning: stopped for no particular reason
4159 other than GDB's request. */
4160 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
4161 && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
4162 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4163 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
4165 stop_print_frame = 1;
4167 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4171 /* See if something interesting happened to the non-current thread. If
4172 so, then switch to that thread. */
4173 if (!ptid_equal (ecs->ptid, inferior_ptid))
4176 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
4178 context_switch (ecs->ptid);
4180 if (deprecated_context_hook)
4181 deprecated_context_hook (pid_to_thread_id (ecs->ptid));
4184 /* At this point, get hold of the now-current thread's frame. */
4185 frame = get_current_frame ();
4186 gdbarch = get_frame_arch (frame);
4188 /* Pull the single step breakpoints out of the target. */
4189 if (singlestep_breakpoints_inserted_p)
4191 /* However, before doing so, if this single-step breakpoint was
4192 actually for another thread, set this thread up for moving
4194 if (!ptid_equal (ecs->ptid, singlestep_ptid)
4195 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
4197 struct regcache *regcache;
4198 struct address_space *aspace;
4201 regcache = get_thread_regcache (ecs->ptid);
4202 aspace = get_regcache_aspace (regcache);
4203 pc = regcache_read_pc (regcache);
4204 if (single_step_breakpoint_inserted_here_p (aspace, pc))
4208 fprintf_unfiltered (gdb_stdlog,
4209 "infrun: [%s] hit step over single-step"
4210 " breakpoint of [%s]\n",
4211 target_pid_to_str (ecs->ptid),
4212 target_pid_to_str (singlestep_ptid));
4214 ecs->hit_singlestep_breakpoint = 1;
4218 remove_single_step_breakpoints ();
4219 singlestep_breakpoints_inserted_p = 0;
4222 if (ecs->stepped_after_stopped_by_watchpoint)
4223 stopped_by_watchpoint = 0;
4225 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
4227 /* If necessary, step over this watchpoint. We'll be back to display
4229 if (stopped_by_watchpoint
4230 && (target_have_steppable_watchpoint
4231 || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
4233 /* At this point, we are stopped at an instruction which has
4234 attempted to write to a piece of memory under control of
4235 a watchpoint. The instruction hasn't actually executed
4236 yet. If we were to evaluate the watchpoint expression
4237 now, we would get the old value, and therefore no change
4238 would seem to have occurred.
4240 In order to make watchpoints work `right', we really need
4241 to complete the memory write, and then evaluate the
4242 watchpoint expression. We do this by single-stepping the
4245 It may not be necessary to disable the watchpoint to step over
4246 it. For example, the PA can (with some kernel cooperation)
4247 single step over a watchpoint without disabling the watchpoint.
4249 It is far more common to need to disable a watchpoint to step
4250 the inferior over it. If we have non-steppable watchpoints,
4251 we must disable the current watchpoint; it's simplest to
4252 disable all watchpoints and breakpoints. */
4255 if (!target_have_steppable_watchpoint)
4257 remove_breakpoints ();
4258 /* See comment in resume why we need to stop bypassing signals
4259 while breakpoints have been removed. */
4260 target_pass_signals (0, NULL);
4263 hw_step = maybe_software_singlestep (gdbarch, stop_pc);
4264 target_resume (ecs->ptid, hw_step, GDB_SIGNAL_0);
4265 waiton_ptid = ecs->ptid;
4266 if (target_have_steppable_watchpoint)
4267 infwait_state = infwait_step_watch_state;
4269 infwait_state = infwait_nonstep_watch_state;
4270 prepare_to_wait (ecs);
4274 ecs->event_thread->stepping_over_breakpoint = 0;
4275 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
4276 ecs->event_thread->control.stop_step = 0;
4277 stop_print_frame = 1;
4278 stopped_by_random_signal = 0;
4280 /* Hide inlined functions starting here, unless we just performed stepi or
4281 nexti. After stepi and nexti, always show the innermost frame (not any
4282 inline function call sites). */
4283 if (ecs->event_thread->control.step_range_end != 1)
4285 struct address_space *aspace =
4286 get_regcache_aspace (get_thread_regcache (ecs->ptid));
4288 /* skip_inline_frames is expensive, so we avoid it if we can
4289 determine that the address is one where functions cannot have
4290 been inlined. This improves performance with inferiors that
4291 load a lot of shared libraries, because the solib event
4292 breakpoint is defined as the address of a function (i.e. not
4293 inline). Note that we have to check the previous PC as well
4294 as the current one to catch cases when we have just
4295 single-stepped off a breakpoint prior to reinstating it.
4296 Note that we're assuming that the code we single-step to is
4297 not inline, but that's not definitive: there's nothing
4298 preventing the event breakpoint function from containing
4299 inlined code, and the single-step ending up there. If the
4300 user had set a breakpoint on that inlined code, the missing
4301 skip_inline_frames call would break things. Fortunately
4302 that's an extremely unlikely scenario. */
4303 if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
4304 && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4305 && ecs->event_thread->control.trap_expected
4306 && pc_at_non_inline_function (aspace,
4307 ecs->event_thread->prev_pc,
4310 skip_inline_frames (ecs->ptid);
4312 /* Re-fetch current thread's frame in case that invalidated
4314 frame = get_current_frame ();
4315 gdbarch = get_frame_arch (frame);
4319 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4320 && ecs->event_thread->control.trap_expected
4321 && gdbarch_single_step_through_delay_p (gdbarch)
4322 && currently_stepping (ecs->event_thread))
4324 /* We're trying to step off a breakpoint. Turns out that we're
4325 also on an instruction that needs to be stepped multiple
4326 times before it's been fully executing. E.g., architectures
4327 with a delay slot. It needs to be stepped twice, once for
4328 the instruction and once for the delay slot. */
4329 int step_through_delay
4330 = gdbarch_single_step_through_delay (gdbarch, frame);
4332 if (debug_infrun && step_through_delay)
4333 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
4334 if (ecs->event_thread->control.step_range_end == 0
4335 && step_through_delay)
4337 /* The user issued a continue when stopped at a breakpoint.
4338 Set up for another trap and get out of here. */
4339 ecs->event_thread->stepping_over_breakpoint = 1;
4343 else if (step_through_delay)
4345 /* The user issued a step when stopped at a breakpoint.
4346 Maybe we should stop, maybe we should not - the delay
4347 slot *might* correspond to a line of source. In any
4348 case, don't decide that here, just set
4349 ecs->stepping_over_breakpoint, making sure we
4350 single-step again before breakpoints are re-inserted. */
4351 ecs->event_thread->stepping_over_breakpoint = 1;
4355 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
4356 handles this event. */
4357 ecs->event_thread->control.stop_bpstat
4358 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4359 stop_pc, ecs->ptid, &ecs->ws);
4361 /* Following in case break condition called a
4363 stop_print_frame = 1;
4365 /* This is where we handle "moribund" watchpoints. Unlike
4366 software breakpoints traps, hardware watchpoint traps are
4367 always distinguishable from random traps. If no high-level
4368 watchpoint is associated with the reported stop data address
4369 anymore, then the bpstat does not explain the signal ---
4370 simply make sure to ignore it if `stopped_by_watchpoint' is
4374 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4375 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
4377 && stopped_by_watchpoint)
4378 fprintf_unfiltered (gdb_stdlog,
4379 "infrun: no user watchpoint explains "
4380 "watchpoint SIGTRAP, ignoring\n");
4382 /* NOTE: cagney/2003-03-29: These checks for a random signal
4383 at one stage in the past included checks for an inferior
4384 function call's call dummy's return breakpoint. The original
4385 comment, that went with the test, read:
4387 ``End of a stack dummy. Some systems (e.g. Sony news) give
4388 another signal besides SIGTRAP, so check here as well as
4391 If someone ever tries to get call dummys on a
4392 non-executable stack to work (where the target would stop
4393 with something like a SIGSEGV), then those tests might need
4394 to be re-instated. Given, however, that the tests were only
4395 enabled when momentary breakpoints were not being used, I
4396 suspect that it won't be the case.
4398 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
4399 be necessary for call dummies on a non-executable stack on
4402 /* See if the breakpoints module can explain the signal. */
4404 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
4405 ecs->event_thread->suspend.stop_signal);
4407 /* If not, perhaps stepping/nexting can. */
4409 random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4410 && currently_stepping (ecs->event_thread));
4412 /* Perhaps the thread hit a single-step breakpoint of _another_
4413 thread. Single-step breakpoints are transparent to the
4414 breakpoints module. */
4416 random_signal = !ecs->hit_singlestep_breakpoint;
4418 /* No? Perhaps we got a moribund watchpoint. */
4420 random_signal = !stopped_by_watchpoint;
4422 /* For the program's own signals, act according to
4423 the signal handling tables. */
4427 /* Signal not for debugging purposes. */
4429 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
4430 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
4433 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
4434 gdb_signal_to_symbol_string (stop_signal));
4436 stopped_by_random_signal = 1;
4438 /* Always stop on signals if we're either just gaining control
4439 of the program, or the user explicitly requested this thread
4440 to remain stopped. */
4441 if (stop_soon != NO_STOP_QUIETLY
4442 || ecs->event_thread->stop_requested
4444 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
4450 /* Notify observers the signal has "handle print" set. Note we
4451 returned early above if stopping; normal_stop handles the
4452 printing in that case. */
4453 if (signal_print[ecs->event_thread->suspend.stop_signal])
4455 /* The signal table tells us to print about this signal. */
4456 target_terminal_ours_for_output ();
4457 observer_notify_signal_received (ecs->event_thread->suspend.stop_signal);
4458 target_terminal_inferior ();
4461 /* Clear the signal if it should not be passed. */
4462 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
4463 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4465 if (ecs->event_thread->prev_pc == stop_pc
4466 && ecs->event_thread->control.trap_expected
4467 && ecs->event_thread->control.step_resume_breakpoint == NULL)
4469 /* We were just starting a new sequence, attempting to
4470 single-step off of a breakpoint and expecting a SIGTRAP.
4471 Instead this signal arrives. This signal will take us out
4472 of the stepping range so GDB needs to remember to, when
4473 the signal handler returns, resume stepping off that
4475 /* To simplify things, "continue" is forced to use the same
4476 code paths as single-step - set a breakpoint at the
4477 signal return address and then, once hit, step off that
4480 fprintf_unfiltered (gdb_stdlog,
4481 "infrun: signal arrived while stepping over "
4484 insert_hp_step_resume_breakpoint_at_frame (frame);
4485 ecs->event_thread->step_after_step_resume_breakpoint = 1;
4486 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4487 ecs->event_thread->control.trap_expected = 0;
4489 /* If we were nexting/stepping some other thread, switch to
4490 it, so that we don't continue it, losing control. */
4491 if (!switch_back_to_stepped_thread (ecs))
4496 if (ecs->event_thread->control.step_range_end != 0
4497 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
4498 && pc_in_thread_step_range (stop_pc, ecs->event_thread)
4499 && frame_id_eq (get_stack_frame_id (frame),
4500 ecs->event_thread->control.step_stack_frame_id)
4501 && ecs->event_thread->control.step_resume_breakpoint == NULL)
4503 /* The inferior is about to take a signal that will take it
4504 out of the single step range. Set a breakpoint at the
4505 current PC (which is presumably where the signal handler
4506 will eventually return) and then allow the inferior to
4509 Note that this is only needed for a signal delivered
4510 while in the single-step range. Nested signals aren't a
4511 problem as they eventually all return. */
4513 fprintf_unfiltered (gdb_stdlog,
4514 "infrun: signal may take us out of "
4515 "single-step range\n");
4517 insert_hp_step_resume_breakpoint_at_frame (frame);
4518 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4519 ecs->event_thread->control.trap_expected = 0;
4524 /* Note: step_resume_breakpoint may be non-NULL. This occures
4525 when either there's a nested signal, or when there's a
4526 pending signal enabled just as the signal handler returns
4527 (leaving the inferior at the step-resume-breakpoint without
4528 actually executing it). Either way continue until the
4529 breakpoint is really hit. */
4531 if (!switch_back_to_stepped_thread (ecs))
4534 fprintf_unfiltered (gdb_stdlog,
4535 "infrun: random signal, keep going\n");
4542 process_event_stop_test (ecs);
4545 /* Come here when we've got some debug event / signal we can explain
4546 (IOW, not a random signal), and test whether it should cause a
4547 stop, or whether we should resume the inferior (transparently).
4548 E.g., could be a breakpoint whose condition evaluates false; we
4549 could be still stepping within the line; etc. */
4552 process_event_stop_test (struct execution_control_state *ecs)
4554 struct symtab_and_line stop_pc_sal;
4555 struct frame_info *frame;
4556 struct gdbarch *gdbarch;
4557 CORE_ADDR jmp_buf_pc;
4558 struct bpstat_what what;
4560 /* Handle cases caused by hitting a breakpoint. */
4562 frame = get_current_frame ();
4563 gdbarch = get_frame_arch (frame);
4565 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
4567 if (what.call_dummy)
4569 stop_stack_dummy = what.call_dummy;
4572 /* If we hit an internal event that triggers symbol changes, the
4573 current frame will be invalidated within bpstat_what (e.g., if we
4574 hit an internal solib event). Re-fetch it. */
4575 frame = get_current_frame ();
4576 gdbarch = get_frame_arch (frame);
4578 switch (what.main_action)
4580 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
4581 /* If we hit the breakpoint at longjmp while stepping, we
4582 install a momentary breakpoint at the target of the
4586 fprintf_unfiltered (gdb_stdlog,
4587 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4589 ecs->event_thread->stepping_over_breakpoint = 1;
4591 if (what.is_longjmp)
4593 struct value *arg_value;
4595 /* If we set the longjmp breakpoint via a SystemTap probe,
4596 then use it to extract the arguments. The destination PC
4597 is the third argument to the probe. */
4598 arg_value = probe_safe_evaluate_at_pc (frame, 2);
4600 jmp_buf_pc = value_as_address (arg_value);
4601 else if (!gdbarch_get_longjmp_target_p (gdbarch)
4602 || !gdbarch_get_longjmp_target (gdbarch,
4603 frame, &jmp_buf_pc))
4606 fprintf_unfiltered (gdb_stdlog,
4607 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4608 "(!gdbarch_get_longjmp_target)\n");
4613 /* Insert a breakpoint at resume address. */
4614 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
4617 check_exception_resume (ecs, frame);
4621 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
4623 struct frame_info *init_frame;
4625 /* There are several cases to consider.
4627 1. The initiating frame no longer exists. In this case we
4628 must stop, because the exception or longjmp has gone too
4631 2. The initiating frame exists, and is the same as the
4632 current frame. We stop, because the exception or longjmp
4635 3. The initiating frame exists and is different from the
4636 current frame. This means the exception or longjmp has
4637 been caught beneath the initiating frame, so keep going.
4639 4. longjmp breakpoint has been placed just to protect
4640 against stale dummy frames and user is not interested in
4641 stopping around longjmps. */
4644 fprintf_unfiltered (gdb_stdlog,
4645 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4647 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
4649 delete_exception_resume_breakpoint (ecs->event_thread);
4651 if (what.is_longjmp)
4653 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
4655 if (!frame_id_p (ecs->event_thread->initiating_frame))
4663 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
4667 struct frame_id current_id
4668 = get_frame_id (get_current_frame ());
4669 if (frame_id_eq (current_id,
4670 ecs->event_thread->initiating_frame))
4672 /* Case 2. Fall through. */
4682 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
4684 delete_step_resume_breakpoint (ecs->event_thread);
4686 end_stepping_range (ecs);
4690 case BPSTAT_WHAT_SINGLE:
4692 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
4693 ecs->event_thread->stepping_over_breakpoint = 1;
4694 /* Still need to check other stuff, at least the case where we
4695 are stepping and step out of the right range. */
4698 case BPSTAT_WHAT_STEP_RESUME:
4700 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
4702 delete_step_resume_breakpoint (ecs->event_thread);
4703 if (ecs->event_thread->control.proceed_to_finish
4704 && execution_direction == EXEC_REVERSE)
4706 struct thread_info *tp = ecs->event_thread;
4708 /* We are finishing a function in reverse, and just hit the
4709 step-resume breakpoint at the start address of the
4710 function, and we're almost there -- just need to back up
4711 by one more single-step, which should take us back to the
4713 tp->control.step_range_start = tp->control.step_range_end = 1;
4717 fill_in_stop_func (gdbarch, ecs);
4718 if (stop_pc == ecs->stop_func_start
4719 && execution_direction == EXEC_REVERSE)
4721 /* We are stepping over a function call in reverse, and just
4722 hit the step-resume breakpoint at the start address of
4723 the function. Go back to single-stepping, which should
4724 take us back to the function call. */
4725 ecs->event_thread->stepping_over_breakpoint = 1;
4731 case BPSTAT_WHAT_STOP_NOISY:
4733 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
4734 stop_print_frame = 1;
4736 /* Assume the thread stopped for a breapoint. We'll still check
4737 whether a/the breakpoint is there when the thread is next
4739 ecs->event_thread->stepping_over_breakpoint = 1;
4744 case BPSTAT_WHAT_STOP_SILENT:
4746 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
4747 stop_print_frame = 0;
4749 /* Assume the thread stopped for a breapoint. We'll still check
4750 whether a/the breakpoint is there when the thread is next
4752 ecs->event_thread->stepping_over_breakpoint = 1;
4756 case BPSTAT_WHAT_HP_STEP_RESUME:
4758 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
4760 delete_step_resume_breakpoint (ecs->event_thread);
4761 if (ecs->event_thread->step_after_step_resume_breakpoint)
4763 /* Back when the step-resume breakpoint was inserted, we
4764 were trying to single-step off a breakpoint. Go back to
4766 ecs->event_thread->step_after_step_resume_breakpoint = 0;
4767 ecs->event_thread->stepping_over_breakpoint = 1;
4773 case BPSTAT_WHAT_KEEP_CHECKING:
4777 /* We come here if we hit a breakpoint but should not stop for it.
4778 Possibly we also were stepping and should stop for that. So fall
4779 through and test for stepping. But, if not stepping, do not
4782 /* In all-stop mode, if we're currently stepping but have stopped in
4783 some other thread, we need to switch back to the stepped thread. */
4784 if (switch_back_to_stepped_thread (ecs))
4787 if (ecs->event_thread->control.step_resume_breakpoint)
4790 fprintf_unfiltered (gdb_stdlog,
4791 "infrun: step-resume breakpoint is inserted\n");
4793 /* Having a step-resume breakpoint overrides anything
4794 else having to do with stepping commands until
4795 that breakpoint is reached. */
4800 if (ecs->event_thread->control.step_range_end == 0)
4803 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
4804 /* Likewise if we aren't even stepping. */
4809 /* Re-fetch current thread's frame in case the code above caused
4810 the frame cache to be re-initialized, making our FRAME variable
4811 a dangling pointer. */
4812 frame = get_current_frame ();
4813 gdbarch = get_frame_arch (frame);
4814 fill_in_stop_func (gdbarch, ecs);
4816 /* If stepping through a line, keep going if still within it.
4818 Note that step_range_end is the address of the first instruction
4819 beyond the step range, and NOT the address of the last instruction
4822 Note also that during reverse execution, we may be stepping
4823 through a function epilogue and therefore must detect when
4824 the current-frame changes in the middle of a line. */
4826 if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
4827 && (execution_direction != EXEC_REVERSE
4828 || frame_id_eq (get_frame_id (frame),
4829 ecs->event_thread->control.step_frame_id)))
4833 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
4834 paddress (gdbarch, ecs->event_thread->control.step_range_start),
4835 paddress (gdbarch, ecs->event_thread->control.step_range_end));
4837 /* Tentatively re-enable range stepping; `resume' disables it if
4838 necessary (e.g., if we're stepping over a breakpoint or we
4839 have software watchpoints). */
4840 ecs->event_thread->control.may_range_step = 1;
4842 /* When stepping backward, stop at beginning of line range
4843 (unless it's the function entry point, in which case
4844 keep going back to the call point). */
4845 if (stop_pc == ecs->event_thread->control.step_range_start
4846 && stop_pc != ecs->stop_func_start
4847 && execution_direction == EXEC_REVERSE)
4848 end_stepping_range (ecs);
4855 /* We stepped out of the stepping range. */
4857 /* If we are stepping at the source level and entered the runtime
4858 loader dynamic symbol resolution code...
4860 EXEC_FORWARD: we keep on single stepping until we exit the run
4861 time loader code and reach the callee's address.
4863 EXEC_REVERSE: we've already executed the callee (backward), and
4864 the runtime loader code is handled just like any other
4865 undebuggable function call. Now we need only keep stepping
4866 backward through the trampoline code, and that's handled further
4867 down, so there is nothing for us to do here. */
4869 if (execution_direction != EXEC_REVERSE
4870 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4871 && in_solib_dynsym_resolve_code (stop_pc))
4873 CORE_ADDR pc_after_resolver =
4874 gdbarch_skip_solib_resolver (gdbarch, stop_pc);
4877 fprintf_unfiltered (gdb_stdlog,
4878 "infrun: stepped into dynsym resolve code\n");
4880 if (pc_after_resolver)
4882 /* Set up a step-resume breakpoint at the address
4883 indicated by SKIP_SOLIB_RESOLVER. */
4884 struct symtab_and_line sr_sal;
4887 sr_sal.pc = pc_after_resolver;
4888 sr_sal.pspace = get_frame_program_space (frame);
4890 insert_step_resume_breakpoint_at_sal (gdbarch,
4891 sr_sal, null_frame_id);
4898 if (ecs->event_thread->control.step_range_end != 1
4899 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4900 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
4901 && get_frame_type (frame) == SIGTRAMP_FRAME)
4904 fprintf_unfiltered (gdb_stdlog,
4905 "infrun: stepped into signal trampoline\n");
4906 /* The inferior, while doing a "step" or "next", has ended up in
4907 a signal trampoline (either by a signal being delivered or by
4908 the signal handler returning). Just single-step until the
4909 inferior leaves the trampoline (either by calling the handler
4915 /* If we're in the return path from a shared library trampoline,
4916 we want to proceed through the trampoline when stepping. */
4917 /* macro/2012-04-25: This needs to come before the subroutine
4918 call check below as on some targets return trampolines look
4919 like subroutine calls (MIPS16 return thunks). */
4920 if (gdbarch_in_solib_return_trampoline (gdbarch,
4921 stop_pc, ecs->stop_func_name)
4922 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
4924 /* Determine where this trampoline returns. */
4925 CORE_ADDR real_stop_pc;
4927 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
4930 fprintf_unfiltered (gdb_stdlog,
4931 "infrun: stepped into solib return tramp\n");
4933 /* Only proceed through if we know where it's going. */
4936 /* And put the step-breakpoint there and go until there. */
4937 struct symtab_and_line sr_sal;
4939 init_sal (&sr_sal); /* initialize to zeroes */
4940 sr_sal.pc = real_stop_pc;
4941 sr_sal.section = find_pc_overlay (sr_sal.pc);
4942 sr_sal.pspace = get_frame_program_space (frame);
4944 /* Do not specify what the fp should be when we stop since
4945 on some machines the prologue is where the new fp value
4947 insert_step_resume_breakpoint_at_sal (gdbarch,
4948 sr_sal, null_frame_id);
4950 /* Restart without fiddling with the step ranges or
4957 /* Check for subroutine calls. The check for the current frame
4958 equalling the step ID is not necessary - the check of the
4959 previous frame's ID is sufficient - but it is a common case and
4960 cheaper than checking the previous frame's ID.
4962 NOTE: frame_id_eq will never report two invalid frame IDs as
4963 being equal, so to get into this block, both the current and
4964 previous frame must have valid frame IDs. */
4965 /* The outer_frame_id check is a heuristic to detect stepping
4966 through startup code. If we step over an instruction which
4967 sets the stack pointer from an invalid value to a valid value,
4968 we may detect that as a subroutine call from the mythical
4969 "outermost" function. This could be fixed by marking
4970 outermost frames as !stack_p,code_p,special_p. Then the
4971 initial outermost frame, before sp was valid, would
4972 have code_addr == &_start. See the comment in frame_id_eq
4974 if (!frame_id_eq (get_stack_frame_id (frame),
4975 ecs->event_thread->control.step_stack_frame_id)
4976 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
4977 ecs->event_thread->control.step_stack_frame_id)
4978 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
4980 || step_start_function != find_pc_function (stop_pc))))
4982 CORE_ADDR real_stop_pc;
4985 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
4987 if ((ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
4988 || ((ecs->event_thread->control.step_range_end == 1)
4989 && in_prologue (gdbarch, ecs->event_thread->prev_pc,
4990 ecs->stop_func_start)))
4992 /* I presume that step_over_calls is only 0 when we're
4993 supposed to be stepping at the assembly language level
4994 ("stepi"). Just stop. */
4995 /* Also, maybe we just did a "nexti" inside a prolog, so we
4996 thought it was a subroutine call but it was not. Stop as
4998 /* And this works the same backward as frontward. MVS */
4999 end_stepping_range (ecs);
5003 /* Reverse stepping through solib trampolines. */
5005 if (execution_direction == EXEC_REVERSE
5006 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
5007 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5008 || (ecs->stop_func_start == 0
5009 && in_solib_dynsym_resolve_code (stop_pc))))
5011 /* Any solib trampoline code can be handled in reverse
5012 by simply continuing to single-step. We have already
5013 executed the solib function (backwards), and a few
5014 steps will take us back through the trampoline to the
5020 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5022 /* We're doing a "next".
5024 Normal (forward) execution: set a breakpoint at the
5025 callee's return address (the address at which the caller
5028 Reverse (backward) execution. set the step-resume
5029 breakpoint at the start of the function that we just
5030 stepped into (backwards), and continue to there. When we
5031 get there, we'll need to single-step back to the caller. */
5033 if (execution_direction == EXEC_REVERSE)
5035 /* If we're already at the start of the function, we've either
5036 just stepped backward into a single instruction function,
5037 or stepped back out of a signal handler to the first instruction
5038 of the function. Just keep going, which will single-step back
5040 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
5042 struct symtab_and_line sr_sal;
5044 /* Normal function call return (static or dynamic). */
5046 sr_sal.pc = ecs->stop_func_start;
5047 sr_sal.pspace = get_frame_program_space (frame);
5048 insert_step_resume_breakpoint_at_sal (gdbarch,
5049 sr_sal, null_frame_id);
5053 insert_step_resume_breakpoint_at_caller (frame);
5059 /* If we are in a function call trampoline (a stub between the
5060 calling routine and the real function), locate the real
5061 function. That's what tells us (a) whether we want to step
5062 into it at all, and (b) what prologue we want to run to the
5063 end of, if we do step into it. */
5064 real_stop_pc = skip_language_trampoline (frame, stop_pc);
5065 if (real_stop_pc == 0)
5066 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
5067 if (real_stop_pc != 0)
5068 ecs->stop_func_start = real_stop_pc;
5070 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
5072 struct symtab_and_line sr_sal;
5075 sr_sal.pc = ecs->stop_func_start;
5076 sr_sal.pspace = get_frame_program_space (frame);
5078 insert_step_resume_breakpoint_at_sal (gdbarch,
5079 sr_sal, null_frame_id);
5084 /* If we have line number information for the function we are
5085 thinking of stepping into and the function isn't on the skip
5088 If there are several symtabs at that PC (e.g. with include
5089 files), just want to know whether *any* of them have line
5090 numbers. find_pc_line handles this. */
5092 struct symtab_and_line tmp_sal;
5094 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
5095 if (tmp_sal.line != 0
5096 && !function_name_is_marked_for_skip (ecs->stop_func_name,
5099 if (execution_direction == EXEC_REVERSE)
5100 handle_step_into_function_backward (gdbarch, ecs);
5102 handle_step_into_function (gdbarch, ecs);
5107 /* If we have no line number and the step-stop-if-no-debug is
5108 set, we stop the step so that the user has a chance to switch
5109 in assembly mode. */
5110 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5111 && step_stop_if_no_debug)
5113 end_stepping_range (ecs);
5117 if (execution_direction == EXEC_REVERSE)
5119 /* If we're already at the start of the function, we've either just
5120 stepped backward into a single instruction function without line
5121 number info, or stepped back out of a signal handler to the first
5122 instruction of the function without line number info. Just keep
5123 going, which will single-step back to the caller. */
5124 if (ecs->stop_func_start != stop_pc)
5126 /* Set a breakpoint at callee's start address.
5127 From there we can step once and be back in the caller. */
5128 struct symtab_and_line sr_sal;
5131 sr_sal.pc = ecs->stop_func_start;
5132 sr_sal.pspace = get_frame_program_space (frame);
5133 insert_step_resume_breakpoint_at_sal (gdbarch,
5134 sr_sal, null_frame_id);
5138 /* Set a breakpoint at callee's return address (the address
5139 at which the caller will resume). */
5140 insert_step_resume_breakpoint_at_caller (frame);
5146 /* Reverse stepping through solib trampolines. */
5148 if (execution_direction == EXEC_REVERSE
5149 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
5151 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5152 || (ecs->stop_func_start == 0
5153 && in_solib_dynsym_resolve_code (stop_pc)))
5155 /* Any solib trampoline code can be handled in reverse
5156 by simply continuing to single-step. We have already
5157 executed the solib function (backwards), and a few
5158 steps will take us back through the trampoline to the
5163 else if (in_solib_dynsym_resolve_code (stop_pc))
5165 /* Stepped backward into the solib dynsym resolver.
5166 Set a breakpoint at its start and continue, then
5167 one more step will take us out. */
5168 struct symtab_and_line sr_sal;
5171 sr_sal.pc = ecs->stop_func_start;
5172 sr_sal.pspace = get_frame_program_space (frame);
5173 insert_step_resume_breakpoint_at_sal (gdbarch,
5174 sr_sal, null_frame_id);
5180 stop_pc_sal = find_pc_line (stop_pc, 0);
5182 /* NOTE: tausq/2004-05-24: This if block used to be done before all
5183 the trampoline processing logic, however, there are some trampolines
5184 that have no names, so we should do trampoline handling first. */
5185 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5186 && ecs->stop_func_name == NULL
5187 && stop_pc_sal.line == 0)
5190 fprintf_unfiltered (gdb_stdlog,
5191 "infrun: stepped into undebuggable function\n");
5193 /* The inferior just stepped into, or returned to, an
5194 undebuggable function (where there is no debugging information
5195 and no line number corresponding to the address where the
5196 inferior stopped). Since we want to skip this kind of code,
5197 we keep going until the inferior returns from this
5198 function - unless the user has asked us not to (via
5199 set step-mode) or we no longer know how to get back
5200 to the call site. */
5201 if (step_stop_if_no_debug
5202 || !frame_id_p (frame_unwind_caller_id (frame)))
5204 /* If we have no line number and the step-stop-if-no-debug
5205 is set, we stop the step so that the user has a chance to
5206 switch in assembly mode. */
5207 end_stepping_range (ecs);
5212 /* Set a breakpoint at callee's return address (the address
5213 at which the caller will resume). */
5214 insert_step_resume_breakpoint_at_caller (frame);
5220 if (ecs->event_thread->control.step_range_end == 1)
5222 /* It is stepi or nexti. We always want to stop stepping after
5225 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
5226 end_stepping_range (ecs);
5230 if (stop_pc_sal.line == 0)
5232 /* We have no line number information. That means to stop
5233 stepping (does this always happen right after one instruction,
5234 when we do "s" in a function with no line numbers,
5235 or can this happen as a result of a return or longjmp?). */
5237 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
5238 end_stepping_range (ecs);
5242 /* Look for "calls" to inlined functions, part one. If the inline
5243 frame machinery detected some skipped call sites, we have entered
5244 a new inline function. */
5246 if (frame_id_eq (get_frame_id (get_current_frame ()),
5247 ecs->event_thread->control.step_frame_id)
5248 && inline_skipped_frames (ecs->ptid))
5250 struct symtab_and_line call_sal;
5253 fprintf_unfiltered (gdb_stdlog,
5254 "infrun: stepped into inlined function\n");
5256 find_frame_sal (get_current_frame (), &call_sal);
5258 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
5260 /* For "step", we're going to stop. But if the call site
5261 for this inlined function is on the same source line as
5262 we were previously stepping, go down into the function
5263 first. Otherwise stop at the call site. */
5265 if (call_sal.line == ecs->event_thread->current_line
5266 && call_sal.symtab == ecs->event_thread->current_symtab)
5267 step_into_inline_frame (ecs->ptid);
5269 end_stepping_range (ecs);
5274 /* For "next", we should stop at the call site if it is on a
5275 different source line. Otherwise continue through the
5276 inlined function. */
5277 if (call_sal.line == ecs->event_thread->current_line
5278 && call_sal.symtab == ecs->event_thread->current_symtab)
5281 end_stepping_range (ecs);
5286 /* Look for "calls" to inlined functions, part two. If we are still
5287 in the same real function we were stepping through, but we have
5288 to go further up to find the exact frame ID, we are stepping
5289 through a more inlined call beyond its call site. */
5291 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
5292 && !frame_id_eq (get_frame_id (get_current_frame ()),
5293 ecs->event_thread->control.step_frame_id)
5294 && stepped_in_from (get_current_frame (),
5295 ecs->event_thread->control.step_frame_id))
5298 fprintf_unfiltered (gdb_stdlog,
5299 "infrun: stepping through inlined function\n");
5301 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5304 end_stepping_range (ecs);
5308 if ((stop_pc == stop_pc_sal.pc)
5309 && (ecs->event_thread->current_line != stop_pc_sal.line
5310 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
5312 /* We are at the start of a different line. So stop. Note that
5313 we don't stop if we step into the middle of a different line.
5314 That is said to make things like for (;;) statements work
5317 fprintf_unfiltered (gdb_stdlog,
5318 "infrun: stepped to a different line\n");
5319 end_stepping_range (ecs);
5323 /* We aren't done stepping.
5325 Optimize by setting the stepping range to the line.
5326 (We might not be in the original line, but if we entered a
5327 new line in mid-statement, we continue stepping. This makes
5328 things like for(;;) statements work better.) */
5330 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
5331 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
5332 ecs->event_thread->control.may_range_step = 1;
5333 set_step_info (frame, stop_pc_sal);
5336 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
5340 /* In all-stop mode, if we're currently stepping but have stopped in
5341 some other thread, we may need to switch back to the stepped
5342 thread. Returns true we set the inferior running, false if we left
5343 it stopped (and the event needs further processing). */
5346 switch_back_to_stepped_thread (struct execution_control_state *ecs)
5350 struct thread_info *tp;
5351 struct thread_info *stepping_thread;
5352 struct thread_info *step_over;
5354 /* If any thread is blocked on some internal breakpoint, and we
5355 simply need to step over that breakpoint to get it going
5356 again, do that first. */
5358 /* However, if we see an event for the stepping thread, then we
5359 know all other threads have been moved past their breakpoints
5360 already. Let the caller check whether the step is finished,
5361 etc., before deciding to move it past a breakpoint. */
5362 if (ecs->event_thread->control.step_range_end != 0)
5365 /* Check if the current thread is blocked on an incomplete
5366 step-over, interrupted by a random signal. */
5367 if (ecs->event_thread->control.trap_expected
5368 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5372 fprintf_unfiltered (gdb_stdlog,
5373 "infrun: need to finish step-over of [%s]\n",
5374 target_pid_to_str (ecs->event_thread->ptid));
5380 /* Check if the current thread is blocked by a single-step
5381 breakpoint of another thread. */
5382 if (ecs->hit_singlestep_breakpoint)
5386 fprintf_unfiltered (gdb_stdlog,
5387 "infrun: need to step [%s] over single-step "
5389 target_pid_to_str (ecs->ptid));
5395 /* Otherwise, we no longer expect a trap in the current thread.
5396 Clear the trap_expected flag before switching back -- this is
5397 what keep_going does as well, if we call it. */
5398 ecs->event_thread->control.trap_expected = 0;
5400 /* Likewise, clear the signal if it should not be passed. */
5401 if (!signal_program[ecs->event_thread->suspend.stop_signal])
5402 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5404 /* If scheduler locking applies even if not stepping, there's no
5405 need to walk over threads. Above we've checked whether the
5406 current thread is stepping. If some other thread not the
5407 event thread is stepping, then it must be that scheduler
5408 locking is not in effect. */
5409 if (schedlock_applies (0))
5412 /* Look for the stepping/nexting thread, and check if any other
5413 thread other than the stepping thread needs to start a
5414 step-over. Do all step-overs before actually proceeding with
5416 stepping_thread = NULL;
5418 ALL_NON_EXITED_THREADS (tp)
5420 /* Ignore threads of processes we're not resuming. */
5422 && ptid_get_pid (tp->ptid) != ptid_get_pid (inferior_ptid))
5425 /* When stepping over a breakpoint, we lock all threads
5426 except the one that needs to move past the breakpoint.
5427 If a non-event thread has this set, the "incomplete
5428 step-over" check above should have caught it earlier. */
5429 gdb_assert (!tp->control.trap_expected);
5431 /* Did we find the stepping thread? */
5432 if (tp->control.step_range_end)
5434 /* Yep. There should only one though. */
5435 gdb_assert (stepping_thread == NULL);
5437 /* The event thread is handled at the top, before we
5439 gdb_assert (tp != ecs->event_thread);
5441 /* If some thread other than the event thread is
5442 stepping, then scheduler locking can't be in effect,
5443 otherwise we wouldn't have resumed the current event
5444 thread in the first place. */
5445 gdb_assert (!schedlock_applies (1));
5447 stepping_thread = tp;
5449 else if (thread_still_needs_step_over (tp))
5453 /* At the top we've returned early if the event thread
5454 is stepping. If some other thread not the event
5455 thread is stepping, then scheduler locking can't be
5456 in effect, and we can resume this thread. No need to
5457 keep looking for the stepping thread then. */
5462 if (step_over != NULL)
5467 fprintf_unfiltered (gdb_stdlog,
5468 "infrun: need to step-over [%s]\n",
5469 target_pid_to_str (tp->ptid));
5472 /* Only the stepping thread should have this set. */
5473 gdb_assert (tp->control.step_range_end == 0);
5475 ecs->ptid = tp->ptid;
5476 ecs->event_thread = tp;
5477 switch_to_thread (ecs->ptid);
5482 if (stepping_thread != NULL)
5484 struct frame_info *frame;
5485 struct gdbarch *gdbarch;
5487 tp = stepping_thread;
5489 /* If the stepping thread exited, then don't try to switch
5490 back and resume it, which could fail in several different
5491 ways depending on the target. Instead, just keep going.
5493 We can find a stepping dead thread in the thread list in
5496 - The target supports thread exit events, and when the
5497 target tries to delete the thread from the thread list,
5498 inferior_ptid pointed at the exiting thread. In such
5499 case, calling delete_thread does not really remove the
5500 thread from the list; instead, the thread is left listed,
5501 with 'exited' state.
5503 - The target's debug interface does not support thread
5504 exit events, and so we have no idea whatsoever if the
5505 previously stepping thread is still alive. For that
5506 reason, we need to synchronously query the target
5508 if (is_exited (tp->ptid)
5509 || !target_thread_alive (tp->ptid))
5512 fprintf_unfiltered (gdb_stdlog,
5513 "infrun: not switching back to "
5514 "stepped thread, it has vanished\n");
5516 delete_thread (tp->ptid);
5522 fprintf_unfiltered (gdb_stdlog,
5523 "infrun: switching back to stepped thread\n");
5525 ecs->event_thread = tp;
5526 ecs->ptid = tp->ptid;
5527 context_switch (ecs->ptid);
5529 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5530 frame = get_current_frame ();
5531 gdbarch = get_frame_arch (frame);
5533 /* If the PC of the thread we were trying to single-step has
5534 changed, then that thread has trapped or been signaled,
5535 but the event has not been reported to GDB yet. Re-poll
5536 the target looking for this particular thread's event
5537 (i.e. temporarily enable schedlock) by:
5539 - setting a break at the current PC
5540 - resuming that particular thread, only (by setting
5543 This prevents us continuously moving the single-step
5544 breakpoint forward, one instruction at a time,
5547 if (gdbarch_software_single_step_p (gdbarch)
5548 && stop_pc != tp->prev_pc)
5551 fprintf_unfiltered (gdb_stdlog,
5552 "infrun: expected thread advanced also\n");
5554 insert_single_step_breakpoint (get_frame_arch (frame),
5555 get_frame_address_space (frame),
5557 singlestep_breakpoints_inserted_p = 1;
5558 ecs->event_thread->control.trap_expected = 1;
5559 singlestep_ptid = inferior_ptid;
5560 singlestep_pc = stop_pc;
5562 resume (0, GDB_SIGNAL_0);
5563 prepare_to_wait (ecs);
5568 fprintf_unfiltered (gdb_stdlog,
5569 "infrun: expected thread still "
5570 "hasn't advanced\n");
5580 /* Is thread TP in the middle of single-stepping? */
5583 currently_stepping (struct thread_info *tp)
5585 return ((tp->control.step_range_end
5586 && tp->control.step_resume_breakpoint == NULL)
5587 || tp->control.trap_expected
5588 || bpstat_should_step ());
5591 /* Inferior has stepped into a subroutine call with source code that
5592 we should not step over. Do step to the first line of code in
5596 handle_step_into_function (struct gdbarch *gdbarch,
5597 struct execution_control_state *ecs)
5600 struct symtab_and_line stop_func_sal, sr_sal;
5602 fill_in_stop_func (gdbarch, ecs);
5604 s = find_pc_symtab (stop_pc);
5605 if (s && s->language != language_asm)
5606 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5607 ecs->stop_func_start);
5609 stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
5610 /* Use the step_resume_break to step until the end of the prologue,
5611 even if that involves jumps (as it seems to on the vax under
5613 /* If the prologue ends in the middle of a source line, continue to
5614 the end of that source line (if it is still within the function).
5615 Otherwise, just go to end of prologue. */
5616 if (stop_func_sal.end
5617 && stop_func_sal.pc != ecs->stop_func_start
5618 && stop_func_sal.end < ecs->stop_func_end)
5619 ecs->stop_func_start = stop_func_sal.end;
5621 /* Architectures which require breakpoint adjustment might not be able
5622 to place a breakpoint at the computed address. If so, the test
5623 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
5624 ecs->stop_func_start to an address at which a breakpoint may be
5625 legitimately placed.
5627 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
5628 made, GDB will enter an infinite loop when stepping through
5629 optimized code consisting of VLIW instructions which contain
5630 subinstructions corresponding to different source lines. On
5631 FR-V, it's not permitted to place a breakpoint on any but the
5632 first subinstruction of a VLIW instruction. When a breakpoint is
5633 set, GDB will adjust the breakpoint address to the beginning of
5634 the VLIW instruction. Thus, we need to make the corresponding
5635 adjustment here when computing the stop address. */
5637 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
5639 ecs->stop_func_start
5640 = gdbarch_adjust_breakpoint_address (gdbarch,
5641 ecs->stop_func_start);
5644 if (ecs->stop_func_start == stop_pc)
5646 /* We are already there: stop now. */
5647 end_stepping_range (ecs);
5652 /* Put the step-breakpoint there and go until there. */
5653 init_sal (&sr_sal); /* initialize to zeroes */
5654 sr_sal.pc = ecs->stop_func_start;
5655 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
5656 sr_sal.pspace = get_frame_program_space (get_current_frame ());
5658 /* Do not specify what the fp should be when we stop since on
5659 some machines the prologue is where the new fp value is
5661 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
5663 /* And make sure stepping stops right away then. */
5664 ecs->event_thread->control.step_range_end
5665 = ecs->event_thread->control.step_range_start;
5670 /* Inferior has stepped backward into a subroutine call with source
5671 code that we should not step over. Do step to the beginning of the
5672 last line of code in it. */
5675 handle_step_into_function_backward (struct gdbarch *gdbarch,
5676 struct execution_control_state *ecs)
5679 struct symtab_and_line stop_func_sal;
5681 fill_in_stop_func (gdbarch, ecs);
5683 s = find_pc_symtab (stop_pc);
5684 if (s && s->language != language_asm)
5685 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5686 ecs->stop_func_start);
5688 stop_func_sal = find_pc_line (stop_pc, 0);
5690 /* OK, we're just going to keep stepping here. */
5691 if (stop_func_sal.pc == stop_pc)
5693 /* We're there already. Just stop stepping now. */
5694 end_stepping_range (ecs);
5698 /* Else just reset the step range and keep going.
5699 No step-resume breakpoint, they don't work for
5700 epilogues, which can have multiple entry paths. */
5701 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
5702 ecs->event_thread->control.step_range_end = stop_func_sal.end;
5708 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
5709 This is used to both functions and to skip over code. */
5712 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
5713 struct symtab_and_line sr_sal,
5714 struct frame_id sr_id,
5715 enum bptype sr_type)
5717 /* There should never be more than one step-resume or longjmp-resume
5718 breakpoint per thread, so we should never be setting a new
5719 step_resume_breakpoint when one is already active. */
5720 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
5721 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
5724 fprintf_unfiltered (gdb_stdlog,
5725 "infrun: inserting step-resume breakpoint at %s\n",
5726 paddress (gdbarch, sr_sal.pc));
5728 inferior_thread ()->control.step_resume_breakpoint
5729 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
5733 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
5734 struct symtab_and_line sr_sal,
5735 struct frame_id sr_id)
5737 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
5742 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
5743 This is used to skip a potential signal handler.
5745 This is called with the interrupted function's frame. The signal
5746 handler, when it returns, will resume the interrupted function at
5750 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
5752 struct symtab_and_line sr_sal;
5753 struct gdbarch *gdbarch;
5755 gdb_assert (return_frame != NULL);
5756 init_sal (&sr_sal); /* initialize to zeros */
5758 gdbarch = get_frame_arch (return_frame);
5759 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
5760 sr_sal.section = find_pc_overlay (sr_sal.pc);
5761 sr_sal.pspace = get_frame_program_space (return_frame);
5763 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
5764 get_stack_frame_id (return_frame),
5768 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
5769 is used to skip a function after stepping into it (for "next" or if
5770 the called function has no debugging information).
5772 The current function has almost always been reached by single
5773 stepping a call or return instruction. NEXT_FRAME belongs to the
5774 current function, and the breakpoint will be set at the caller's
5777 This is a separate function rather than reusing
5778 insert_hp_step_resume_breakpoint_at_frame in order to avoid
5779 get_prev_frame, which may stop prematurely (see the implementation
5780 of frame_unwind_caller_id for an example). */
5783 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
5785 struct symtab_and_line sr_sal;
5786 struct gdbarch *gdbarch;
5788 /* We shouldn't have gotten here if we don't know where the call site
5790 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
5792 init_sal (&sr_sal); /* initialize to zeros */
5794 gdbarch = frame_unwind_caller_arch (next_frame);
5795 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
5796 frame_unwind_caller_pc (next_frame));
5797 sr_sal.section = find_pc_overlay (sr_sal.pc);
5798 sr_sal.pspace = frame_unwind_program_space (next_frame);
5800 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
5801 frame_unwind_caller_id (next_frame));
5804 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
5805 new breakpoint at the target of a jmp_buf. The handling of
5806 longjmp-resume uses the same mechanisms used for handling
5807 "step-resume" breakpoints. */
5810 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
5812 /* There should never be more than one longjmp-resume breakpoint per
5813 thread, so we should never be setting a new
5814 longjmp_resume_breakpoint when one is already active. */
5815 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
5818 fprintf_unfiltered (gdb_stdlog,
5819 "infrun: inserting longjmp-resume breakpoint at %s\n",
5820 paddress (gdbarch, pc));
5822 inferior_thread ()->control.exception_resume_breakpoint =
5823 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
5826 /* Insert an exception resume breakpoint. TP is the thread throwing
5827 the exception. The block B is the block of the unwinder debug hook
5828 function. FRAME is the frame corresponding to the call to this
5829 function. SYM is the symbol of the function argument holding the
5830 target PC of the exception. */
5833 insert_exception_resume_breakpoint (struct thread_info *tp,
5834 const struct block *b,
5835 struct frame_info *frame,
5838 volatile struct gdb_exception e;
5840 /* We want to ignore errors here. */
5841 TRY_CATCH (e, RETURN_MASK_ERROR)
5843 struct symbol *vsym;
5844 struct value *value;
5846 struct breakpoint *bp;
5848 vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
5849 value = read_var_value (vsym, frame);
5850 /* If the value was optimized out, revert to the old behavior. */
5851 if (! value_optimized_out (value))
5853 handler = value_as_address (value);
5856 fprintf_unfiltered (gdb_stdlog,
5857 "infrun: exception resume at %lx\n",
5858 (unsigned long) handler);
5860 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5861 handler, bp_exception_resume);
5863 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
5866 bp->thread = tp->num;
5867 inferior_thread ()->control.exception_resume_breakpoint = bp;
5872 /* A helper for check_exception_resume that sets an
5873 exception-breakpoint based on a SystemTap probe. */
5876 insert_exception_resume_from_probe (struct thread_info *tp,
5877 const struct bound_probe *probe,
5878 struct frame_info *frame)
5880 struct value *arg_value;
5882 struct breakpoint *bp;
5884 arg_value = probe_safe_evaluate_at_pc (frame, 1);
5888 handler = value_as_address (arg_value);
5891 fprintf_unfiltered (gdb_stdlog,
5892 "infrun: exception resume at %s\n",
5893 paddress (get_objfile_arch (probe->objfile),
5896 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5897 handler, bp_exception_resume);
5898 bp->thread = tp->num;
5899 inferior_thread ()->control.exception_resume_breakpoint = bp;
5902 /* This is called when an exception has been intercepted. Check to
5903 see whether the exception's destination is of interest, and if so,
5904 set an exception resume breakpoint there. */
5907 check_exception_resume (struct execution_control_state *ecs,
5908 struct frame_info *frame)
5910 volatile struct gdb_exception e;
5911 struct bound_probe probe;
5912 struct symbol *func;
5914 /* First see if this exception unwinding breakpoint was set via a
5915 SystemTap probe point. If so, the probe has two arguments: the
5916 CFA and the HANDLER. We ignore the CFA, extract the handler, and
5917 set a breakpoint there. */
5918 probe = find_probe_by_pc (get_frame_pc (frame));
5921 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
5925 func = get_frame_function (frame);
5929 TRY_CATCH (e, RETURN_MASK_ERROR)
5931 const struct block *b;
5932 struct block_iterator iter;
5936 /* The exception breakpoint is a thread-specific breakpoint on
5937 the unwinder's debug hook, declared as:
5939 void _Unwind_DebugHook (void *cfa, void *handler);
5941 The CFA argument indicates the frame to which control is
5942 about to be transferred. HANDLER is the destination PC.
5944 We ignore the CFA and set a temporary breakpoint at HANDLER.
5945 This is not extremely efficient but it avoids issues in gdb
5946 with computing the DWARF CFA, and it also works even in weird
5947 cases such as throwing an exception from inside a signal
5950 b = SYMBOL_BLOCK_VALUE (func);
5951 ALL_BLOCK_SYMBOLS (b, iter, sym)
5953 if (!SYMBOL_IS_ARGUMENT (sym))
5960 insert_exception_resume_breakpoint (ecs->event_thread,
5969 stop_waiting (struct execution_control_state *ecs)
5972 fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
5974 clear_step_over_info ();
5976 /* Let callers know we don't want to wait for the inferior anymore. */
5977 ecs->wait_some_more = 0;
5980 /* Called when we should continue running the inferior, because the
5981 current event doesn't cause a user visible stop. This does the
5982 resuming part; waiting for the next event is done elsewhere. */
5985 keep_going (struct execution_control_state *ecs)
5987 /* Make sure normal_stop is called if we get a QUIT handled before
5989 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
5991 /* Save the pc before execution, to compare with pc after stop. */
5992 ecs->event_thread->prev_pc
5993 = regcache_read_pc (get_thread_regcache (ecs->ptid));
5995 if (ecs->event_thread->control.trap_expected
5996 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5998 /* We haven't yet gotten our trap, and either: intercepted a
5999 non-signal event (e.g., a fork); or took a signal which we
6000 are supposed to pass through to the inferior. Simply
6002 discard_cleanups (old_cleanups);
6003 resume (currently_stepping (ecs->event_thread),
6004 ecs->event_thread->suspend.stop_signal);
6008 volatile struct gdb_exception e;
6009 struct regcache *regcache = get_current_regcache ();
6011 /* Either the trap was not expected, but we are continuing
6012 anyway (if we got a signal, the user asked it be passed to
6015 We got our expected trap, but decided we should resume from
6018 We're going to run this baby now!
6020 Note that insert_breakpoints won't try to re-insert
6021 already inserted breakpoints. Therefore, we don't
6022 care if breakpoints were already inserted, or not. */
6024 /* If we need to step over a breakpoint, and we're not using
6025 displaced stepping to do so, insert all breakpoints
6026 (watchpoints, etc.) but the one we're stepping over, step one
6027 instruction, and then re-insert the breakpoint when that step
6029 if ((ecs->hit_singlestep_breakpoint
6030 || thread_still_needs_step_over (ecs->event_thread))
6031 && !use_displaced_stepping (get_regcache_arch (regcache)))
6033 set_step_over_info (get_regcache_aspace (regcache),
6034 regcache_read_pc (regcache));
6037 clear_step_over_info ();
6039 /* Stop stepping if inserting breakpoints fails. */
6040 TRY_CATCH (e, RETURN_MASK_ERROR)
6042 insert_breakpoints ();
6046 exception_print (gdb_stderr, e);
6051 ecs->event_thread->control.trap_expected
6052 = (ecs->event_thread->stepping_over_breakpoint
6053 || ecs->hit_singlestep_breakpoint);
6055 /* Do not deliver GDB_SIGNAL_TRAP (except when the user
6056 explicitly specifies that such a signal should be delivered
6057 to the target program). Typically, that would occur when a
6058 user is debugging a target monitor on a simulator: the target
6059 monitor sets a breakpoint; the simulator encounters this
6060 breakpoint and halts the simulation handing control to GDB;
6061 GDB, noting that the stop address doesn't map to any known
6062 breakpoint, returns control back to the simulator; the
6063 simulator then delivers the hardware equivalent of a
6064 GDB_SIGNAL_TRAP to the program being debugged. */
6065 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6066 && !signal_program[ecs->event_thread->suspend.stop_signal])
6067 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6069 discard_cleanups (old_cleanups);
6070 resume (currently_stepping (ecs->event_thread),
6071 ecs->event_thread->suspend.stop_signal);
6074 prepare_to_wait (ecs);
6077 /* This function normally comes after a resume, before
6078 handle_inferior_event exits. It takes care of any last bits of
6079 housekeeping, and sets the all-important wait_some_more flag. */
6082 prepare_to_wait (struct execution_control_state *ecs)
6085 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
6087 /* This is the old end of the while loop. Let everybody know we
6088 want to wait for the inferior some more and get called again
6090 ecs->wait_some_more = 1;
6093 /* We are done with the step range of a step/next/si/ni command.
6094 Called once for each n of a "step n" operation. */
6097 end_stepping_range (struct execution_control_state *ecs)
6099 ecs->event_thread->control.stop_step = 1;
6103 /* Several print_*_reason functions to print why the inferior has stopped.
6104 We always print something when the inferior exits, or receives a signal.
6105 The rest of the cases are dealt with later on in normal_stop and
6106 print_it_typical. Ideally there should be a call to one of these
6107 print_*_reason functions functions from handle_inferior_event each time
6108 stop_waiting is called.
6110 Note that we don't call these directly, instead we delegate that to
6111 the interpreters, through observers. Interpreters then call these
6112 with whatever uiout is right. */
6115 print_end_stepping_range_reason (struct ui_out *uiout)
6117 /* For CLI-like interpreters, print nothing. */
6119 if (ui_out_is_mi_like_p (uiout))
6121 ui_out_field_string (uiout, "reason",
6122 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
6127 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6129 annotate_signalled ();
6130 if (ui_out_is_mi_like_p (uiout))
6132 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
6133 ui_out_text (uiout, "\nProgram terminated with signal ");
6134 annotate_signal_name ();
6135 ui_out_field_string (uiout, "signal-name",
6136 gdb_signal_to_name (siggnal));
6137 annotate_signal_name_end ();
6138 ui_out_text (uiout, ", ");
6139 annotate_signal_string ();
6140 ui_out_field_string (uiout, "signal-meaning",
6141 gdb_signal_to_string (siggnal));
6142 annotate_signal_string_end ();
6143 ui_out_text (uiout, ".\n");
6144 ui_out_text (uiout, "The program no longer exists.\n");
6148 print_exited_reason (struct ui_out *uiout, int exitstatus)
6150 struct inferior *inf = current_inferior ();
6151 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
6153 annotate_exited (exitstatus);
6156 if (ui_out_is_mi_like_p (uiout))
6157 ui_out_field_string (uiout, "reason",
6158 async_reason_lookup (EXEC_ASYNC_EXITED));
6159 ui_out_text (uiout, "[Inferior ");
6160 ui_out_text (uiout, plongest (inf->num));
6161 ui_out_text (uiout, " (");
6162 ui_out_text (uiout, pidstr);
6163 ui_out_text (uiout, ") exited with code ");
6164 ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
6165 ui_out_text (uiout, "]\n");
6169 if (ui_out_is_mi_like_p (uiout))
6171 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
6172 ui_out_text (uiout, "[Inferior ");
6173 ui_out_text (uiout, plongest (inf->num));
6174 ui_out_text (uiout, " (");
6175 ui_out_text (uiout, pidstr);
6176 ui_out_text (uiout, ") exited normally]\n");
6181 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6185 if (siggnal == GDB_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
6187 struct thread_info *t = inferior_thread ();
6189 ui_out_text (uiout, "\n[");
6190 ui_out_field_string (uiout, "thread-name",
6191 target_pid_to_str (t->ptid));
6192 ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
6193 ui_out_text (uiout, " stopped");
6197 ui_out_text (uiout, "\nProgram received signal ");
6198 annotate_signal_name ();
6199 if (ui_out_is_mi_like_p (uiout))
6201 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
6202 ui_out_field_string (uiout, "signal-name",
6203 gdb_signal_to_name (siggnal));
6204 annotate_signal_name_end ();
6205 ui_out_text (uiout, ", ");
6206 annotate_signal_string ();
6207 ui_out_field_string (uiout, "signal-meaning",
6208 gdb_signal_to_string (siggnal));
6209 annotate_signal_string_end ();
6211 ui_out_text (uiout, ".\n");
6215 print_no_history_reason (struct ui_out *uiout)
6217 ui_out_text (uiout, "\nNo more reverse-execution history.\n");
6220 /* Print current location without a level number, if we have changed
6221 functions or hit a breakpoint. Print source line if we have one.
6222 bpstat_print contains the logic deciding in detail what to print,
6223 based on the event(s) that just occurred. */
6226 print_stop_event (struct target_waitstatus *ws)
6230 int do_frame_printing = 1;
6231 struct thread_info *tp = inferior_thread ();
6233 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
6237 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
6238 should) carry around the function and does (or should) use
6239 that when doing a frame comparison. */
6240 if (tp->control.stop_step
6241 && frame_id_eq (tp->control.step_frame_id,
6242 get_frame_id (get_current_frame ()))
6243 && step_start_function == find_pc_function (stop_pc))
6245 /* Finished step, just print source line. */
6246 source_flag = SRC_LINE;
6250 /* Print location and source line. */
6251 source_flag = SRC_AND_LOC;
6254 case PRINT_SRC_AND_LOC:
6255 /* Print location and source line. */
6256 source_flag = SRC_AND_LOC;
6258 case PRINT_SRC_ONLY:
6259 source_flag = SRC_LINE;
6262 /* Something bogus. */
6263 source_flag = SRC_LINE;
6264 do_frame_printing = 0;
6267 internal_error (__FILE__, __LINE__, _("Unknown value."));
6270 /* The behavior of this routine with respect to the source
6272 SRC_LINE: Print only source line
6273 LOCATION: Print only location
6274 SRC_AND_LOC: Print location and source line. */
6275 if (do_frame_printing)
6276 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
6278 /* Display the auto-display expressions. */
6282 /* Here to return control to GDB when the inferior stops for real.
6283 Print appropriate messages, remove breakpoints, give terminal our modes.
6285 STOP_PRINT_FRAME nonzero means print the executing frame
6286 (pc, function, args, file, line number and line text).
6287 BREAKPOINTS_FAILED nonzero means stop was due to error
6288 attempting to insert breakpoints. */
6293 struct target_waitstatus last;
6295 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
6297 get_last_target_status (&last_ptid, &last);
6299 /* If an exception is thrown from this point on, make sure to
6300 propagate GDB's knowledge of the executing state to the
6301 frontend/user running state. A QUIT is an easy exception to see
6302 here, so do this before any filtered output. */
6304 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
6305 else if (last.kind != TARGET_WAITKIND_SIGNALLED
6306 && last.kind != TARGET_WAITKIND_EXITED
6307 && last.kind != TARGET_WAITKIND_NO_RESUMED)
6308 make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
6310 /* As we're presenting a stop, and potentially removing breakpoints,
6311 update the thread list so we can tell whether there are threads
6312 running on the target. With target remote, for example, we can
6313 only learn about new threads when we explicitly update the thread
6314 list. Do this before notifying the interpreters about signal
6315 stops, end of stepping ranges, etc., so that the "new thread"
6316 output is emitted before e.g., "Program received signal FOO",
6317 instead of after. */
6318 update_thread_list ();
6320 if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
6321 observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
6323 /* As with the notification of thread events, we want to delay
6324 notifying the user that we've switched thread context until
6325 the inferior actually stops.
6327 There's no point in saying anything if the inferior has exited.
6328 Note that SIGNALLED here means "exited with a signal", not
6329 "received a signal".
6331 Also skip saying anything in non-stop mode. In that mode, as we
6332 don't want GDB to switch threads behind the user's back, to avoid
6333 races where the user is typing a command to apply to thread x,
6334 but GDB switches to thread y before the user finishes entering
6335 the command, fetch_inferior_event installs a cleanup to restore
6336 the current thread back to the thread the user had selected right
6337 after this event is handled, so we're not really switching, only
6338 informing of a stop. */
6340 && !ptid_equal (previous_inferior_ptid, inferior_ptid)
6341 && target_has_execution
6342 && last.kind != TARGET_WAITKIND_SIGNALLED
6343 && last.kind != TARGET_WAITKIND_EXITED
6344 && last.kind != TARGET_WAITKIND_NO_RESUMED)
6346 target_terminal_ours_for_output ();
6347 printf_filtered (_("[Switching to %s]\n"),
6348 target_pid_to_str (inferior_ptid));
6349 annotate_thread_changed ();
6350 previous_inferior_ptid = inferior_ptid;
6353 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
6355 gdb_assert (sync_execution || !target_can_async_p ());
6357 target_terminal_ours_for_output ();
6358 printf_filtered (_("No unwaited-for children left.\n"));
6361 /* Note: this depends on the update_thread_list call above. */
6362 if (!breakpoints_should_be_inserted_now () && target_has_execution)
6364 if (remove_breakpoints ())
6366 target_terminal_ours_for_output ();
6367 printf_filtered (_("Cannot remove breakpoints because "
6368 "program is no longer writable.\nFurther "
6369 "execution is probably impossible.\n"));
6373 /* If an auto-display called a function and that got a signal,
6374 delete that auto-display to avoid an infinite recursion. */
6376 if (stopped_by_random_signal)
6377 disable_current_display ();
6379 /* Notify observers if we finished a "step"-like command, etc. */
6380 if (target_has_execution
6381 && last.kind != TARGET_WAITKIND_SIGNALLED
6382 && last.kind != TARGET_WAITKIND_EXITED
6383 && inferior_thread ()->control.stop_step)
6385 /* But not if if in the middle of doing a "step n" operation for
6387 if (inferior_thread ()->step_multi)
6390 observer_notify_end_stepping_range ();
6393 target_terminal_ours ();
6394 async_enable_stdin ();
6396 /* Set the current source location. This will also happen if we
6397 display the frame below, but the current SAL will be incorrect
6398 during a user hook-stop function. */
6399 if (has_stack_frames () && !stop_stack_dummy)
6400 set_current_sal_from_frame (get_current_frame ());
6402 /* Let the user/frontend see the threads as stopped, but do nothing
6403 if the thread was running an infcall. We may be e.g., evaluating
6404 a breakpoint condition. In that case, the thread had state
6405 THREAD_RUNNING before the infcall, and shall remain set to
6406 running, all without informing the user/frontend about state
6407 transition changes. If this is actually a call command, then the
6408 thread was originally already stopped, so there's no state to
6410 if (target_has_execution && inferior_thread ()->control.in_infcall)
6411 discard_cleanups (old_chain);
6413 do_cleanups (old_chain);
6415 /* Look up the hook_stop and run it (CLI internally handles problem
6416 of stop_command's pre-hook not existing). */
6418 catch_errors (hook_stop_stub, stop_command,
6419 "Error while running hook_stop:\n", RETURN_MASK_ALL);
6421 if (!has_stack_frames ())
6424 if (last.kind == TARGET_WAITKIND_SIGNALLED
6425 || last.kind == TARGET_WAITKIND_EXITED)
6428 /* Select innermost stack frame - i.e., current frame is frame 0,
6429 and current location is based on that.
6430 Don't do this on return from a stack dummy routine,
6431 or if the program has exited. */
6433 if (!stop_stack_dummy)
6435 select_frame (get_current_frame ());
6437 /* If --batch-silent is enabled then there's no need to print the current
6438 source location, and to try risks causing an error message about
6439 missing source files. */
6440 if (stop_print_frame && !batch_silent)
6441 print_stop_event (&last);
6444 /* Save the function value return registers, if we care.
6445 We might be about to restore their previous contents. */
6446 if (inferior_thread ()->control.proceed_to_finish
6447 && execution_direction != EXEC_REVERSE)
6449 /* This should not be necessary. */
6451 regcache_xfree (stop_registers);
6453 /* NB: The copy goes through to the target picking up the value of
6454 all the registers. */
6455 stop_registers = regcache_dup (get_current_regcache ());
6458 if (stop_stack_dummy == STOP_STACK_DUMMY)
6460 /* Pop the empty frame that contains the stack dummy.
6461 This also restores inferior state prior to the call
6462 (struct infcall_suspend_state). */
6463 struct frame_info *frame = get_current_frame ();
6465 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
6467 /* frame_pop() calls reinit_frame_cache as the last thing it
6468 does which means there's currently no selected frame. We
6469 don't need to re-establish a selected frame if the dummy call
6470 returns normally, that will be done by
6471 restore_infcall_control_state. However, we do have to handle
6472 the case where the dummy call is returning after being
6473 stopped (e.g. the dummy call previously hit a breakpoint).
6474 We can't know which case we have so just always re-establish
6475 a selected frame here. */
6476 select_frame (get_current_frame ());
6480 annotate_stopped ();
6482 /* Suppress the stop observer if we're in the middle of:
6484 - a step n (n > 1), as there still more steps to be done.
6486 - a "finish" command, as the observer will be called in
6487 finish_command_continuation, so it can include the inferior
6488 function's return value.
6490 - calling an inferior function, as we pretend we inferior didn't
6491 run at all. The return value of the call is handled by the
6492 expression evaluator, through call_function_by_hand. */
6494 if (!target_has_execution
6495 || last.kind == TARGET_WAITKIND_SIGNALLED
6496 || last.kind == TARGET_WAITKIND_EXITED
6497 || last.kind == TARGET_WAITKIND_NO_RESUMED
6498 || (!(inferior_thread ()->step_multi
6499 && inferior_thread ()->control.stop_step)
6500 && !(inferior_thread ()->control.stop_bpstat
6501 && inferior_thread ()->control.proceed_to_finish)
6502 && !inferior_thread ()->control.in_infcall))
6504 if (!ptid_equal (inferior_ptid, null_ptid))
6505 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
6508 observer_notify_normal_stop (NULL, stop_print_frame);
6511 if (target_has_execution)
6513 if (last.kind != TARGET_WAITKIND_SIGNALLED
6514 && last.kind != TARGET_WAITKIND_EXITED)
6515 /* Delete the breakpoint we stopped at, if it wants to be deleted.
6516 Delete any breakpoint that is to be deleted at the next stop. */
6517 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
6520 /* Try to get rid of automatically added inferiors that are no
6521 longer needed. Keeping those around slows down things linearly.
6522 Note that this never removes the current inferior. */
6527 hook_stop_stub (void *cmd)
6529 execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
6534 signal_stop_state (int signo)
6536 return signal_stop[signo];
6540 signal_print_state (int signo)
6542 return signal_print[signo];
6546 signal_pass_state (int signo)
6548 return signal_program[signo];
6552 signal_cache_update (int signo)
6556 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
6557 signal_cache_update (signo);
6562 signal_pass[signo] = (signal_stop[signo] == 0
6563 && signal_print[signo] == 0
6564 && signal_program[signo] == 1
6565 && signal_catch[signo] == 0);
6569 signal_stop_update (int signo, int state)
6571 int ret = signal_stop[signo];
6573 signal_stop[signo] = state;
6574 signal_cache_update (signo);
6579 signal_print_update (int signo, int state)
6581 int ret = signal_print[signo];
6583 signal_print[signo] = state;
6584 signal_cache_update (signo);
6589 signal_pass_update (int signo, int state)
6591 int ret = signal_program[signo];
6593 signal_program[signo] = state;
6594 signal_cache_update (signo);
6598 /* Update the global 'signal_catch' from INFO and notify the
6602 signal_catch_update (const unsigned int *info)
6606 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
6607 signal_catch[i] = info[i] > 0;
6608 signal_cache_update (-1);
6609 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6613 sig_print_header (void)
6615 printf_filtered (_("Signal Stop\tPrint\tPass "
6616 "to program\tDescription\n"));
6620 sig_print_info (enum gdb_signal oursig)
6622 const char *name = gdb_signal_to_name (oursig);
6623 int name_padding = 13 - strlen (name);
6625 if (name_padding <= 0)
6628 printf_filtered ("%s", name);
6629 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
6630 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
6631 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
6632 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
6633 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
6636 /* Specify how various signals in the inferior should be handled. */
6639 handle_command (char *args, int from_tty)
6642 int digits, wordlen;
6643 int sigfirst, signum, siglast;
6644 enum gdb_signal oursig;
6647 unsigned char *sigs;
6648 struct cleanup *old_chain;
6652 error_no_arg (_("signal to handle"));
6655 /* Allocate and zero an array of flags for which signals to handle. */
6657 nsigs = (int) GDB_SIGNAL_LAST;
6658 sigs = (unsigned char *) alloca (nsigs);
6659 memset (sigs, 0, nsigs);
6661 /* Break the command line up into args. */
6663 argv = gdb_buildargv (args);
6664 old_chain = make_cleanup_freeargv (argv);
6666 /* Walk through the args, looking for signal oursigs, signal names, and
6667 actions. Signal numbers and signal names may be interspersed with
6668 actions, with the actions being performed for all signals cumulatively
6669 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
6671 while (*argv != NULL)
6673 wordlen = strlen (*argv);
6674 for (digits = 0; isdigit ((*argv)[digits]); digits++)
6678 sigfirst = siglast = -1;
6680 if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
6682 /* Apply action to all signals except those used by the
6683 debugger. Silently skip those. */
6686 siglast = nsigs - 1;
6688 else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
6690 SET_SIGS (nsigs, sigs, signal_stop);
6691 SET_SIGS (nsigs, sigs, signal_print);
6693 else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
6695 UNSET_SIGS (nsigs, sigs, signal_program);
6697 else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
6699 SET_SIGS (nsigs, sigs, signal_print);
6701 else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
6703 SET_SIGS (nsigs, sigs, signal_program);
6705 else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
6707 UNSET_SIGS (nsigs, sigs, signal_stop);
6709 else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
6711 SET_SIGS (nsigs, sigs, signal_program);
6713 else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
6715 UNSET_SIGS (nsigs, sigs, signal_print);
6716 UNSET_SIGS (nsigs, sigs, signal_stop);
6718 else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
6720 UNSET_SIGS (nsigs, sigs, signal_program);
6722 else if (digits > 0)
6724 /* It is numeric. The numeric signal refers to our own
6725 internal signal numbering from target.h, not to host/target
6726 signal number. This is a feature; users really should be
6727 using symbolic names anyway, and the common ones like
6728 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
6730 sigfirst = siglast = (int)
6731 gdb_signal_from_command (atoi (*argv));
6732 if ((*argv)[digits] == '-')
6735 gdb_signal_from_command (atoi ((*argv) + digits + 1));
6737 if (sigfirst > siglast)
6739 /* Bet he didn't figure we'd think of this case... */
6747 oursig = gdb_signal_from_name (*argv);
6748 if (oursig != GDB_SIGNAL_UNKNOWN)
6750 sigfirst = siglast = (int) oursig;
6754 /* Not a number and not a recognized flag word => complain. */
6755 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv);
6759 /* If any signal numbers or symbol names were found, set flags for
6760 which signals to apply actions to. */
6762 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
6764 switch ((enum gdb_signal) signum)
6766 case GDB_SIGNAL_TRAP:
6767 case GDB_SIGNAL_INT:
6768 if (!allsigs && !sigs[signum])
6770 if (query (_("%s is used by the debugger.\n\
6771 Are you sure you want to change it? "),
6772 gdb_signal_to_name ((enum gdb_signal) signum)))
6778 printf_unfiltered (_("Not confirmed, unchanged.\n"));
6779 gdb_flush (gdb_stdout);
6784 case GDB_SIGNAL_DEFAULT:
6785 case GDB_SIGNAL_UNKNOWN:
6786 /* Make sure that "all" doesn't print these. */
6797 for (signum = 0; signum < nsigs; signum++)
6800 signal_cache_update (-1);
6801 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6802 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
6806 /* Show the results. */
6807 sig_print_header ();
6808 for (; signum < nsigs; signum++)
6810 sig_print_info (signum);
6816 do_cleanups (old_chain);
6819 /* Complete the "handle" command. */
6821 static VEC (char_ptr) *
6822 handle_completer (struct cmd_list_element *ignore,
6823 const char *text, const char *word)
6825 VEC (char_ptr) *vec_signals, *vec_keywords, *return_val;
6826 static const char * const keywords[] =
6840 vec_signals = signal_completer (ignore, text, word);
6841 vec_keywords = complete_on_enum (keywords, word, word);
6843 return_val = VEC_merge (char_ptr, vec_signals, vec_keywords);
6844 VEC_free (char_ptr, vec_signals);
6845 VEC_free (char_ptr, vec_keywords);
6850 xdb_handle_command (char *args, int from_tty)
6853 struct cleanup *old_chain;
6856 error_no_arg (_("xdb command"));
6858 /* Break the command line up into args. */
6860 argv = gdb_buildargv (args);
6861 old_chain = make_cleanup_freeargv (argv);
6862 if (argv[1] != (char *) NULL)
6867 bufLen = strlen (argv[0]) + 20;
6868 argBuf = (char *) xmalloc (bufLen);
6872 enum gdb_signal oursig;
6874 oursig = gdb_signal_from_name (argv[0]);
6875 memset (argBuf, 0, bufLen);
6876 if (strcmp (argv[1], "Q") == 0)
6877 sprintf (argBuf, "%s %s", argv[0], "noprint");
6880 if (strcmp (argv[1], "s") == 0)
6882 if (!signal_stop[oursig])
6883 sprintf (argBuf, "%s %s", argv[0], "stop");
6885 sprintf (argBuf, "%s %s", argv[0], "nostop");
6887 else if (strcmp (argv[1], "i") == 0)
6889 if (!signal_program[oursig])
6890 sprintf (argBuf, "%s %s", argv[0], "pass");
6892 sprintf (argBuf, "%s %s", argv[0], "nopass");
6894 else if (strcmp (argv[1], "r") == 0)
6896 if (!signal_print[oursig])
6897 sprintf (argBuf, "%s %s", argv[0], "print");
6899 sprintf (argBuf, "%s %s", argv[0], "noprint");
6905 handle_command (argBuf, from_tty);
6907 printf_filtered (_("Invalid signal handling flag.\n"));
6912 do_cleanups (old_chain);
6916 gdb_signal_from_command (int num)
6918 if (num >= 1 && num <= 15)
6919 return (enum gdb_signal) num;
6920 error (_("Only signals 1-15 are valid as numeric signals.\n\
6921 Use \"info signals\" for a list of symbolic signals."));
6924 /* Print current contents of the tables set by the handle command.
6925 It is possible we should just be printing signals actually used
6926 by the current target (but for things to work right when switching
6927 targets, all signals should be in the signal tables). */
6930 signals_info (char *signum_exp, int from_tty)
6932 enum gdb_signal oursig;
6934 sig_print_header ();
6938 /* First see if this is a symbol name. */
6939 oursig = gdb_signal_from_name (signum_exp);
6940 if (oursig == GDB_SIGNAL_UNKNOWN)
6942 /* No, try numeric. */
6944 gdb_signal_from_command (parse_and_eval_long (signum_exp));
6946 sig_print_info (oursig);
6950 printf_filtered ("\n");
6951 /* These ugly casts brought to you by the native VAX compiler. */
6952 for (oursig = GDB_SIGNAL_FIRST;
6953 (int) oursig < (int) GDB_SIGNAL_LAST;
6954 oursig = (enum gdb_signal) ((int) oursig + 1))
6958 if (oursig != GDB_SIGNAL_UNKNOWN
6959 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
6960 sig_print_info (oursig);
6963 printf_filtered (_("\nUse the \"handle\" command "
6964 "to change these tables.\n"));
6967 /* Check if it makes sense to read $_siginfo from the current thread
6968 at this point. If not, throw an error. */
6971 validate_siginfo_access (void)
6973 /* No current inferior, no siginfo. */
6974 if (ptid_equal (inferior_ptid, null_ptid))
6975 error (_("No thread selected."));
6977 /* Don't try to read from a dead thread. */
6978 if (is_exited (inferior_ptid))
6979 error (_("The current thread has terminated"));
6981 /* ... or from a spinning thread. */
6982 if (is_running (inferior_ptid))
6983 error (_("Selected thread is running."));
6986 /* The $_siginfo convenience variable is a bit special. We don't know
6987 for sure the type of the value until we actually have a chance to
6988 fetch the data. The type can change depending on gdbarch, so it is
6989 also dependent on which thread you have selected.
6991 1. making $_siginfo be an internalvar that creates a new value on
6994 2. making the value of $_siginfo be an lval_computed value. */
6996 /* This function implements the lval_computed support for reading a
7000 siginfo_value_read (struct value *v)
7002 LONGEST transferred;
7004 validate_siginfo_access ();
7007 target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO,
7009 value_contents_all_raw (v),
7011 TYPE_LENGTH (value_type (v)));
7013 if (transferred != TYPE_LENGTH (value_type (v)))
7014 error (_("Unable to read siginfo"));
7017 /* This function implements the lval_computed support for writing a
7021 siginfo_value_write (struct value *v, struct value *fromval)
7023 LONGEST transferred;
7025 validate_siginfo_access ();
7027 transferred = target_write (¤t_target,
7028 TARGET_OBJECT_SIGNAL_INFO,
7030 value_contents_all_raw (fromval),
7032 TYPE_LENGTH (value_type (fromval)));
7034 if (transferred != TYPE_LENGTH (value_type (fromval)))
7035 error (_("Unable to write siginfo"));
7038 static const struct lval_funcs siginfo_value_funcs =
7044 /* Return a new value with the correct type for the siginfo object of
7045 the current thread using architecture GDBARCH. Return a void value
7046 if there's no object available. */
7048 static struct value *
7049 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
7052 if (target_has_stack
7053 && !ptid_equal (inferior_ptid, null_ptid)
7054 && gdbarch_get_siginfo_type_p (gdbarch))
7056 struct type *type = gdbarch_get_siginfo_type (gdbarch);
7058 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
7061 return allocate_value (builtin_type (gdbarch)->builtin_void);
7065 /* infcall_suspend_state contains state about the program itself like its
7066 registers and any signal it received when it last stopped.
7067 This state must be restored regardless of how the inferior function call
7068 ends (either successfully, or after it hits a breakpoint or signal)
7069 if the program is to properly continue where it left off. */
7071 struct infcall_suspend_state
7073 struct thread_suspend_state thread_suspend;
7074 #if 0 /* Currently unused and empty structures are not valid C. */
7075 struct inferior_suspend_state inferior_suspend;
7080 struct regcache *registers;
7082 /* Format of SIGINFO_DATA or NULL if it is not present. */
7083 struct gdbarch *siginfo_gdbarch;
7085 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
7086 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
7087 content would be invalid. */
7088 gdb_byte *siginfo_data;
7091 struct infcall_suspend_state *
7092 save_infcall_suspend_state (void)
7094 struct infcall_suspend_state *inf_state;
7095 struct thread_info *tp = inferior_thread ();
7097 struct inferior *inf = current_inferior ();
7099 struct regcache *regcache = get_current_regcache ();
7100 struct gdbarch *gdbarch = get_regcache_arch (regcache);
7101 gdb_byte *siginfo_data = NULL;
7103 if (gdbarch_get_siginfo_type_p (gdbarch))
7105 struct type *type = gdbarch_get_siginfo_type (gdbarch);
7106 size_t len = TYPE_LENGTH (type);
7107 struct cleanup *back_to;
7109 siginfo_data = xmalloc (len);
7110 back_to = make_cleanup (xfree, siginfo_data);
7112 if (target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
7113 siginfo_data, 0, len) == len)
7114 discard_cleanups (back_to);
7117 /* Errors ignored. */
7118 do_cleanups (back_to);
7119 siginfo_data = NULL;
7123 inf_state = XCNEW (struct infcall_suspend_state);
7127 inf_state->siginfo_gdbarch = gdbarch;
7128 inf_state->siginfo_data = siginfo_data;
7131 inf_state->thread_suspend = tp->suspend;
7132 #if 0 /* Currently unused and empty structures are not valid C. */
7133 inf_state->inferior_suspend = inf->suspend;
7136 /* run_inferior_call will not use the signal due to its `proceed' call with
7137 GDB_SIGNAL_0 anyway. */
7138 tp->suspend.stop_signal = GDB_SIGNAL_0;
7140 inf_state->stop_pc = stop_pc;
7142 inf_state->registers = regcache_dup (regcache);
7147 /* Restore inferior session state to INF_STATE. */
7150 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
7152 struct thread_info *tp = inferior_thread ();
7154 struct inferior *inf = current_inferior ();
7156 struct regcache *regcache = get_current_regcache ();
7157 struct gdbarch *gdbarch = get_regcache_arch (regcache);
7159 tp->suspend = inf_state->thread_suspend;
7160 #if 0 /* Currently unused and empty structures are not valid C. */
7161 inf->suspend = inf_state->inferior_suspend;
7164 stop_pc = inf_state->stop_pc;
7166 if (inf_state->siginfo_gdbarch == gdbarch)
7168 struct type *type = gdbarch_get_siginfo_type (gdbarch);
7170 /* Errors ignored. */
7171 target_write (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
7172 inf_state->siginfo_data, 0, TYPE_LENGTH (type));
7175 /* The inferior can be gone if the user types "print exit(0)"
7176 (and perhaps other times). */
7177 if (target_has_execution)
7178 /* NB: The register write goes through to the target. */
7179 regcache_cpy (regcache, inf_state->registers);
7181 discard_infcall_suspend_state (inf_state);
7185 do_restore_infcall_suspend_state_cleanup (void *state)
7187 restore_infcall_suspend_state (state);
7191 make_cleanup_restore_infcall_suspend_state
7192 (struct infcall_suspend_state *inf_state)
7194 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
7198 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
7200 regcache_xfree (inf_state->registers);
7201 xfree (inf_state->siginfo_data);
7206 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
7208 return inf_state->registers;
7211 /* infcall_control_state contains state regarding gdb's control of the
7212 inferior itself like stepping control. It also contains session state like
7213 the user's currently selected frame. */
7215 struct infcall_control_state
7217 struct thread_control_state thread_control;
7218 struct inferior_control_state inferior_control;
7221 enum stop_stack_kind stop_stack_dummy;
7222 int stopped_by_random_signal;
7223 int stop_after_trap;
7225 /* ID if the selected frame when the inferior function call was made. */
7226 struct frame_id selected_frame_id;
7229 /* Save all of the information associated with the inferior<==>gdb
7232 struct infcall_control_state *
7233 save_infcall_control_state (void)
7235 struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status));
7236 struct thread_info *tp = inferior_thread ();
7237 struct inferior *inf = current_inferior ();
7239 inf_status->thread_control = tp->control;
7240 inf_status->inferior_control = inf->control;
7242 tp->control.step_resume_breakpoint = NULL;
7243 tp->control.exception_resume_breakpoint = NULL;
7245 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
7246 chain. If caller's caller is walking the chain, they'll be happier if we
7247 hand them back the original chain when restore_infcall_control_state is
7249 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
7252 inf_status->stop_stack_dummy = stop_stack_dummy;
7253 inf_status->stopped_by_random_signal = stopped_by_random_signal;
7254 inf_status->stop_after_trap = stop_after_trap;
7256 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
7262 restore_selected_frame (void *args)
7264 struct frame_id *fid = (struct frame_id *) args;
7265 struct frame_info *frame;
7267 frame = frame_find_by_id (*fid);
7269 /* If inf_status->selected_frame_id is NULL, there was no previously
7273 warning (_("Unable to restore previously selected frame."));
7277 select_frame (frame);
7282 /* Restore inferior session state to INF_STATUS. */
7285 restore_infcall_control_state (struct infcall_control_state *inf_status)
7287 struct thread_info *tp = inferior_thread ();
7288 struct inferior *inf = current_inferior ();
7290 if (tp->control.step_resume_breakpoint)
7291 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
7293 if (tp->control.exception_resume_breakpoint)
7294 tp->control.exception_resume_breakpoint->disposition
7295 = disp_del_at_next_stop;
7297 /* Handle the bpstat_copy of the chain. */
7298 bpstat_clear (&tp->control.stop_bpstat);
7300 tp->control = inf_status->thread_control;
7301 inf->control = inf_status->inferior_control;
7304 stop_stack_dummy = inf_status->stop_stack_dummy;
7305 stopped_by_random_signal = inf_status->stopped_by_random_signal;
7306 stop_after_trap = inf_status->stop_after_trap;
7308 if (target_has_stack)
7310 /* The point of catch_errors is that if the stack is clobbered,
7311 walking the stack might encounter a garbage pointer and
7312 error() trying to dereference it. */
7314 (restore_selected_frame, &inf_status->selected_frame_id,
7315 "Unable to restore previously selected frame:\n",
7316 RETURN_MASK_ERROR) == 0)
7317 /* Error in restoring the selected frame. Select the innermost
7319 select_frame (get_current_frame ());
7326 do_restore_infcall_control_state_cleanup (void *sts)
7328 restore_infcall_control_state (sts);
7332 make_cleanup_restore_infcall_control_state
7333 (struct infcall_control_state *inf_status)
7335 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
7339 discard_infcall_control_state (struct infcall_control_state *inf_status)
7341 if (inf_status->thread_control.step_resume_breakpoint)
7342 inf_status->thread_control.step_resume_breakpoint->disposition
7343 = disp_del_at_next_stop;
7345 if (inf_status->thread_control.exception_resume_breakpoint)
7346 inf_status->thread_control.exception_resume_breakpoint->disposition
7347 = disp_del_at_next_stop;
7349 /* See save_infcall_control_state for info on stop_bpstat. */
7350 bpstat_clear (&inf_status->thread_control.stop_bpstat);
7355 /* restore_inferior_ptid() will be used by the cleanup machinery
7356 to restore the inferior_ptid value saved in a call to
7357 save_inferior_ptid(). */
7360 restore_inferior_ptid (void *arg)
7362 ptid_t *saved_ptid_ptr = arg;
7364 inferior_ptid = *saved_ptid_ptr;
7368 /* Save the value of inferior_ptid so that it may be restored by a
7369 later call to do_cleanups(). Returns the struct cleanup pointer
7370 needed for later doing the cleanup. */
7373 save_inferior_ptid (void)
7375 ptid_t *saved_ptid_ptr;
7377 saved_ptid_ptr = xmalloc (sizeof (ptid_t));
7378 *saved_ptid_ptr = inferior_ptid;
7379 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
7385 clear_exit_convenience_vars (void)
7387 clear_internalvar (lookup_internalvar ("_exitsignal"));
7388 clear_internalvar (lookup_internalvar ("_exitcode"));
7392 /* User interface for reverse debugging:
7393 Set exec-direction / show exec-direction commands
7394 (returns error unless target implements to_set_exec_direction method). */
7396 int execution_direction = EXEC_FORWARD;
7397 static const char exec_forward[] = "forward";
7398 static const char exec_reverse[] = "reverse";
7399 static const char *exec_direction = exec_forward;
7400 static const char *const exec_direction_names[] = {
7407 set_exec_direction_func (char *args, int from_tty,
7408 struct cmd_list_element *cmd)
7410 if (target_can_execute_reverse)
7412 if (!strcmp (exec_direction, exec_forward))
7413 execution_direction = EXEC_FORWARD;
7414 else if (!strcmp (exec_direction, exec_reverse))
7415 execution_direction = EXEC_REVERSE;
7419 exec_direction = exec_forward;
7420 error (_("Target does not support this operation."));
7425 show_exec_direction_func (struct ui_file *out, int from_tty,
7426 struct cmd_list_element *cmd, const char *value)
7428 switch (execution_direction) {
7430 fprintf_filtered (out, _("Forward.\n"));
7433 fprintf_filtered (out, _("Reverse.\n"));
7436 internal_error (__FILE__, __LINE__,
7437 _("bogus execution_direction value: %d"),
7438 (int) execution_direction);
7443 show_schedule_multiple (struct ui_file *file, int from_tty,
7444 struct cmd_list_element *c, const char *value)
7446 fprintf_filtered (file, _("Resuming the execution of threads "
7447 "of all processes is %s.\n"), value);
7450 /* Implementation of `siginfo' variable. */
7452 static const struct internalvar_funcs siginfo_funcs =
7460 _initialize_infrun (void)
7464 struct cmd_list_element *c;
7466 add_info ("signals", signals_info, _("\
7467 What debugger does when program gets various signals.\n\
7468 Specify a signal as argument to print info on that signal only."));
7469 add_info_alias ("handle", "signals", 0);
7471 c = add_com ("handle", class_run, handle_command, _("\
7472 Specify how to handle signals.\n\
7473 Usage: handle SIGNAL [ACTIONS]\n\
7474 Args are signals and actions to apply to those signals.\n\
7475 If no actions are specified, the current settings for the specified signals\n\
7476 will be displayed instead.\n\
7478 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7479 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7480 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7481 The special arg \"all\" is recognized to mean all signals except those\n\
7482 used by the debugger, typically SIGTRAP and SIGINT.\n\
7484 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7485 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7486 Stop means reenter debugger if this signal happens (implies print).\n\
7487 Print means print a message if this signal happens.\n\
7488 Pass means let program see this signal; otherwise program doesn't know.\n\
7489 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7490 Pass and Stop may be combined.\n\
7492 Multiple signals may be specified. Signal numbers and signal names\n\
7493 may be interspersed with actions, with the actions being performed for\n\
7494 all signals cumulatively specified."));
7495 set_cmd_completer (c, handle_completer);
7499 add_com ("lz", class_info, signals_info, _("\
7500 What debugger does when program gets various signals.\n\
7501 Specify a signal as argument to print info on that signal only."));
7502 add_com ("z", class_run, xdb_handle_command, _("\
7503 Specify how to handle a signal.\n\
7504 Args are signals and actions to apply to those signals.\n\
7505 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7506 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7507 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7508 The special arg \"all\" is recognized to mean all signals except those\n\
7509 used by the debugger, typically SIGTRAP and SIGINT.\n\
7510 Recognized actions include \"s\" (toggles between stop and nostop),\n\
7511 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
7512 nopass), \"Q\" (noprint)\n\
7513 Stop means reenter debugger if this signal happens (implies print).\n\
7514 Print means print a message if this signal happens.\n\
7515 Pass means let program see this signal; otherwise program doesn't know.\n\
7516 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7517 Pass and Stop may be combined."));
7521 stop_command = add_cmd ("stop", class_obscure,
7522 not_just_help_class_command, _("\
7523 There is no `stop' command, but you can set a hook on `stop'.\n\
7524 This allows you to set a list of commands to be run each time execution\n\
7525 of the program stops."), &cmdlist);
7527 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
7528 Set inferior debugging."), _("\
7529 Show inferior debugging."), _("\
7530 When non-zero, inferior specific debugging is enabled."),
7533 &setdebuglist, &showdebuglist);
7535 add_setshow_boolean_cmd ("displaced", class_maintenance,
7536 &debug_displaced, _("\
7537 Set displaced stepping debugging."), _("\
7538 Show displaced stepping debugging."), _("\
7539 When non-zero, displaced stepping specific debugging is enabled."),
7541 show_debug_displaced,
7542 &setdebuglist, &showdebuglist);
7544 add_setshow_boolean_cmd ("non-stop", no_class,
7546 Set whether gdb controls the inferior in non-stop mode."), _("\
7547 Show whether gdb controls the inferior in non-stop mode."), _("\
7548 When debugging a multi-threaded program and this setting is\n\
7549 off (the default, also called all-stop mode), when one thread stops\n\
7550 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7551 all other threads in the program while you interact with the thread of\n\
7552 interest. When you continue or step a thread, you can allow the other\n\
7553 threads to run, or have them remain stopped, but while you inspect any\n\
7554 thread's state, all threads stop.\n\
7556 In non-stop mode, when one thread stops, other threads can continue\n\
7557 to run freely. You'll be able to step each thread independently,\n\
7558 leave it stopped or free to run as needed."),
7564 numsigs = (int) GDB_SIGNAL_LAST;
7565 signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
7566 signal_print = (unsigned char *)
7567 xmalloc (sizeof (signal_print[0]) * numsigs);
7568 signal_program = (unsigned char *)
7569 xmalloc (sizeof (signal_program[0]) * numsigs);
7570 signal_catch = (unsigned char *)
7571 xmalloc (sizeof (signal_catch[0]) * numsigs);
7572 signal_pass = (unsigned char *)
7573 xmalloc (sizeof (signal_pass[0]) * numsigs);
7574 for (i = 0; i < numsigs; i++)
7577 signal_print[i] = 1;
7578 signal_program[i] = 1;
7579 signal_catch[i] = 0;
7582 /* Signals caused by debugger's own actions
7583 should not be given to the program afterwards. */
7584 signal_program[GDB_SIGNAL_TRAP] = 0;
7585 signal_program[GDB_SIGNAL_INT] = 0;
7587 /* Signals that are not errors should not normally enter the debugger. */
7588 signal_stop[GDB_SIGNAL_ALRM] = 0;
7589 signal_print[GDB_SIGNAL_ALRM] = 0;
7590 signal_stop[GDB_SIGNAL_VTALRM] = 0;
7591 signal_print[GDB_SIGNAL_VTALRM] = 0;
7592 signal_stop[GDB_SIGNAL_PROF] = 0;
7593 signal_print[GDB_SIGNAL_PROF] = 0;
7594 signal_stop[GDB_SIGNAL_CHLD] = 0;
7595 signal_print[GDB_SIGNAL_CHLD] = 0;
7596 signal_stop[GDB_SIGNAL_IO] = 0;
7597 signal_print[GDB_SIGNAL_IO] = 0;
7598 signal_stop[GDB_SIGNAL_POLL] = 0;
7599 signal_print[GDB_SIGNAL_POLL] = 0;
7600 signal_stop[GDB_SIGNAL_URG] = 0;
7601 signal_print[GDB_SIGNAL_URG] = 0;
7602 signal_stop[GDB_SIGNAL_WINCH] = 0;
7603 signal_print[GDB_SIGNAL_WINCH] = 0;
7604 signal_stop[GDB_SIGNAL_PRIO] = 0;
7605 signal_print[GDB_SIGNAL_PRIO] = 0;
7607 /* These signals are used internally by user-level thread
7608 implementations. (See signal(5) on Solaris.) Like the above
7609 signals, a healthy program receives and handles them as part of
7610 its normal operation. */
7611 signal_stop[GDB_SIGNAL_LWP] = 0;
7612 signal_print[GDB_SIGNAL_LWP] = 0;
7613 signal_stop[GDB_SIGNAL_WAITING] = 0;
7614 signal_print[GDB_SIGNAL_WAITING] = 0;
7615 signal_stop[GDB_SIGNAL_CANCEL] = 0;
7616 signal_print[GDB_SIGNAL_CANCEL] = 0;
7618 /* Update cached state. */
7619 signal_cache_update (-1);
7621 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
7622 &stop_on_solib_events, _("\
7623 Set stopping for shared library events."), _("\
7624 Show stopping for shared library events."), _("\
7625 If nonzero, gdb will give control to the user when the dynamic linker\n\
7626 notifies gdb of shared library events. The most common event of interest\n\
7627 to the user would be loading/unloading of a new library."),
7628 set_stop_on_solib_events,
7629 show_stop_on_solib_events,
7630 &setlist, &showlist);
7632 add_setshow_enum_cmd ("follow-fork-mode", class_run,
7633 follow_fork_mode_kind_names,
7634 &follow_fork_mode_string, _("\
7635 Set debugger response to a program call of fork or vfork."), _("\
7636 Show debugger response to a program call of fork or vfork."), _("\
7637 A fork or vfork creates a new process. follow-fork-mode can be:\n\
7638 parent - the original process is debugged after a fork\n\
7639 child - the new process is debugged after a fork\n\
7640 The unfollowed process will continue to run.\n\
7641 By default, the debugger will follow the parent process."),
7643 show_follow_fork_mode_string,
7644 &setlist, &showlist);
7646 add_setshow_enum_cmd ("follow-exec-mode", class_run,
7647 follow_exec_mode_names,
7648 &follow_exec_mode_string, _("\
7649 Set debugger response to a program call of exec."), _("\
7650 Show debugger response to a program call of exec."), _("\
7651 An exec call replaces the program image of a process.\n\
7653 follow-exec-mode can be:\n\
7655 new - the debugger creates a new inferior and rebinds the process\n\
7656 to this new inferior. The program the process was running before\n\
7657 the exec call can be restarted afterwards by restarting the original\n\
7660 same - the debugger keeps the process bound to the same inferior.\n\
7661 The new executable image replaces the previous executable loaded in\n\
7662 the inferior. Restarting the inferior after the exec call restarts\n\
7663 the executable the process was running after the exec call.\n\
7665 By default, the debugger will use the same inferior."),
7667 show_follow_exec_mode_string,
7668 &setlist, &showlist);
7670 add_setshow_enum_cmd ("scheduler-locking", class_run,
7671 scheduler_enums, &scheduler_mode, _("\
7672 Set mode for locking scheduler during execution."), _("\
7673 Show mode for locking scheduler during execution."), _("\
7674 off == no locking (threads may preempt at any time)\n\
7675 on == full locking (no thread except the current thread may run)\n\
7676 step == scheduler locked during every single-step operation.\n\
7677 In this mode, no other thread may run during a step command.\n\
7678 Other threads may run while stepping over a function call ('next')."),
7679 set_schedlock_func, /* traps on target vector */
7680 show_scheduler_mode,
7681 &setlist, &showlist);
7683 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
7684 Set mode for resuming threads of all processes."), _("\
7685 Show mode for resuming threads of all processes."), _("\
7686 When on, execution commands (such as 'continue' or 'next') resume all\n\
7687 threads of all processes. When off (which is the default), execution\n\
7688 commands only resume the threads of the current process. The set of\n\
7689 threads that are resumed is further refined by the scheduler-locking\n\
7690 mode (see help set scheduler-locking)."),
7692 show_schedule_multiple,
7693 &setlist, &showlist);
7695 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
7696 Set mode of the step operation."), _("\
7697 Show mode of the step operation."), _("\
7698 When set, doing a step over a function without debug line information\n\
7699 will stop at the first instruction of that function. Otherwise, the\n\
7700 function is skipped and the step command stops at a different source line."),
7702 show_step_stop_if_no_debug,
7703 &setlist, &showlist);
7705 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
7706 &can_use_displaced_stepping, _("\
7707 Set debugger's willingness to use displaced stepping."), _("\
7708 Show debugger's willingness to use displaced stepping."), _("\
7709 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7710 supported by the target architecture. If off, gdb will not use displaced\n\
7711 stepping to step over breakpoints, even if such is supported by the target\n\
7712 architecture. If auto (which is the default), gdb will use displaced stepping\n\
7713 if the target architecture supports it and non-stop mode is active, but will not\n\
7714 use it in all-stop mode (see help set non-stop)."),
7716 show_can_use_displaced_stepping,
7717 &setlist, &showlist);
7719 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
7720 &exec_direction, _("Set direction of execution.\n\
7721 Options are 'forward' or 'reverse'."),
7722 _("Show direction of execution (forward/reverse)."),
7723 _("Tells gdb whether to execute forward or backward."),
7724 set_exec_direction_func, show_exec_direction_func,
7725 &setlist, &showlist);
7727 /* Set/show detach-on-fork: user-settable mode. */
7729 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
7730 Set whether gdb will detach the child of a fork."), _("\
7731 Show whether gdb will detach the child of a fork."), _("\
7732 Tells gdb whether to detach the child of a fork."),
7733 NULL, NULL, &setlist, &showlist);
7735 /* Set/show disable address space randomization mode. */
7737 add_setshow_boolean_cmd ("disable-randomization", class_support,
7738 &disable_randomization, _("\
7739 Set disabling of debuggee's virtual address space randomization."), _("\
7740 Show disabling of debuggee's virtual address space randomization."), _("\
7741 When this mode is on (which is the default), randomization of the virtual\n\
7742 address space is disabled. Standalone programs run with the randomization\n\
7743 enabled by default on some platforms."),
7744 &set_disable_randomization,
7745 &show_disable_randomization,
7746 &setlist, &showlist);
7748 /* ptid initializations */
7749 inferior_ptid = null_ptid;
7750 target_last_wait_ptid = minus_one_ptid;
7752 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
7753 observer_attach_thread_stop_requested (infrun_thread_stop_requested);
7754 observer_attach_thread_exit (infrun_thread_thread_exit);
7755 observer_attach_inferior_exit (infrun_inferior_exit);
7757 /* Explicitly create without lookup, since that tries to create a
7758 value with a void typed value, and when we get here, gdbarch
7759 isn't initialized yet. At this point, we're quite sure there
7760 isn't another convenience variable of the same name. */
7761 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
7763 add_setshow_boolean_cmd ("observer", no_class,
7764 &observer_mode_1, _("\
7765 Set whether gdb controls the inferior in observer mode."), _("\
7766 Show whether gdb controls the inferior in observer mode."), _("\
7767 In observer mode, GDB can get data from the inferior, but not\n\
7768 affect its execution. Registers and memory may not be changed,\n\
7769 breakpoints may not be set, and the program cannot be interrupted\n\