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. */
4428 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
4429 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
4432 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
4433 gdb_signal_to_symbol_string (stop_signal));
4435 stopped_by_random_signal = 1;
4437 /* Always stop on signals if we're either just gaining control
4438 of the program, or the user explicitly requested this thread
4439 to remain stopped. */
4440 if (stop_soon != NO_STOP_QUIETLY
4441 || ecs->event_thread->stop_requested
4443 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
4449 /* Notify observers the signal has "handle print" set. Note we
4450 returned early above if stopping; normal_stop handles the
4451 printing in that case. */
4452 if (signal_print[ecs->event_thread->suspend.stop_signal])
4454 /* The signal table tells us to print about this signal. */
4455 target_terminal_ours_for_output ();
4456 observer_notify_signal_received (ecs->event_thread->suspend.stop_signal);
4457 target_terminal_inferior ();
4460 /* Clear the signal if it should not be passed. */
4461 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
4462 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4464 if (ecs->event_thread->prev_pc == stop_pc
4465 && ecs->event_thread->control.trap_expected
4466 && ecs->event_thread->control.step_resume_breakpoint == NULL)
4468 /* We were just starting a new sequence, attempting to
4469 single-step off of a breakpoint and expecting a SIGTRAP.
4470 Instead this signal arrives. This signal will take us out
4471 of the stepping range so GDB needs to remember to, when
4472 the signal handler returns, resume stepping off that
4474 /* To simplify things, "continue" is forced to use the same
4475 code paths as single-step - set a breakpoint at the
4476 signal return address and then, once hit, step off that
4479 fprintf_unfiltered (gdb_stdlog,
4480 "infrun: signal arrived while stepping over "
4483 insert_hp_step_resume_breakpoint_at_frame (frame);
4484 ecs->event_thread->step_after_step_resume_breakpoint = 1;
4485 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4486 ecs->event_thread->control.trap_expected = 0;
4488 /* If we were nexting/stepping some other thread, switch to
4489 it, so that we don't continue it, losing control. */
4490 if (!switch_back_to_stepped_thread (ecs))
4495 if (ecs->event_thread->control.step_range_end != 0
4496 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
4497 && pc_in_thread_step_range (stop_pc, ecs->event_thread)
4498 && frame_id_eq (get_stack_frame_id (frame),
4499 ecs->event_thread->control.step_stack_frame_id)
4500 && ecs->event_thread->control.step_resume_breakpoint == NULL)
4502 /* The inferior is about to take a signal that will take it
4503 out of the single step range. Set a breakpoint at the
4504 current PC (which is presumably where the signal handler
4505 will eventually return) and then allow the inferior to
4508 Note that this is only needed for a signal delivered
4509 while in the single-step range. Nested signals aren't a
4510 problem as they eventually all return. */
4512 fprintf_unfiltered (gdb_stdlog,
4513 "infrun: signal may take us out of "
4514 "single-step range\n");
4516 insert_hp_step_resume_breakpoint_at_frame (frame);
4517 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4518 ecs->event_thread->control.trap_expected = 0;
4523 /* Note: step_resume_breakpoint may be non-NULL. This occures
4524 when either there's a nested signal, or when there's a
4525 pending signal enabled just as the signal handler returns
4526 (leaving the inferior at the step-resume-breakpoint without
4527 actually executing it). Either way continue until the
4528 breakpoint is really hit. */
4530 if (!switch_back_to_stepped_thread (ecs))
4533 fprintf_unfiltered (gdb_stdlog,
4534 "infrun: random signal, keep going\n");
4541 process_event_stop_test (ecs);
4544 /* Come here when we've got some debug event / signal we can explain
4545 (IOW, not a random signal), and test whether it should cause a
4546 stop, or whether we should resume the inferior (transparently).
4547 E.g., could be a breakpoint whose condition evaluates false; we
4548 could be still stepping within the line; etc. */
4551 process_event_stop_test (struct execution_control_state *ecs)
4553 struct symtab_and_line stop_pc_sal;
4554 struct frame_info *frame;
4555 struct gdbarch *gdbarch;
4556 CORE_ADDR jmp_buf_pc;
4557 struct bpstat_what what;
4559 /* Handle cases caused by hitting a breakpoint. */
4561 frame = get_current_frame ();
4562 gdbarch = get_frame_arch (frame);
4564 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
4566 if (what.call_dummy)
4568 stop_stack_dummy = what.call_dummy;
4571 /* If we hit an internal event that triggers symbol changes, the
4572 current frame will be invalidated within bpstat_what (e.g., if we
4573 hit an internal solib event). Re-fetch it. */
4574 frame = get_current_frame ();
4575 gdbarch = get_frame_arch (frame);
4577 switch (what.main_action)
4579 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
4580 /* If we hit the breakpoint at longjmp while stepping, we
4581 install a momentary breakpoint at the target of the
4585 fprintf_unfiltered (gdb_stdlog,
4586 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4588 ecs->event_thread->stepping_over_breakpoint = 1;
4590 if (what.is_longjmp)
4592 struct value *arg_value;
4594 /* If we set the longjmp breakpoint via a SystemTap probe,
4595 then use it to extract the arguments. The destination PC
4596 is the third argument to the probe. */
4597 arg_value = probe_safe_evaluate_at_pc (frame, 2);
4599 jmp_buf_pc = value_as_address (arg_value);
4600 else if (!gdbarch_get_longjmp_target_p (gdbarch)
4601 || !gdbarch_get_longjmp_target (gdbarch,
4602 frame, &jmp_buf_pc))
4605 fprintf_unfiltered (gdb_stdlog,
4606 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4607 "(!gdbarch_get_longjmp_target)\n");
4612 /* Insert a breakpoint at resume address. */
4613 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
4616 check_exception_resume (ecs, frame);
4620 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
4622 struct frame_info *init_frame;
4624 /* There are several cases to consider.
4626 1. The initiating frame no longer exists. In this case we
4627 must stop, because the exception or longjmp has gone too
4630 2. The initiating frame exists, and is the same as the
4631 current frame. We stop, because the exception or longjmp
4634 3. The initiating frame exists and is different from the
4635 current frame. This means the exception or longjmp has
4636 been caught beneath the initiating frame, so keep going.
4638 4. longjmp breakpoint has been placed just to protect
4639 against stale dummy frames and user is not interested in
4640 stopping around longjmps. */
4643 fprintf_unfiltered (gdb_stdlog,
4644 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4646 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
4648 delete_exception_resume_breakpoint (ecs->event_thread);
4650 if (what.is_longjmp)
4652 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
4654 if (!frame_id_p (ecs->event_thread->initiating_frame))
4662 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
4666 struct frame_id current_id
4667 = get_frame_id (get_current_frame ());
4668 if (frame_id_eq (current_id,
4669 ecs->event_thread->initiating_frame))
4671 /* Case 2. Fall through. */
4681 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
4683 delete_step_resume_breakpoint (ecs->event_thread);
4685 end_stepping_range (ecs);
4689 case BPSTAT_WHAT_SINGLE:
4691 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
4692 ecs->event_thread->stepping_over_breakpoint = 1;
4693 /* Still need to check other stuff, at least the case where we
4694 are stepping and step out of the right range. */
4697 case BPSTAT_WHAT_STEP_RESUME:
4699 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
4701 delete_step_resume_breakpoint (ecs->event_thread);
4702 if (ecs->event_thread->control.proceed_to_finish
4703 && execution_direction == EXEC_REVERSE)
4705 struct thread_info *tp = ecs->event_thread;
4707 /* We are finishing a function in reverse, and just hit the
4708 step-resume breakpoint at the start address of the
4709 function, and we're almost there -- just need to back up
4710 by one more single-step, which should take us back to the
4712 tp->control.step_range_start = tp->control.step_range_end = 1;
4716 fill_in_stop_func (gdbarch, ecs);
4717 if (stop_pc == ecs->stop_func_start
4718 && execution_direction == EXEC_REVERSE)
4720 /* We are stepping over a function call in reverse, and just
4721 hit the step-resume breakpoint at the start address of
4722 the function. Go back to single-stepping, which should
4723 take us back to the function call. */
4724 ecs->event_thread->stepping_over_breakpoint = 1;
4730 case BPSTAT_WHAT_STOP_NOISY:
4732 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
4733 stop_print_frame = 1;
4735 /* Assume the thread stopped for a breapoint. We'll still check
4736 whether a/the breakpoint is there when the thread is next
4738 ecs->event_thread->stepping_over_breakpoint = 1;
4743 case BPSTAT_WHAT_STOP_SILENT:
4745 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
4746 stop_print_frame = 0;
4748 /* Assume the thread stopped for a breapoint. We'll still check
4749 whether a/the breakpoint is there when the thread is next
4751 ecs->event_thread->stepping_over_breakpoint = 1;
4755 case BPSTAT_WHAT_HP_STEP_RESUME:
4757 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
4759 delete_step_resume_breakpoint (ecs->event_thread);
4760 if (ecs->event_thread->step_after_step_resume_breakpoint)
4762 /* Back when the step-resume breakpoint was inserted, we
4763 were trying to single-step off a breakpoint. Go back to
4765 ecs->event_thread->step_after_step_resume_breakpoint = 0;
4766 ecs->event_thread->stepping_over_breakpoint = 1;
4772 case BPSTAT_WHAT_KEEP_CHECKING:
4776 /* We come here if we hit a breakpoint but should not stop for it.
4777 Possibly we also were stepping and should stop for that. So fall
4778 through and test for stepping. But, if not stepping, do not
4781 /* In all-stop mode, if we're currently stepping but have stopped in
4782 some other thread, we need to switch back to the stepped thread. */
4783 if (switch_back_to_stepped_thread (ecs))
4786 if (ecs->event_thread->control.step_resume_breakpoint)
4789 fprintf_unfiltered (gdb_stdlog,
4790 "infrun: step-resume breakpoint is inserted\n");
4792 /* Having a step-resume breakpoint overrides anything
4793 else having to do with stepping commands until
4794 that breakpoint is reached. */
4799 if (ecs->event_thread->control.step_range_end == 0)
4802 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
4803 /* Likewise if we aren't even stepping. */
4808 /* Re-fetch current thread's frame in case the code above caused
4809 the frame cache to be re-initialized, making our FRAME variable
4810 a dangling pointer. */
4811 frame = get_current_frame ();
4812 gdbarch = get_frame_arch (frame);
4813 fill_in_stop_func (gdbarch, ecs);
4815 /* If stepping through a line, keep going if still within it.
4817 Note that step_range_end is the address of the first instruction
4818 beyond the step range, and NOT the address of the last instruction
4821 Note also that during reverse execution, we may be stepping
4822 through a function epilogue and therefore must detect when
4823 the current-frame changes in the middle of a line. */
4825 if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
4826 && (execution_direction != EXEC_REVERSE
4827 || frame_id_eq (get_frame_id (frame),
4828 ecs->event_thread->control.step_frame_id)))
4832 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
4833 paddress (gdbarch, ecs->event_thread->control.step_range_start),
4834 paddress (gdbarch, ecs->event_thread->control.step_range_end));
4836 /* Tentatively re-enable range stepping; `resume' disables it if
4837 necessary (e.g., if we're stepping over a breakpoint or we
4838 have software watchpoints). */
4839 ecs->event_thread->control.may_range_step = 1;
4841 /* When stepping backward, stop at beginning of line range
4842 (unless it's the function entry point, in which case
4843 keep going back to the call point). */
4844 if (stop_pc == ecs->event_thread->control.step_range_start
4845 && stop_pc != ecs->stop_func_start
4846 && execution_direction == EXEC_REVERSE)
4847 end_stepping_range (ecs);
4854 /* We stepped out of the stepping range. */
4856 /* If we are stepping at the source level and entered the runtime
4857 loader dynamic symbol resolution code...
4859 EXEC_FORWARD: we keep on single stepping until we exit the run
4860 time loader code and reach the callee's address.
4862 EXEC_REVERSE: we've already executed the callee (backward), and
4863 the runtime loader code is handled just like any other
4864 undebuggable function call. Now we need only keep stepping
4865 backward through the trampoline code, and that's handled further
4866 down, so there is nothing for us to do here. */
4868 if (execution_direction != EXEC_REVERSE
4869 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4870 && in_solib_dynsym_resolve_code (stop_pc))
4872 CORE_ADDR pc_after_resolver =
4873 gdbarch_skip_solib_resolver (gdbarch, stop_pc);
4876 fprintf_unfiltered (gdb_stdlog,
4877 "infrun: stepped into dynsym resolve code\n");
4879 if (pc_after_resolver)
4881 /* Set up a step-resume breakpoint at the address
4882 indicated by SKIP_SOLIB_RESOLVER. */
4883 struct symtab_and_line sr_sal;
4886 sr_sal.pc = pc_after_resolver;
4887 sr_sal.pspace = get_frame_program_space (frame);
4889 insert_step_resume_breakpoint_at_sal (gdbarch,
4890 sr_sal, null_frame_id);
4897 if (ecs->event_thread->control.step_range_end != 1
4898 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4899 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
4900 && get_frame_type (frame) == SIGTRAMP_FRAME)
4903 fprintf_unfiltered (gdb_stdlog,
4904 "infrun: stepped into signal trampoline\n");
4905 /* The inferior, while doing a "step" or "next", has ended up in
4906 a signal trampoline (either by a signal being delivered or by
4907 the signal handler returning). Just single-step until the
4908 inferior leaves the trampoline (either by calling the handler
4914 /* If we're in the return path from a shared library trampoline,
4915 we want to proceed through the trampoline when stepping. */
4916 /* macro/2012-04-25: This needs to come before the subroutine
4917 call check below as on some targets return trampolines look
4918 like subroutine calls (MIPS16 return thunks). */
4919 if (gdbarch_in_solib_return_trampoline (gdbarch,
4920 stop_pc, ecs->stop_func_name)
4921 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
4923 /* Determine where this trampoline returns. */
4924 CORE_ADDR real_stop_pc;
4926 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
4929 fprintf_unfiltered (gdb_stdlog,
4930 "infrun: stepped into solib return tramp\n");
4932 /* Only proceed through if we know where it's going. */
4935 /* And put the step-breakpoint there and go until there. */
4936 struct symtab_and_line sr_sal;
4938 init_sal (&sr_sal); /* initialize to zeroes */
4939 sr_sal.pc = real_stop_pc;
4940 sr_sal.section = find_pc_overlay (sr_sal.pc);
4941 sr_sal.pspace = get_frame_program_space (frame);
4943 /* Do not specify what the fp should be when we stop since
4944 on some machines the prologue is where the new fp value
4946 insert_step_resume_breakpoint_at_sal (gdbarch,
4947 sr_sal, null_frame_id);
4949 /* Restart without fiddling with the step ranges or
4956 /* Check for subroutine calls. The check for the current frame
4957 equalling the step ID is not necessary - the check of the
4958 previous frame's ID is sufficient - but it is a common case and
4959 cheaper than checking the previous frame's ID.
4961 NOTE: frame_id_eq will never report two invalid frame IDs as
4962 being equal, so to get into this block, both the current and
4963 previous frame must have valid frame IDs. */
4964 /* The outer_frame_id check is a heuristic to detect stepping
4965 through startup code. If we step over an instruction which
4966 sets the stack pointer from an invalid value to a valid value,
4967 we may detect that as a subroutine call from the mythical
4968 "outermost" function. This could be fixed by marking
4969 outermost frames as !stack_p,code_p,special_p. Then the
4970 initial outermost frame, before sp was valid, would
4971 have code_addr == &_start. See the comment in frame_id_eq
4973 if (!frame_id_eq (get_stack_frame_id (frame),
4974 ecs->event_thread->control.step_stack_frame_id)
4975 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
4976 ecs->event_thread->control.step_stack_frame_id)
4977 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
4979 || step_start_function != find_pc_function (stop_pc))))
4981 CORE_ADDR real_stop_pc;
4984 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
4986 if ((ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
4987 || ((ecs->event_thread->control.step_range_end == 1)
4988 && in_prologue (gdbarch, ecs->event_thread->prev_pc,
4989 ecs->stop_func_start)))
4991 /* I presume that step_over_calls is only 0 when we're
4992 supposed to be stepping at the assembly language level
4993 ("stepi"). Just stop. */
4994 /* Also, maybe we just did a "nexti" inside a prolog, so we
4995 thought it was a subroutine call but it was not. Stop as
4997 /* And this works the same backward as frontward. MVS */
4998 end_stepping_range (ecs);
5002 /* Reverse stepping through solib trampolines. */
5004 if (execution_direction == EXEC_REVERSE
5005 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
5006 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5007 || (ecs->stop_func_start == 0
5008 && in_solib_dynsym_resolve_code (stop_pc))))
5010 /* Any solib trampoline code can be handled in reverse
5011 by simply continuing to single-step. We have already
5012 executed the solib function (backwards), and a few
5013 steps will take us back through the trampoline to the
5019 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5021 /* We're doing a "next".
5023 Normal (forward) execution: set a breakpoint at the
5024 callee's return address (the address at which the caller
5027 Reverse (backward) execution. set the step-resume
5028 breakpoint at the start of the function that we just
5029 stepped into (backwards), and continue to there. When we
5030 get there, we'll need to single-step back to the caller. */
5032 if (execution_direction == EXEC_REVERSE)
5034 /* If we're already at the start of the function, we've either
5035 just stepped backward into a single instruction function,
5036 or stepped back out of a signal handler to the first instruction
5037 of the function. Just keep going, which will single-step back
5039 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
5041 struct symtab_and_line sr_sal;
5043 /* Normal function call return (static or dynamic). */
5045 sr_sal.pc = ecs->stop_func_start;
5046 sr_sal.pspace = get_frame_program_space (frame);
5047 insert_step_resume_breakpoint_at_sal (gdbarch,
5048 sr_sal, null_frame_id);
5052 insert_step_resume_breakpoint_at_caller (frame);
5058 /* If we are in a function call trampoline (a stub between the
5059 calling routine and the real function), locate the real
5060 function. That's what tells us (a) whether we want to step
5061 into it at all, and (b) what prologue we want to run to the
5062 end of, if we do step into it. */
5063 real_stop_pc = skip_language_trampoline (frame, stop_pc);
5064 if (real_stop_pc == 0)
5065 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
5066 if (real_stop_pc != 0)
5067 ecs->stop_func_start = real_stop_pc;
5069 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
5071 struct symtab_and_line sr_sal;
5074 sr_sal.pc = ecs->stop_func_start;
5075 sr_sal.pspace = get_frame_program_space (frame);
5077 insert_step_resume_breakpoint_at_sal (gdbarch,
5078 sr_sal, null_frame_id);
5083 /* If we have line number information for the function we are
5084 thinking of stepping into and the function isn't on the skip
5087 If there are several symtabs at that PC (e.g. with include
5088 files), just want to know whether *any* of them have line
5089 numbers. find_pc_line handles this. */
5091 struct symtab_and_line tmp_sal;
5093 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
5094 if (tmp_sal.line != 0
5095 && !function_name_is_marked_for_skip (ecs->stop_func_name,
5098 if (execution_direction == EXEC_REVERSE)
5099 handle_step_into_function_backward (gdbarch, ecs);
5101 handle_step_into_function (gdbarch, ecs);
5106 /* If we have no line number and the step-stop-if-no-debug is
5107 set, we stop the step so that the user has a chance to switch
5108 in assembly mode. */
5109 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5110 && step_stop_if_no_debug)
5112 end_stepping_range (ecs);
5116 if (execution_direction == EXEC_REVERSE)
5118 /* If we're already at the start of the function, we've either just
5119 stepped backward into a single instruction function without line
5120 number info, or stepped back out of a signal handler to the first
5121 instruction of the function without line number info. Just keep
5122 going, which will single-step back to the caller. */
5123 if (ecs->stop_func_start != stop_pc)
5125 /* Set a breakpoint at callee's start address.
5126 From there we can step once and be back in the caller. */
5127 struct symtab_and_line sr_sal;
5130 sr_sal.pc = ecs->stop_func_start;
5131 sr_sal.pspace = get_frame_program_space (frame);
5132 insert_step_resume_breakpoint_at_sal (gdbarch,
5133 sr_sal, null_frame_id);
5137 /* Set a breakpoint at callee's return address (the address
5138 at which the caller will resume). */
5139 insert_step_resume_breakpoint_at_caller (frame);
5145 /* Reverse stepping through solib trampolines. */
5147 if (execution_direction == EXEC_REVERSE
5148 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
5150 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5151 || (ecs->stop_func_start == 0
5152 && in_solib_dynsym_resolve_code (stop_pc)))
5154 /* Any solib trampoline code can be handled in reverse
5155 by simply continuing to single-step. We have already
5156 executed the solib function (backwards), and a few
5157 steps will take us back through the trampoline to the
5162 else if (in_solib_dynsym_resolve_code (stop_pc))
5164 /* Stepped backward into the solib dynsym resolver.
5165 Set a breakpoint at its start and continue, then
5166 one more step will take us out. */
5167 struct symtab_and_line sr_sal;
5170 sr_sal.pc = ecs->stop_func_start;
5171 sr_sal.pspace = get_frame_program_space (frame);
5172 insert_step_resume_breakpoint_at_sal (gdbarch,
5173 sr_sal, null_frame_id);
5179 stop_pc_sal = find_pc_line (stop_pc, 0);
5181 /* NOTE: tausq/2004-05-24: This if block used to be done before all
5182 the trampoline processing logic, however, there are some trampolines
5183 that have no names, so we should do trampoline handling first. */
5184 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5185 && ecs->stop_func_name == NULL
5186 && stop_pc_sal.line == 0)
5189 fprintf_unfiltered (gdb_stdlog,
5190 "infrun: stepped into undebuggable function\n");
5192 /* The inferior just stepped into, or returned to, an
5193 undebuggable function (where there is no debugging information
5194 and no line number corresponding to the address where the
5195 inferior stopped). Since we want to skip this kind of code,
5196 we keep going until the inferior returns from this
5197 function - unless the user has asked us not to (via
5198 set step-mode) or we no longer know how to get back
5199 to the call site. */
5200 if (step_stop_if_no_debug
5201 || !frame_id_p (frame_unwind_caller_id (frame)))
5203 /* If we have no line number and the step-stop-if-no-debug
5204 is set, we stop the step so that the user has a chance to
5205 switch in assembly mode. */
5206 end_stepping_range (ecs);
5211 /* Set a breakpoint at callee's return address (the address
5212 at which the caller will resume). */
5213 insert_step_resume_breakpoint_at_caller (frame);
5219 if (ecs->event_thread->control.step_range_end == 1)
5221 /* It is stepi or nexti. We always want to stop stepping after
5224 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
5225 end_stepping_range (ecs);
5229 if (stop_pc_sal.line == 0)
5231 /* We have no line number information. That means to stop
5232 stepping (does this always happen right after one instruction,
5233 when we do "s" in a function with no line numbers,
5234 or can this happen as a result of a return or longjmp?). */
5236 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
5237 end_stepping_range (ecs);
5241 /* Look for "calls" to inlined functions, part one. If the inline
5242 frame machinery detected some skipped call sites, we have entered
5243 a new inline function. */
5245 if (frame_id_eq (get_frame_id (get_current_frame ()),
5246 ecs->event_thread->control.step_frame_id)
5247 && inline_skipped_frames (ecs->ptid))
5249 struct symtab_and_line call_sal;
5252 fprintf_unfiltered (gdb_stdlog,
5253 "infrun: stepped into inlined function\n");
5255 find_frame_sal (get_current_frame (), &call_sal);
5257 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
5259 /* For "step", we're going to stop. But if the call site
5260 for this inlined function is on the same source line as
5261 we were previously stepping, go down into the function
5262 first. Otherwise stop at the call site. */
5264 if (call_sal.line == ecs->event_thread->current_line
5265 && call_sal.symtab == ecs->event_thread->current_symtab)
5266 step_into_inline_frame (ecs->ptid);
5268 end_stepping_range (ecs);
5273 /* For "next", we should stop at the call site if it is on a
5274 different source line. Otherwise continue through the
5275 inlined function. */
5276 if (call_sal.line == ecs->event_thread->current_line
5277 && call_sal.symtab == ecs->event_thread->current_symtab)
5280 end_stepping_range (ecs);
5285 /* Look for "calls" to inlined functions, part two. If we are still
5286 in the same real function we were stepping through, but we have
5287 to go further up to find the exact frame ID, we are stepping
5288 through a more inlined call beyond its call site. */
5290 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
5291 && !frame_id_eq (get_frame_id (get_current_frame ()),
5292 ecs->event_thread->control.step_frame_id)
5293 && stepped_in_from (get_current_frame (),
5294 ecs->event_thread->control.step_frame_id))
5297 fprintf_unfiltered (gdb_stdlog,
5298 "infrun: stepping through inlined function\n");
5300 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5303 end_stepping_range (ecs);
5307 if ((stop_pc == stop_pc_sal.pc)
5308 && (ecs->event_thread->current_line != stop_pc_sal.line
5309 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
5311 /* We are at the start of a different line. So stop. Note that
5312 we don't stop if we step into the middle of a different line.
5313 That is said to make things like for (;;) statements work
5316 fprintf_unfiltered (gdb_stdlog,
5317 "infrun: stepped to a different line\n");
5318 end_stepping_range (ecs);
5322 /* We aren't done stepping.
5324 Optimize by setting the stepping range to the line.
5325 (We might not be in the original line, but if we entered a
5326 new line in mid-statement, we continue stepping. This makes
5327 things like for(;;) statements work better.) */
5329 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
5330 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
5331 ecs->event_thread->control.may_range_step = 1;
5332 set_step_info (frame, stop_pc_sal);
5335 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
5339 /* In all-stop mode, if we're currently stepping but have stopped in
5340 some other thread, we may need to switch back to the stepped
5341 thread. Returns true we set the inferior running, false if we left
5342 it stopped (and the event needs further processing). */
5345 switch_back_to_stepped_thread (struct execution_control_state *ecs)
5349 struct thread_info *tp;
5350 struct thread_info *stepping_thread;
5351 struct thread_info *step_over;
5353 /* If any thread is blocked on some internal breakpoint, and we
5354 simply need to step over that breakpoint to get it going
5355 again, do that first. */
5357 /* However, if we see an event for the stepping thread, then we
5358 know all other threads have been moved past their breakpoints
5359 already. Let the caller check whether the step is finished,
5360 etc., before deciding to move it past a breakpoint. */
5361 if (ecs->event_thread->control.step_range_end != 0)
5364 /* Check if the current thread is blocked on an incomplete
5365 step-over, interrupted by a random signal. */
5366 if (ecs->event_thread->control.trap_expected
5367 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5371 fprintf_unfiltered (gdb_stdlog,
5372 "infrun: need to finish step-over of [%s]\n",
5373 target_pid_to_str (ecs->event_thread->ptid));
5379 /* Check if the current thread is blocked by a single-step
5380 breakpoint of another thread. */
5381 if (ecs->hit_singlestep_breakpoint)
5385 fprintf_unfiltered (gdb_stdlog,
5386 "infrun: need to step [%s] over single-step "
5388 target_pid_to_str (ecs->ptid));
5394 /* Otherwise, we no longer expect a trap in the current thread.
5395 Clear the trap_expected flag before switching back -- this is
5396 what keep_going does as well, if we call it. */
5397 ecs->event_thread->control.trap_expected = 0;
5399 /* Likewise, clear the signal if it should not be passed. */
5400 if (!signal_program[ecs->event_thread->suspend.stop_signal])
5401 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5403 /* If scheduler locking applies even if not stepping, there's no
5404 need to walk over threads. Above we've checked whether the
5405 current thread is stepping. If some other thread not the
5406 event thread is stepping, then it must be that scheduler
5407 locking is not in effect. */
5408 if (schedlock_applies (0))
5411 /* Look for the stepping/nexting thread, and check if any other
5412 thread other than the stepping thread needs to start a
5413 step-over. Do all step-overs before actually proceeding with
5415 stepping_thread = NULL;
5417 ALL_NON_EXITED_THREADS (tp)
5419 /* Ignore threads of processes we're not resuming. */
5421 && ptid_get_pid (tp->ptid) != ptid_get_pid (inferior_ptid))
5424 /* When stepping over a breakpoint, we lock all threads
5425 except the one that needs to move past the breakpoint.
5426 If a non-event thread has this set, the "incomplete
5427 step-over" check above should have caught it earlier. */
5428 gdb_assert (!tp->control.trap_expected);
5430 /* Did we find the stepping thread? */
5431 if (tp->control.step_range_end)
5433 /* Yep. There should only one though. */
5434 gdb_assert (stepping_thread == NULL);
5436 /* The event thread is handled at the top, before we
5438 gdb_assert (tp != ecs->event_thread);
5440 /* If some thread other than the event thread is
5441 stepping, then scheduler locking can't be in effect,
5442 otherwise we wouldn't have resumed the current event
5443 thread in the first place. */
5444 gdb_assert (!schedlock_applies (1));
5446 stepping_thread = tp;
5448 else if (thread_still_needs_step_over (tp))
5452 /* At the top we've returned early if the event thread
5453 is stepping. If some other thread not the event
5454 thread is stepping, then scheduler locking can't be
5455 in effect, and we can resume this thread. No need to
5456 keep looking for the stepping thread then. */
5461 if (step_over != NULL)
5466 fprintf_unfiltered (gdb_stdlog,
5467 "infrun: need to step-over [%s]\n",
5468 target_pid_to_str (tp->ptid));
5471 /* Only the stepping thread should have this set. */
5472 gdb_assert (tp->control.step_range_end == 0);
5474 ecs->ptid = tp->ptid;
5475 ecs->event_thread = tp;
5476 switch_to_thread (ecs->ptid);
5481 if (stepping_thread != NULL)
5483 struct frame_info *frame;
5484 struct gdbarch *gdbarch;
5486 tp = stepping_thread;
5488 /* If the stepping thread exited, then don't try to switch
5489 back and resume it, which could fail in several different
5490 ways depending on the target. Instead, just keep going.
5492 We can find a stepping dead thread in the thread list in
5495 - The target supports thread exit events, and when the
5496 target tries to delete the thread from the thread list,
5497 inferior_ptid pointed at the exiting thread. In such
5498 case, calling delete_thread does not really remove the
5499 thread from the list; instead, the thread is left listed,
5500 with 'exited' state.
5502 - The target's debug interface does not support thread
5503 exit events, and so we have no idea whatsoever if the
5504 previously stepping thread is still alive. For that
5505 reason, we need to synchronously query the target
5507 if (is_exited (tp->ptid)
5508 || !target_thread_alive (tp->ptid))
5511 fprintf_unfiltered (gdb_stdlog,
5512 "infrun: not switching back to "
5513 "stepped thread, it has vanished\n");
5515 delete_thread (tp->ptid);
5521 fprintf_unfiltered (gdb_stdlog,
5522 "infrun: switching back to stepped thread\n");
5524 ecs->event_thread = tp;
5525 ecs->ptid = tp->ptid;
5526 context_switch (ecs->ptid);
5528 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5529 frame = get_current_frame ();
5530 gdbarch = get_frame_arch (frame);
5532 /* If the PC of the thread we were trying to single-step has
5533 changed, then that thread has trapped or been signaled,
5534 but the event has not been reported to GDB yet. Re-poll
5535 the target looking for this particular thread's event
5536 (i.e. temporarily enable schedlock) by:
5538 - setting a break at the current PC
5539 - resuming that particular thread, only (by setting
5542 This prevents us continuously moving the single-step
5543 breakpoint forward, one instruction at a time,
5546 if (gdbarch_software_single_step_p (gdbarch)
5547 && stop_pc != tp->prev_pc)
5550 fprintf_unfiltered (gdb_stdlog,
5551 "infrun: expected thread advanced also\n");
5553 insert_single_step_breakpoint (get_frame_arch (frame),
5554 get_frame_address_space (frame),
5556 singlestep_breakpoints_inserted_p = 1;
5557 ecs->event_thread->control.trap_expected = 1;
5558 singlestep_ptid = inferior_ptid;
5559 singlestep_pc = stop_pc;
5561 resume (0, GDB_SIGNAL_0);
5562 prepare_to_wait (ecs);
5567 fprintf_unfiltered (gdb_stdlog,
5568 "infrun: expected thread still "
5569 "hasn't advanced\n");
5579 /* Is thread TP in the middle of single-stepping? */
5582 currently_stepping (struct thread_info *tp)
5584 return ((tp->control.step_range_end
5585 && tp->control.step_resume_breakpoint == NULL)
5586 || tp->control.trap_expected
5587 || bpstat_should_step ());
5590 /* Inferior has stepped into a subroutine call with source code that
5591 we should not step over. Do step to the first line of code in
5595 handle_step_into_function (struct gdbarch *gdbarch,
5596 struct execution_control_state *ecs)
5599 struct symtab_and_line stop_func_sal, sr_sal;
5601 fill_in_stop_func (gdbarch, ecs);
5603 s = find_pc_symtab (stop_pc);
5604 if (s && s->language != language_asm)
5605 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5606 ecs->stop_func_start);
5608 stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
5609 /* Use the step_resume_break to step until the end of the prologue,
5610 even if that involves jumps (as it seems to on the vax under
5612 /* If the prologue ends in the middle of a source line, continue to
5613 the end of that source line (if it is still within the function).
5614 Otherwise, just go to end of prologue. */
5615 if (stop_func_sal.end
5616 && stop_func_sal.pc != ecs->stop_func_start
5617 && stop_func_sal.end < ecs->stop_func_end)
5618 ecs->stop_func_start = stop_func_sal.end;
5620 /* Architectures which require breakpoint adjustment might not be able
5621 to place a breakpoint at the computed address. If so, the test
5622 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
5623 ecs->stop_func_start to an address at which a breakpoint may be
5624 legitimately placed.
5626 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
5627 made, GDB will enter an infinite loop when stepping through
5628 optimized code consisting of VLIW instructions which contain
5629 subinstructions corresponding to different source lines. On
5630 FR-V, it's not permitted to place a breakpoint on any but the
5631 first subinstruction of a VLIW instruction. When a breakpoint is
5632 set, GDB will adjust the breakpoint address to the beginning of
5633 the VLIW instruction. Thus, we need to make the corresponding
5634 adjustment here when computing the stop address. */
5636 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
5638 ecs->stop_func_start
5639 = gdbarch_adjust_breakpoint_address (gdbarch,
5640 ecs->stop_func_start);
5643 if (ecs->stop_func_start == stop_pc)
5645 /* We are already there: stop now. */
5646 end_stepping_range (ecs);
5651 /* Put the step-breakpoint there and go until there. */
5652 init_sal (&sr_sal); /* initialize to zeroes */
5653 sr_sal.pc = ecs->stop_func_start;
5654 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
5655 sr_sal.pspace = get_frame_program_space (get_current_frame ());
5657 /* Do not specify what the fp should be when we stop since on
5658 some machines the prologue is where the new fp value is
5660 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
5662 /* And make sure stepping stops right away then. */
5663 ecs->event_thread->control.step_range_end
5664 = ecs->event_thread->control.step_range_start;
5669 /* Inferior has stepped backward into a subroutine call with source
5670 code that we should not step over. Do step to the beginning of the
5671 last line of code in it. */
5674 handle_step_into_function_backward (struct gdbarch *gdbarch,
5675 struct execution_control_state *ecs)
5678 struct symtab_and_line stop_func_sal;
5680 fill_in_stop_func (gdbarch, ecs);
5682 s = find_pc_symtab (stop_pc);
5683 if (s && s->language != language_asm)
5684 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5685 ecs->stop_func_start);
5687 stop_func_sal = find_pc_line (stop_pc, 0);
5689 /* OK, we're just going to keep stepping here. */
5690 if (stop_func_sal.pc == stop_pc)
5692 /* We're there already. Just stop stepping now. */
5693 end_stepping_range (ecs);
5697 /* Else just reset the step range and keep going.
5698 No step-resume breakpoint, they don't work for
5699 epilogues, which can have multiple entry paths. */
5700 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
5701 ecs->event_thread->control.step_range_end = stop_func_sal.end;
5707 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
5708 This is used to both functions and to skip over code. */
5711 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
5712 struct symtab_and_line sr_sal,
5713 struct frame_id sr_id,
5714 enum bptype sr_type)
5716 /* There should never be more than one step-resume or longjmp-resume
5717 breakpoint per thread, so we should never be setting a new
5718 step_resume_breakpoint when one is already active. */
5719 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
5720 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
5723 fprintf_unfiltered (gdb_stdlog,
5724 "infrun: inserting step-resume breakpoint at %s\n",
5725 paddress (gdbarch, sr_sal.pc));
5727 inferior_thread ()->control.step_resume_breakpoint
5728 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
5732 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
5733 struct symtab_and_line sr_sal,
5734 struct frame_id sr_id)
5736 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
5741 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
5742 This is used to skip a potential signal handler.
5744 This is called with the interrupted function's frame. The signal
5745 handler, when it returns, will resume the interrupted function at
5749 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
5751 struct symtab_and_line sr_sal;
5752 struct gdbarch *gdbarch;
5754 gdb_assert (return_frame != NULL);
5755 init_sal (&sr_sal); /* initialize to zeros */
5757 gdbarch = get_frame_arch (return_frame);
5758 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
5759 sr_sal.section = find_pc_overlay (sr_sal.pc);
5760 sr_sal.pspace = get_frame_program_space (return_frame);
5762 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
5763 get_stack_frame_id (return_frame),
5767 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
5768 is used to skip a function after stepping into it (for "next" or if
5769 the called function has no debugging information).
5771 The current function has almost always been reached by single
5772 stepping a call or return instruction. NEXT_FRAME belongs to the
5773 current function, and the breakpoint will be set at the caller's
5776 This is a separate function rather than reusing
5777 insert_hp_step_resume_breakpoint_at_frame in order to avoid
5778 get_prev_frame, which may stop prematurely (see the implementation
5779 of frame_unwind_caller_id for an example). */
5782 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
5784 struct symtab_and_line sr_sal;
5785 struct gdbarch *gdbarch;
5787 /* We shouldn't have gotten here if we don't know where the call site
5789 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
5791 init_sal (&sr_sal); /* initialize to zeros */
5793 gdbarch = frame_unwind_caller_arch (next_frame);
5794 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
5795 frame_unwind_caller_pc (next_frame));
5796 sr_sal.section = find_pc_overlay (sr_sal.pc);
5797 sr_sal.pspace = frame_unwind_program_space (next_frame);
5799 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
5800 frame_unwind_caller_id (next_frame));
5803 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
5804 new breakpoint at the target of a jmp_buf. The handling of
5805 longjmp-resume uses the same mechanisms used for handling
5806 "step-resume" breakpoints. */
5809 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
5811 /* There should never be more than one longjmp-resume breakpoint per
5812 thread, so we should never be setting a new
5813 longjmp_resume_breakpoint when one is already active. */
5814 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
5817 fprintf_unfiltered (gdb_stdlog,
5818 "infrun: inserting longjmp-resume breakpoint at %s\n",
5819 paddress (gdbarch, pc));
5821 inferior_thread ()->control.exception_resume_breakpoint =
5822 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
5825 /* Insert an exception resume breakpoint. TP is the thread throwing
5826 the exception. The block B is the block of the unwinder debug hook
5827 function. FRAME is the frame corresponding to the call to this
5828 function. SYM is the symbol of the function argument holding the
5829 target PC of the exception. */
5832 insert_exception_resume_breakpoint (struct thread_info *tp,
5833 const struct block *b,
5834 struct frame_info *frame,
5837 volatile struct gdb_exception e;
5839 /* We want to ignore errors here. */
5840 TRY_CATCH (e, RETURN_MASK_ERROR)
5842 struct symbol *vsym;
5843 struct value *value;
5845 struct breakpoint *bp;
5847 vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
5848 value = read_var_value (vsym, frame);
5849 /* If the value was optimized out, revert to the old behavior. */
5850 if (! value_optimized_out (value))
5852 handler = value_as_address (value);
5855 fprintf_unfiltered (gdb_stdlog,
5856 "infrun: exception resume at %lx\n",
5857 (unsigned long) handler);
5859 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5860 handler, bp_exception_resume);
5862 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
5865 bp->thread = tp->num;
5866 inferior_thread ()->control.exception_resume_breakpoint = bp;
5871 /* A helper for check_exception_resume that sets an
5872 exception-breakpoint based on a SystemTap probe. */
5875 insert_exception_resume_from_probe (struct thread_info *tp,
5876 const struct bound_probe *probe,
5877 struct frame_info *frame)
5879 struct value *arg_value;
5881 struct breakpoint *bp;
5883 arg_value = probe_safe_evaluate_at_pc (frame, 1);
5887 handler = value_as_address (arg_value);
5890 fprintf_unfiltered (gdb_stdlog,
5891 "infrun: exception resume at %s\n",
5892 paddress (get_objfile_arch (probe->objfile),
5895 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5896 handler, bp_exception_resume);
5897 bp->thread = tp->num;
5898 inferior_thread ()->control.exception_resume_breakpoint = bp;
5901 /* This is called when an exception has been intercepted. Check to
5902 see whether the exception's destination is of interest, and if so,
5903 set an exception resume breakpoint there. */
5906 check_exception_resume (struct execution_control_state *ecs,
5907 struct frame_info *frame)
5909 volatile struct gdb_exception e;
5910 struct bound_probe probe;
5911 struct symbol *func;
5913 /* First see if this exception unwinding breakpoint was set via a
5914 SystemTap probe point. If so, the probe has two arguments: the
5915 CFA and the HANDLER. We ignore the CFA, extract the handler, and
5916 set a breakpoint there. */
5917 probe = find_probe_by_pc (get_frame_pc (frame));
5920 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
5924 func = get_frame_function (frame);
5928 TRY_CATCH (e, RETURN_MASK_ERROR)
5930 const struct block *b;
5931 struct block_iterator iter;
5935 /* The exception breakpoint is a thread-specific breakpoint on
5936 the unwinder's debug hook, declared as:
5938 void _Unwind_DebugHook (void *cfa, void *handler);
5940 The CFA argument indicates the frame to which control is
5941 about to be transferred. HANDLER is the destination PC.
5943 We ignore the CFA and set a temporary breakpoint at HANDLER.
5944 This is not extremely efficient but it avoids issues in gdb
5945 with computing the DWARF CFA, and it also works even in weird
5946 cases such as throwing an exception from inside a signal
5949 b = SYMBOL_BLOCK_VALUE (func);
5950 ALL_BLOCK_SYMBOLS (b, iter, sym)
5952 if (!SYMBOL_IS_ARGUMENT (sym))
5959 insert_exception_resume_breakpoint (ecs->event_thread,
5968 stop_waiting (struct execution_control_state *ecs)
5971 fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
5973 clear_step_over_info ();
5975 /* Let callers know we don't want to wait for the inferior anymore. */
5976 ecs->wait_some_more = 0;
5979 /* Called when we should continue running the inferior, because the
5980 current event doesn't cause a user visible stop. This does the
5981 resuming part; waiting for the next event is done elsewhere. */
5984 keep_going (struct execution_control_state *ecs)
5986 /* Make sure normal_stop is called if we get a QUIT handled before
5988 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
5990 /* Save the pc before execution, to compare with pc after stop. */
5991 ecs->event_thread->prev_pc
5992 = regcache_read_pc (get_thread_regcache (ecs->ptid));
5994 if (ecs->event_thread->control.trap_expected
5995 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5997 /* We haven't yet gotten our trap, and either: intercepted a
5998 non-signal event (e.g., a fork); or took a signal which we
5999 are supposed to pass through to the inferior. Simply
6001 discard_cleanups (old_cleanups);
6002 resume (currently_stepping (ecs->event_thread),
6003 ecs->event_thread->suspend.stop_signal);
6007 volatile struct gdb_exception e;
6008 struct regcache *regcache = get_current_regcache ();
6010 /* Either the trap was not expected, but we are continuing
6011 anyway (if we got a signal, the user asked it be passed to
6014 We got our expected trap, but decided we should resume from
6017 We're going to run this baby now!
6019 Note that insert_breakpoints won't try to re-insert
6020 already inserted breakpoints. Therefore, we don't
6021 care if breakpoints were already inserted, or not. */
6023 /* If we need to step over a breakpoint, and we're not using
6024 displaced stepping to do so, insert all breakpoints
6025 (watchpoints, etc.) but the one we're stepping over, step one
6026 instruction, and then re-insert the breakpoint when that step
6028 if ((ecs->hit_singlestep_breakpoint
6029 || thread_still_needs_step_over (ecs->event_thread))
6030 && !use_displaced_stepping (get_regcache_arch (regcache)))
6032 set_step_over_info (get_regcache_aspace (regcache),
6033 regcache_read_pc (regcache));
6036 clear_step_over_info ();
6038 /* Stop stepping if inserting breakpoints fails. */
6039 TRY_CATCH (e, RETURN_MASK_ERROR)
6041 insert_breakpoints ();
6045 exception_print (gdb_stderr, e);
6050 ecs->event_thread->control.trap_expected
6051 = (ecs->event_thread->stepping_over_breakpoint
6052 || ecs->hit_singlestep_breakpoint);
6054 /* Do not deliver GDB_SIGNAL_TRAP (except when the user
6055 explicitly specifies that such a signal should be delivered
6056 to the target program). Typically, that would occur when a
6057 user is debugging a target monitor on a simulator: the target
6058 monitor sets a breakpoint; the simulator encounters this
6059 breakpoint and halts the simulation handing control to GDB;
6060 GDB, noting that the stop address doesn't map to any known
6061 breakpoint, returns control back to the simulator; the
6062 simulator then delivers the hardware equivalent of a
6063 GDB_SIGNAL_TRAP to the program being debugged. */
6064 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6065 && !signal_program[ecs->event_thread->suspend.stop_signal])
6066 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6068 discard_cleanups (old_cleanups);
6069 resume (currently_stepping (ecs->event_thread),
6070 ecs->event_thread->suspend.stop_signal);
6073 prepare_to_wait (ecs);
6076 /* This function normally comes after a resume, before
6077 handle_inferior_event exits. It takes care of any last bits of
6078 housekeeping, and sets the all-important wait_some_more flag. */
6081 prepare_to_wait (struct execution_control_state *ecs)
6084 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
6086 /* This is the old end of the while loop. Let everybody know we
6087 want to wait for the inferior some more and get called again
6089 ecs->wait_some_more = 1;
6092 /* We are done with the step range of a step/next/si/ni command.
6093 Called once for each n of a "step n" operation. */
6096 end_stepping_range (struct execution_control_state *ecs)
6098 ecs->event_thread->control.stop_step = 1;
6102 /* Several print_*_reason functions to print why the inferior has stopped.
6103 We always print something when the inferior exits, or receives a signal.
6104 The rest of the cases are dealt with later on in normal_stop and
6105 print_it_typical. Ideally there should be a call to one of these
6106 print_*_reason functions functions from handle_inferior_event each time
6107 stop_waiting is called.
6109 Note that we don't call these directly, instead we delegate that to
6110 the interpreters, through observers. Interpreters then call these
6111 with whatever uiout is right. */
6114 print_end_stepping_range_reason (struct ui_out *uiout)
6116 /* For CLI-like interpreters, print nothing. */
6118 if (ui_out_is_mi_like_p (uiout))
6120 ui_out_field_string (uiout, "reason",
6121 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
6126 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6128 annotate_signalled ();
6129 if (ui_out_is_mi_like_p (uiout))
6131 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
6132 ui_out_text (uiout, "\nProgram terminated with signal ");
6133 annotate_signal_name ();
6134 ui_out_field_string (uiout, "signal-name",
6135 gdb_signal_to_name (siggnal));
6136 annotate_signal_name_end ();
6137 ui_out_text (uiout, ", ");
6138 annotate_signal_string ();
6139 ui_out_field_string (uiout, "signal-meaning",
6140 gdb_signal_to_string (siggnal));
6141 annotate_signal_string_end ();
6142 ui_out_text (uiout, ".\n");
6143 ui_out_text (uiout, "The program no longer exists.\n");
6147 print_exited_reason (struct ui_out *uiout, int exitstatus)
6149 struct inferior *inf = current_inferior ();
6150 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
6152 annotate_exited (exitstatus);
6155 if (ui_out_is_mi_like_p (uiout))
6156 ui_out_field_string (uiout, "reason",
6157 async_reason_lookup (EXEC_ASYNC_EXITED));
6158 ui_out_text (uiout, "[Inferior ");
6159 ui_out_text (uiout, plongest (inf->num));
6160 ui_out_text (uiout, " (");
6161 ui_out_text (uiout, pidstr);
6162 ui_out_text (uiout, ") exited with code ");
6163 ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
6164 ui_out_text (uiout, "]\n");
6168 if (ui_out_is_mi_like_p (uiout))
6170 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
6171 ui_out_text (uiout, "[Inferior ");
6172 ui_out_text (uiout, plongest (inf->num));
6173 ui_out_text (uiout, " (");
6174 ui_out_text (uiout, pidstr);
6175 ui_out_text (uiout, ") exited normally]\n");
6180 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6184 if (siggnal == GDB_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
6186 struct thread_info *t = inferior_thread ();
6188 ui_out_text (uiout, "\n[");
6189 ui_out_field_string (uiout, "thread-name",
6190 target_pid_to_str (t->ptid));
6191 ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
6192 ui_out_text (uiout, " stopped");
6196 ui_out_text (uiout, "\nProgram received signal ");
6197 annotate_signal_name ();
6198 if (ui_out_is_mi_like_p (uiout))
6200 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
6201 ui_out_field_string (uiout, "signal-name",
6202 gdb_signal_to_name (siggnal));
6203 annotate_signal_name_end ();
6204 ui_out_text (uiout, ", ");
6205 annotate_signal_string ();
6206 ui_out_field_string (uiout, "signal-meaning",
6207 gdb_signal_to_string (siggnal));
6208 annotate_signal_string_end ();
6210 ui_out_text (uiout, ".\n");
6214 print_no_history_reason (struct ui_out *uiout)
6216 ui_out_text (uiout, "\nNo more reverse-execution history.\n");
6219 /* Print current location without a level number, if we have changed
6220 functions or hit a breakpoint. Print source line if we have one.
6221 bpstat_print contains the logic deciding in detail what to print,
6222 based on the event(s) that just occurred. */
6225 print_stop_event (struct target_waitstatus *ws)
6229 int do_frame_printing = 1;
6230 struct thread_info *tp = inferior_thread ();
6232 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
6236 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
6237 should) carry around the function and does (or should) use
6238 that when doing a frame comparison. */
6239 if (tp->control.stop_step
6240 && frame_id_eq (tp->control.step_frame_id,
6241 get_frame_id (get_current_frame ()))
6242 && step_start_function == find_pc_function (stop_pc))
6244 /* Finished step, just print source line. */
6245 source_flag = SRC_LINE;
6249 /* Print location and source line. */
6250 source_flag = SRC_AND_LOC;
6253 case PRINT_SRC_AND_LOC:
6254 /* Print location and source line. */
6255 source_flag = SRC_AND_LOC;
6257 case PRINT_SRC_ONLY:
6258 source_flag = SRC_LINE;
6261 /* Something bogus. */
6262 source_flag = SRC_LINE;
6263 do_frame_printing = 0;
6266 internal_error (__FILE__, __LINE__, _("Unknown value."));
6269 /* The behavior of this routine with respect to the source
6271 SRC_LINE: Print only source line
6272 LOCATION: Print only location
6273 SRC_AND_LOC: Print location and source line. */
6274 if (do_frame_printing)
6275 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
6277 /* Display the auto-display expressions. */
6281 /* Here to return control to GDB when the inferior stops for real.
6282 Print appropriate messages, remove breakpoints, give terminal our modes.
6284 STOP_PRINT_FRAME nonzero means print the executing frame
6285 (pc, function, args, file, line number and line text).
6286 BREAKPOINTS_FAILED nonzero means stop was due to error
6287 attempting to insert breakpoints. */
6292 struct target_waitstatus last;
6294 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
6296 get_last_target_status (&last_ptid, &last);
6298 /* If an exception is thrown from this point on, make sure to
6299 propagate GDB's knowledge of the executing state to the
6300 frontend/user running state. A QUIT is an easy exception to see
6301 here, so do this before any filtered output. */
6303 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
6304 else if (last.kind != TARGET_WAITKIND_SIGNALLED
6305 && last.kind != TARGET_WAITKIND_EXITED
6306 && last.kind != TARGET_WAITKIND_NO_RESUMED)
6307 make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
6309 /* As we're presenting a stop, and potentially removing breakpoints,
6310 update the thread list so we can tell whether there are threads
6311 running on the target. With target remote, for example, we can
6312 only learn about new threads when we explicitly update the thread
6313 list. Do this before notifying the interpreters about signal
6314 stops, end of stepping ranges, etc., so that the "new thread"
6315 output is emitted before e.g., "Program received signal FOO",
6316 instead of after. */
6317 update_thread_list ();
6319 if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
6320 observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
6322 /* As with the notification of thread events, we want to delay
6323 notifying the user that we've switched thread context until
6324 the inferior actually stops.
6326 There's no point in saying anything if the inferior has exited.
6327 Note that SIGNALLED here means "exited with a signal", not
6328 "received a signal".
6330 Also skip saying anything in non-stop mode. In that mode, as we
6331 don't want GDB to switch threads behind the user's back, to avoid
6332 races where the user is typing a command to apply to thread x,
6333 but GDB switches to thread y before the user finishes entering
6334 the command, fetch_inferior_event installs a cleanup to restore
6335 the current thread back to the thread the user had selected right
6336 after this event is handled, so we're not really switching, only
6337 informing of a stop. */
6339 && !ptid_equal (previous_inferior_ptid, inferior_ptid)
6340 && target_has_execution
6341 && last.kind != TARGET_WAITKIND_SIGNALLED
6342 && last.kind != TARGET_WAITKIND_EXITED
6343 && last.kind != TARGET_WAITKIND_NO_RESUMED)
6345 target_terminal_ours_for_output ();
6346 printf_filtered (_("[Switching to %s]\n"),
6347 target_pid_to_str (inferior_ptid));
6348 annotate_thread_changed ();
6349 previous_inferior_ptid = inferior_ptid;
6352 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
6354 gdb_assert (sync_execution || !target_can_async_p ());
6356 target_terminal_ours_for_output ();
6357 printf_filtered (_("No unwaited-for children left.\n"));
6360 /* Note: this depends on the update_thread_list call above. */
6361 if (!breakpoints_should_be_inserted_now () && target_has_execution)
6363 if (remove_breakpoints ())
6365 target_terminal_ours_for_output ();
6366 printf_filtered (_("Cannot remove breakpoints because "
6367 "program is no longer writable.\nFurther "
6368 "execution is probably impossible.\n"));
6372 /* If an auto-display called a function and that got a signal,
6373 delete that auto-display to avoid an infinite recursion. */
6375 if (stopped_by_random_signal)
6376 disable_current_display ();
6378 /* Notify observers if we finished a "step"-like command, etc. */
6379 if (target_has_execution
6380 && last.kind != TARGET_WAITKIND_SIGNALLED
6381 && last.kind != TARGET_WAITKIND_EXITED
6382 && inferior_thread ()->control.stop_step)
6384 /* But not if in the middle of doing a "step n" operation for
6386 if (inferior_thread ()->step_multi)
6389 observer_notify_end_stepping_range ();
6392 target_terminal_ours ();
6393 async_enable_stdin ();
6395 /* Set the current source location. This will also happen if we
6396 display the frame below, but the current SAL will be incorrect
6397 during a user hook-stop function. */
6398 if (has_stack_frames () && !stop_stack_dummy)
6399 set_current_sal_from_frame (get_current_frame ());
6401 /* Let the user/frontend see the threads as stopped, but do nothing
6402 if the thread was running an infcall. We may be e.g., evaluating
6403 a breakpoint condition. In that case, the thread had state
6404 THREAD_RUNNING before the infcall, and shall remain set to
6405 running, all without informing the user/frontend about state
6406 transition changes. If this is actually a call command, then the
6407 thread was originally already stopped, so there's no state to
6409 if (target_has_execution && inferior_thread ()->control.in_infcall)
6410 discard_cleanups (old_chain);
6412 do_cleanups (old_chain);
6414 /* Look up the hook_stop and run it (CLI internally handles problem
6415 of stop_command's pre-hook not existing). */
6417 catch_errors (hook_stop_stub, stop_command,
6418 "Error while running hook_stop:\n", RETURN_MASK_ALL);
6420 if (!has_stack_frames ())
6423 if (last.kind == TARGET_WAITKIND_SIGNALLED
6424 || last.kind == TARGET_WAITKIND_EXITED)
6427 /* Select innermost stack frame - i.e., current frame is frame 0,
6428 and current location is based on that.
6429 Don't do this on return from a stack dummy routine,
6430 or if the program has exited. */
6432 if (!stop_stack_dummy)
6434 select_frame (get_current_frame ());
6436 /* If --batch-silent is enabled then there's no need to print the current
6437 source location, and to try risks causing an error message about
6438 missing source files. */
6439 if (stop_print_frame && !batch_silent)
6440 print_stop_event (&last);
6443 /* Save the function value return registers, if we care.
6444 We might be about to restore their previous contents. */
6445 if (inferior_thread ()->control.proceed_to_finish
6446 && execution_direction != EXEC_REVERSE)
6448 /* This should not be necessary. */
6450 regcache_xfree (stop_registers);
6452 /* NB: The copy goes through to the target picking up the value of
6453 all the registers. */
6454 stop_registers = regcache_dup (get_current_regcache ());
6457 if (stop_stack_dummy == STOP_STACK_DUMMY)
6459 /* Pop the empty frame that contains the stack dummy.
6460 This also restores inferior state prior to the call
6461 (struct infcall_suspend_state). */
6462 struct frame_info *frame = get_current_frame ();
6464 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
6466 /* frame_pop() calls reinit_frame_cache as the last thing it
6467 does which means there's currently no selected frame. We
6468 don't need to re-establish a selected frame if the dummy call
6469 returns normally, that will be done by
6470 restore_infcall_control_state. However, we do have to handle
6471 the case where the dummy call is returning after being
6472 stopped (e.g. the dummy call previously hit a breakpoint).
6473 We can't know which case we have so just always re-establish
6474 a selected frame here. */
6475 select_frame (get_current_frame ());
6479 annotate_stopped ();
6481 /* Suppress the stop observer if we're in the middle of:
6483 - a step n (n > 1), as there still more steps to be done.
6485 - a "finish" command, as the observer will be called in
6486 finish_command_continuation, so it can include the inferior
6487 function's return value.
6489 - calling an inferior function, as we pretend we inferior didn't
6490 run at all. The return value of the call is handled by the
6491 expression evaluator, through call_function_by_hand. */
6493 if (!target_has_execution
6494 || last.kind == TARGET_WAITKIND_SIGNALLED
6495 || last.kind == TARGET_WAITKIND_EXITED
6496 || last.kind == TARGET_WAITKIND_NO_RESUMED
6497 || (!(inferior_thread ()->step_multi
6498 && inferior_thread ()->control.stop_step)
6499 && !(inferior_thread ()->control.stop_bpstat
6500 && inferior_thread ()->control.proceed_to_finish)
6501 && !inferior_thread ()->control.in_infcall))
6503 if (!ptid_equal (inferior_ptid, null_ptid))
6504 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
6507 observer_notify_normal_stop (NULL, stop_print_frame);
6510 if (target_has_execution)
6512 if (last.kind != TARGET_WAITKIND_SIGNALLED
6513 && last.kind != TARGET_WAITKIND_EXITED)
6514 /* Delete the breakpoint we stopped at, if it wants to be deleted.
6515 Delete any breakpoint that is to be deleted at the next stop. */
6516 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
6519 /* Try to get rid of automatically added inferiors that are no
6520 longer needed. Keeping those around slows down things linearly.
6521 Note that this never removes the current inferior. */
6526 hook_stop_stub (void *cmd)
6528 execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
6533 signal_stop_state (int signo)
6535 return signal_stop[signo];
6539 signal_print_state (int signo)
6541 return signal_print[signo];
6545 signal_pass_state (int signo)
6547 return signal_program[signo];
6551 signal_cache_update (int signo)
6555 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
6556 signal_cache_update (signo);
6561 signal_pass[signo] = (signal_stop[signo] == 0
6562 && signal_print[signo] == 0
6563 && signal_program[signo] == 1
6564 && signal_catch[signo] == 0);
6568 signal_stop_update (int signo, int state)
6570 int ret = signal_stop[signo];
6572 signal_stop[signo] = state;
6573 signal_cache_update (signo);
6578 signal_print_update (int signo, int state)
6580 int ret = signal_print[signo];
6582 signal_print[signo] = state;
6583 signal_cache_update (signo);
6588 signal_pass_update (int signo, int state)
6590 int ret = signal_program[signo];
6592 signal_program[signo] = state;
6593 signal_cache_update (signo);
6597 /* Update the global 'signal_catch' from INFO and notify the
6601 signal_catch_update (const unsigned int *info)
6605 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
6606 signal_catch[i] = info[i] > 0;
6607 signal_cache_update (-1);
6608 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6612 sig_print_header (void)
6614 printf_filtered (_("Signal Stop\tPrint\tPass "
6615 "to program\tDescription\n"));
6619 sig_print_info (enum gdb_signal oursig)
6621 const char *name = gdb_signal_to_name (oursig);
6622 int name_padding = 13 - strlen (name);
6624 if (name_padding <= 0)
6627 printf_filtered ("%s", name);
6628 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
6629 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
6630 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
6631 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
6632 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
6635 /* Specify how various signals in the inferior should be handled. */
6638 handle_command (char *args, int from_tty)
6641 int digits, wordlen;
6642 int sigfirst, signum, siglast;
6643 enum gdb_signal oursig;
6646 unsigned char *sigs;
6647 struct cleanup *old_chain;
6651 error_no_arg (_("signal to handle"));
6654 /* Allocate and zero an array of flags for which signals to handle. */
6656 nsigs = (int) GDB_SIGNAL_LAST;
6657 sigs = (unsigned char *) alloca (nsigs);
6658 memset (sigs, 0, nsigs);
6660 /* Break the command line up into args. */
6662 argv = gdb_buildargv (args);
6663 old_chain = make_cleanup_freeargv (argv);
6665 /* Walk through the args, looking for signal oursigs, signal names, and
6666 actions. Signal numbers and signal names may be interspersed with
6667 actions, with the actions being performed for all signals cumulatively
6668 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
6670 while (*argv != NULL)
6672 wordlen = strlen (*argv);
6673 for (digits = 0; isdigit ((*argv)[digits]); digits++)
6677 sigfirst = siglast = -1;
6679 if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
6681 /* Apply action to all signals except those used by the
6682 debugger. Silently skip those. */
6685 siglast = nsigs - 1;
6687 else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
6689 SET_SIGS (nsigs, sigs, signal_stop);
6690 SET_SIGS (nsigs, sigs, signal_print);
6692 else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
6694 UNSET_SIGS (nsigs, sigs, signal_program);
6696 else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
6698 SET_SIGS (nsigs, sigs, signal_print);
6700 else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
6702 SET_SIGS (nsigs, sigs, signal_program);
6704 else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
6706 UNSET_SIGS (nsigs, sigs, signal_stop);
6708 else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
6710 SET_SIGS (nsigs, sigs, signal_program);
6712 else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
6714 UNSET_SIGS (nsigs, sigs, signal_print);
6715 UNSET_SIGS (nsigs, sigs, signal_stop);
6717 else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
6719 UNSET_SIGS (nsigs, sigs, signal_program);
6721 else if (digits > 0)
6723 /* It is numeric. The numeric signal refers to our own
6724 internal signal numbering from target.h, not to host/target
6725 signal number. This is a feature; users really should be
6726 using symbolic names anyway, and the common ones like
6727 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
6729 sigfirst = siglast = (int)
6730 gdb_signal_from_command (atoi (*argv));
6731 if ((*argv)[digits] == '-')
6734 gdb_signal_from_command (atoi ((*argv) + digits + 1));
6736 if (sigfirst > siglast)
6738 /* Bet he didn't figure we'd think of this case... */
6746 oursig = gdb_signal_from_name (*argv);
6747 if (oursig != GDB_SIGNAL_UNKNOWN)
6749 sigfirst = siglast = (int) oursig;
6753 /* Not a number and not a recognized flag word => complain. */
6754 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv);
6758 /* If any signal numbers or symbol names were found, set flags for
6759 which signals to apply actions to. */
6761 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
6763 switch ((enum gdb_signal) signum)
6765 case GDB_SIGNAL_TRAP:
6766 case GDB_SIGNAL_INT:
6767 if (!allsigs && !sigs[signum])
6769 if (query (_("%s is used by the debugger.\n\
6770 Are you sure you want to change it? "),
6771 gdb_signal_to_name ((enum gdb_signal) signum)))
6777 printf_unfiltered (_("Not confirmed, unchanged.\n"));
6778 gdb_flush (gdb_stdout);
6783 case GDB_SIGNAL_DEFAULT:
6784 case GDB_SIGNAL_UNKNOWN:
6785 /* Make sure that "all" doesn't print these. */
6796 for (signum = 0; signum < nsigs; signum++)
6799 signal_cache_update (-1);
6800 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6801 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
6805 /* Show the results. */
6806 sig_print_header ();
6807 for (; signum < nsigs; signum++)
6809 sig_print_info (signum);
6815 do_cleanups (old_chain);
6818 /* Complete the "handle" command. */
6820 static VEC (char_ptr) *
6821 handle_completer (struct cmd_list_element *ignore,
6822 const char *text, const char *word)
6824 VEC (char_ptr) *vec_signals, *vec_keywords, *return_val;
6825 static const char * const keywords[] =
6839 vec_signals = signal_completer (ignore, text, word);
6840 vec_keywords = complete_on_enum (keywords, word, word);
6842 return_val = VEC_merge (char_ptr, vec_signals, vec_keywords);
6843 VEC_free (char_ptr, vec_signals);
6844 VEC_free (char_ptr, vec_keywords);
6849 xdb_handle_command (char *args, int from_tty)
6852 struct cleanup *old_chain;
6855 error_no_arg (_("xdb command"));
6857 /* Break the command line up into args. */
6859 argv = gdb_buildargv (args);
6860 old_chain = make_cleanup_freeargv (argv);
6861 if (argv[1] != (char *) NULL)
6866 bufLen = strlen (argv[0]) + 20;
6867 argBuf = (char *) xmalloc (bufLen);
6871 enum gdb_signal oursig;
6873 oursig = gdb_signal_from_name (argv[0]);
6874 memset (argBuf, 0, bufLen);
6875 if (strcmp (argv[1], "Q") == 0)
6876 sprintf (argBuf, "%s %s", argv[0], "noprint");
6879 if (strcmp (argv[1], "s") == 0)
6881 if (!signal_stop[oursig])
6882 sprintf (argBuf, "%s %s", argv[0], "stop");
6884 sprintf (argBuf, "%s %s", argv[0], "nostop");
6886 else if (strcmp (argv[1], "i") == 0)
6888 if (!signal_program[oursig])
6889 sprintf (argBuf, "%s %s", argv[0], "pass");
6891 sprintf (argBuf, "%s %s", argv[0], "nopass");
6893 else if (strcmp (argv[1], "r") == 0)
6895 if (!signal_print[oursig])
6896 sprintf (argBuf, "%s %s", argv[0], "print");
6898 sprintf (argBuf, "%s %s", argv[0], "noprint");
6904 handle_command (argBuf, from_tty);
6906 printf_filtered (_("Invalid signal handling flag.\n"));
6911 do_cleanups (old_chain);
6915 gdb_signal_from_command (int num)
6917 if (num >= 1 && num <= 15)
6918 return (enum gdb_signal) num;
6919 error (_("Only signals 1-15 are valid as numeric signals.\n\
6920 Use \"info signals\" for a list of symbolic signals."));
6923 /* Print current contents of the tables set by the handle command.
6924 It is possible we should just be printing signals actually used
6925 by the current target (but for things to work right when switching
6926 targets, all signals should be in the signal tables). */
6929 signals_info (char *signum_exp, int from_tty)
6931 enum gdb_signal oursig;
6933 sig_print_header ();
6937 /* First see if this is a symbol name. */
6938 oursig = gdb_signal_from_name (signum_exp);
6939 if (oursig == GDB_SIGNAL_UNKNOWN)
6941 /* No, try numeric. */
6943 gdb_signal_from_command (parse_and_eval_long (signum_exp));
6945 sig_print_info (oursig);
6949 printf_filtered ("\n");
6950 /* These ugly casts brought to you by the native VAX compiler. */
6951 for (oursig = GDB_SIGNAL_FIRST;
6952 (int) oursig < (int) GDB_SIGNAL_LAST;
6953 oursig = (enum gdb_signal) ((int) oursig + 1))
6957 if (oursig != GDB_SIGNAL_UNKNOWN
6958 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
6959 sig_print_info (oursig);
6962 printf_filtered (_("\nUse the \"handle\" command "
6963 "to change these tables.\n"));
6966 /* Check if it makes sense to read $_siginfo from the current thread
6967 at this point. If not, throw an error. */
6970 validate_siginfo_access (void)
6972 /* No current inferior, no siginfo. */
6973 if (ptid_equal (inferior_ptid, null_ptid))
6974 error (_("No thread selected."));
6976 /* Don't try to read from a dead thread. */
6977 if (is_exited (inferior_ptid))
6978 error (_("The current thread has terminated"));
6980 /* ... or from a spinning thread. */
6981 if (is_running (inferior_ptid))
6982 error (_("Selected thread is running."));
6985 /* The $_siginfo convenience variable is a bit special. We don't know
6986 for sure the type of the value until we actually have a chance to
6987 fetch the data. The type can change depending on gdbarch, so it is
6988 also dependent on which thread you have selected.
6990 1. making $_siginfo be an internalvar that creates a new value on
6993 2. making the value of $_siginfo be an lval_computed value. */
6995 /* This function implements the lval_computed support for reading a
6999 siginfo_value_read (struct value *v)
7001 LONGEST transferred;
7003 validate_siginfo_access ();
7006 target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO,
7008 value_contents_all_raw (v),
7010 TYPE_LENGTH (value_type (v)));
7012 if (transferred != TYPE_LENGTH (value_type (v)))
7013 error (_("Unable to read siginfo"));
7016 /* This function implements the lval_computed support for writing a
7020 siginfo_value_write (struct value *v, struct value *fromval)
7022 LONGEST transferred;
7024 validate_siginfo_access ();
7026 transferred = target_write (¤t_target,
7027 TARGET_OBJECT_SIGNAL_INFO,
7029 value_contents_all_raw (fromval),
7031 TYPE_LENGTH (value_type (fromval)));
7033 if (transferred != TYPE_LENGTH (value_type (fromval)))
7034 error (_("Unable to write siginfo"));
7037 static const struct lval_funcs siginfo_value_funcs =
7043 /* Return a new value with the correct type for the siginfo object of
7044 the current thread using architecture GDBARCH. Return a void value
7045 if there's no object available. */
7047 static struct value *
7048 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
7051 if (target_has_stack
7052 && !ptid_equal (inferior_ptid, null_ptid)
7053 && gdbarch_get_siginfo_type_p (gdbarch))
7055 struct type *type = gdbarch_get_siginfo_type (gdbarch);
7057 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
7060 return allocate_value (builtin_type (gdbarch)->builtin_void);
7064 /* infcall_suspend_state contains state about the program itself like its
7065 registers and any signal it received when it last stopped.
7066 This state must be restored regardless of how the inferior function call
7067 ends (either successfully, or after it hits a breakpoint or signal)
7068 if the program is to properly continue where it left off. */
7070 struct infcall_suspend_state
7072 struct thread_suspend_state thread_suspend;
7073 #if 0 /* Currently unused and empty structures are not valid C. */
7074 struct inferior_suspend_state inferior_suspend;
7079 struct regcache *registers;
7081 /* Format of SIGINFO_DATA or NULL if it is not present. */
7082 struct gdbarch *siginfo_gdbarch;
7084 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
7085 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
7086 content would be invalid. */
7087 gdb_byte *siginfo_data;
7090 struct infcall_suspend_state *
7091 save_infcall_suspend_state (void)
7093 struct infcall_suspend_state *inf_state;
7094 struct thread_info *tp = inferior_thread ();
7096 struct inferior *inf = current_inferior ();
7098 struct regcache *regcache = get_current_regcache ();
7099 struct gdbarch *gdbarch = get_regcache_arch (regcache);
7100 gdb_byte *siginfo_data = NULL;
7102 if (gdbarch_get_siginfo_type_p (gdbarch))
7104 struct type *type = gdbarch_get_siginfo_type (gdbarch);
7105 size_t len = TYPE_LENGTH (type);
7106 struct cleanup *back_to;
7108 siginfo_data = xmalloc (len);
7109 back_to = make_cleanup (xfree, siginfo_data);
7111 if (target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
7112 siginfo_data, 0, len) == len)
7113 discard_cleanups (back_to);
7116 /* Errors ignored. */
7117 do_cleanups (back_to);
7118 siginfo_data = NULL;
7122 inf_state = XCNEW (struct infcall_suspend_state);
7126 inf_state->siginfo_gdbarch = gdbarch;
7127 inf_state->siginfo_data = siginfo_data;
7130 inf_state->thread_suspend = tp->suspend;
7131 #if 0 /* Currently unused and empty structures are not valid C. */
7132 inf_state->inferior_suspend = inf->suspend;
7135 /* run_inferior_call will not use the signal due to its `proceed' call with
7136 GDB_SIGNAL_0 anyway. */
7137 tp->suspend.stop_signal = GDB_SIGNAL_0;
7139 inf_state->stop_pc = stop_pc;
7141 inf_state->registers = regcache_dup (regcache);
7146 /* Restore inferior session state to INF_STATE. */
7149 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
7151 struct thread_info *tp = inferior_thread ();
7153 struct inferior *inf = current_inferior ();
7155 struct regcache *regcache = get_current_regcache ();
7156 struct gdbarch *gdbarch = get_regcache_arch (regcache);
7158 tp->suspend = inf_state->thread_suspend;
7159 #if 0 /* Currently unused and empty structures are not valid C. */
7160 inf->suspend = inf_state->inferior_suspend;
7163 stop_pc = inf_state->stop_pc;
7165 if (inf_state->siginfo_gdbarch == gdbarch)
7167 struct type *type = gdbarch_get_siginfo_type (gdbarch);
7169 /* Errors ignored. */
7170 target_write (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
7171 inf_state->siginfo_data, 0, TYPE_LENGTH (type));
7174 /* The inferior can be gone if the user types "print exit(0)"
7175 (and perhaps other times). */
7176 if (target_has_execution)
7177 /* NB: The register write goes through to the target. */
7178 regcache_cpy (regcache, inf_state->registers);
7180 discard_infcall_suspend_state (inf_state);
7184 do_restore_infcall_suspend_state_cleanup (void *state)
7186 restore_infcall_suspend_state (state);
7190 make_cleanup_restore_infcall_suspend_state
7191 (struct infcall_suspend_state *inf_state)
7193 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
7197 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
7199 regcache_xfree (inf_state->registers);
7200 xfree (inf_state->siginfo_data);
7205 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
7207 return inf_state->registers;
7210 /* infcall_control_state contains state regarding gdb's control of the
7211 inferior itself like stepping control. It also contains session state like
7212 the user's currently selected frame. */
7214 struct infcall_control_state
7216 struct thread_control_state thread_control;
7217 struct inferior_control_state inferior_control;
7220 enum stop_stack_kind stop_stack_dummy;
7221 int stopped_by_random_signal;
7222 int stop_after_trap;
7224 /* ID if the selected frame when the inferior function call was made. */
7225 struct frame_id selected_frame_id;
7228 /* Save all of the information associated with the inferior<==>gdb
7231 struct infcall_control_state *
7232 save_infcall_control_state (void)
7234 struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status));
7235 struct thread_info *tp = inferior_thread ();
7236 struct inferior *inf = current_inferior ();
7238 inf_status->thread_control = tp->control;
7239 inf_status->inferior_control = inf->control;
7241 tp->control.step_resume_breakpoint = NULL;
7242 tp->control.exception_resume_breakpoint = NULL;
7244 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
7245 chain. If caller's caller is walking the chain, they'll be happier if we
7246 hand them back the original chain when restore_infcall_control_state is
7248 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
7251 inf_status->stop_stack_dummy = stop_stack_dummy;
7252 inf_status->stopped_by_random_signal = stopped_by_random_signal;
7253 inf_status->stop_after_trap = stop_after_trap;
7255 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
7261 restore_selected_frame (void *args)
7263 struct frame_id *fid = (struct frame_id *) args;
7264 struct frame_info *frame;
7266 frame = frame_find_by_id (*fid);
7268 /* If inf_status->selected_frame_id is NULL, there was no previously
7272 warning (_("Unable to restore previously selected frame."));
7276 select_frame (frame);
7281 /* Restore inferior session state to INF_STATUS. */
7284 restore_infcall_control_state (struct infcall_control_state *inf_status)
7286 struct thread_info *tp = inferior_thread ();
7287 struct inferior *inf = current_inferior ();
7289 if (tp->control.step_resume_breakpoint)
7290 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
7292 if (tp->control.exception_resume_breakpoint)
7293 tp->control.exception_resume_breakpoint->disposition
7294 = disp_del_at_next_stop;
7296 /* Handle the bpstat_copy of the chain. */
7297 bpstat_clear (&tp->control.stop_bpstat);
7299 tp->control = inf_status->thread_control;
7300 inf->control = inf_status->inferior_control;
7303 stop_stack_dummy = inf_status->stop_stack_dummy;
7304 stopped_by_random_signal = inf_status->stopped_by_random_signal;
7305 stop_after_trap = inf_status->stop_after_trap;
7307 if (target_has_stack)
7309 /* The point of catch_errors is that if the stack is clobbered,
7310 walking the stack might encounter a garbage pointer and
7311 error() trying to dereference it. */
7313 (restore_selected_frame, &inf_status->selected_frame_id,
7314 "Unable to restore previously selected frame:\n",
7315 RETURN_MASK_ERROR) == 0)
7316 /* Error in restoring the selected frame. Select the innermost
7318 select_frame (get_current_frame ());
7325 do_restore_infcall_control_state_cleanup (void *sts)
7327 restore_infcall_control_state (sts);
7331 make_cleanup_restore_infcall_control_state
7332 (struct infcall_control_state *inf_status)
7334 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
7338 discard_infcall_control_state (struct infcall_control_state *inf_status)
7340 if (inf_status->thread_control.step_resume_breakpoint)
7341 inf_status->thread_control.step_resume_breakpoint->disposition
7342 = disp_del_at_next_stop;
7344 if (inf_status->thread_control.exception_resume_breakpoint)
7345 inf_status->thread_control.exception_resume_breakpoint->disposition
7346 = disp_del_at_next_stop;
7348 /* See save_infcall_control_state for info on stop_bpstat. */
7349 bpstat_clear (&inf_status->thread_control.stop_bpstat);
7354 /* restore_inferior_ptid() will be used by the cleanup machinery
7355 to restore the inferior_ptid value saved in a call to
7356 save_inferior_ptid(). */
7359 restore_inferior_ptid (void *arg)
7361 ptid_t *saved_ptid_ptr = arg;
7363 inferior_ptid = *saved_ptid_ptr;
7367 /* Save the value of inferior_ptid so that it may be restored by a
7368 later call to do_cleanups(). Returns the struct cleanup pointer
7369 needed for later doing the cleanup. */
7372 save_inferior_ptid (void)
7374 ptid_t *saved_ptid_ptr;
7376 saved_ptid_ptr = xmalloc (sizeof (ptid_t));
7377 *saved_ptid_ptr = inferior_ptid;
7378 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
7384 clear_exit_convenience_vars (void)
7386 clear_internalvar (lookup_internalvar ("_exitsignal"));
7387 clear_internalvar (lookup_internalvar ("_exitcode"));
7391 /* User interface for reverse debugging:
7392 Set exec-direction / show exec-direction commands
7393 (returns error unless target implements to_set_exec_direction method). */
7395 int execution_direction = EXEC_FORWARD;
7396 static const char exec_forward[] = "forward";
7397 static const char exec_reverse[] = "reverse";
7398 static const char *exec_direction = exec_forward;
7399 static const char *const exec_direction_names[] = {
7406 set_exec_direction_func (char *args, int from_tty,
7407 struct cmd_list_element *cmd)
7409 if (target_can_execute_reverse)
7411 if (!strcmp (exec_direction, exec_forward))
7412 execution_direction = EXEC_FORWARD;
7413 else if (!strcmp (exec_direction, exec_reverse))
7414 execution_direction = EXEC_REVERSE;
7418 exec_direction = exec_forward;
7419 error (_("Target does not support this operation."));
7424 show_exec_direction_func (struct ui_file *out, int from_tty,
7425 struct cmd_list_element *cmd, const char *value)
7427 switch (execution_direction) {
7429 fprintf_filtered (out, _("Forward.\n"));
7432 fprintf_filtered (out, _("Reverse.\n"));
7435 internal_error (__FILE__, __LINE__,
7436 _("bogus execution_direction value: %d"),
7437 (int) execution_direction);
7442 show_schedule_multiple (struct ui_file *file, int from_tty,
7443 struct cmd_list_element *c, const char *value)
7445 fprintf_filtered (file, _("Resuming the execution of threads "
7446 "of all processes is %s.\n"), value);
7449 /* Implementation of `siginfo' variable. */
7451 static const struct internalvar_funcs siginfo_funcs =
7459 _initialize_infrun (void)
7463 struct cmd_list_element *c;
7465 add_info ("signals", signals_info, _("\
7466 What debugger does when program gets various signals.\n\
7467 Specify a signal as argument to print info on that signal only."));
7468 add_info_alias ("handle", "signals", 0);
7470 c = add_com ("handle", class_run, handle_command, _("\
7471 Specify how to handle signals.\n\
7472 Usage: handle SIGNAL [ACTIONS]\n\
7473 Args are signals and actions to apply to those signals.\n\
7474 If no actions are specified, the current settings for the specified signals\n\
7475 will be displayed instead.\n\
7477 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7478 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7479 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7480 The special arg \"all\" is recognized to mean all signals except those\n\
7481 used by the debugger, typically SIGTRAP and SIGINT.\n\
7483 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7484 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7485 Stop means reenter debugger if this signal happens (implies print).\n\
7486 Print means print a message if this signal happens.\n\
7487 Pass means let program see this signal; otherwise program doesn't know.\n\
7488 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7489 Pass and Stop may be combined.\n\
7491 Multiple signals may be specified. Signal numbers and signal names\n\
7492 may be interspersed with actions, with the actions being performed for\n\
7493 all signals cumulatively specified."));
7494 set_cmd_completer (c, handle_completer);
7498 add_com ("lz", class_info, signals_info, _("\
7499 What debugger does when program gets various signals.\n\
7500 Specify a signal as argument to print info on that signal only."));
7501 add_com ("z", class_run, xdb_handle_command, _("\
7502 Specify how to handle a signal.\n\
7503 Args are signals and actions to apply to those signals.\n\
7504 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7505 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7506 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7507 The special arg \"all\" is recognized to mean all signals except those\n\
7508 used by the debugger, typically SIGTRAP and SIGINT.\n\
7509 Recognized actions include \"s\" (toggles between stop and nostop),\n\
7510 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
7511 nopass), \"Q\" (noprint)\n\
7512 Stop means reenter debugger if this signal happens (implies print).\n\
7513 Print means print a message if this signal happens.\n\
7514 Pass means let program see this signal; otherwise program doesn't know.\n\
7515 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7516 Pass and Stop may be combined."));
7520 stop_command = add_cmd ("stop", class_obscure,
7521 not_just_help_class_command, _("\
7522 There is no `stop' command, but you can set a hook on `stop'.\n\
7523 This allows you to set a list of commands to be run each time execution\n\
7524 of the program stops."), &cmdlist);
7526 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
7527 Set inferior debugging."), _("\
7528 Show inferior debugging."), _("\
7529 When non-zero, inferior specific debugging is enabled."),
7532 &setdebuglist, &showdebuglist);
7534 add_setshow_boolean_cmd ("displaced", class_maintenance,
7535 &debug_displaced, _("\
7536 Set displaced stepping debugging."), _("\
7537 Show displaced stepping debugging."), _("\
7538 When non-zero, displaced stepping specific debugging is enabled."),
7540 show_debug_displaced,
7541 &setdebuglist, &showdebuglist);
7543 add_setshow_boolean_cmd ("non-stop", no_class,
7545 Set whether gdb controls the inferior in non-stop mode."), _("\
7546 Show whether gdb controls the inferior in non-stop mode."), _("\
7547 When debugging a multi-threaded program and this setting is\n\
7548 off (the default, also called all-stop mode), when one thread stops\n\
7549 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7550 all other threads in the program while you interact with the thread of\n\
7551 interest. When you continue or step a thread, you can allow the other\n\
7552 threads to run, or have them remain stopped, but while you inspect any\n\
7553 thread's state, all threads stop.\n\
7555 In non-stop mode, when one thread stops, other threads can continue\n\
7556 to run freely. You'll be able to step each thread independently,\n\
7557 leave it stopped or free to run as needed."),
7563 numsigs = (int) GDB_SIGNAL_LAST;
7564 signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
7565 signal_print = (unsigned char *)
7566 xmalloc (sizeof (signal_print[0]) * numsigs);
7567 signal_program = (unsigned char *)
7568 xmalloc (sizeof (signal_program[0]) * numsigs);
7569 signal_catch = (unsigned char *)
7570 xmalloc (sizeof (signal_catch[0]) * numsigs);
7571 signal_pass = (unsigned char *)
7572 xmalloc (sizeof (signal_pass[0]) * numsigs);
7573 for (i = 0; i < numsigs; i++)
7576 signal_print[i] = 1;
7577 signal_program[i] = 1;
7578 signal_catch[i] = 0;
7581 /* Signals caused by debugger's own actions
7582 should not be given to the program afterwards. */
7583 signal_program[GDB_SIGNAL_TRAP] = 0;
7584 signal_program[GDB_SIGNAL_INT] = 0;
7586 /* Signals that are not errors should not normally enter the debugger. */
7587 signal_stop[GDB_SIGNAL_ALRM] = 0;
7588 signal_print[GDB_SIGNAL_ALRM] = 0;
7589 signal_stop[GDB_SIGNAL_VTALRM] = 0;
7590 signal_print[GDB_SIGNAL_VTALRM] = 0;
7591 signal_stop[GDB_SIGNAL_PROF] = 0;
7592 signal_print[GDB_SIGNAL_PROF] = 0;
7593 signal_stop[GDB_SIGNAL_CHLD] = 0;
7594 signal_print[GDB_SIGNAL_CHLD] = 0;
7595 signal_stop[GDB_SIGNAL_IO] = 0;
7596 signal_print[GDB_SIGNAL_IO] = 0;
7597 signal_stop[GDB_SIGNAL_POLL] = 0;
7598 signal_print[GDB_SIGNAL_POLL] = 0;
7599 signal_stop[GDB_SIGNAL_URG] = 0;
7600 signal_print[GDB_SIGNAL_URG] = 0;
7601 signal_stop[GDB_SIGNAL_WINCH] = 0;
7602 signal_print[GDB_SIGNAL_WINCH] = 0;
7603 signal_stop[GDB_SIGNAL_PRIO] = 0;
7604 signal_print[GDB_SIGNAL_PRIO] = 0;
7606 /* These signals are used internally by user-level thread
7607 implementations. (See signal(5) on Solaris.) Like the above
7608 signals, a healthy program receives and handles them as part of
7609 its normal operation. */
7610 signal_stop[GDB_SIGNAL_LWP] = 0;
7611 signal_print[GDB_SIGNAL_LWP] = 0;
7612 signal_stop[GDB_SIGNAL_WAITING] = 0;
7613 signal_print[GDB_SIGNAL_WAITING] = 0;
7614 signal_stop[GDB_SIGNAL_CANCEL] = 0;
7615 signal_print[GDB_SIGNAL_CANCEL] = 0;
7617 /* Update cached state. */
7618 signal_cache_update (-1);
7620 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
7621 &stop_on_solib_events, _("\
7622 Set stopping for shared library events."), _("\
7623 Show stopping for shared library events."), _("\
7624 If nonzero, gdb will give control to the user when the dynamic linker\n\
7625 notifies gdb of shared library events. The most common event of interest\n\
7626 to the user would be loading/unloading of a new library."),
7627 set_stop_on_solib_events,
7628 show_stop_on_solib_events,
7629 &setlist, &showlist);
7631 add_setshow_enum_cmd ("follow-fork-mode", class_run,
7632 follow_fork_mode_kind_names,
7633 &follow_fork_mode_string, _("\
7634 Set debugger response to a program call of fork or vfork."), _("\
7635 Show debugger response to a program call of fork or vfork."), _("\
7636 A fork or vfork creates a new process. follow-fork-mode can be:\n\
7637 parent - the original process is debugged after a fork\n\
7638 child - the new process is debugged after a fork\n\
7639 The unfollowed process will continue to run.\n\
7640 By default, the debugger will follow the parent process."),
7642 show_follow_fork_mode_string,
7643 &setlist, &showlist);
7645 add_setshow_enum_cmd ("follow-exec-mode", class_run,
7646 follow_exec_mode_names,
7647 &follow_exec_mode_string, _("\
7648 Set debugger response to a program call of exec."), _("\
7649 Show debugger response to a program call of exec."), _("\
7650 An exec call replaces the program image of a process.\n\
7652 follow-exec-mode can be:\n\
7654 new - the debugger creates a new inferior and rebinds the process\n\
7655 to this new inferior. The program the process was running before\n\
7656 the exec call can be restarted afterwards by restarting the original\n\
7659 same - the debugger keeps the process bound to the same inferior.\n\
7660 The new executable image replaces the previous executable loaded in\n\
7661 the inferior. Restarting the inferior after the exec call restarts\n\
7662 the executable the process was running after the exec call.\n\
7664 By default, the debugger will use the same inferior."),
7666 show_follow_exec_mode_string,
7667 &setlist, &showlist);
7669 add_setshow_enum_cmd ("scheduler-locking", class_run,
7670 scheduler_enums, &scheduler_mode, _("\
7671 Set mode for locking scheduler during execution."), _("\
7672 Show mode for locking scheduler during execution."), _("\
7673 off == no locking (threads may preempt at any time)\n\
7674 on == full locking (no thread except the current thread may run)\n\
7675 step == scheduler locked during every single-step operation.\n\
7676 In this mode, no other thread may run during a step command.\n\
7677 Other threads may run while stepping over a function call ('next')."),
7678 set_schedlock_func, /* traps on target vector */
7679 show_scheduler_mode,
7680 &setlist, &showlist);
7682 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
7683 Set mode for resuming threads of all processes."), _("\
7684 Show mode for resuming threads of all processes."), _("\
7685 When on, execution commands (such as 'continue' or 'next') resume all\n\
7686 threads of all processes. When off (which is the default), execution\n\
7687 commands only resume the threads of the current process. The set of\n\
7688 threads that are resumed is further refined by the scheduler-locking\n\
7689 mode (see help set scheduler-locking)."),
7691 show_schedule_multiple,
7692 &setlist, &showlist);
7694 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
7695 Set mode of the step operation."), _("\
7696 Show mode of the step operation."), _("\
7697 When set, doing a step over a function without debug line information\n\
7698 will stop at the first instruction of that function. Otherwise, the\n\
7699 function is skipped and the step command stops at a different source line."),
7701 show_step_stop_if_no_debug,
7702 &setlist, &showlist);
7704 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
7705 &can_use_displaced_stepping, _("\
7706 Set debugger's willingness to use displaced stepping."), _("\
7707 Show debugger's willingness to use displaced stepping."), _("\
7708 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7709 supported by the target architecture. If off, gdb will not use displaced\n\
7710 stepping to step over breakpoints, even if such is supported by the target\n\
7711 architecture. If auto (which is the default), gdb will use displaced stepping\n\
7712 if the target architecture supports it and non-stop mode is active, but will not\n\
7713 use it in all-stop mode (see help set non-stop)."),
7715 show_can_use_displaced_stepping,
7716 &setlist, &showlist);
7718 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
7719 &exec_direction, _("Set direction of execution.\n\
7720 Options are 'forward' or 'reverse'."),
7721 _("Show direction of execution (forward/reverse)."),
7722 _("Tells gdb whether to execute forward or backward."),
7723 set_exec_direction_func, show_exec_direction_func,
7724 &setlist, &showlist);
7726 /* Set/show detach-on-fork: user-settable mode. */
7728 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
7729 Set whether gdb will detach the child of a fork."), _("\
7730 Show whether gdb will detach the child of a fork."), _("\
7731 Tells gdb whether to detach the child of a fork."),
7732 NULL, NULL, &setlist, &showlist);
7734 /* Set/show disable address space randomization mode. */
7736 add_setshow_boolean_cmd ("disable-randomization", class_support,
7737 &disable_randomization, _("\
7738 Set disabling of debuggee's virtual address space randomization."), _("\
7739 Show disabling of debuggee's virtual address space randomization."), _("\
7740 When this mode is on (which is the default), randomization of the virtual\n\
7741 address space is disabled. Standalone programs run with the randomization\n\
7742 enabled by default on some platforms."),
7743 &set_disable_randomization,
7744 &show_disable_randomization,
7745 &setlist, &showlist);
7747 /* ptid initializations */
7748 inferior_ptid = null_ptid;
7749 target_last_wait_ptid = minus_one_ptid;
7751 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
7752 observer_attach_thread_stop_requested (infrun_thread_stop_requested);
7753 observer_attach_thread_exit (infrun_thread_thread_exit);
7754 observer_attach_inferior_exit (infrun_inferior_exit);
7756 /* Explicitly create without lookup, since that tries to create a
7757 value with a void typed value, and when we get here, gdbarch
7758 isn't initialized yet. At this point, we're quite sure there
7759 isn't another convenience variable of the same name. */
7760 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
7762 add_setshow_boolean_cmd ("observer", no_class,
7763 &observer_mode_1, _("\
7764 Set whether gdb controls the inferior in observer mode."), _("\
7765 Show whether gdb controls the inferior in observer mode."), _("\
7766 In observer mode, GDB can get data from the inferior, but not\n\
7767 affect its execution. Registers and memory may not be changed,\n\
7768 breakpoints may not be set, and the program cannot be interrupted\n\