1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2015 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 #include "event-loop.h"
65 #include "thread-fsm.h"
66 #include "common/enum-flags.h"
68 /* Prototypes for local functions */
70 static void signals_info (char *, int);
72 static void handle_command (char *, int);
74 static void sig_print_info (enum gdb_signal);
76 static void sig_print_header (void);
78 static void resume_cleanups (void *);
80 static int hook_stop_stub (void *);
82 static int restore_selected_frame (void *);
84 static int follow_fork (void);
86 static int follow_fork_inferior (int follow_child, int detach_fork);
88 static void follow_inferior_reset_breakpoints (void);
90 static void set_schedlock_func (char *args, int from_tty,
91 struct cmd_list_element *c);
93 static int currently_stepping (struct thread_info *tp);
95 void _initialize_infrun (void);
97 void nullify_last_target_wait_ptid (void);
99 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
101 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
103 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
105 static int maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc);
107 /* Asynchronous signal handler registered as event loop source for
108 when we have pending events ready to be passed to the core. */
109 static struct async_event_handler *infrun_async_inferior_event_token;
111 /* Stores whether infrun_async was previously enabled or disabled.
112 Starts off as -1, indicating "never enabled/disabled". */
113 static int infrun_is_async = -1;
118 infrun_async (int enable)
120 if (infrun_is_async != enable)
122 infrun_is_async = enable;
125 fprintf_unfiltered (gdb_stdlog,
126 "infrun: infrun_async(%d)\n",
130 mark_async_event_handler (infrun_async_inferior_event_token);
132 clear_async_event_handler (infrun_async_inferior_event_token);
139 mark_infrun_async_event_handler (void)
141 mark_async_event_handler (infrun_async_inferior_event_token);
144 /* When set, stop the 'step' command if we enter a function which has
145 no line number information. The normal behavior is that we step
146 over such function. */
147 int step_stop_if_no_debug = 0;
149 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
150 struct cmd_list_element *c, const char *value)
152 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
155 /* In asynchronous mode, but simulating synchronous execution. */
157 int sync_execution = 0;
159 /* proceed and normal_stop use this to notify the user when the
160 inferior stopped in a different thread than it had been running
163 static ptid_t previous_inferior_ptid;
165 /* If set (default for legacy reasons), when following a fork, GDB
166 will detach from one of the fork branches, child or parent.
167 Exactly which branch is detached depends on 'set follow-fork-mode'
170 static int detach_fork = 1;
172 int debug_displaced = 0;
174 show_debug_displaced (struct ui_file *file, int from_tty,
175 struct cmd_list_element *c, const char *value)
177 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
180 unsigned int debug_infrun = 0;
182 show_debug_infrun (struct ui_file *file, int from_tty,
183 struct cmd_list_element *c, const char *value)
185 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
189 /* Support for disabling address space randomization. */
191 int disable_randomization = 1;
194 show_disable_randomization (struct ui_file *file, int from_tty,
195 struct cmd_list_element *c, const char *value)
197 if (target_supports_disable_randomization ())
198 fprintf_filtered (file,
199 _("Disabling randomization of debuggee's "
200 "virtual address space is %s.\n"),
203 fputs_filtered (_("Disabling randomization of debuggee's "
204 "virtual address space is unsupported on\n"
205 "this platform.\n"), file);
209 set_disable_randomization (char *args, int from_tty,
210 struct cmd_list_element *c)
212 if (!target_supports_disable_randomization ())
213 error (_("Disabling randomization of debuggee's "
214 "virtual address space is unsupported on\n"
218 /* User interface for non-stop mode. */
221 static int non_stop_1 = 0;
224 set_non_stop (char *args, int from_tty,
225 struct cmd_list_element *c)
227 if (target_has_execution)
229 non_stop_1 = non_stop;
230 error (_("Cannot change this setting while the inferior is running."));
233 non_stop = non_stop_1;
237 show_non_stop (struct ui_file *file, int from_tty,
238 struct cmd_list_element *c, const char *value)
240 fprintf_filtered (file,
241 _("Controlling the inferior in non-stop mode is %s.\n"),
245 /* "Observer mode" is somewhat like a more extreme version of
246 non-stop, in which all GDB operations that might affect the
247 target's execution have been disabled. */
249 int observer_mode = 0;
250 static int observer_mode_1 = 0;
253 set_observer_mode (char *args, int from_tty,
254 struct cmd_list_element *c)
256 if (target_has_execution)
258 observer_mode_1 = observer_mode;
259 error (_("Cannot change this setting while the inferior is running."));
262 observer_mode = observer_mode_1;
264 may_write_registers = !observer_mode;
265 may_write_memory = !observer_mode;
266 may_insert_breakpoints = !observer_mode;
267 may_insert_tracepoints = !observer_mode;
268 /* We can insert fast tracepoints in or out of observer mode,
269 but enable them if we're going into this mode. */
271 may_insert_fast_tracepoints = 1;
272 may_stop = !observer_mode;
273 update_target_permissions ();
275 /* Going *into* observer mode we must force non-stop, then
276 going out we leave it that way. */
279 pagination_enabled = 0;
280 non_stop = non_stop_1 = 1;
284 printf_filtered (_("Observer mode is now %s.\n"),
285 (observer_mode ? "on" : "off"));
289 show_observer_mode (struct ui_file *file, int from_tty,
290 struct cmd_list_element *c, const char *value)
292 fprintf_filtered (file, _("Observer mode is %s.\n"), value);
295 /* This updates the value of observer mode based on changes in
296 permissions. Note that we are deliberately ignoring the values of
297 may-write-registers and may-write-memory, since the user may have
298 reason to enable these during a session, for instance to turn on a
299 debugging-related global. */
302 update_observer_mode (void)
306 newval = (!may_insert_breakpoints
307 && !may_insert_tracepoints
308 && may_insert_fast_tracepoints
312 /* Let the user know if things change. */
313 if (newval != observer_mode)
314 printf_filtered (_("Observer mode is now %s.\n"),
315 (newval ? "on" : "off"));
317 observer_mode = observer_mode_1 = newval;
320 /* Tables of how to react to signals; the user sets them. */
322 static unsigned char *signal_stop;
323 static unsigned char *signal_print;
324 static unsigned char *signal_program;
326 /* Table of signals that are registered with "catch signal". A
327 non-zero entry indicates that the signal is caught by some "catch
328 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
330 static unsigned char *signal_catch;
332 /* Table of signals that the target may silently handle.
333 This is automatically determined from the flags above,
334 and simply cached here. */
335 static unsigned char *signal_pass;
337 #define SET_SIGS(nsigs,sigs,flags) \
339 int signum = (nsigs); \
340 while (signum-- > 0) \
341 if ((sigs)[signum]) \
342 (flags)[signum] = 1; \
345 #define UNSET_SIGS(nsigs,sigs,flags) \
347 int signum = (nsigs); \
348 while (signum-- > 0) \
349 if ((sigs)[signum]) \
350 (flags)[signum] = 0; \
353 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
354 this function is to avoid exporting `signal_program'. */
357 update_signals_program_target (void)
359 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
362 /* Value to pass to target_resume() to cause all threads to resume. */
364 #define RESUME_ALL minus_one_ptid
366 /* Command list pointer for the "stop" placeholder. */
368 static struct cmd_list_element *stop_command;
370 /* Nonzero if we want to give control to the user when we're notified
371 of shared library events by the dynamic linker. */
372 int stop_on_solib_events;
374 /* Enable or disable optional shared library event breakpoints
375 as appropriate when the above flag is changed. */
378 set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
380 update_solib_breakpoints ();
384 show_stop_on_solib_events (struct ui_file *file, int from_tty,
385 struct cmd_list_element *c, const char *value)
387 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
391 /* Nonzero after stop if current stack frame should be printed. */
393 static int stop_print_frame;
395 /* This is a cached copy of the pid/waitstatus of the last event
396 returned by target_wait()/deprecated_target_wait_hook(). This
397 information is returned by get_last_target_status(). */
398 static ptid_t target_last_wait_ptid;
399 static struct target_waitstatus target_last_waitstatus;
401 static void context_switch (ptid_t ptid);
403 void init_thread_stepping_state (struct thread_info *tss);
405 static const char follow_fork_mode_child[] = "child";
406 static const char follow_fork_mode_parent[] = "parent";
408 static const char *const follow_fork_mode_kind_names[] = {
409 follow_fork_mode_child,
410 follow_fork_mode_parent,
414 static const char *follow_fork_mode_string = follow_fork_mode_parent;
416 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
417 struct cmd_list_element *c, const char *value)
419 fprintf_filtered (file,
420 _("Debugger response to a program "
421 "call of fork or vfork is \"%s\".\n"),
426 /* Handle changes to the inferior list based on the type of fork,
427 which process is being followed, and whether the other process
428 should be detached. On entry inferior_ptid must be the ptid of
429 the fork parent. At return inferior_ptid is the ptid of the
430 followed inferior. */
433 follow_fork_inferior (int follow_child, int detach_fork)
436 ptid_t parent_ptid, child_ptid;
438 has_vforked = (inferior_thread ()->pending_follow.kind
439 == TARGET_WAITKIND_VFORKED);
440 parent_ptid = inferior_ptid;
441 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
444 && !non_stop /* Non-stop always resumes both branches. */
445 && (!target_is_async_p () || sync_execution)
446 && !(follow_child || detach_fork || sched_multi))
448 /* The parent stays blocked inside the vfork syscall until the
449 child execs or exits. If we don't let the child run, then
450 the parent stays blocked. If we're telling the parent to run
451 in the foreground, the user will not be able to ctrl-c to get
452 back the terminal, effectively hanging the debug session. */
453 fprintf_filtered (gdb_stderr, _("\
454 Can not resume the parent process over vfork in the foreground while\n\
455 holding the child stopped. Try \"set detach-on-fork\" or \
456 \"set schedule-multiple\".\n"));
457 /* FIXME output string > 80 columns. */
463 /* Detach new forked process? */
466 struct cleanup *old_chain;
468 /* Before detaching from the child, remove all breakpoints
469 from it. If we forked, then this has already been taken
470 care of by infrun.c. If we vforked however, any
471 breakpoint inserted in the parent is visible in the
472 child, even those added while stopped in a vfork
473 catchpoint. This will remove the breakpoints from the
474 parent also, but they'll be reinserted below. */
477 /* Keep breakpoints list in sync. */
478 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
481 if (info_verbose || debug_infrun)
483 /* Ensure that we have a process ptid. */
484 ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
486 target_terminal_ours_for_output ();
487 fprintf_filtered (gdb_stdlog,
488 _("Detaching after %s from child %s.\n"),
489 has_vforked ? "vfork" : "fork",
490 target_pid_to_str (process_ptid));
495 struct inferior *parent_inf, *child_inf;
496 struct cleanup *old_chain;
498 /* Add process to GDB's tables. */
499 child_inf = add_inferior (ptid_get_pid (child_ptid));
501 parent_inf = current_inferior ();
502 child_inf->attach_flag = parent_inf->attach_flag;
503 copy_terminal_info (child_inf, parent_inf);
504 child_inf->gdbarch = parent_inf->gdbarch;
505 copy_inferior_target_desc_info (child_inf, parent_inf);
507 old_chain = save_inferior_ptid ();
508 save_current_program_space ();
510 inferior_ptid = child_ptid;
511 add_thread (inferior_ptid);
512 child_inf->symfile_flags = SYMFILE_NO_READ;
514 /* If this is a vfork child, then the address-space is
515 shared with the parent. */
518 child_inf->pspace = parent_inf->pspace;
519 child_inf->aspace = parent_inf->aspace;
521 /* The parent will be frozen until the child is done
522 with the shared region. Keep track of the
524 child_inf->vfork_parent = parent_inf;
525 child_inf->pending_detach = 0;
526 parent_inf->vfork_child = child_inf;
527 parent_inf->pending_detach = 0;
531 child_inf->aspace = new_address_space ();
532 child_inf->pspace = add_program_space (child_inf->aspace);
533 child_inf->removable = 1;
534 set_current_program_space (child_inf->pspace);
535 clone_program_space (child_inf->pspace, parent_inf->pspace);
537 /* Let the shared library layer (e.g., solib-svr4) learn
538 about this new process, relocate the cloned exec, pull
539 in shared libraries, and install the solib event
540 breakpoint. If a "cloned-VM" event was propagated
541 better throughout the core, this wouldn't be
543 solib_create_inferior_hook (0);
546 do_cleanups (old_chain);
551 struct inferior *parent_inf;
553 parent_inf = current_inferior ();
555 /* If we detached from the child, then we have to be careful
556 to not insert breakpoints in the parent until the child
557 is done with the shared memory region. However, if we're
558 staying attached to the child, then we can and should
559 insert breakpoints, so that we can debug it. A
560 subsequent child exec or exit is enough to know when does
561 the child stops using the parent's address space. */
562 parent_inf->waiting_for_vfork_done = detach_fork;
563 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
568 /* Follow the child. */
569 struct inferior *parent_inf, *child_inf;
570 struct program_space *parent_pspace;
572 if (info_verbose || debug_infrun)
574 target_terminal_ours_for_output ();
575 fprintf_filtered (gdb_stdlog,
576 _("Attaching after %s %s to child %s.\n"),
577 target_pid_to_str (parent_ptid),
578 has_vforked ? "vfork" : "fork",
579 target_pid_to_str (child_ptid));
582 /* Add the new inferior first, so that the target_detach below
583 doesn't unpush the target. */
585 child_inf = add_inferior (ptid_get_pid (child_ptid));
587 parent_inf = current_inferior ();
588 child_inf->attach_flag = parent_inf->attach_flag;
589 copy_terminal_info (child_inf, parent_inf);
590 child_inf->gdbarch = parent_inf->gdbarch;
591 copy_inferior_target_desc_info (child_inf, parent_inf);
593 parent_pspace = parent_inf->pspace;
595 /* If we're vforking, we want to hold on to the parent until the
596 child exits or execs. At child exec or exit time we can
597 remove the old breakpoints from the parent and detach or
598 resume debugging it. Otherwise, detach the parent now; we'll
599 want to reuse it's program/address spaces, but we can't set
600 them to the child before removing breakpoints from the
601 parent, otherwise, the breakpoints module could decide to
602 remove breakpoints from the wrong process (since they'd be
603 assigned to the same address space). */
607 gdb_assert (child_inf->vfork_parent == NULL);
608 gdb_assert (parent_inf->vfork_child == NULL);
609 child_inf->vfork_parent = parent_inf;
610 child_inf->pending_detach = 0;
611 parent_inf->vfork_child = child_inf;
612 parent_inf->pending_detach = detach_fork;
613 parent_inf->waiting_for_vfork_done = 0;
615 else if (detach_fork)
617 if (info_verbose || debug_infrun)
619 /* Ensure that we have a process ptid. */
620 ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
622 target_terminal_ours_for_output ();
623 fprintf_filtered (gdb_stdlog,
624 _("Detaching after fork from "
626 target_pid_to_str (process_ptid));
629 target_detach (NULL, 0);
632 /* Note that the detach above makes PARENT_INF dangling. */
634 /* Add the child thread to the appropriate lists, and switch to
635 this new thread, before cloning the program space, and
636 informing the solib layer about this new process. */
638 inferior_ptid = child_ptid;
639 add_thread (inferior_ptid);
641 /* If this is a vfork child, then the address-space is shared
642 with the parent. If we detached from the parent, then we can
643 reuse the parent's program/address spaces. */
644 if (has_vforked || detach_fork)
646 child_inf->pspace = parent_pspace;
647 child_inf->aspace = child_inf->pspace->aspace;
651 child_inf->aspace = new_address_space ();
652 child_inf->pspace = add_program_space (child_inf->aspace);
653 child_inf->removable = 1;
654 child_inf->symfile_flags = SYMFILE_NO_READ;
655 set_current_program_space (child_inf->pspace);
656 clone_program_space (child_inf->pspace, parent_pspace);
658 /* Let the shared library layer (e.g., solib-svr4) learn
659 about this new process, relocate the cloned exec, pull in
660 shared libraries, and install the solib event breakpoint.
661 If a "cloned-VM" event was propagated better throughout
662 the core, this wouldn't be required. */
663 solib_create_inferior_hook (0);
667 return target_follow_fork (follow_child, detach_fork);
670 /* Tell the target to follow the fork we're stopped at. Returns true
671 if the inferior should be resumed; false, if the target for some
672 reason decided it's best not to resume. */
677 int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
678 int should_resume = 1;
679 struct thread_info *tp;
681 /* Copy user stepping state to the new inferior thread. FIXME: the
682 followed fork child thread should have a copy of most of the
683 parent thread structure's run control related fields, not just these.
684 Initialized to avoid "may be used uninitialized" warnings from gcc. */
685 struct breakpoint *step_resume_breakpoint = NULL;
686 struct breakpoint *exception_resume_breakpoint = NULL;
687 CORE_ADDR step_range_start = 0;
688 CORE_ADDR step_range_end = 0;
689 struct frame_id step_frame_id = { 0 };
690 struct interp *command_interp = NULL;
695 struct target_waitstatus wait_status;
697 /* Get the last target status returned by target_wait(). */
698 get_last_target_status (&wait_ptid, &wait_status);
700 /* If not stopped at a fork event, then there's nothing else to
702 if (wait_status.kind != TARGET_WAITKIND_FORKED
703 && wait_status.kind != TARGET_WAITKIND_VFORKED)
706 /* Check if we switched over from WAIT_PTID, since the event was
708 if (!ptid_equal (wait_ptid, minus_one_ptid)
709 && !ptid_equal (inferior_ptid, wait_ptid))
711 /* We did. Switch back to WAIT_PTID thread, to tell the
712 target to follow it (in either direction). We'll
713 afterwards refuse to resume, and inform the user what
715 switch_to_thread (wait_ptid);
720 tp = inferior_thread ();
722 /* If there were any forks/vforks that were caught and are now to be
723 followed, then do so now. */
724 switch (tp->pending_follow.kind)
726 case TARGET_WAITKIND_FORKED:
727 case TARGET_WAITKIND_VFORKED:
729 ptid_t parent, child;
731 /* If the user did a next/step, etc, over a fork call,
732 preserve the stepping state in the fork child. */
733 if (follow_child && should_resume)
735 step_resume_breakpoint = clone_momentary_breakpoint
736 (tp->control.step_resume_breakpoint);
737 step_range_start = tp->control.step_range_start;
738 step_range_end = tp->control.step_range_end;
739 step_frame_id = tp->control.step_frame_id;
740 exception_resume_breakpoint
741 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
742 command_interp = tp->control.command_interp;
744 /* For now, delete the parent's sr breakpoint, otherwise,
745 parent/child sr breakpoints are considered duplicates,
746 and the child version will not be installed. Remove
747 this when the breakpoints module becomes aware of
748 inferiors and address spaces. */
749 delete_step_resume_breakpoint (tp);
750 tp->control.step_range_start = 0;
751 tp->control.step_range_end = 0;
752 tp->control.step_frame_id = null_frame_id;
753 delete_exception_resume_breakpoint (tp);
754 tp->control.command_interp = NULL;
757 parent = inferior_ptid;
758 child = tp->pending_follow.value.related_pid;
760 /* Set up inferior(s) as specified by the caller, and tell the
761 target to do whatever is necessary to follow either parent
763 if (follow_fork_inferior (follow_child, detach_fork))
765 /* Target refused to follow, or there's some other reason
766 we shouldn't resume. */
771 /* This pending follow fork event is now handled, one way
772 or another. The previous selected thread may be gone
773 from the lists by now, but if it is still around, need
774 to clear the pending follow request. */
775 tp = find_thread_ptid (parent);
777 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
779 /* This makes sure we don't try to apply the "Switched
780 over from WAIT_PID" logic above. */
781 nullify_last_target_wait_ptid ();
783 /* If we followed the child, switch to it... */
786 switch_to_thread (child);
788 /* ... and preserve the stepping state, in case the
789 user was stepping over the fork call. */
792 tp = inferior_thread ();
793 tp->control.step_resume_breakpoint
794 = step_resume_breakpoint;
795 tp->control.step_range_start = step_range_start;
796 tp->control.step_range_end = step_range_end;
797 tp->control.step_frame_id = step_frame_id;
798 tp->control.exception_resume_breakpoint
799 = exception_resume_breakpoint;
800 tp->control.command_interp = command_interp;
804 /* If we get here, it was because we're trying to
805 resume from a fork catchpoint, but, the user
806 has switched threads away from the thread that
807 forked. In that case, the resume command
808 issued is most likely not applicable to the
809 child, so just warn, and refuse to resume. */
810 warning (_("Not resuming: switched threads "
811 "before following fork child."));
814 /* Reset breakpoints in the child as appropriate. */
815 follow_inferior_reset_breakpoints ();
818 switch_to_thread (parent);
822 case TARGET_WAITKIND_SPURIOUS:
823 /* Nothing to follow. */
826 internal_error (__FILE__, __LINE__,
827 "Unexpected pending_follow.kind %d\n",
828 tp->pending_follow.kind);
832 return should_resume;
836 follow_inferior_reset_breakpoints (void)
838 struct thread_info *tp = inferior_thread ();
840 /* Was there a step_resume breakpoint? (There was if the user
841 did a "next" at the fork() call.) If so, explicitly reset its
842 thread number. Cloned step_resume breakpoints are disabled on
843 creation, so enable it here now that it is associated with the
846 step_resumes are a form of bp that are made to be per-thread.
847 Since we created the step_resume bp when the parent process
848 was being debugged, and now are switching to the child process,
849 from the breakpoint package's viewpoint, that's a switch of
850 "threads". We must update the bp's notion of which thread
851 it is for, or it'll be ignored when it triggers. */
853 if (tp->control.step_resume_breakpoint)
855 breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
856 tp->control.step_resume_breakpoint->loc->enabled = 1;
859 /* Treat exception_resume breakpoints like step_resume breakpoints. */
860 if (tp->control.exception_resume_breakpoint)
862 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
863 tp->control.exception_resume_breakpoint->loc->enabled = 1;
866 /* Reinsert all breakpoints in the child. The user may have set
867 breakpoints after catching the fork, in which case those
868 were never set in the child, but only in the parent. This makes
869 sure the inserted breakpoints match the breakpoint list. */
871 breakpoint_re_set ();
872 insert_breakpoints ();
875 /* The child has exited or execed: resume threads of the parent the
876 user wanted to be executing. */
879 proceed_after_vfork_done (struct thread_info *thread,
882 int pid = * (int *) arg;
884 if (ptid_get_pid (thread->ptid) == pid
885 && is_running (thread->ptid)
886 && !is_executing (thread->ptid)
887 && !thread->stop_requested
888 && thread->suspend.stop_signal == GDB_SIGNAL_0)
891 fprintf_unfiltered (gdb_stdlog,
892 "infrun: resuming vfork parent thread %s\n",
893 target_pid_to_str (thread->ptid));
895 switch_to_thread (thread->ptid);
896 clear_proceed_status (0);
897 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
903 /* Called whenever we notice an exec or exit event, to handle
904 detaching or resuming a vfork parent. */
907 handle_vfork_child_exec_or_exit (int exec)
909 struct inferior *inf = current_inferior ();
911 if (inf->vfork_parent)
913 int resume_parent = -1;
915 /* This exec or exit marks the end of the shared memory region
916 between the parent and the child. If the user wanted to
917 detach from the parent, now is the time. */
919 if (inf->vfork_parent->pending_detach)
921 struct thread_info *tp;
922 struct cleanup *old_chain;
923 struct program_space *pspace;
924 struct address_space *aspace;
926 /* follow-fork child, detach-on-fork on. */
928 inf->vfork_parent->pending_detach = 0;
932 /* If we're handling a child exit, then inferior_ptid
933 points at the inferior's pid, not to a thread. */
934 old_chain = save_inferior_ptid ();
935 save_current_program_space ();
936 save_current_inferior ();
939 old_chain = save_current_space_and_thread ();
941 /* We're letting loose of the parent. */
942 tp = any_live_thread_of_process (inf->vfork_parent->pid);
943 switch_to_thread (tp->ptid);
945 /* We're about to detach from the parent, which implicitly
946 removes breakpoints from its address space. There's a
947 catch here: we want to reuse the spaces for the child,
948 but, parent/child are still sharing the pspace at this
949 point, although the exec in reality makes the kernel give
950 the child a fresh set of new pages. The problem here is
951 that the breakpoints module being unaware of this, would
952 likely chose the child process to write to the parent
953 address space. Swapping the child temporarily away from
954 the spaces has the desired effect. Yes, this is "sort
957 pspace = inf->pspace;
958 aspace = inf->aspace;
962 if (debug_infrun || info_verbose)
964 target_terminal_ours_for_output ();
968 fprintf_filtered (gdb_stdlog,
969 _("Detaching vfork parent process "
970 "%d after child exec.\n"),
971 inf->vfork_parent->pid);
975 fprintf_filtered (gdb_stdlog,
976 _("Detaching vfork parent process "
977 "%d after child exit.\n"),
978 inf->vfork_parent->pid);
982 target_detach (NULL, 0);
985 inf->pspace = pspace;
986 inf->aspace = aspace;
988 do_cleanups (old_chain);
992 /* We're staying attached to the parent, so, really give the
993 child a new address space. */
994 inf->pspace = add_program_space (maybe_new_address_space ());
995 inf->aspace = inf->pspace->aspace;
997 set_current_program_space (inf->pspace);
999 resume_parent = inf->vfork_parent->pid;
1001 /* Break the bonds. */
1002 inf->vfork_parent->vfork_child = NULL;
1006 struct cleanup *old_chain;
1007 struct program_space *pspace;
1009 /* If this is a vfork child exiting, then the pspace and
1010 aspaces were shared with the parent. Since we're
1011 reporting the process exit, we'll be mourning all that is
1012 found in the address space, and switching to null_ptid,
1013 preparing to start a new inferior. But, since we don't
1014 want to clobber the parent's address/program spaces, we
1015 go ahead and create a new one for this exiting
1018 /* Switch to null_ptid, so that clone_program_space doesn't want
1019 to read the selected frame of a dead process. */
1020 old_chain = save_inferior_ptid ();
1021 inferior_ptid = null_ptid;
1023 /* This inferior is dead, so avoid giving the breakpoints
1024 module the option to write through to it (cloning a
1025 program space resets breakpoints). */
1028 pspace = add_program_space (maybe_new_address_space ());
1029 set_current_program_space (pspace);
1031 inf->symfile_flags = SYMFILE_NO_READ;
1032 clone_program_space (pspace, inf->vfork_parent->pspace);
1033 inf->pspace = pspace;
1034 inf->aspace = pspace->aspace;
1036 /* Put back inferior_ptid. We'll continue mourning this
1038 do_cleanups (old_chain);
1040 resume_parent = inf->vfork_parent->pid;
1041 /* Break the bonds. */
1042 inf->vfork_parent->vfork_child = NULL;
1045 inf->vfork_parent = NULL;
1047 gdb_assert (current_program_space == inf->pspace);
1049 if (non_stop && resume_parent != -1)
1051 /* If the user wanted the parent to be running, let it go
1053 struct cleanup *old_chain = make_cleanup_restore_current_thread ();
1056 fprintf_unfiltered (gdb_stdlog,
1057 "infrun: resuming vfork parent process %d\n",
1060 iterate_over_threads (proceed_after_vfork_done, &resume_parent);
1062 do_cleanups (old_chain);
1067 /* Enum strings for "set|show follow-exec-mode". */
1069 static const char follow_exec_mode_new[] = "new";
1070 static const char follow_exec_mode_same[] = "same";
1071 static const char *const follow_exec_mode_names[] =
1073 follow_exec_mode_new,
1074 follow_exec_mode_same,
1078 static const char *follow_exec_mode_string = follow_exec_mode_same;
1080 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1081 struct cmd_list_element *c, const char *value)
1083 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
1086 /* EXECD_PATHNAME is assumed to be non-NULL. */
1089 follow_exec (ptid_t ptid, char *execd_pathname)
1091 struct thread_info *th, *tmp;
1092 struct inferior *inf = current_inferior ();
1093 int pid = ptid_get_pid (ptid);
1094 ptid_t process_ptid;
1096 /* This is an exec event that we actually wish to pay attention to.
1097 Refresh our symbol table to the newly exec'd program, remove any
1098 momentary bp's, etc.
1100 If there are breakpoints, they aren't really inserted now,
1101 since the exec() transformed our inferior into a fresh set
1104 We want to preserve symbolic breakpoints on the list, since
1105 we have hopes that they can be reset after the new a.out's
1106 symbol table is read.
1108 However, any "raw" breakpoints must be removed from the list
1109 (e.g., the solib bp's), since their address is probably invalid
1112 And, we DON'T want to call delete_breakpoints() here, since
1113 that may write the bp's "shadow contents" (the instruction
1114 value that was overwritten witha TRAP instruction). Since
1115 we now have a new a.out, those shadow contents aren't valid. */
1117 mark_breakpoints_out ();
1119 /* The target reports the exec event to the main thread, even if
1120 some other thread does the exec, and even if the main thread was
1121 stopped or already gone. We may still have non-leader threads of
1122 the process on our list. E.g., on targets that don't have thread
1123 exit events (like remote); or on native Linux in non-stop mode if
1124 there were only two threads in the inferior and the non-leader
1125 one is the one that execs (and nothing forces an update of the
1126 thread list up to here). When debugging remotely, it's best to
1127 avoid extra traffic, when possible, so avoid syncing the thread
1128 list with the target, and instead go ahead and delete all threads
1129 of the process but one that reported the event. Note this must
1130 be done before calling update_breakpoints_after_exec, as
1131 otherwise clearing the threads' resources would reference stale
1132 thread breakpoints -- it may have been one of these threads that
1133 stepped across the exec. We could just clear their stepping
1134 states, but as long as we're iterating, might as well delete
1135 them. Deleting them now rather than at the next user-visible
1136 stop provides a nicer sequence of events for user and MI
1138 ALL_THREADS_SAFE (th, tmp)
1139 if (ptid_get_pid (th->ptid) == pid && !ptid_equal (th->ptid, ptid))
1140 delete_thread (th->ptid);
1142 /* We also need to clear any left over stale state for the
1143 leader/event thread. E.g., if there was any step-resume
1144 breakpoint or similar, it's gone now. We cannot truly
1145 step-to-next statement through an exec(). */
1146 th = inferior_thread ();
1147 th->control.step_resume_breakpoint = NULL;
1148 th->control.exception_resume_breakpoint = NULL;
1149 th->control.single_step_breakpoints = NULL;
1150 th->control.step_range_start = 0;
1151 th->control.step_range_end = 0;
1153 /* The user may have had the main thread held stopped in the
1154 previous image (e.g., schedlock on, or non-stop). Release
1156 th->stop_requested = 0;
1158 update_breakpoints_after_exec ();
1160 /* What is this a.out's name? */
1161 process_ptid = pid_to_ptid (pid);
1162 printf_unfiltered (_("%s is executing new program: %s\n"),
1163 target_pid_to_str (process_ptid),
1166 /* We've followed the inferior through an exec. Therefore, the
1167 inferior has essentially been killed & reborn. */
1169 gdb_flush (gdb_stdout);
1171 breakpoint_init_inferior (inf_execd);
1173 if (*gdb_sysroot != '\0')
1175 char *name = exec_file_find (execd_pathname, NULL);
1177 execd_pathname = (char *) alloca (strlen (name) + 1);
1178 strcpy (execd_pathname, name);
1182 /* Reset the shared library package. This ensures that we get a
1183 shlib event when the child reaches "_start", at which point the
1184 dld will have had a chance to initialize the child. */
1185 /* Also, loading a symbol file below may trigger symbol lookups, and
1186 we don't want those to be satisfied by the libraries of the
1187 previous incarnation of this process. */
1188 no_shared_libraries (NULL, 0);
1190 if (follow_exec_mode_string == follow_exec_mode_new)
1192 /* The user wants to keep the old inferior and program spaces
1193 around. Create a new fresh one, and switch to it. */
1195 /* Do exit processing for the original inferior before adding
1196 the new inferior so we don't have two active inferiors with
1197 the same ptid, which can confuse find_inferior_ptid. */
1198 exit_inferior_num_silent (current_inferior ()->num);
1200 inf = add_inferior_with_spaces ();
1202 target_follow_exec (inf, execd_pathname);
1204 set_current_inferior (inf);
1205 set_current_program_space (inf->pspace);
1210 /* The old description may no longer be fit for the new image.
1211 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1212 old description; we'll read a new one below. No need to do
1213 this on "follow-exec-mode new", as the old inferior stays
1214 around (its description is later cleared/refetched on
1216 target_clear_description ();
1219 gdb_assert (current_program_space == inf->pspace);
1221 /* That a.out is now the one to use. */
1222 exec_file_attach (execd_pathname, 0);
1224 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1225 (Position Independent Executable) main symbol file will get applied by
1226 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1227 the breakpoints with the zero displacement. */
1229 symbol_file_add (execd_pathname,
1231 | SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET),
1234 if ((inf->symfile_flags & SYMFILE_NO_READ) == 0)
1235 set_initial_language ();
1237 /* If the target can specify a description, read it. Must do this
1238 after flipping to the new executable (because the target supplied
1239 description must be compatible with the executable's
1240 architecture, and the old executable may e.g., be 32-bit, while
1241 the new one 64-bit), and before anything involving memory or
1243 target_find_description ();
1245 solib_create_inferior_hook (0);
1247 jit_inferior_created_hook ();
1249 breakpoint_re_set ();
1251 /* Reinsert all breakpoints. (Those which were symbolic have
1252 been reset to the proper address in the new a.out, thanks
1253 to symbol_file_command...). */
1254 insert_breakpoints ();
1256 /* The next resume of this inferior should bring it to the shlib
1257 startup breakpoints. (If the user had also set bp's on
1258 "main" from the old (parent) process, then they'll auto-
1259 matically get reset there in the new process.). */
1262 /* The queue of threads that need to do a step-over operation to get
1263 past e.g., a breakpoint. What technique is used to step over the
1264 breakpoint/watchpoint does not matter -- all threads end up in the
1265 same queue, to maintain rough temporal order of execution, in order
1266 to avoid starvation, otherwise, we could e.g., find ourselves
1267 constantly stepping the same couple threads past their breakpoints
1268 over and over, if the single-step finish fast enough. */
1269 struct thread_info *step_over_queue_head;
1271 /* Bit flags indicating what the thread needs to step over. */
1273 enum step_over_what_flag
1275 /* Step over a breakpoint. */
1276 STEP_OVER_BREAKPOINT = 1,
1278 /* Step past a non-continuable watchpoint, in order to let the
1279 instruction execute so we can evaluate the watchpoint
1281 STEP_OVER_WATCHPOINT = 2
1283 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag, step_over_what);
1285 /* Info about an instruction that is being stepped over. */
1287 struct step_over_info
1289 /* If we're stepping past a breakpoint, this is the address space
1290 and address of the instruction the breakpoint is set at. We'll
1291 skip inserting all breakpoints here. Valid iff ASPACE is
1293 struct address_space *aspace;
1296 /* The instruction being stepped over triggers a nonsteppable
1297 watchpoint. If true, we'll skip inserting watchpoints. */
1298 int nonsteppable_watchpoint_p;
1301 /* The step-over info of the location that is being stepped over.
1303 Note that with async/breakpoint always-inserted mode, a user might
1304 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1305 being stepped over. As setting a new breakpoint inserts all
1306 breakpoints, we need to make sure the breakpoint being stepped over
1307 isn't inserted then. We do that by only clearing the step-over
1308 info when the step-over is actually finished (or aborted).
1310 Presently GDB can only step over one breakpoint at any given time.
1311 Given threads that can't run code in the same address space as the
1312 breakpoint's can't really miss the breakpoint, GDB could be taught
1313 to step-over at most one breakpoint per address space (so this info
1314 could move to the address space object if/when GDB is extended).
1315 The set of breakpoints being stepped over will normally be much
1316 smaller than the set of all breakpoints, so a flag in the
1317 breakpoint location structure would be wasteful. A separate list
1318 also saves complexity and run-time, as otherwise we'd have to go
1319 through all breakpoint locations clearing their flag whenever we
1320 start a new sequence. Similar considerations weigh against storing
1321 this info in the thread object. Plus, not all step overs actually
1322 have breakpoint locations -- e.g., stepping past a single-step
1323 breakpoint, or stepping to complete a non-continuable
1325 static struct step_over_info step_over_info;
1327 /* Record the address of the breakpoint/instruction we're currently
1331 set_step_over_info (struct address_space *aspace, CORE_ADDR address,
1332 int nonsteppable_watchpoint_p)
1334 step_over_info.aspace = aspace;
1335 step_over_info.address = address;
1336 step_over_info.nonsteppable_watchpoint_p = nonsteppable_watchpoint_p;
1339 /* Called when we're not longer stepping over a breakpoint / an
1340 instruction, so all breakpoints are free to be (re)inserted. */
1343 clear_step_over_info (void)
1346 fprintf_unfiltered (gdb_stdlog,
1347 "infrun: clear_step_over_info\n");
1348 step_over_info.aspace = NULL;
1349 step_over_info.address = 0;
1350 step_over_info.nonsteppable_watchpoint_p = 0;
1356 stepping_past_instruction_at (struct address_space *aspace,
1359 return (step_over_info.aspace != NULL
1360 && breakpoint_address_match (aspace, address,
1361 step_over_info.aspace,
1362 step_over_info.address));
1368 stepping_past_nonsteppable_watchpoint (void)
1370 return step_over_info.nonsteppable_watchpoint_p;
1373 /* Returns true if step-over info is valid. */
1376 step_over_info_valid_p (void)
1378 return (step_over_info.aspace != NULL
1379 || stepping_past_nonsteppable_watchpoint ());
1383 /* Displaced stepping. */
1385 /* In non-stop debugging mode, we must take special care to manage
1386 breakpoints properly; in particular, the traditional strategy for
1387 stepping a thread past a breakpoint it has hit is unsuitable.
1388 'Displaced stepping' is a tactic for stepping one thread past a
1389 breakpoint it has hit while ensuring that other threads running
1390 concurrently will hit the breakpoint as they should.
1392 The traditional way to step a thread T off a breakpoint in a
1393 multi-threaded program in all-stop mode is as follows:
1395 a0) Initially, all threads are stopped, and breakpoints are not
1397 a1) We single-step T, leaving breakpoints uninserted.
1398 a2) We insert breakpoints, and resume all threads.
1400 In non-stop debugging, however, this strategy is unsuitable: we
1401 don't want to have to stop all threads in the system in order to
1402 continue or step T past a breakpoint. Instead, we use displaced
1405 n0) Initially, T is stopped, other threads are running, and
1406 breakpoints are inserted.
1407 n1) We copy the instruction "under" the breakpoint to a separate
1408 location, outside the main code stream, making any adjustments
1409 to the instruction, register, and memory state as directed by
1411 n2) We single-step T over the instruction at its new location.
1412 n3) We adjust the resulting register and memory state as directed
1413 by T's architecture. This includes resetting T's PC to point
1414 back into the main instruction stream.
1417 This approach depends on the following gdbarch methods:
1419 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1420 indicate where to copy the instruction, and how much space must
1421 be reserved there. We use these in step n1.
1423 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1424 address, and makes any necessary adjustments to the instruction,
1425 register contents, and memory. We use this in step n1.
1427 - gdbarch_displaced_step_fixup adjusts registers and memory after
1428 we have successfuly single-stepped the instruction, to yield the
1429 same effect the instruction would have had if we had executed it
1430 at its original address. We use this in step n3.
1432 - gdbarch_displaced_step_free_closure provides cleanup.
1434 The gdbarch_displaced_step_copy_insn and
1435 gdbarch_displaced_step_fixup functions must be written so that
1436 copying an instruction with gdbarch_displaced_step_copy_insn,
1437 single-stepping across the copied instruction, and then applying
1438 gdbarch_displaced_insn_fixup should have the same effects on the
1439 thread's memory and registers as stepping the instruction in place
1440 would have. Exactly which responsibilities fall to the copy and
1441 which fall to the fixup is up to the author of those functions.
1443 See the comments in gdbarch.sh for details.
1445 Note that displaced stepping and software single-step cannot
1446 currently be used in combination, although with some care I think
1447 they could be made to. Software single-step works by placing
1448 breakpoints on all possible subsequent instructions; if the
1449 displaced instruction is a PC-relative jump, those breakpoints
1450 could fall in very strange places --- on pages that aren't
1451 executable, or at addresses that are not proper instruction
1452 boundaries. (We do generally let other threads run while we wait
1453 to hit the software single-step breakpoint, and they might
1454 encounter such a corrupted instruction.) One way to work around
1455 this would be to have gdbarch_displaced_step_copy_insn fully
1456 simulate the effect of PC-relative instructions (and return NULL)
1457 on architectures that use software single-stepping.
1459 In non-stop mode, we can have independent and simultaneous step
1460 requests, so more than one thread may need to simultaneously step
1461 over a breakpoint. The current implementation assumes there is
1462 only one scratch space per process. In this case, we have to
1463 serialize access to the scratch space. If thread A wants to step
1464 over a breakpoint, but we are currently waiting for some other
1465 thread to complete a displaced step, we leave thread A stopped and
1466 place it in the displaced_step_request_queue. Whenever a displaced
1467 step finishes, we pick the next thread in the queue and start a new
1468 displaced step operation on it. See displaced_step_prepare and
1469 displaced_step_fixup for details. */
1471 /* Per-inferior displaced stepping state. */
1472 struct displaced_step_inferior_state
1474 /* Pointer to next in linked list. */
1475 struct displaced_step_inferior_state *next;
1477 /* The process this displaced step state refers to. */
1480 /* True if preparing a displaced step ever failed. If so, we won't
1481 try displaced stepping for this inferior again. */
1484 /* If this is not null_ptid, this is the thread carrying out a
1485 displaced single-step in process PID. This thread's state will
1486 require fixing up once it has completed its step. */
1489 /* The architecture the thread had when we stepped it. */
1490 struct gdbarch *step_gdbarch;
1492 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1493 for post-step cleanup. */
1494 struct displaced_step_closure *step_closure;
1496 /* The address of the original instruction, and the copy we
1498 CORE_ADDR step_original, step_copy;
1500 /* Saved contents of copy area. */
1501 gdb_byte *step_saved_copy;
1504 /* The list of states of processes involved in displaced stepping
1506 static struct displaced_step_inferior_state *displaced_step_inferior_states;
1508 /* Get the displaced stepping state of process PID. */
1510 static struct displaced_step_inferior_state *
1511 get_displaced_stepping_state (int pid)
1513 struct displaced_step_inferior_state *state;
1515 for (state = displaced_step_inferior_states;
1517 state = state->next)
1518 if (state->pid == pid)
1524 /* Returns true if any inferior has a thread doing a displaced
1528 displaced_step_in_progress_any_inferior (void)
1530 struct displaced_step_inferior_state *state;
1532 for (state = displaced_step_inferior_states;
1534 state = state->next)
1535 if (!ptid_equal (state->step_ptid, null_ptid))
1541 /* Return true if thread represented by PTID is doing a displaced
1545 displaced_step_in_progress_thread (ptid_t ptid)
1547 struct displaced_step_inferior_state *displaced;
1549 gdb_assert (!ptid_equal (ptid, null_ptid));
1551 displaced = get_displaced_stepping_state (ptid_get_pid (ptid));
1553 return (displaced != NULL && ptid_equal (displaced->step_ptid, ptid));
1556 /* Return true if process PID has a thread doing a displaced step. */
1559 displaced_step_in_progress (int pid)
1561 struct displaced_step_inferior_state *displaced;
1563 displaced = get_displaced_stepping_state (pid);
1564 if (displaced != NULL && !ptid_equal (displaced->step_ptid, null_ptid))
1570 /* Add a new displaced stepping state for process PID to the displaced
1571 stepping state list, or return a pointer to an already existing
1572 entry, if it already exists. Never returns NULL. */
1574 static struct displaced_step_inferior_state *
1575 add_displaced_stepping_state (int pid)
1577 struct displaced_step_inferior_state *state;
1579 for (state = displaced_step_inferior_states;
1581 state = state->next)
1582 if (state->pid == pid)
1585 state = XCNEW (struct displaced_step_inferior_state);
1587 state->next = displaced_step_inferior_states;
1588 displaced_step_inferior_states = state;
1593 /* If inferior is in displaced stepping, and ADDR equals to starting address
1594 of copy area, return corresponding displaced_step_closure. Otherwise,
1597 struct displaced_step_closure*
1598 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1600 struct displaced_step_inferior_state *displaced
1601 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1603 /* If checking the mode of displaced instruction in copy area. */
1604 if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1605 && (displaced->step_copy == addr))
1606 return displaced->step_closure;
1611 /* Remove the displaced stepping state of process PID. */
1614 remove_displaced_stepping_state (int pid)
1616 struct displaced_step_inferior_state *it, **prev_next_p;
1618 gdb_assert (pid != 0);
1620 it = displaced_step_inferior_states;
1621 prev_next_p = &displaced_step_inferior_states;
1626 *prev_next_p = it->next;
1631 prev_next_p = &it->next;
1637 infrun_inferior_exit (struct inferior *inf)
1639 remove_displaced_stepping_state (inf->pid);
1642 /* If ON, and the architecture supports it, GDB will use displaced
1643 stepping to step over breakpoints. If OFF, or if the architecture
1644 doesn't support it, GDB will instead use the traditional
1645 hold-and-step approach. If AUTO (which is the default), GDB will
1646 decide which technique to use to step over breakpoints depending on
1647 which of all-stop or non-stop mode is active --- displaced stepping
1648 in non-stop mode; hold-and-step in all-stop mode. */
1650 static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
1653 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1654 struct cmd_list_element *c,
1657 if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1658 fprintf_filtered (file,
1659 _("Debugger's willingness to use displaced stepping "
1660 "to step over breakpoints is %s (currently %s).\n"),
1661 value, target_is_non_stop_p () ? "on" : "off");
1663 fprintf_filtered (file,
1664 _("Debugger's willingness to use displaced stepping "
1665 "to step over breakpoints is %s.\n"), value);
1668 /* Return non-zero if displaced stepping can/should be used to step
1669 over breakpoints of thread TP. */
1672 use_displaced_stepping (struct thread_info *tp)
1674 struct regcache *regcache = get_thread_regcache (tp->ptid);
1675 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1676 struct displaced_step_inferior_state *displaced_state;
1678 displaced_state = get_displaced_stepping_state (ptid_get_pid (tp->ptid));
1680 return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
1681 && target_is_non_stop_p ())
1682 || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1683 && gdbarch_displaced_step_copy_insn_p (gdbarch)
1684 && find_record_target () == NULL
1685 && (displaced_state == NULL
1686 || !displaced_state->failed_before));
1689 /* Clean out any stray displaced stepping state. */
1691 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1693 /* Indicate that there is no cleanup pending. */
1694 displaced->step_ptid = null_ptid;
1696 if (displaced->step_closure)
1698 gdbarch_displaced_step_free_closure (displaced->step_gdbarch,
1699 displaced->step_closure);
1700 displaced->step_closure = NULL;
1705 displaced_step_clear_cleanup (void *arg)
1707 struct displaced_step_inferior_state *state
1708 = (struct displaced_step_inferior_state *) arg;
1710 displaced_step_clear (state);
1713 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1715 displaced_step_dump_bytes (struct ui_file *file,
1716 const gdb_byte *buf,
1721 for (i = 0; i < len; i++)
1722 fprintf_unfiltered (file, "%02x ", buf[i]);
1723 fputs_unfiltered ("\n", file);
1726 /* Prepare to single-step, using displaced stepping.
1728 Note that we cannot use displaced stepping when we have a signal to
1729 deliver. If we have a signal to deliver and an instruction to step
1730 over, then after the step, there will be no indication from the
1731 target whether the thread entered a signal handler or ignored the
1732 signal and stepped over the instruction successfully --- both cases
1733 result in a simple SIGTRAP. In the first case we mustn't do a
1734 fixup, and in the second case we must --- but we can't tell which.
1735 Comments in the code for 'random signals' in handle_inferior_event
1736 explain how we handle this case instead.
1738 Returns 1 if preparing was successful -- this thread is going to be
1739 stepped now; 0 if displaced stepping this thread got queued; or -1
1740 if this instruction can't be displaced stepped. */
1743 displaced_step_prepare_throw (ptid_t ptid)
1745 struct cleanup *old_cleanups, *ignore_cleanups;
1746 struct thread_info *tp = find_thread_ptid (ptid);
1747 struct regcache *regcache = get_thread_regcache (ptid);
1748 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1749 struct address_space *aspace = get_regcache_aspace (regcache);
1750 CORE_ADDR original, copy;
1752 struct displaced_step_closure *closure;
1753 struct displaced_step_inferior_state *displaced;
1756 /* We should never reach this function if the architecture does not
1757 support displaced stepping. */
1758 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1760 /* Nor if the thread isn't meant to step over a breakpoint. */
1761 gdb_assert (tp->control.trap_expected);
1763 /* Disable range stepping while executing in the scratch pad. We
1764 want a single-step even if executing the displaced instruction in
1765 the scratch buffer lands within the stepping range (e.g., a
1767 tp->control.may_range_step = 0;
1769 /* We have to displaced step one thread at a time, as we only have
1770 access to a single scratch space per inferior. */
1772 displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1774 if (!ptid_equal (displaced->step_ptid, null_ptid))
1776 /* Already waiting for a displaced step to finish. Defer this
1777 request and place in queue. */
1779 if (debug_displaced)
1780 fprintf_unfiltered (gdb_stdlog,
1781 "displaced: deferring step of %s\n",
1782 target_pid_to_str (ptid));
1784 thread_step_over_chain_enqueue (tp);
1789 if (debug_displaced)
1790 fprintf_unfiltered (gdb_stdlog,
1791 "displaced: stepping %s now\n",
1792 target_pid_to_str (ptid));
1795 displaced_step_clear (displaced);
1797 old_cleanups = save_inferior_ptid ();
1798 inferior_ptid = ptid;
1800 original = regcache_read_pc (regcache);
1802 copy = gdbarch_displaced_step_location (gdbarch);
1803 len = gdbarch_max_insn_length (gdbarch);
1805 if (breakpoint_in_range_p (aspace, copy, len))
1807 /* There's a breakpoint set in the scratch pad location range
1808 (which is usually around the entry point). We'd either
1809 install it before resuming, which would overwrite/corrupt the
1810 scratch pad, or if it was already inserted, this displaced
1811 step would overwrite it. The latter is OK in the sense that
1812 we already assume that no thread is going to execute the code
1813 in the scratch pad range (after initial startup) anyway, but
1814 the former is unacceptable. Simply punt and fallback to
1815 stepping over this breakpoint in-line. */
1816 if (debug_displaced)
1818 fprintf_unfiltered (gdb_stdlog,
1819 "displaced: breakpoint set in scratch pad. "
1820 "Stepping over breakpoint in-line instead.\n");
1823 do_cleanups (old_cleanups);
1827 /* Save the original contents of the copy area. */
1828 displaced->step_saved_copy = (gdb_byte *) xmalloc (len);
1829 ignore_cleanups = make_cleanup (free_current_contents,
1830 &displaced->step_saved_copy);
1831 status = target_read_memory (copy, displaced->step_saved_copy, len);
1833 throw_error (MEMORY_ERROR,
1834 _("Error accessing memory address %s (%s) for "
1835 "displaced-stepping scratch space."),
1836 paddress (gdbarch, copy), safe_strerror (status));
1837 if (debug_displaced)
1839 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1840 paddress (gdbarch, copy));
1841 displaced_step_dump_bytes (gdb_stdlog,
1842 displaced->step_saved_copy,
1846 closure = gdbarch_displaced_step_copy_insn (gdbarch,
1847 original, copy, regcache);
1848 if (closure == NULL)
1850 /* The architecture doesn't know how or want to displaced step
1851 this instruction or instruction sequence. Fallback to
1852 stepping over the breakpoint in-line. */
1853 do_cleanups (old_cleanups);
1857 /* Save the information we need to fix things up if the step
1859 displaced->step_ptid = ptid;
1860 displaced->step_gdbarch = gdbarch;
1861 displaced->step_closure = closure;
1862 displaced->step_original = original;
1863 displaced->step_copy = copy;
1865 make_cleanup (displaced_step_clear_cleanup, displaced);
1867 /* Resume execution at the copy. */
1868 regcache_write_pc (regcache, copy);
1870 discard_cleanups (ignore_cleanups);
1872 do_cleanups (old_cleanups);
1874 if (debug_displaced)
1875 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1876 paddress (gdbarch, copy));
1881 /* Wrapper for displaced_step_prepare_throw that disabled further
1882 attempts at displaced stepping if we get a memory error. */
1885 displaced_step_prepare (ptid_t ptid)
1891 prepared = displaced_step_prepare_throw (ptid);
1893 CATCH (ex, RETURN_MASK_ERROR)
1895 struct displaced_step_inferior_state *displaced_state;
1897 if (ex.error != MEMORY_ERROR)
1898 throw_exception (ex);
1902 fprintf_unfiltered (gdb_stdlog,
1903 "infrun: disabling displaced stepping: %s\n",
1907 /* Be verbose if "set displaced-stepping" is "on", silent if
1909 if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1911 warning (_("disabling displaced stepping: %s"),
1915 /* Disable further displaced stepping attempts. */
1917 = get_displaced_stepping_state (ptid_get_pid (ptid));
1918 displaced_state->failed_before = 1;
1926 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1927 const gdb_byte *myaddr, int len)
1929 struct cleanup *ptid_cleanup = save_inferior_ptid ();
1931 inferior_ptid = ptid;
1932 write_memory (memaddr, myaddr, len);
1933 do_cleanups (ptid_cleanup);
1936 /* Restore the contents of the copy area for thread PTID. */
1939 displaced_step_restore (struct displaced_step_inferior_state *displaced,
1942 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1944 write_memory_ptid (ptid, displaced->step_copy,
1945 displaced->step_saved_copy, len);
1946 if (debug_displaced)
1947 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1948 target_pid_to_str (ptid),
1949 paddress (displaced->step_gdbarch,
1950 displaced->step_copy));
1953 /* If we displaced stepped an instruction successfully, adjust
1954 registers and memory to yield the same effect the instruction would
1955 have had if we had executed it at its original address, and return
1956 1. If the instruction didn't complete, relocate the PC and return
1957 -1. If the thread wasn't displaced stepping, return 0. */
1960 displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
1962 struct cleanup *old_cleanups;
1963 struct displaced_step_inferior_state *displaced
1964 = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1967 /* Was any thread of this process doing a displaced step? */
1968 if (displaced == NULL)
1971 /* Was this event for the pid we displaced? */
1972 if (ptid_equal (displaced->step_ptid, null_ptid)
1973 || ! ptid_equal (displaced->step_ptid, event_ptid))
1976 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1978 displaced_step_restore (displaced, displaced->step_ptid);
1980 /* Fixup may need to read memory/registers. Switch to the thread
1981 that we're fixing up. Also, target_stopped_by_watchpoint checks
1982 the current thread. */
1983 switch_to_thread (event_ptid);
1985 /* Did the instruction complete successfully? */
1986 if (signal == GDB_SIGNAL_TRAP
1987 && !(target_stopped_by_watchpoint ()
1988 && (gdbarch_have_nonsteppable_watchpoint (displaced->step_gdbarch)
1989 || target_have_steppable_watchpoint)))
1991 /* Fix up the resulting state. */
1992 gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1993 displaced->step_closure,
1994 displaced->step_original,
1995 displaced->step_copy,
1996 get_thread_regcache (displaced->step_ptid));
2001 /* Since the instruction didn't complete, all we can do is
2003 struct regcache *regcache = get_thread_regcache (event_ptid);
2004 CORE_ADDR pc = regcache_read_pc (regcache);
2006 pc = displaced->step_original + (pc - displaced->step_copy);
2007 regcache_write_pc (regcache, pc);
2011 do_cleanups (old_cleanups);
2013 displaced->step_ptid = null_ptid;
2018 /* Data to be passed around while handling an event. This data is
2019 discarded between events. */
2020 struct execution_control_state
2023 /* The thread that got the event, if this was a thread event; NULL
2025 struct thread_info *event_thread;
2027 struct target_waitstatus ws;
2028 int stop_func_filled_in;
2029 CORE_ADDR stop_func_start;
2030 CORE_ADDR stop_func_end;
2031 const char *stop_func_name;
2034 /* True if the event thread hit the single-step breakpoint of
2035 another thread. Thus the event doesn't cause a stop, the thread
2036 needs to be single-stepped past the single-step breakpoint before
2037 we can switch back to the original stepping thread. */
2038 int hit_singlestep_breakpoint;
2041 /* Clear ECS and set it to point at TP. */
2044 reset_ecs (struct execution_control_state *ecs, struct thread_info *tp)
2046 memset (ecs, 0, sizeof (*ecs));
2047 ecs->event_thread = tp;
2048 ecs->ptid = tp->ptid;
2051 static void keep_going_pass_signal (struct execution_control_state *ecs);
2052 static void prepare_to_wait (struct execution_control_state *ecs);
2053 static int keep_going_stepped_thread (struct thread_info *tp);
2054 static step_over_what thread_still_needs_step_over (struct thread_info *tp);
2055 static void stop_all_threads (void);
2057 /* Are there any pending step-over requests? If so, run all we can
2058 now and return true. Otherwise, return false. */
2061 start_step_over (void)
2063 struct thread_info *tp, *next;
2065 /* Don't start a new step-over if we already have an in-line
2066 step-over operation ongoing. */
2067 if (step_over_info_valid_p ())
2070 for (tp = step_over_queue_head; tp != NULL; tp = next)
2072 struct execution_control_state ecss;
2073 struct execution_control_state *ecs = &ecss;
2074 step_over_what step_what;
2075 int must_be_in_line;
2077 next = thread_step_over_chain_next (tp);
2079 /* If this inferior already has a displaced step in process,
2080 don't start a new one. */
2081 if (displaced_step_in_progress (ptid_get_pid (tp->ptid)))
2084 step_what = thread_still_needs_step_over (tp);
2085 must_be_in_line = ((step_what & STEP_OVER_WATCHPOINT)
2086 || ((step_what & STEP_OVER_BREAKPOINT)
2087 && !use_displaced_stepping (tp)));
2089 /* We currently stop all threads of all processes to step-over
2090 in-line. If we need to start a new in-line step-over, let
2091 any pending displaced steps finish first. */
2092 if (must_be_in_line && displaced_step_in_progress_any_inferior ())
2095 thread_step_over_chain_remove (tp);
2097 if (step_over_queue_head == NULL)
2100 fprintf_unfiltered (gdb_stdlog,
2101 "infrun: step-over queue now empty\n");
2104 if (tp->control.trap_expected
2108 internal_error (__FILE__, __LINE__,
2109 "[%s] has inconsistent state: "
2110 "trap_expected=%d, resumed=%d, executing=%d\n",
2111 target_pid_to_str (tp->ptid),
2112 tp->control.trap_expected,
2118 fprintf_unfiltered (gdb_stdlog,
2119 "infrun: resuming [%s] for step-over\n",
2120 target_pid_to_str (tp->ptid));
2122 /* keep_going_pass_signal skips the step-over if the breakpoint
2123 is no longer inserted. In all-stop, we want to keep looking
2124 for a thread that needs a step-over instead of resuming TP,
2125 because we wouldn't be able to resume anything else until the
2126 target stops again. In non-stop, the resume always resumes
2127 only TP, so it's OK to let the thread resume freely. */
2128 if (!target_is_non_stop_p () && !step_what)
2131 switch_to_thread (tp->ptid);
2132 reset_ecs (ecs, tp);
2133 keep_going_pass_signal (ecs);
2135 if (!ecs->wait_some_more)
2136 error (_("Command aborted."));
2138 gdb_assert (tp->resumed);
2140 /* If we started a new in-line step-over, we're done. */
2141 if (step_over_info_valid_p ())
2143 gdb_assert (tp->control.trap_expected);
2147 if (!target_is_non_stop_p ())
2149 /* On all-stop, shouldn't have resumed unless we needed a
2151 gdb_assert (tp->control.trap_expected
2152 || tp->step_after_step_resume_breakpoint);
2154 /* With remote targets (at least), in all-stop, we can't
2155 issue any further remote commands until the program stops
2160 /* Either the thread no longer needed a step-over, or a new
2161 displaced stepping sequence started. Even in the latter
2162 case, continue looking. Maybe we can also start another
2163 displaced step on a thread of other process. */
2169 /* Update global variables holding ptids to hold NEW_PTID if they were
2170 holding OLD_PTID. */
2172 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
2174 struct displaced_step_request *it;
2175 struct displaced_step_inferior_state *displaced;
2177 if (ptid_equal (inferior_ptid, old_ptid))
2178 inferior_ptid = new_ptid;
2180 for (displaced = displaced_step_inferior_states;
2182 displaced = displaced->next)
2184 if (ptid_equal (displaced->step_ptid, old_ptid))
2185 displaced->step_ptid = new_ptid;
2192 /* Things to clean up if we QUIT out of resume (). */
2194 resume_cleanups (void *ignore)
2196 if (!ptid_equal (inferior_ptid, null_ptid))
2197 delete_single_step_breakpoints (inferior_thread ());
2202 static const char schedlock_off[] = "off";
2203 static const char schedlock_on[] = "on";
2204 static const char schedlock_step[] = "step";
2205 static const char schedlock_replay[] = "replay";
2206 static const char *const scheduler_enums[] = {
2213 static const char *scheduler_mode = schedlock_replay;
2215 show_scheduler_mode (struct ui_file *file, int from_tty,
2216 struct cmd_list_element *c, const char *value)
2218 fprintf_filtered (file,
2219 _("Mode for locking scheduler "
2220 "during execution is \"%s\".\n"),
2225 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
2227 if (!target_can_lock_scheduler)
2229 scheduler_mode = schedlock_off;
2230 error (_("Target '%s' cannot support this command."), target_shortname);
2234 /* True if execution commands resume all threads of all processes by
2235 default; otherwise, resume only threads of the current inferior
2237 int sched_multi = 0;
2239 /* Try to setup for software single stepping over the specified location.
2240 Return 1 if target_resume() should use hardware single step.
2242 GDBARCH the current gdbarch.
2243 PC the location to step over. */
2246 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
2250 if (execution_direction == EXEC_FORWARD
2251 && gdbarch_software_single_step_p (gdbarch)
2252 && gdbarch_software_single_step (gdbarch, get_current_frame ()))
2262 user_visible_resume_ptid (int step)
2268 /* With non-stop mode on, threads are always handled
2270 resume_ptid = inferior_ptid;
2272 else if ((scheduler_mode == schedlock_on)
2273 || (scheduler_mode == schedlock_step && step))
2275 /* User-settable 'scheduler' mode requires solo thread
2277 resume_ptid = inferior_ptid;
2279 else if ((scheduler_mode == schedlock_replay)
2280 && target_record_will_replay (minus_one_ptid, execution_direction))
2282 /* User-settable 'scheduler' mode requires solo thread resume in replay
2284 resume_ptid = inferior_ptid;
2286 else if (!sched_multi && target_supports_multi_process ())
2288 /* Resume all threads of the current process (and none of other
2290 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
2294 /* Resume all threads of all processes. */
2295 resume_ptid = RESUME_ALL;
2301 /* Return a ptid representing the set of threads that we will resume,
2302 in the perspective of the target, assuming run control handling
2303 does not require leaving some threads stopped (e.g., stepping past
2304 breakpoint). USER_STEP indicates whether we're about to start the
2305 target for a stepping command. */
2308 internal_resume_ptid (int user_step)
2310 /* In non-stop, we always control threads individually. Note that
2311 the target may always work in non-stop mode even with "set
2312 non-stop off", in which case user_visible_resume_ptid could
2313 return a wildcard ptid. */
2314 if (target_is_non_stop_p ())
2315 return inferior_ptid;
2317 return user_visible_resume_ptid (user_step);
2320 /* Wrapper for target_resume, that handles infrun-specific
2324 do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig)
2326 struct thread_info *tp = inferior_thread ();
2328 /* Install inferior's terminal modes. */
2329 target_terminal_inferior ();
2331 /* Avoid confusing the next resume, if the next stop/resume
2332 happens to apply to another thread. */
2333 tp->suspend.stop_signal = GDB_SIGNAL_0;
2335 /* Advise target which signals may be handled silently.
2337 If we have removed breakpoints because we are stepping over one
2338 in-line (in any thread), we need to receive all signals to avoid
2339 accidentally skipping a breakpoint during execution of a signal
2342 Likewise if we're displaced stepping, otherwise a trap for a
2343 breakpoint in a signal handler might be confused with the
2344 displaced step finishing. We don't make the displaced_step_fixup
2345 step distinguish the cases instead, because:
2347 - a backtrace while stopped in the signal handler would show the
2348 scratch pad as frame older than the signal handler, instead of
2349 the real mainline code.
2351 - when the thread is later resumed, the signal handler would
2352 return to the scratch pad area, which would no longer be
2354 if (step_over_info_valid_p ()
2355 || displaced_step_in_progress (ptid_get_pid (tp->ptid)))
2356 target_pass_signals (0, NULL);
2358 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2360 target_resume (resume_ptid, step, sig);
2363 /* Resume the inferior, but allow a QUIT. This is useful if the user
2364 wants to interrupt some lengthy single-stepping operation
2365 (for child processes, the SIGINT goes to the inferior, and so
2366 we get a SIGINT random_signal, but for remote debugging and perhaps
2367 other targets, that's not true).
2369 SIG is the signal to give the inferior (zero for none). */
2371 resume (enum gdb_signal sig)
2373 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
2374 struct regcache *regcache = get_current_regcache ();
2375 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2376 struct thread_info *tp = inferior_thread ();
2377 CORE_ADDR pc = regcache_read_pc (regcache);
2378 struct address_space *aspace = get_regcache_aspace (regcache);
2380 /* This represents the user's step vs continue request. When
2381 deciding whether "set scheduler-locking step" applies, it's the
2382 user's intention that counts. */
2383 const int user_step = tp->control.stepping_command;
2384 /* This represents what we'll actually request the target to do.
2385 This can decay from a step to a continue, if e.g., we need to
2386 implement single-stepping with breakpoints (software
2390 gdb_assert (!thread_is_in_step_over_chain (tp));
2394 if (tp->suspend.waitstatus_pending_p)
2400 statstr = target_waitstatus_to_string (&tp->suspend.waitstatus);
2401 fprintf_unfiltered (gdb_stdlog,
2402 "infrun: resume: thread %s has pending wait status %s "
2403 "(currently_stepping=%d).\n",
2404 target_pid_to_str (tp->ptid), statstr,
2405 currently_stepping (tp));
2411 /* FIXME: What should we do if we are supposed to resume this
2412 thread with a signal? Maybe we should maintain a queue of
2413 pending signals to deliver. */
2414 if (sig != GDB_SIGNAL_0)
2416 warning (_("Couldn't deliver signal %s to %s."),
2417 gdb_signal_to_name (sig), target_pid_to_str (tp->ptid));
2420 tp->suspend.stop_signal = GDB_SIGNAL_0;
2421 discard_cleanups (old_cleanups);
2423 if (target_can_async_p ())
2428 tp->stepped_breakpoint = 0;
2430 /* Depends on stepped_breakpoint. */
2431 step = currently_stepping (tp);
2433 if (current_inferior ()->waiting_for_vfork_done)
2435 /* Don't try to single-step a vfork parent that is waiting for
2436 the child to get out of the shared memory region (by exec'ing
2437 or exiting). This is particularly important on software
2438 single-step archs, as the child process would trip on the
2439 software single step breakpoint inserted for the parent
2440 process. Since the parent will not actually execute any
2441 instruction until the child is out of the shared region (such
2442 are vfork's semantics), it is safe to simply continue it.
2443 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2444 the parent, and tell it to `keep_going', which automatically
2445 re-sets it stepping. */
2447 fprintf_unfiltered (gdb_stdlog,
2448 "infrun: resume : clear step\n");
2453 fprintf_unfiltered (gdb_stdlog,
2454 "infrun: resume (step=%d, signal=%s), "
2455 "trap_expected=%d, current thread [%s] at %s\n",
2456 step, gdb_signal_to_symbol_string (sig),
2457 tp->control.trap_expected,
2458 target_pid_to_str (inferior_ptid),
2459 paddress (gdbarch, pc));
2461 /* Normally, by the time we reach `resume', the breakpoints are either
2462 removed or inserted, as appropriate. The exception is if we're sitting
2463 at a permanent breakpoint; we need to step over it, but permanent
2464 breakpoints can't be removed. So we have to test for it here. */
2465 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
2467 if (sig != GDB_SIGNAL_0)
2469 /* We have a signal to pass to the inferior. The resume
2470 may, or may not take us to the signal handler. If this
2471 is a step, we'll need to stop in the signal handler, if
2472 there's one, (if the target supports stepping into
2473 handlers), or in the next mainline instruction, if
2474 there's no handler. If this is a continue, we need to be
2475 sure to run the handler with all breakpoints inserted.
2476 In all cases, set a breakpoint at the current address
2477 (where the handler returns to), and once that breakpoint
2478 is hit, resume skipping the permanent breakpoint. If
2479 that breakpoint isn't hit, then we've stepped into the
2480 signal handler (or hit some other event). We'll delete
2481 the step-resume breakpoint then. */
2484 fprintf_unfiltered (gdb_stdlog,
2485 "infrun: resume: skipping permanent breakpoint, "
2486 "deliver signal first\n");
2488 clear_step_over_info ();
2489 tp->control.trap_expected = 0;
2491 if (tp->control.step_resume_breakpoint == NULL)
2493 /* Set a "high-priority" step-resume, as we don't want
2494 user breakpoints at PC to trigger (again) when this
2496 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2497 gdb_assert (tp->control.step_resume_breakpoint->loc->permanent);
2499 tp->step_after_step_resume_breakpoint = step;
2502 insert_breakpoints ();
2506 /* There's no signal to pass, we can go ahead and skip the
2507 permanent breakpoint manually. */
2509 fprintf_unfiltered (gdb_stdlog,
2510 "infrun: resume: skipping permanent breakpoint\n");
2511 gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2512 /* Update pc to reflect the new address from which we will
2513 execute instructions. */
2514 pc = regcache_read_pc (regcache);
2518 /* We've already advanced the PC, so the stepping part
2519 is done. Now we need to arrange for a trap to be
2520 reported to handle_inferior_event. Set a breakpoint
2521 at the current PC, and run to it. Don't update
2522 prev_pc, because if we end in
2523 switch_back_to_stepped_thread, we want the "expected
2524 thread advanced also" branch to be taken. IOW, we
2525 don't want this thread to step further from PC
2527 gdb_assert (!step_over_info_valid_p ());
2528 insert_single_step_breakpoint (gdbarch, aspace, pc);
2529 insert_breakpoints ();
2531 resume_ptid = internal_resume_ptid (user_step);
2532 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
2533 discard_cleanups (old_cleanups);
2540 /* If we have a breakpoint to step over, make sure to do a single
2541 step only. Same if we have software watchpoints. */
2542 if (tp->control.trap_expected || bpstat_should_step ())
2543 tp->control.may_range_step = 0;
2545 /* If enabled, step over breakpoints by executing a copy of the
2546 instruction at a different address.
2548 We can't use displaced stepping when we have a signal to deliver;
2549 the comments for displaced_step_prepare explain why. The
2550 comments in the handle_inferior event for dealing with 'random
2551 signals' explain what we do instead.
2553 We can't use displaced stepping when we are waiting for vfork_done
2554 event, displaced stepping breaks the vfork child similarly as single
2555 step software breakpoint. */
2556 if (tp->control.trap_expected
2557 && use_displaced_stepping (tp)
2558 && !step_over_info_valid_p ()
2559 && sig == GDB_SIGNAL_0
2560 && !current_inferior ()->waiting_for_vfork_done)
2562 int prepared = displaced_step_prepare (inferior_ptid);
2567 fprintf_unfiltered (gdb_stdlog,
2568 "Got placed in step-over queue\n");
2570 tp->control.trap_expected = 0;
2571 discard_cleanups (old_cleanups);
2574 else if (prepared < 0)
2576 /* Fallback to stepping over the breakpoint in-line. */
2578 if (target_is_non_stop_p ())
2579 stop_all_threads ();
2581 set_step_over_info (get_regcache_aspace (regcache),
2582 regcache_read_pc (regcache), 0);
2584 step = maybe_software_singlestep (gdbarch, pc);
2586 insert_breakpoints ();
2588 else if (prepared > 0)
2590 struct displaced_step_inferior_state *displaced;
2592 /* Update pc to reflect the new address from which we will
2593 execute instructions due to displaced stepping. */
2594 pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
2596 displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
2597 step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2598 displaced->step_closure);
2602 /* Do we need to do it the hard way, w/temp breakpoints? */
2604 step = maybe_software_singlestep (gdbarch, pc);
2606 /* Currently, our software single-step implementation leads to different
2607 results than hardware single-stepping in one situation: when stepping
2608 into delivering a signal which has an associated signal handler,
2609 hardware single-step will stop at the first instruction of the handler,
2610 while software single-step will simply skip execution of the handler.
2612 For now, this difference in behavior is accepted since there is no
2613 easy way to actually implement single-stepping into a signal handler
2614 without kernel support.
2616 However, there is one scenario where this difference leads to follow-on
2617 problems: if we're stepping off a breakpoint by removing all breakpoints
2618 and then single-stepping. In this case, the software single-step
2619 behavior means that even if there is a *breakpoint* in the signal
2620 handler, GDB still would not stop.
2622 Fortunately, we can at least fix this particular issue. We detect
2623 here the case where we are about to deliver a signal while software
2624 single-stepping with breakpoints removed. In this situation, we
2625 revert the decisions to remove all breakpoints and insert single-
2626 step breakpoints, and instead we install a step-resume breakpoint
2627 at the current address, deliver the signal without stepping, and
2628 once we arrive back at the step-resume breakpoint, actually step
2629 over the breakpoint we originally wanted to step over. */
2630 if (thread_has_single_step_breakpoints_set (tp)
2631 && sig != GDB_SIGNAL_0
2632 && step_over_info_valid_p ())
2634 /* If we have nested signals or a pending signal is delivered
2635 immediately after a handler returns, might might already have
2636 a step-resume breakpoint set on the earlier handler. We cannot
2637 set another step-resume breakpoint; just continue on until the
2638 original breakpoint is hit. */
2639 if (tp->control.step_resume_breakpoint == NULL)
2641 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2642 tp->step_after_step_resume_breakpoint = 1;
2645 delete_single_step_breakpoints (tp);
2647 clear_step_over_info ();
2648 tp->control.trap_expected = 0;
2650 insert_breakpoints ();
2653 /* If STEP is set, it's a request to use hardware stepping
2654 facilities. But in that case, we should never
2655 use singlestep breakpoint. */
2656 gdb_assert (!(thread_has_single_step_breakpoints_set (tp) && step));
2658 /* Decide the set of threads to ask the target to resume. */
2659 if (tp->control.trap_expected)
2661 /* We're allowing a thread to run past a breakpoint it has
2662 hit, either by single-stepping the thread with the breakpoint
2663 removed, or by displaced stepping, with the breakpoint inserted.
2664 In the former case, we need to single-step only this thread,
2665 and keep others stopped, as they can miss this breakpoint if
2666 allowed to run. That's not really a problem for displaced
2667 stepping, but, we still keep other threads stopped, in case
2668 another thread is also stopped for a breakpoint waiting for
2669 its turn in the displaced stepping queue. */
2670 resume_ptid = inferior_ptid;
2673 resume_ptid = internal_resume_ptid (user_step);
2675 if (execution_direction != EXEC_REVERSE
2676 && step && breakpoint_inserted_here_p (aspace, pc))
2678 /* There are two cases where we currently need to step a
2679 breakpoint instruction when we have a signal to deliver:
2681 - See handle_signal_stop where we handle random signals that
2682 could take out us out of the stepping range. Normally, in
2683 that case we end up continuing (instead of stepping) over the
2684 signal handler with a breakpoint at PC, but there are cases
2685 where we should _always_ single-step, even if we have a
2686 step-resume breakpoint, like when a software watchpoint is
2687 set. Assuming single-stepping and delivering a signal at the
2688 same time would takes us to the signal handler, then we could
2689 have removed the breakpoint at PC to step over it. However,
2690 some hardware step targets (like e.g., Mac OS) can't step
2691 into signal handlers, and for those, we need to leave the
2692 breakpoint at PC inserted, as otherwise if the handler
2693 recurses and executes PC again, it'll miss the breakpoint.
2694 So we leave the breakpoint inserted anyway, but we need to
2695 record that we tried to step a breakpoint instruction, so
2696 that adjust_pc_after_break doesn't end up confused.
2698 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2699 in one thread after another thread that was stepping had been
2700 momentarily paused for a step-over. When we re-resume the
2701 stepping thread, it may be resumed from that address with a
2702 breakpoint that hasn't trapped yet. Seen with
2703 gdb.threads/non-stop-fair-events.exp, on targets that don't
2704 do displaced stepping. */
2707 fprintf_unfiltered (gdb_stdlog,
2708 "infrun: resume: [%s] stepped breakpoint\n",
2709 target_pid_to_str (tp->ptid));
2711 tp->stepped_breakpoint = 1;
2713 /* Most targets can step a breakpoint instruction, thus
2714 executing it normally. But if this one cannot, just
2715 continue and we will hit it anyway. */
2716 if (gdbarch_cannot_step_breakpoint (gdbarch))
2721 && tp->control.trap_expected
2722 && use_displaced_stepping (tp)
2723 && !step_over_info_valid_p ())
2725 struct regcache *resume_regcache = get_thread_regcache (tp->ptid);
2726 struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
2727 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2730 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2731 paddress (resume_gdbarch, actual_pc));
2732 read_memory (actual_pc, buf, sizeof (buf));
2733 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2736 if (tp->control.may_range_step)
2738 /* If we're resuming a thread with the PC out of the step
2739 range, then we're doing some nested/finer run control
2740 operation, like stepping the thread out of the dynamic
2741 linker or the displaced stepping scratch pad. We
2742 shouldn't have allowed a range step then. */
2743 gdb_assert (pc_in_thread_step_range (pc, tp));
2746 do_target_resume (resume_ptid, step, sig);
2748 discard_cleanups (old_cleanups);
2755 /* Counter that tracks number of user visible stops. This can be used
2756 to tell whether a command has proceeded the inferior past the
2757 current location. This allows e.g., inferior function calls in
2758 breakpoint commands to not interrupt the command list. When the
2759 call finishes successfully, the inferior is standing at the same
2760 breakpoint as if nothing happened (and so we don't call
2762 static ULONGEST current_stop_id;
2769 return current_stop_id;
2772 /* Called when we report a user visible stop. */
2780 /* Clear out all variables saying what to do when inferior is continued.
2781 First do this, then set the ones you want, then call `proceed'. */
2784 clear_proceed_status_thread (struct thread_info *tp)
2787 fprintf_unfiltered (gdb_stdlog,
2788 "infrun: clear_proceed_status_thread (%s)\n",
2789 target_pid_to_str (tp->ptid));
2791 /* If we're starting a new sequence, then the previous finished
2792 single-step is no longer relevant. */
2793 if (tp->suspend.waitstatus_pending_p)
2795 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
2798 fprintf_unfiltered (gdb_stdlog,
2799 "infrun: clear_proceed_status: pending "
2800 "event of %s was a finished step. "
2802 target_pid_to_str (tp->ptid));
2804 tp->suspend.waitstatus_pending_p = 0;
2805 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
2807 else if (debug_infrun)
2811 statstr = target_waitstatus_to_string (&tp->suspend.waitstatus);
2812 fprintf_unfiltered (gdb_stdlog,
2813 "infrun: clear_proceed_status_thread: thread %s "
2814 "has pending wait status %s "
2815 "(currently_stepping=%d).\n",
2816 target_pid_to_str (tp->ptid), statstr,
2817 currently_stepping (tp));
2822 /* If this signal should not be seen by program, give it zero.
2823 Used for debugging signals. */
2824 if (!signal_pass_state (tp->suspend.stop_signal))
2825 tp->suspend.stop_signal = GDB_SIGNAL_0;
2827 thread_fsm_delete (tp->thread_fsm);
2828 tp->thread_fsm = NULL;
2830 tp->control.trap_expected = 0;
2831 tp->control.step_range_start = 0;
2832 tp->control.step_range_end = 0;
2833 tp->control.may_range_step = 0;
2834 tp->control.step_frame_id = null_frame_id;
2835 tp->control.step_stack_frame_id = null_frame_id;
2836 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
2837 tp->control.step_start_function = NULL;
2838 tp->stop_requested = 0;
2840 tp->control.stop_step = 0;
2842 tp->control.proceed_to_finish = 0;
2844 tp->control.command_interp = NULL;
2845 tp->control.stepping_command = 0;
2847 /* Discard any remaining commands or status from previous stop. */
2848 bpstat_clear (&tp->control.stop_bpstat);
2852 clear_proceed_status (int step)
2854 /* With scheduler-locking replay, stop replaying other threads if we're
2855 not replaying the user-visible resume ptid.
2857 This is a convenience feature to not require the user to explicitly
2858 stop replaying the other threads. We're assuming that the user's
2859 intent is to resume tracing the recorded process. */
2860 if (!non_stop && scheduler_mode == schedlock_replay
2861 && target_record_is_replaying (minus_one_ptid)
2862 && !target_record_will_replay (user_visible_resume_ptid (step),
2863 execution_direction))
2864 target_record_stop_replaying ();
2868 struct thread_info *tp;
2871 resume_ptid = user_visible_resume_ptid (step);
2873 /* In all-stop mode, delete the per-thread status of all threads
2874 we're about to resume, implicitly and explicitly. */
2875 ALL_NON_EXITED_THREADS (tp)
2877 if (!ptid_match (tp->ptid, resume_ptid))
2879 clear_proceed_status_thread (tp);
2883 if (!ptid_equal (inferior_ptid, null_ptid))
2885 struct inferior *inferior;
2889 /* If in non-stop mode, only delete the per-thread status of
2890 the current thread. */
2891 clear_proceed_status_thread (inferior_thread ());
2894 inferior = current_inferior ();
2895 inferior->control.stop_soon = NO_STOP_QUIETLY;
2898 observer_notify_about_to_proceed ();
2901 /* Returns true if TP is still stopped at a breakpoint that needs
2902 stepping-over in order to make progress. If the breakpoint is gone
2903 meanwhile, we can skip the whole step-over dance. */
2906 thread_still_needs_step_over_bp (struct thread_info *tp)
2908 if (tp->stepping_over_breakpoint)
2910 struct regcache *regcache = get_thread_regcache (tp->ptid);
2912 if (breakpoint_here_p (get_regcache_aspace (regcache),
2913 regcache_read_pc (regcache))
2914 == ordinary_breakpoint_here)
2917 tp->stepping_over_breakpoint = 0;
2923 /* Check whether thread TP still needs to start a step-over in order
2924 to make progress when resumed. Returns an bitwise or of enum
2925 step_over_what bits, indicating what needs to be stepped over. */
2927 static step_over_what
2928 thread_still_needs_step_over (struct thread_info *tp)
2930 struct inferior *inf = find_inferior_ptid (tp->ptid);
2931 step_over_what what = 0;
2933 if (thread_still_needs_step_over_bp (tp))
2934 what |= STEP_OVER_BREAKPOINT;
2936 if (tp->stepping_over_watchpoint
2937 && !target_have_steppable_watchpoint)
2938 what |= STEP_OVER_WATCHPOINT;
2943 /* Returns true if scheduler locking applies. STEP indicates whether
2944 we're about to do a step/next-like command to a thread. */
2947 schedlock_applies (struct thread_info *tp)
2949 return (scheduler_mode == schedlock_on
2950 || (scheduler_mode == schedlock_step
2951 && tp->control.stepping_command)
2952 || (scheduler_mode == schedlock_replay
2953 && target_record_will_replay (minus_one_ptid,
2954 execution_direction)));
2957 /* Basic routine for continuing the program in various fashions.
2959 ADDR is the address to resume at, or -1 for resume where stopped.
2960 SIGGNAL is the signal to give it, or 0 for none,
2961 or -1 for act according to how it stopped.
2962 STEP is nonzero if should trap after one instruction.
2963 -1 means return after that and print nothing.
2964 You should probably set various step_... variables
2965 before calling here, if you are stepping.
2967 You should call clear_proceed_status before calling proceed. */
2970 proceed (CORE_ADDR addr, enum gdb_signal siggnal)
2972 struct regcache *regcache;
2973 struct gdbarch *gdbarch;
2974 struct thread_info *tp;
2976 struct address_space *aspace;
2978 struct execution_control_state ecss;
2979 struct execution_control_state *ecs = &ecss;
2980 struct cleanup *old_chain;
2983 /* If we're stopped at a fork/vfork, follow the branch set by the
2984 "set follow-fork-mode" command; otherwise, we'll just proceed
2985 resuming the current thread. */
2986 if (!follow_fork ())
2988 /* The target for some reason decided not to resume. */
2990 if (target_can_async_p ())
2991 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2995 /* We'll update this if & when we switch to a new thread. */
2996 previous_inferior_ptid = inferior_ptid;
2998 regcache = get_current_regcache ();
2999 gdbarch = get_regcache_arch (regcache);
3000 aspace = get_regcache_aspace (regcache);
3001 pc = regcache_read_pc (regcache);
3002 tp = inferior_thread ();
3004 /* Fill in with reasonable starting values. */
3005 init_thread_stepping_state (tp);
3007 gdb_assert (!thread_is_in_step_over_chain (tp));
3009 if (addr == (CORE_ADDR) -1)
3012 && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
3013 && execution_direction != EXEC_REVERSE)
3014 /* There is a breakpoint at the address we will resume at,
3015 step one instruction before inserting breakpoints so that
3016 we do not stop right away (and report a second hit at this
3019 Note, we don't do this in reverse, because we won't
3020 actually be executing the breakpoint insn anyway.
3021 We'll be (un-)executing the previous instruction. */
3022 tp->stepping_over_breakpoint = 1;
3023 else if (gdbarch_single_step_through_delay_p (gdbarch)
3024 && gdbarch_single_step_through_delay (gdbarch,
3025 get_current_frame ()))
3026 /* We stepped onto an instruction that needs to be stepped
3027 again before re-inserting the breakpoint, do so. */
3028 tp->stepping_over_breakpoint = 1;
3032 regcache_write_pc (regcache, addr);
3035 if (siggnal != GDB_SIGNAL_DEFAULT)
3036 tp->suspend.stop_signal = siggnal;
3038 /* Record the interpreter that issued the execution command that
3039 caused this thread to resume. If the top level interpreter is
3040 MI/async, and the execution command was a CLI command
3041 (next/step/etc.), we'll want to print stop event output to the MI
3042 console channel (the stepped-to line, etc.), as if the user
3043 entered the execution command on a real GDB console. */
3044 tp->control.command_interp = command_interp ();
3046 resume_ptid = user_visible_resume_ptid (tp->control.stepping_command);
3048 /* If an exception is thrown from this point on, make sure to
3049 propagate GDB's knowledge of the executing state to the
3050 frontend/user running state. */
3051 old_chain = make_cleanup (finish_thread_state_cleanup, &resume_ptid);
3053 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3054 threads (e.g., we might need to set threads stepping over
3055 breakpoints first), from the user/frontend's point of view, all
3056 threads in RESUME_PTID are now running. Unless we're calling an
3057 inferior function, as in that case we pretend the inferior
3058 doesn't run at all. */
3059 if (!tp->control.in_infcall)
3060 set_running (resume_ptid, 1);
3063 fprintf_unfiltered (gdb_stdlog,
3064 "infrun: proceed (addr=%s, signal=%s)\n",
3065 paddress (gdbarch, addr),
3066 gdb_signal_to_symbol_string (siggnal));
3068 annotate_starting ();
3070 /* Make sure that output from GDB appears before output from the
3072 gdb_flush (gdb_stdout);
3074 /* In a multi-threaded task we may select another thread and
3075 then continue or step.
3077 But if a thread that we're resuming had stopped at a breakpoint,
3078 it will immediately cause another breakpoint stop without any
3079 execution (i.e. it will report a breakpoint hit incorrectly). So
3080 we must step over it first.
3082 Look for threads other than the current (TP) that reported a
3083 breakpoint hit and haven't been resumed yet since. */
3085 /* If scheduler locking applies, we can avoid iterating over all
3087 if (!non_stop && !schedlock_applies (tp))
3089 struct thread_info *current = tp;
3091 ALL_NON_EXITED_THREADS (tp)
3093 /* Ignore the current thread here. It's handled
3098 /* Ignore threads of processes we're not resuming. */
3099 if (!ptid_match (tp->ptid, resume_ptid))
3102 if (!thread_still_needs_step_over (tp))
3105 gdb_assert (!thread_is_in_step_over_chain (tp));
3108 fprintf_unfiltered (gdb_stdlog,
3109 "infrun: need to step-over [%s] first\n",
3110 target_pid_to_str (tp->ptid));
3112 thread_step_over_chain_enqueue (tp);
3118 /* Enqueue the current thread last, so that we move all other
3119 threads over their breakpoints first. */
3120 if (tp->stepping_over_breakpoint)
3121 thread_step_over_chain_enqueue (tp);
3123 /* If the thread isn't started, we'll still need to set its prev_pc,
3124 so that switch_back_to_stepped_thread knows the thread hasn't
3125 advanced. Must do this before resuming any thread, as in
3126 all-stop/remote, once we resume we can't send any other packet
3127 until the target stops again. */
3128 tp->prev_pc = regcache_read_pc (regcache);
3130 started = start_step_over ();
3132 if (step_over_info_valid_p ())
3134 /* Either this thread started a new in-line step over, or some
3135 other thread was already doing one. In either case, don't
3136 resume anything else until the step-over is finished. */
3138 else if (started && !target_is_non_stop_p ())
3140 /* A new displaced stepping sequence was started. In all-stop,
3141 we can't talk to the target anymore until it next stops. */
3143 else if (!non_stop && target_is_non_stop_p ())
3145 /* In all-stop, but the target is always in non-stop mode.
3146 Start all other threads that are implicitly resumed too. */
3147 ALL_NON_EXITED_THREADS (tp)
3149 /* Ignore threads of processes we're not resuming. */
3150 if (!ptid_match (tp->ptid, resume_ptid))
3156 fprintf_unfiltered (gdb_stdlog,
3157 "infrun: proceed: [%s] resumed\n",
3158 target_pid_to_str (tp->ptid));
3159 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
3163 if (thread_is_in_step_over_chain (tp))
3166 fprintf_unfiltered (gdb_stdlog,
3167 "infrun: proceed: [%s] needs step-over\n",
3168 target_pid_to_str (tp->ptid));
3173 fprintf_unfiltered (gdb_stdlog,
3174 "infrun: proceed: resuming %s\n",
3175 target_pid_to_str (tp->ptid));
3177 reset_ecs (ecs, tp);
3178 switch_to_thread (tp->ptid);
3179 keep_going_pass_signal (ecs);
3180 if (!ecs->wait_some_more)
3181 error (_("Command aborted."));
3184 else if (!tp->resumed && !thread_is_in_step_over_chain (tp))
3186 /* The thread wasn't started, and isn't queued, run it now. */
3187 reset_ecs (ecs, tp);
3188 switch_to_thread (tp->ptid);
3189 keep_going_pass_signal (ecs);
3190 if (!ecs->wait_some_more)
3191 error (_("Command aborted."));
3194 discard_cleanups (old_chain);
3196 /* Tell the event loop to wait for it to stop. If the target
3197 supports asynchronous execution, it'll do this from within
3199 if (!target_can_async_p ())
3200 mark_async_event_handler (infrun_async_inferior_event_token);
3204 /* Start remote-debugging of a machine over a serial link. */
3207 start_remote (int from_tty)
3209 struct inferior *inferior;
3211 inferior = current_inferior ();
3212 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
3214 /* Always go on waiting for the target, regardless of the mode. */
3215 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3216 indicate to wait_for_inferior that a target should timeout if
3217 nothing is returned (instead of just blocking). Because of this,
3218 targets expecting an immediate response need to, internally, set
3219 things up so that the target_wait() is forced to eventually
3221 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3222 differentiate to its caller what the state of the target is after
3223 the initial open has been performed. Here we're assuming that
3224 the target has stopped. It should be possible to eventually have
3225 target_open() return to the caller an indication that the target
3226 is currently running and GDB state should be set to the same as
3227 for an async run. */
3228 wait_for_inferior ();
3230 /* Now that the inferior has stopped, do any bookkeeping like
3231 loading shared libraries. We want to do this before normal_stop,
3232 so that the displayed frame is up to date. */
3233 post_create_inferior (¤t_target, from_tty);
3238 /* Initialize static vars when a new inferior begins. */
3241 init_wait_for_inferior (void)
3243 /* These are meaningless until the first time through wait_for_inferior. */
3245 breakpoint_init_inferior (inf_starting);
3247 clear_proceed_status (0);
3249 target_last_wait_ptid = minus_one_ptid;
3251 previous_inferior_ptid = inferior_ptid;
3253 /* Discard any skipped inlined frames. */
3254 clear_inline_frame_state (minus_one_ptid);
3259 static void handle_inferior_event (struct execution_control_state *ecs);
3261 static void handle_step_into_function (struct gdbarch *gdbarch,
3262 struct execution_control_state *ecs);
3263 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
3264 struct execution_control_state *ecs);
3265 static void handle_signal_stop (struct execution_control_state *ecs);
3266 static void check_exception_resume (struct execution_control_state *,
3267 struct frame_info *);
3269 static void end_stepping_range (struct execution_control_state *ecs);
3270 static void stop_waiting (struct execution_control_state *ecs);
3271 static void keep_going (struct execution_control_state *ecs);
3272 static void process_event_stop_test (struct execution_control_state *ecs);
3273 static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
3275 /* Callback for iterate over threads. If the thread is stopped, but
3276 the user/frontend doesn't know about that yet, go through
3277 normal_stop, as if the thread had just stopped now. ARG points at
3278 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
3279 ptid_is_pid(PTID) is true, applies to all threads of the process
3280 pointed at by PTID. Otherwise, apply only to the thread pointed by
3284 infrun_thread_stop_requested_callback (struct thread_info *info, void *arg)
3286 ptid_t ptid = * (ptid_t *) arg;
3288 if ((ptid_equal (info->ptid, ptid)
3289 || ptid_equal (minus_one_ptid, ptid)
3290 || (ptid_is_pid (ptid)
3291 && ptid_get_pid (ptid) == ptid_get_pid (info->ptid)))
3292 && is_running (info->ptid)
3293 && !is_executing (info->ptid))
3295 struct cleanup *old_chain;
3296 struct execution_control_state ecss;
3297 struct execution_control_state *ecs = &ecss;
3299 memset (ecs, 0, sizeof (*ecs));
3301 old_chain = make_cleanup_restore_current_thread ();
3303 overlay_cache_invalid = 1;
3304 /* Flush target cache before starting to handle each event.
3305 Target was running and cache could be stale. This is just a
3306 heuristic. Running threads may modify target memory, but we
3307 don't get any event. */
3308 target_dcache_invalidate ();
3310 /* Go through handle_inferior_event/normal_stop, so we always
3311 have consistent output as if the stop event had been
3313 ecs->ptid = info->ptid;
3314 ecs->event_thread = info;
3315 ecs->ws.kind = TARGET_WAITKIND_STOPPED;
3316 ecs->ws.value.sig = GDB_SIGNAL_0;
3318 handle_inferior_event (ecs);
3320 if (!ecs->wait_some_more)
3322 /* Cancel any running execution command. */
3323 thread_cancel_execution_command (info);
3328 do_cleanups (old_chain);
3334 /* This function is attached as a "thread_stop_requested" observer.
3335 Cleanup local state that assumed the PTID was to be resumed, and
3336 report the stop to the frontend. */
3339 infrun_thread_stop_requested (ptid_t ptid)
3341 struct thread_info *tp;
3343 /* PTID was requested to stop. Remove matching threads from the
3344 step-over queue, so we don't try to resume them
3346 ALL_NON_EXITED_THREADS (tp)
3347 if (ptid_match (tp->ptid, ptid))
3349 if (thread_is_in_step_over_chain (tp))
3350 thread_step_over_chain_remove (tp);
3353 iterate_over_threads (infrun_thread_stop_requested_callback, &ptid);
3357 infrun_thread_thread_exit (struct thread_info *tp, int silent)
3359 if (ptid_equal (target_last_wait_ptid, tp->ptid))
3360 nullify_last_target_wait_ptid ();
3363 /* Delete the step resume, single-step and longjmp/exception resume
3364 breakpoints of TP. */
3367 delete_thread_infrun_breakpoints (struct thread_info *tp)
3369 delete_step_resume_breakpoint (tp);
3370 delete_exception_resume_breakpoint (tp);
3371 delete_single_step_breakpoints (tp);
3374 /* If the target still has execution, call FUNC for each thread that
3375 just stopped. In all-stop, that's all the non-exited threads; in
3376 non-stop, that's the current thread, only. */
3378 typedef void (*for_each_just_stopped_thread_callback_func)
3379 (struct thread_info *tp);
3382 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
3384 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
3387 if (target_is_non_stop_p ())
3389 /* If in non-stop mode, only the current thread stopped. */
3390 func (inferior_thread ());
3394 struct thread_info *tp;
3396 /* In all-stop mode, all threads have stopped. */
3397 ALL_NON_EXITED_THREADS (tp)
3404 /* Delete the step resume and longjmp/exception resume breakpoints of
3405 the threads that just stopped. */
3408 delete_just_stopped_threads_infrun_breakpoints (void)
3410 for_each_just_stopped_thread (delete_thread_infrun_breakpoints);
3413 /* Delete the single-step breakpoints of the threads that just
3417 delete_just_stopped_threads_single_step_breakpoints (void)
3419 for_each_just_stopped_thread (delete_single_step_breakpoints);
3422 /* A cleanup wrapper. */
3425 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg)
3427 delete_just_stopped_threads_infrun_breakpoints ();
3433 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
3434 const struct target_waitstatus *ws)
3436 char *status_string = target_waitstatus_to_string (ws);
3437 struct ui_file *tmp_stream = mem_fileopen ();
3440 /* The text is split over several lines because it was getting too long.
3441 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3442 output as a unit; we want only one timestamp printed if debug_timestamp
3445 fprintf_unfiltered (tmp_stream,
3446 "infrun: target_wait (%d.%ld.%ld",
3447 ptid_get_pid (waiton_ptid),
3448 ptid_get_lwp (waiton_ptid),
3449 ptid_get_tid (waiton_ptid));
3450 if (ptid_get_pid (waiton_ptid) != -1)
3451 fprintf_unfiltered (tmp_stream,
3452 " [%s]", target_pid_to_str (waiton_ptid));
3453 fprintf_unfiltered (tmp_stream, ", status) =\n");
3454 fprintf_unfiltered (tmp_stream,
3455 "infrun: %d.%ld.%ld [%s],\n",
3456 ptid_get_pid (result_ptid),
3457 ptid_get_lwp (result_ptid),
3458 ptid_get_tid (result_ptid),
3459 target_pid_to_str (result_ptid));
3460 fprintf_unfiltered (tmp_stream,
3464 text = ui_file_xstrdup (tmp_stream, NULL);
3466 /* This uses %s in part to handle %'s in the text, but also to avoid
3467 a gcc error: the format attribute requires a string literal. */
3468 fprintf_unfiltered (gdb_stdlog, "%s", text);
3470 xfree (status_string);
3472 ui_file_delete (tmp_stream);
3475 /* Select a thread at random, out of those which are resumed and have
3478 static struct thread_info *
3479 random_pending_event_thread (ptid_t waiton_ptid)
3481 struct thread_info *event_tp;
3483 int random_selector;
3485 /* First see how many events we have. Count only resumed threads
3486 that have an event pending. */
3487 ALL_NON_EXITED_THREADS (event_tp)
3488 if (ptid_match (event_tp->ptid, waiton_ptid)
3489 && event_tp->resumed
3490 && event_tp->suspend.waitstatus_pending_p)
3493 if (num_events == 0)
3496 /* Now randomly pick a thread out of those that have had events. */
3497 random_selector = (int)
3498 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
3500 if (debug_infrun && num_events > 1)
3501 fprintf_unfiltered (gdb_stdlog,
3502 "infrun: Found %d events, selecting #%d\n",
3503 num_events, random_selector);
3505 /* Select the Nth thread that has had an event. */
3506 ALL_NON_EXITED_THREADS (event_tp)
3507 if (ptid_match (event_tp->ptid, waiton_ptid)
3508 && event_tp->resumed
3509 && event_tp->suspend.waitstatus_pending_p)
3510 if (random_selector-- == 0)
3516 /* Wrapper for target_wait that first checks whether threads have
3517 pending statuses to report before actually asking the target for
3521 do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
3524 struct thread_info *tp;
3526 /* First check if there is a resumed thread with a wait status
3528 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3530 tp = random_pending_event_thread (ptid);
3535 fprintf_unfiltered (gdb_stdlog,
3536 "infrun: Waiting for specific thread %s.\n",
3537 target_pid_to_str (ptid));
3539 /* We have a specific thread to check. */
3540 tp = find_thread_ptid (ptid);
3541 gdb_assert (tp != NULL);
3542 if (!tp->suspend.waitstatus_pending_p)
3547 && (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3548 || tp->suspend.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
3550 struct regcache *regcache = get_thread_regcache (tp->ptid);
3551 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3555 pc = regcache_read_pc (regcache);
3557 if (pc != tp->suspend.stop_pc)
3560 fprintf_unfiltered (gdb_stdlog,
3561 "infrun: PC of %s changed. was=%s, now=%s\n",
3562 target_pid_to_str (tp->ptid),
3563 paddress (gdbarch, tp->prev_pc),
3564 paddress (gdbarch, pc));
3567 else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3570 fprintf_unfiltered (gdb_stdlog,
3571 "infrun: previous breakpoint of %s, at %s gone\n",
3572 target_pid_to_str (tp->ptid),
3573 paddress (gdbarch, pc));
3581 fprintf_unfiltered (gdb_stdlog,
3582 "infrun: pending event of %s cancelled.\n",
3583 target_pid_to_str (tp->ptid));
3585 tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
3586 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3596 statstr = target_waitstatus_to_string (&tp->suspend.waitstatus);
3597 fprintf_unfiltered (gdb_stdlog,
3598 "infrun: Using pending wait status %s for %s.\n",
3600 target_pid_to_str (tp->ptid));
3604 /* Now that we've selected our final event LWP, un-adjust its PC
3605 if it was a software breakpoint (and the target doesn't
3606 always adjust the PC itself). */
3607 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3608 && !target_supports_stopped_by_sw_breakpoint ())
3610 struct regcache *regcache;
3611 struct gdbarch *gdbarch;
3614 regcache = get_thread_regcache (tp->ptid);
3615 gdbarch = get_regcache_arch (regcache);
3617 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3622 pc = regcache_read_pc (regcache);
3623 regcache_write_pc (regcache, pc + decr_pc);
3627 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3628 *status = tp->suspend.waitstatus;
3629 tp->suspend.waitstatus_pending_p = 0;
3631 /* Wake up the event loop again, until all pending events are
3633 if (target_is_async_p ())
3634 mark_async_event_handler (infrun_async_inferior_event_token);
3638 /* But if we don't find one, we'll have to wait. */
3640 if (deprecated_target_wait_hook)
3641 event_ptid = deprecated_target_wait_hook (ptid, status, options);
3643 event_ptid = target_wait (ptid, status, options);
3648 /* Prepare and stabilize the inferior for detaching it. E.g.,
3649 detaching while a thread is displaced stepping is a recipe for
3650 crashing it, as nothing would readjust the PC out of the scratch
3654 prepare_for_detach (void)
3656 struct inferior *inf = current_inferior ();
3657 ptid_t pid_ptid = pid_to_ptid (inf->pid);
3658 struct cleanup *old_chain_1;
3659 struct displaced_step_inferior_state *displaced;
3661 displaced = get_displaced_stepping_state (inf->pid);
3663 /* Is any thread of this process displaced stepping? If not,
3664 there's nothing else to do. */
3665 if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
3669 fprintf_unfiltered (gdb_stdlog,
3670 "displaced-stepping in-process while detaching");
3672 old_chain_1 = make_cleanup_restore_integer (&inf->detaching);
3675 while (!ptid_equal (displaced->step_ptid, null_ptid))
3677 struct cleanup *old_chain_2;
3678 struct execution_control_state ecss;
3679 struct execution_control_state *ecs;
3682 memset (ecs, 0, sizeof (*ecs));
3684 overlay_cache_invalid = 1;
3685 /* Flush target cache before starting to handle each event.
3686 Target was running and cache could be stale. This is just a
3687 heuristic. Running threads may modify target memory, but we
3688 don't get any event. */
3689 target_dcache_invalidate ();
3691 ecs->ptid = do_target_wait (pid_ptid, &ecs->ws, 0);
3694 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
3696 /* If an error happens while handling the event, propagate GDB's
3697 knowledge of the executing state to the frontend/user running
3699 old_chain_2 = make_cleanup (finish_thread_state_cleanup,
3702 /* Now figure out what to do with the result of the result. */
3703 handle_inferior_event (ecs);
3705 /* No error, don't finish the state yet. */
3706 discard_cleanups (old_chain_2);
3708 /* Breakpoints and watchpoints are not installed on the target
3709 at this point, and signals are passed directly to the
3710 inferior, so this must mean the process is gone. */
3711 if (!ecs->wait_some_more)
3713 discard_cleanups (old_chain_1);
3714 error (_("Program exited while detaching"));
3718 discard_cleanups (old_chain_1);
3721 /* Wait for control to return from inferior to debugger.
3723 If inferior gets a signal, we may decide to start it up again
3724 instead of returning. That is why there is a loop in this function.
3725 When this function actually returns it means the inferior
3726 should be left stopped and GDB should read more commands. */
3729 wait_for_inferior (void)
3731 struct cleanup *old_cleanups;
3732 struct cleanup *thread_state_chain;
3736 (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3739 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup,
3742 /* If an error happens while handling the event, propagate GDB's
3743 knowledge of the executing state to the frontend/user running
3745 thread_state_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3749 struct execution_control_state ecss;
3750 struct execution_control_state *ecs = &ecss;
3751 ptid_t waiton_ptid = minus_one_ptid;
3753 memset (ecs, 0, sizeof (*ecs));
3755 overlay_cache_invalid = 1;
3757 /* Flush target cache before starting to handle each event.
3758 Target was running and cache could be stale. This is just a
3759 heuristic. Running threads may modify target memory, but we
3760 don't get any event. */
3761 target_dcache_invalidate ();
3763 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws, 0);
3766 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3768 /* Now figure out what to do with the result of the result. */
3769 handle_inferior_event (ecs);
3771 if (!ecs->wait_some_more)
3775 /* No error, don't finish the state yet. */
3776 discard_cleanups (thread_state_chain);
3778 do_cleanups (old_cleanups);
3781 /* Cleanup that reinstalls the readline callback handler, if the
3782 target is running in the background. If while handling the target
3783 event something triggered a secondary prompt, like e.g., a
3784 pagination prompt, we'll have removed the callback handler (see
3785 gdb_readline_wrapper_line). Need to do this as we go back to the
3786 event loop, ready to process further input. Note this has no
3787 effect if the handler hasn't actually been removed, because calling
3788 rl_callback_handler_install resets the line buffer, thus losing
3792 reinstall_readline_callback_handler_cleanup (void *arg)
3794 if (!interpreter_async)
3796 /* We're not going back to the top level event loop yet. Don't
3797 install the readline callback, as it'd prep the terminal,
3798 readline-style (raw, noecho) (e.g., --batch). We'll install
3799 it the next time the prompt is displayed, when we're ready
3804 if (async_command_editing_p && !sync_execution)
3805 gdb_rl_callback_handler_reinstall ();
3808 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3809 that's just the event thread. In all-stop, that's all threads. */
3812 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
3814 struct thread_info *thr = ecs->event_thread;
3816 if (thr != NULL && thr->thread_fsm != NULL)
3817 thread_fsm_clean_up (thr->thread_fsm);
3821 ALL_NON_EXITED_THREADS (thr)
3823 if (thr->thread_fsm == NULL)
3825 if (thr == ecs->event_thread)
3828 switch_to_thread (thr->ptid);
3829 thread_fsm_clean_up (thr->thread_fsm);
3832 if (ecs->event_thread != NULL)
3833 switch_to_thread (ecs->event_thread->ptid);
3837 /* A cleanup that restores the execution direction to the value saved
3841 restore_execution_direction (void *arg)
3843 enum exec_direction_kind *save_exec_dir = (enum exec_direction_kind *) arg;
3845 execution_direction = *save_exec_dir;
3848 /* Asynchronous version of wait_for_inferior. It is called by the
3849 event loop whenever a change of state is detected on the file
3850 descriptor corresponding to the target. It can be called more than
3851 once to complete a single execution command. In such cases we need
3852 to keep the state in a global variable ECSS. If it is the last time
3853 that this function is called for a single execution command, then
3854 report to the user that the inferior has stopped, and do the
3855 necessary cleanups. */
3858 fetch_inferior_event (void *client_data)
3860 struct execution_control_state ecss;
3861 struct execution_control_state *ecs = &ecss;
3862 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3863 struct cleanup *ts_old_chain;
3864 int was_sync = sync_execution;
3865 enum exec_direction_kind save_exec_dir = execution_direction;
3867 ptid_t waiton_ptid = minus_one_ptid;
3869 memset (ecs, 0, sizeof (*ecs));
3871 /* End up with readline processing input, if necessary. */
3872 make_cleanup (reinstall_readline_callback_handler_cleanup, NULL);
3874 /* We're handling a live event, so make sure we're doing live
3875 debugging. If we're looking at traceframes while the target is
3876 running, we're going to need to get back to that mode after
3877 handling the event. */
3880 make_cleanup_restore_current_traceframe ();
3881 set_current_traceframe (-1);
3885 /* In non-stop mode, the user/frontend should not notice a thread
3886 switch due to internal events. Make sure we reverse to the
3887 user selected thread and frame after handling the event and
3888 running any breakpoint commands. */
3889 make_cleanup_restore_current_thread ();
3891 overlay_cache_invalid = 1;
3892 /* Flush target cache before starting to handle each event. Target
3893 was running and cache could be stale. This is just a heuristic.
3894 Running threads may modify target memory, but we don't get any
3896 target_dcache_invalidate ();
3898 make_cleanup (restore_execution_direction, &save_exec_dir);
3899 execution_direction = target_execution_direction ();
3901 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
3902 target_can_async_p () ? TARGET_WNOHANG : 0);
3905 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3907 /* If an error happens while handling the event, propagate GDB's
3908 knowledge of the executing state to the frontend/user running
3910 if (!target_is_non_stop_p ())
3911 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3913 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
3915 /* Get executed before make_cleanup_restore_current_thread above to apply
3916 still for the thread which has thrown the exception. */
3917 make_bpstat_clear_actions_cleanup ();
3919 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
3921 /* Now figure out what to do with the result of the result. */
3922 handle_inferior_event (ecs);
3924 if (!ecs->wait_some_more)
3926 struct inferior *inf = find_inferior_ptid (ecs->ptid);
3927 int should_stop = 1;
3928 struct thread_info *thr = ecs->event_thread;
3929 int should_notify_stop = 1;
3931 delete_just_stopped_threads_infrun_breakpoints ();
3935 struct thread_fsm *thread_fsm = thr->thread_fsm;
3937 if (thread_fsm != NULL)
3938 should_stop = thread_fsm_should_stop (thread_fsm);
3947 clean_up_just_stopped_threads_fsms (ecs);
3949 if (thr != NULL && thr->thread_fsm != NULL)
3952 = thread_fsm_should_notify_stop (thr->thread_fsm);
3955 if (should_notify_stop)
3959 /* We may not find an inferior if this was a process exit. */
3960 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3961 proceeded = normal_stop ();
3965 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3972 /* No error, don't finish the thread states yet. */
3973 discard_cleanups (ts_old_chain);
3975 /* Revert thread and frame. */
3976 do_cleanups (old_chain);
3978 /* If the inferior was in sync execution mode, and now isn't,
3979 restore the prompt (a synchronous execution command has finished,
3980 and we're ready for input). */
3981 if (interpreter_async && was_sync && !sync_execution)
3982 observer_notify_sync_execution_done ();
3986 && exec_done_display_p
3987 && (ptid_equal (inferior_ptid, null_ptid)
3988 || !is_running (inferior_ptid)))
3989 printf_unfiltered (_("completed.\n"));
3992 /* Record the frame and location we're currently stepping through. */
3994 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3996 struct thread_info *tp = inferior_thread ();
3998 tp->control.step_frame_id = get_frame_id (frame);
3999 tp->control.step_stack_frame_id = get_stack_frame_id (frame);
4001 tp->current_symtab = sal.symtab;
4002 tp->current_line = sal.line;
4005 /* Clear context switchable stepping state. */
4008 init_thread_stepping_state (struct thread_info *tss)
4010 tss->stepped_breakpoint = 0;
4011 tss->stepping_over_breakpoint = 0;
4012 tss->stepping_over_watchpoint = 0;
4013 tss->step_after_step_resume_breakpoint = 0;
4016 /* Set the cached copy of the last ptid/waitstatus. */
4019 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
4021 target_last_wait_ptid = ptid;
4022 target_last_waitstatus = status;
4025 /* Return the cached copy of the last pid/waitstatus returned by
4026 target_wait()/deprecated_target_wait_hook(). The data is actually
4027 cached by handle_inferior_event(), which gets called immediately
4028 after target_wait()/deprecated_target_wait_hook(). */
4031 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
4033 *ptidp = target_last_wait_ptid;
4034 *status = target_last_waitstatus;
4038 nullify_last_target_wait_ptid (void)
4040 target_last_wait_ptid = minus_one_ptid;
4043 /* Switch thread contexts. */
4046 context_switch (ptid_t ptid)
4048 if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
4050 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
4051 target_pid_to_str (inferior_ptid));
4052 fprintf_unfiltered (gdb_stdlog, "to %s\n",
4053 target_pid_to_str (ptid));
4056 switch_to_thread (ptid);
4059 /* If the target can't tell whether we've hit breakpoints
4060 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4061 check whether that could have been caused by a breakpoint. If so,
4062 adjust the PC, per gdbarch_decr_pc_after_break. */
4065 adjust_pc_after_break (struct thread_info *thread,
4066 struct target_waitstatus *ws)
4068 struct regcache *regcache;
4069 struct gdbarch *gdbarch;
4070 struct address_space *aspace;
4071 CORE_ADDR breakpoint_pc, decr_pc;
4073 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4074 we aren't, just return.
4076 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4077 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4078 implemented by software breakpoints should be handled through the normal
4081 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4082 different signals (SIGILL or SIGEMT for instance), but it is less
4083 clear where the PC is pointing afterwards. It may not match
4084 gdbarch_decr_pc_after_break. I don't know any specific target that
4085 generates these signals at breakpoints (the code has been in GDB since at
4086 least 1992) so I can not guess how to handle them here.
4088 In earlier versions of GDB, a target with
4089 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4090 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4091 target with both of these set in GDB history, and it seems unlikely to be
4092 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4094 if (ws->kind != TARGET_WAITKIND_STOPPED)
4097 if (ws->value.sig != GDB_SIGNAL_TRAP)
4100 /* In reverse execution, when a breakpoint is hit, the instruction
4101 under it has already been de-executed. The reported PC always
4102 points at the breakpoint address, so adjusting it further would
4103 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4106 B1 0x08000000 : INSN1
4107 B2 0x08000001 : INSN2
4109 PC -> 0x08000003 : INSN4
4111 Say you're stopped at 0x08000003 as above. Reverse continuing
4112 from that point should hit B2 as below. Reading the PC when the
4113 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4114 been de-executed already.
4116 B1 0x08000000 : INSN1
4117 B2 PC -> 0x08000001 : INSN2
4121 We can't apply the same logic as for forward execution, because
4122 we would wrongly adjust the PC to 0x08000000, since there's a
4123 breakpoint at PC - 1. We'd then report a hit on B1, although
4124 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4126 if (execution_direction == EXEC_REVERSE)
4129 /* If the target can tell whether the thread hit a SW breakpoint,
4130 trust it. Targets that can tell also adjust the PC
4132 if (target_supports_stopped_by_sw_breakpoint ())
4135 /* Note that relying on whether a breakpoint is planted in memory to
4136 determine this can fail. E.g,. the breakpoint could have been
4137 removed since. Or the thread could have been told to step an
4138 instruction the size of a breakpoint instruction, and only
4139 _after_ was a breakpoint inserted at its address. */
4141 /* If this target does not decrement the PC after breakpoints, then
4142 we have nothing to do. */
4143 regcache = get_thread_regcache (thread->ptid);
4144 gdbarch = get_regcache_arch (regcache);
4146 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
4150 aspace = get_regcache_aspace (regcache);
4152 /* Find the location where (if we've hit a breakpoint) the
4153 breakpoint would be. */
4154 breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
4156 /* If the target can't tell whether a software breakpoint triggered,
4157 fallback to figuring it out based on breakpoints we think were
4158 inserted in the target, and on whether the thread was stepped or
4161 /* Check whether there actually is a software breakpoint inserted at
4164 If in non-stop mode, a race condition is possible where we've
4165 removed a breakpoint, but stop events for that breakpoint were
4166 already queued and arrive later. To suppress those spurious
4167 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4168 and retire them after a number of stop events are reported. Note
4169 this is an heuristic and can thus get confused. The real fix is
4170 to get the "stopped by SW BP and needs adjustment" info out of
4171 the target/kernel (and thus never reach here; see above). */
4172 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
4173 || (target_is_non_stop_p ()
4174 && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
4176 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
4178 if (record_full_is_used ())
4179 record_full_gdb_operation_disable_set ();
4181 /* When using hardware single-step, a SIGTRAP is reported for both
4182 a completed single-step and a software breakpoint. Need to
4183 differentiate between the two, as the latter needs adjusting
4184 but the former does not.
4186 The SIGTRAP can be due to a completed hardware single-step only if
4187 - we didn't insert software single-step breakpoints
4188 - this thread is currently being stepped
4190 If any of these events did not occur, we must have stopped due
4191 to hitting a software breakpoint, and have to back up to the
4194 As a special case, we could have hardware single-stepped a
4195 software breakpoint. In this case (prev_pc == breakpoint_pc),
4196 we also need to back up to the breakpoint address. */
4198 if (thread_has_single_step_breakpoints_set (thread)
4199 || !currently_stepping (thread)
4200 || (thread->stepped_breakpoint
4201 && thread->prev_pc == breakpoint_pc))
4202 regcache_write_pc (regcache, breakpoint_pc);
4204 do_cleanups (old_cleanups);
4209 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
4211 for (frame = get_prev_frame (frame);
4213 frame = get_prev_frame (frame))
4215 if (frame_id_eq (get_frame_id (frame), step_frame_id))
4217 if (get_frame_type (frame) != INLINE_FRAME)
4224 /* Auxiliary function that handles syscall entry/return events.
4225 It returns 1 if the inferior should keep going (and GDB
4226 should ignore the event), or 0 if the event deserves to be
4230 handle_syscall_event (struct execution_control_state *ecs)
4232 struct regcache *regcache;
4235 if (!ptid_equal (ecs->ptid, inferior_ptid))
4236 context_switch (ecs->ptid);
4238 regcache = get_thread_regcache (ecs->ptid);
4239 syscall_number = ecs->ws.value.syscall_number;
4240 stop_pc = regcache_read_pc (regcache);
4242 if (catch_syscall_enabled () > 0
4243 && catching_syscall_number (syscall_number) > 0)
4246 fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
4249 ecs->event_thread->control.stop_bpstat
4250 = bpstat_stop_status (get_regcache_aspace (regcache),
4251 stop_pc, ecs->ptid, &ecs->ws);
4253 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4255 /* Catchpoint hit. */
4260 /* If no catchpoint triggered for this, then keep going. */
4265 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4268 fill_in_stop_func (struct gdbarch *gdbarch,
4269 struct execution_control_state *ecs)
4271 if (!ecs->stop_func_filled_in)
4273 /* Don't care about return value; stop_func_start and stop_func_name
4274 will both be 0 if it doesn't work. */
4275 find_pc_partial_function (stop_pc, &ecs->stop_func_name,
4276 &ecs->stop_func_start, &ecs->stop_func_end);
4277 ecs->stop_func_start
4278 += gdbarch_deprecated_function_start_offset (gdbarch);
4280 if (gdbarch_skip_entrypoint_p (gdbarch))
4281 ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
4282 ecs->stop_func_start);
4284 ecs->stop_func_filled_in = 1;
4289 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
4291 static enum stop_kind
4292 get_inferior_stop_soon (ptid_t ptid)
4294 struct inferior *inf = find_inferior_ptid (ptid);
4296 gdb_assert (inf != NULL);
4297 return inf->control.stop_soon;
4300 /* Wait for one event. Store the resulting waitstatus in WS, and
4301 return the event ptid. */
4304 wait_one (struct target_waitstatus *ws)
4307 ptid_t wait_ptid = minus_one_ptid;
4309 overlay_cache_invalid = 1;
4311 /* Flush target cache before starting to handle each event.
4312 Target was running and cache could be stale. This is just a
4313 heuristic. Running threads may modify target memory, but we
4314 don't get any event. */
4315 target_dcache_invalidate ();
4317 if (deprecated_target_wait_hook)
4318 event_ptid = deprecated_target_wait_hook (wait_ptid, ws, 0);
4320 event_ptid = target_wait (wait_ptid, ws, 0);
4323 print_target_wait_results (wait_ptid, event_ptid, ws);
4328 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4329 instead of the current thread. */
4330 #define THREAD_STOPPED_BY(REASON) \
4332 thread_stopped_by_ ## REASON (ptid_t ptid) \
4334 struct cleanup *old_chain; \
4337 old_chain = save_inferior_ptid (); \
4338 inferior_ptid = ptid; \
4340 res = target_stopped_by_ ## REASON (); \
4342 do_cleanups (old_chain); \
4347 /* Generate thread_stopped_by_watchpoint. */
4348 THREAD_STOPPED_BY (watchpoint)
4349 /* Generate thread_stopped_by_sw_breakpoint. */
4350 THREAD_STOPPED_BY (sw_breakpoint)
4351 /* Generate thread_stopped_by_hw_breakpoint. */
4352 THREAD_STOPPED_BY (hw_breakpoint)
4354 /* Cleanups that switches to the PTID pointed at by PTID_P. */
4357 switch_to_thread_cleanup (void *ptid_p)
4359 ptid_t ptid = *(ptid_t *) ptid_p;
4361 switch_to_thread (ptid);
4364 /* Save the thread's event and stop reason to process it later. */
4367 save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws)
4369 struct regcache *regcache;
4370 struct address_space *aspace;
4376 statstr = target_waitstatus_to_string (ws);
4377 fprintf_unfiltered (gdb_stdlog,
4378 "infrun: saving status %s for %d.%ld.%ld\n",
4380 ptid_get_pid (tp->ptid),
4381 ptid_get_lwp (tp->ptid),
4382 ptid_get_tid (tp->ptid));
4386 /* Record for later. */
4387 tp->suspend.waitstatus = *ws;
4388 tp->suspend.waitstatus_pending_p = 1;
4390 regcache = get_thread_regcache (tp->ptid);
4391 aspace = get_regcache_aspace (regcache);
4393 if (ws->kind == TARGET_WAITKIND_STOPPED
4394 && ws->value.sig == GDB_SIGNAL_TRAP)
4396 CORE_ADDR pc = regcache_read_pc (regcache);
4398 adjust_pc_after_break (tp, &tp->suspend.waitstatus);
4400 if (thread_stopped_by_watchpoint (tp->ptid))
4402 tp->suspend.stop_reason
4403 = TARGET_STOPPED_BY_WATCHPOINT;
4405 else if (target_supports_stopped_by_sw_breakpoint ()
4406 && thread_stopped_by_sw_breakpoint (tp->ptid))
4408 tp->suspend.stop_reason
4409 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4411 else if (target_supports_stopped_by_hw_breakpoint ()
4412 && thread_stopped_by_hw_breakpoint (tp->ptid))
4414 tp->suspend.stop_reason
4415 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4417 else if (!target_supports_stopped_by_hw_breakpoint ()
4418 && hardware_breakpoint_inserted_here_p (aspace,
4421 tp->suspend.stop_reason
4422 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4424 else if (!target_supports_stopped_by_sw_breakpoint ()
4425 && software_breakpoint_inserted_here_p (aspace,
4428 tp->suspend.stop_reason
4429 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4431 else if (!thread_has_single_step_breakpoints_set (tp)
4432 && currently_stepping (tp))
4434 tp->suspend.stop_reason
4435 = TARGET_STOPPED_BY_SINGLE_STEP;
4440 /* Stop all threads. */
4443 stop_all_threads (void)
4445 /* We may need multiple passes to discover all threads. */
4449 struct cleanup *old_chain;
4451 gdb_assert (target_is_non_stop_p ());
4454 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
4456 entry_ptid = inferior_ptid;
4457 old_chain = make_cleanup (switch_to_thread_cleanup, &entry_ptid);
4459 /* Request threads to stop, and then wait for the stops. Because
4460 threads we already know about can spawn more threads while we're
4461 trying to stop them, and we only learn about new threads when we
4462 update the thread list, do this in a loop, and keep iterating
4463 until two passes find no threads that need to be stopped. */
4464 for (pass = 0; pass < 2; pass++, iterations++)
4467 fprintf_unfiltered (gdb_stdlog,
4468 "infrun: stop_all_threads, pass=%d, "
4469 "iterations=%d\n", pass, iterations);
4473 struct target_waitstatus ws;
4475 struct thread_info *t;
4477 update_thread_list ();
4479 /* Go through all threads looking for threads that we need
4480 to tell the target to stop. */
4481 ALL_NON_EXITED_THREADS (t)
4485 /* If already stopping, don't request a stop again.
4486 We just haven't seen the notification yet. */
4487 if (!t->stop_requested)
4490 fprintf_unfiltered (gdb_stdlog,
4491 "infrun: %s executing, "
4493 target_pid_to_str (t->ptid));
4494 target_stop (t->ptid);
4495 t->stop_requested = 1;
4500 fprintf_unfiltered (gdb_stdlog,
4501 "infrun: %s executing, "
4502 "already stopping\n",
4503 target_pid_to_str (t->ptid));
4506 if (t->stop_requested)
4512 fprintf_unfiltered (gdb_stdlog,
4513 "infrun: %s not executing\n",
4514 target_pid_to_str (t->ptid));
4516 /* The thread may be not executing, but still be
4517 resumed with a pending status to process. */
4525 /* If we find new threads on the second iteration, restart
4526 over. We want to see two iterations in a row with all
4531 event_ptid = wait_one (&ws);
4532 if (ws.kind == TARGET_WAITKIND_NO_RESUMED)
4534 /* All resumed threads exited. */
4536 else if (ws.kind == TARGET_WAITKIND_EXITED
4537 || ws.kind == TARGET_WAITKIND_SIGNALLED)
4541 ptid_t ptid = pid_to_ptid (ws.value.integer);
4543 fprintf_unfiltered (gdb_stdlog,
4544 "infrun: %s exited while "
4545 "stopping threads\n",
4546 target_pid_to_str (ptid));
4551 t = find_thread_ptid (event_ptid);
4553 t = add_thread (event_ptid);
4555 t->stop_requested = 0;
4558 t->control.may_range_step = 0;
4560 if (ws.kind == TARGET_WAITKIND_STOPPED
4561 && ws.value.sig == GDB_SIGNAL_0)
4563 /* We caught the event that we intended to catch, so
4564 there's no event pending. */
4565 t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
4566 t->suspend.waitstatus_pending_p = 0;
4568 if (displaced_step_fixup (t->ptid, GDB_SIGNAL_0) < 0)
4570 /* Add it back to the step-over queue. */
4573 fprintf_unfiltered (gdb_stdlog,
4574 "infrun: displaced-step of %s "
4575 "canceled: adding back to the "
4576 "step-over queue\n",
4577 target_pid_to_str (t->ptid));
4579 t->control.trap_expected = 0;
4580 thread_step_over_chain_enqueue (t);
4585 enum gdb_signal sig;
4586 struct regcache *regcache;
4587 struct address_space *aspace;
4593 statstr = target_waitstatus_to_string (&ws);
4594 fprintf_unfiltered (gdb_stdlog,
4595 "infrun: target_wait %s, saving "
4596 "status for %d.%ld.%ld\n",
4598 ptid_get_pid (t->ptid),
4599 ptid_get_lwp (t->ptid),
4600 ptid_get_tid (t->ptid));
4604 /* Record for later. */
4605 save_waitstatus (t, &ws);
4607 sig = (ws.kind == TARGET_WAITKIND_STOPPED
4608 ? ws.value.sig : GDB_SIGNAL_0);
4610 if (displaced_step_fixup (t->ptid, sig) < 0)
4612 /* Add it back to the step-over queue. */
4613 t->control.trap_expected = 0;
4614 thread_step_over_chain_enqueue (t);
4617 regcache = get_thread_regcache (t->ptid);
4618 t->suspend.stop_pc = regcache_read_pc (regcache);
4622 fprintf_unfiltered (gdb_stdlog,
4623 "infrun: saved stop_pc=%s for %s "
4624 "(currently_stepping=%d)\n",
4625 paddress (target_gdbarch (),
4626 t->suspend.stop_pc),
4627 target_pid_to_str (t->ptid),
4628 currently_stepping (t));
4635 do_cleanups (old_chain);
4638 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
4641 /* Given an execution control state that has been freshly filled in by
4642 an event from the inferior, figure out what it means and take
4645 The alternatives are:
4647 1) stop_waiting and return; to really stop and return to the
4650 2) keep_going and return; to wait for the next event (set
4651 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4655 handle_inferior_event_1 (struct execution_control_state *ecs)
4657 enum stop_kind stop_soon;
4659 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
4661 /* We had an event in the inferior, but we are not interested in
4662 handling it at this level. The lower layers have already
4663 done what needs to be done, if anything.
4665 One of the possible circumstances for this is when the
4666 inferior produces output for the console. The inferior has
4667 not stopped, and we are ignoring the event. Another possible
4668 circumstance is any event which the lower level knows will be
4669 reported multiple times without an intervening resume. */
4671 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
4672 prepare_to_wait (ecs);
4676 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
4677 && target_can_async_p () && !sync_execution)
4679 /* There were no unwaited-for children left in the target, but,
4680 we're not synchronously waiting for events either. Just
4681 ignore. Otherwise, if we were running a synchronous
4682 execution command, we need to cancel it and give the user
4683 back the terminal. */
4685 fprintf_unfiltered (gdb_stdlog,
4686 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
4687 prepare_to_wait (ecs);
4691 /* Cache the last pid/waitstatus. */
4692 set_last_target_status (ecs->ptid, ecs->ws);
4694 /* Always clear state belonging to the previous time we stopped. */
4695 stop_stack_dummy = STOP_NONE;
4697 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
4699 /* No unwaited-for children left. IOW, all resumed children
4702 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4704 stop_print_frame = 0;
4709 if (ecs->ws.kind != TARGET_WAITKIND_EXITED
4710 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
4712 ecs->event_thread = find_thread_ptid (ecs->ptid);
4713 /* If it's a new thread, add it to the thread database. */
4714 if (ecs->event_thread == NULL)
4715 ecs->event_thread = add_thread (ecs->ptid);
4717 /* Disable range stepping. If the next step request could use a
4718 range, this will be end up re-enabled then. */
4719 ecs->event_thread->control.may_range_step = 0;
4722 /* Dependent on valid ECS->EVENT_THREAD. */
4723 adjust_pc_after_break (ecs->event_thread, &ecs->ws);
4725 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4726 reinit_frame_cache ();
4728 breakpoint_retire_moribund ();
4730 /* First, distinguish signals caused by the debugger from signals
4731 that have to do with the program's own actions. Note that
4732 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4733 on the operating system version. Here we detect when a SIGILL or
4734 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4735 something similar for SIGSEGV, since a SIGSEGV will be generated
4736 when we're trying to execute a breakpoint instruction on a
4737 non-executable stack. This happens for call dummy breakpoints
4738 for architectures like SPARC that place call dummies on the
4740 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
4741 && (ecs->ws.value.sig == GDB_SIGNAL_ILL
4742 || ecs->ws.value.sig == GDB_SIGNAL_SEGV
4743 || ecs->ws.value.sig == GDB_SIGNAL_EMT))
4745 struct regcache *regcache = get_thread_regcache (ecs->ptid);
4747 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache),
4748 regcache_read_pc (regcache)))
4751 fprintf_unfiltered (gdb_stdlog,
4752 "infrun: Treating signal as SIGTRAP\n");
4753 ecs->ws.value.sig = GDB_SIGNAL_TRAP;
4757 /* Mark the non-executing threads accordingly. In all-stop, all
4758 threads of all processes are stopped when we get any event
4759 reported. In non-stop mode, only the event thread stops. */
4763 if (!target_is_non_stop_p ())
4764 mark_ptid = minus_one_ptid;
4765 else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
4766 || ecs->ws.kind == TARGET_WAITKIND_EXITED)
4768 /* If we're handling a process exit in non-stop mode, even
4769 though threads haven't been deleted yet, one would think
4770 that there is nothing to do, as threads of the dead process
4771 will be soon deleted, and threads of any other process were
4772 left running. However, on some targets, threads survive a
4773 process exit event. E.g., for the "checkpoint" command,
4774 when the current checkpoint/fork exits, linux-fork.c
4775 automatically switches to another fork from within
4776 target_mourn_inferior, by associating the same
4777 inferior/thread to another fork. We haven't mourned yet at
4778 this point, but we must mark any threads left in the
4779 process as not-executing so that finish_thread_state marks
4780 them stopped (in the user's perspective) if/when we present
4781 the stop to the user. */
4782 mark_ptid = pid_to_ptid (ptid_get_pid (ecs->ptid));
4785 mark_ptid = ecs->ptid;
4787 set_executing (mark_ptid, 0);
4789 /* Likewise the resumed flag. */
4790 set_resumed (mark_ptid, 0);
4793 switch (ecs->ws.kind)
4795 case TARGET_WAITKIND_LOADED:
4797 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
4798 if (!ptid_equal (ecs->ptid, inferior_ptid))
4799 context_switch (ecs->ptid);
4800 /* Ignore gracefully during startup of the inferior, as it might
4801 be the shell which has just loaded some objects, otherwise
4802 add the symbols for the newly loaded objects. Also ignore at
4803 the beginning of an attach or remote session; we will query
4804 the full list of libraries once the connection is
4807 stop_soon = get_inferior_stop_soon (ecs->ptid);
4808 if (stop_soon == NO_STOP_QUIETLY)
4810 struct regcache *regcache;
4812 regcache = get_thread_regcache (ecs->ptid);
4814 handle_solib_event ();
4816 ecs->event_thread->control.stop_bpstat
4817 = bpstat_stop_status (get_regcache_aspace (regcache),
4818 stop_pc, ecs->ptid, &ecs->ws);
4820 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4822 /* A catchpoint triggered. */
4823 process_event_stop_test (ecs);
4827 /* If requested, stop when the dynamic linker notifies
4828 gdb of events. This allows the user to get control
4829 and place breakpoints in initializer routines for
4830 dynamically loaded objects (among other things). */
4831 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4832 if (stop_on_solib_events)
4834 /* Make sure we print "Stopped due to solib-event" in
4836 stop_print_frame = 1;
4843 /* If we are skipping through a shell, or through shared library
4844 loading that we aren't interested in, resume the program. If
4845 we're running the program normally, also resume. */
4846 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
4848 /* Loading of shared libraries might have changed breakpoint
4849 addresses. Make sure new breakpoints are inserted. */
4850 if (stop_soon == NO_STOP_QUIETLY)
4851 insert_breakpoints ();
4852 resume (GDB_SIGNAL_0);
4853 prepare_to_wait (ecs);
4857 /* But stop if we're attaching or setting up a remote
4859 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
4860 || stop_soon == STOP_QUIETLY_REMOTE)
4863 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
4868 internal_error (__FILE__, __LINE__,
4869 _("unhandled stop_soon: %d"), (int) stop_soon);
4871 case TARGET_WAITKIND_SPURIOUS:
4873 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
4874 if (!ptid_equal (ecs->ptid, inferior_ptid))
4875 context_switch (ecs->ptid);
4876 resume (GDB_SIGNAL_0);
4877 prepare_to_wait (ecs);
4880 case TARGET_WAITKIND_EXITED:
4881 case TARGET_WAITKIND_SIGNALLED:
4884 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
4885 fprintf_unfiltered (gdb_stdlog,
4886 "infrun: TARGET_WAITKIND_EXITED\n");
4888 fprintf_unfiltered (gdb_stdlog,
4889 "infrun: TARGET_WAITKIND_SIGNALLED\n");
4892 inferior_ptid = ecs->ptid;
4893 set_current_inferior (find_inferior_ptid (ecs->ptid));
4894 set_current_program_space (current_inferior ()->pspace);
4895 handle_vfork_child_exec_or_exit (0);
4896 target_terminal_ours (); /* Must do this before mourn anyway. */
4898 /* Clearing any previous state of convenience variables. */
4899 clear_exit_convenience_vars ();
4901 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
4903 /* Record the exit code in the convenience variable $_exitcode, so
4904 that the user can inspect this again later. */
4905 set_internalvar_integer (lookup_internalvar ("_exitcode"),
4906 (LONGEST) ecs->ws.value.integer);
4908 /* Also record this in the inferior itself. */
4909 current_inferior ()->has_exit_code = 1;
4910 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
4912 /* Support the --return-child-result option. */
4913 return_child_result_value = ecs->ws.value.integer;
4915 observer_notify_exited (ecs->ws.value.integer);
4919 struct regcache *regcache = get_thread_regcache (ecs->ptid);
4920 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4922 if (gdbarch_gdb_signal_to_target_p (gdbarch))
4924 /* Set the value of the internal variable $_exitsignal,
4925 which holds the signal uncaught by the inferior. */
4926 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
4927 gdbarch_gdb_signal_to_target (gdbarch,
4928 ecs->ws.value.sig));
4932 /* We don't have access to the target's method used for
4933 converting between signal numbers (GDB's internal
4934 representation <-> target's representation).
4935 Therefore, we cannot do a good job at displaying this
4936 information to the user. It's better to just warn
4937 her about it (if infrun debugging is enabled), and
4940 fprintf_filtered (gdb_stdlog, _("\
4941 Cannot fill $_exitsignal with the correct signal number.\n"));
4944 observer_notify_signal_exited (ecs->ws.value.sig);
4947 gdb_flush (gdb_stdout);
4948 target_mourn_inferior ();
4949 stop_print_frame = 0;
4953 /* The following are the only cases in which we keep going;
4954 the above cases end in a continue or goto. */
4955 case TARGET_WAITKIND_FORKED:
4956 case TARGET_WAITKIND_VFORKED:
4959 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
4960 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
4962 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
4965 /* Check whether the inferior is displaced stepping. */
4967 struct regcache *regcache = get_thread_regcache (ecs->ptid);
4968 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4970 /* If checking displaced stepping is supported, and thread
4971 ecs->ptid is displaced stepping. */
4972 if (displaced_step_in_progress_thread (ecs->ptid))
4974 struct inferior *parent_inf
4975 = find_inferior_ptid (ecs->ptid);
4976 struct regcache *child_regcache;
4977 CORE_ADDR parent_pc;
4979 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
4980 indicating that the displaced stepping of syscall instruction
4981 has been done. Perform cleanup for parent process here. Note
4982 that this operation also cleans up the child process for vfork,
4983 because their pages are shared. */
4984 displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
4985 /* Start a new step-over in another thread if there's one
4989 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
4991 struct displaced_step_inferior_state *displaced
4992 = get_displaced_stepping_state (ptid_get_pid (ecs->ptid));
4994 /* Restore scratch pad for child process. */
4995 displaced_step_restore (displaced, ecs->ws.value.related_pid);
4998 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
4999 the child's PC is also within the scratchpad. Set the child's PC
5000 to the parent's PC value, which has already been fixed up.
5001 FIXME: we use the parent's aspace here, although we're touching
5002 the child, because the child hasn't been added to the inferior
5003 list yet at this point. */
5006 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
5008 parent_inf->aspace);
5009 /* Read PC value of parent process. */
5010 parent_pc = regcache_read_pc (regcache);
5012 if (debug_displaced)
5013 fprintf_unfiltered (gdb_stdlog,
5014 "displaced: write child pc from %s to %s\n",
5016 regcache_read_pc (child_regcache)),
5017 paddress (gdbarch, parent_pc));
5019 regcache_write_pc (child_regcache, parent_pc);
5023 if (!ptid_equal (ecs->ptid, inferior_ptid))
5024 context_switch (ecs->ptid);
5026 /* Immediately detach breakpoints from the child before there's
5027 any chance of letting the user delete breakpoints from the
5028 breakpoint lists. If we don't do this early, it's easy to
5029 leave left over traps in the child, vis: "break foo; catch
5030 fork; c; <fork>; del; c; <child calls foo>". We only follow
5031 the fork on the last `continue', and by that time the
5032 breakpoint at "foo" is long gone from the breakpoint table.
5033 If we vforked, then we don't need to unpatch here, since both
5034 parent and child are sharing the same memory pages; we'll
5035 need to unpatch at follow/detach time instead to be certain
5036 that new breakpoints added between catchpoint hit time and
5037 vfork follow are detached. */
5038 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
5040 /* This won't actually modify the breakpoint list, but will
5041 physically remove the breakpoints from the child. */
5042 detach_breakpoints (ecs->ws.value.related_pid);
5045 delete_just_stopped_threads_single_step_breakpoints ();
5047 /* In case the event is caught by a catchpoint, remember that
5048 the event is to be followed at the next resume of the thread,
5049 and not immediately. */
5050 ecs->event_thread->pending_follow = ecs->ws;
5052 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5054 ecs->event_thread->control.stop_bpstat
5055 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5056 stop_pc, ecs->ptid, &ecs->ws);
5058 /* If no catchpoint triggered for this, then keep going. Note
5059 that we're interested in knowing the bpstat actually causes a
5060 stop, not just if it may explain the signal. Software
5061 watchpoints, for example, always appear in the bpstat. */
5062 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5068 = (follow_fork_mode_string == follow_fork_mode_child);
5070 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5072 should_resume = follow_fork ();
5075 child = ecs->ws.value.related_pid;
5077 /* In non-stop mode, also resume the other branch. */
5078 if (!detach_fork && (non_stop
5079 || (sched_multi && target_is_non_stop_p ())))
5082 switch_to_thread (parent);
5084 switch_to_thread (child);
5086 ecs->event_thread = inferior_thread ();
5087 ecs->ptid = inferior_ptid;
5092 switch_to_thread (child);
5094 switch_to_thread (parent);
5096 ecs->event_thread = inferior_thread ();
5097 ecs->ptid = inferior_ptid;
5105 process_event_stop_test (ecs);
5108 case TARGET_WAITKIND_VFORK_DONE:
5109 /* Done with the shared memory region. Re-insert breakpoints in
5110 the parent, and keep going. */
5113 fprintf_unfiltered (gdb_stdlog,
5114 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
5116 if (!ptid_equal (ecs->ptid, inferior_ptid))
5117 context_switch (ecs->ptid);
5119 current_inferior ()->waiting_for_vfork_done = 0;
5120 current_inferior ()->pspace->breakpoints_not_allowed = 0;
5121 /* This also takes care of reinserting breakpoints in the
5122 previously locked inferior. */
5126 case TARGET_WAITKIND_EXECD:
5128 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
5130 if (!ptid_equal (ecs->ptid, inferior_ptid))
5131 context_switch (ecs->ptid);
5133 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5135 /* Do whatever is necessary to the parent branch of the vfork. */
5136 handle_vfork_child_exec_or_exit (1);
5138 /* This causes the eventpoints and symbol table to be reset.
5139 Must do this now, before trying to determine whether to
5141 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
5143 /* In follow_exec we may have deleted the original thread and
5144 created a new one. Make sure that the event thread is the
5145 execd thread for that case (this is a nop otherwise). */
5146 ecs->event_thread = inferior_thread ();
5148 ecs->event_thread->control.stop_bpstat
5149 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5150 stop_pc, ecs->ptid, &ecs->ws);
5152 /* Note that this may be referenced from inside
5153 bpstat_stop_status above, through inferior_has_execd. */
5154 xfree (ecs->ws.value.execd_pathname);
5155 ecs->ws.value.execd_pathname = NULL;
5157 /* If no catchpoint triggered for this, then keep going. */
5158 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5160 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5164 process_event_stop_test (ecs);
5167 /* Be careful not to try to gather much state about a thread
5168 that's in a syscall. It's frequently a losing proposition. */
5169 case TARGET_WAITKIND_SYSCALL_ENTRY:
5171 fprintf_unfiltered (gdb_stdlog,
5172 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
5173 /* Getting the current syscall number. */
5174 if (handle_syscall_event (ecs) == 0)
5175 process_event_stop_test (ecs);
5178 /* Before examining the threads further, step this thread to
5179 get it entirely out of the syscall. (We get notice of the
5180 event when the thread is just on the verge of exiting a
5181 syscall. Stepping one instruction seems to get it back
5183 case TARGET_WAITKIND_SYSCALL_RETURN:
5185 fprintf_unfiltered (gdb_stdlog,
5186 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5187 if (handle_syscall_event (ecs) == 0)
5188 process_event_stop_test (ecs);
5191 case TARGET_WAITKIND_STOPPED:
5193 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
5194 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
5195 handle_signal_stop (ecs);
5198 case TARGET_WAITKIND_NO_HISTORY:
5200 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5201 /* Reverse execution: target ran out of history info. */
5203 /* Switch to the stopped thread. */
5204 if (!ptid_equal (ecs->ptid, inferior_ptid))
5205 context_switch (ecs->ptid);
5207 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
5209 delete_just_stopped_threads_single_step_breakpoints ();
5210 stop_pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
5211 observer_notify_no_history ();
5217 /* A wrapper around handle_inferior_event_1, which also makes sure
5218 that all temporary struct value objects that were created during
5219 the handling of the event get deleted at the end. */
5222 handle_inferior_event (struct execution_control_state *ecs)
5224 struct value *mark = value_mark ();
5226 handle_inferior_event_1 (ecs);
5227 /* Purge all temporary values created during the event handling,
5228 as it could be a long time before we return to the command level
5229 where such values would otherwise be purged. */
5230 value_free_to_mark (mark);
5233 /* Restart threads back to what they were trying to do back when we
5234 paused them for an in-line step-over. The EVENT_THREAD thread is
5238 restart_threads (struct thread_info *event_thread)
5240 struct thread_info *tp;
5241 struct thread_info *step_over = NULL;
5243 /* In case the instruction just stepped spawned a new thread. */
5244 update_thread_list ();
5246 ALL_NON_EXITED_THREADS (tp)
5248 if (tp == event_thread)
5251 fprintf_unfiltered (gdb_stdlog,
5252 "infrun: restart threads: "
5253 "[%s] is event thread\n",
5254 target_pid_to_str (tp->ptid));
5258 if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
5261 fprintf_unfiltered (gdb_stdlog,
5262 "infrun: restart threads: "
5263 "[%s] not meant to be running\n",
5264 target_pid_to_str (tp->ptid));
5271 fprintf_unfiltered (gdb_stdlog,
5272 "infrun: restart threads: [%s] resumed\n",
5273 target_pid_to_str (tp->ptid));
5274 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
5278 if (thread_is_in_step_over_chain (tp))
5281 fprintf_unfiltered (gdb_stdlog,
5282 "infrun: restart threads: "
5283 "[%s] needs step-over\n",
5284 target_pid_to_str (tp->ptid));
5285 gdb_assert (!tp->resumed);
5290 if (tp->suspend.waitstatus_pending_p)
5293 fprintf_unfiltered (gdb_stdlog,
5294 "infrun: restart threads: "
5295 "[%s] has pending status\n",
5296 target_pid_to_str (tp->ptid));
5301 /* If some thread needs to start a step-over at this point, it
5302 should still be in the step-over queue, and thus skipped
5304 if (thread_still_needs_step_over (tp))
5306 internal_error (__FILE__, __LINE__,
5307 "thread [%s] needs a step-over, but not in "
5308 "step-over queue\n",
5309 target_pid_to_str (tp->ptid));
5312 if (currently_stepping (tp))
5315 fprintf_unfiltered (gdb_stdlog,
5316 "infrun: restart threads: [%s] was stepping\n",
5317 target_pid_to_str (tp->ptid));
5318 keep_going_stepped_thread (tp);
5322 struct execution_control_state ecss;
5323 struct execution_control_state *ecs = &ecss;
5326 fprintf_unfiltered (gdb_stdlog,
5327 "infrun: restart threads: [%s] continuing\n",
5328 target_pid_to_str (tp->ptid));
5329 reset_ecs (ecs, tp);
5330 switch_to_thread (tp->ptid);
5331 keep_going_pass_signal (ecs);
5336 /* Callback for iterate_over_threads. Find a resumed thread that has
5337 a pending waitstatus. */
5340 resumed_thread_with_pending_status (struct thread_info *tp,
5344 && tp->suspend.waitstatus_pending_p);
5347 /* Called when we get an event that may finish an in-line or
5348 out-of-line (displaced stepping) step-over started previously.
5349 Return true if the event is processed and we should go back to the
5350 event loop; false if the caller should continue processing the
5354 finish_step_over (struct execution_control_state *ecs)
5356 int had_step_over_info;
5358 displaced_step_fixup (ecs->ptid,
5359 ecs->event_thread->suspend.stop_signal);
5361 had_step_over_info = step_over_info_valid_p ();
5363 if (had_step_over_info)
5365 /* If we're stepping over a breakpoint with all threads locked,
5366 then only the thread that was stepped should be reporting
5368 gdb_assert (ecs->event_thread->control.trap_expected);
5370 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5371 clear_step_over_info ();
5374 if (!target_is_non_stop_p ())
5377 /* Start a new step-over in another thread if there's one that
5381 /* If we were stepping over a breakpoint before, and haven't started
5382 a new in-line step-over sequence, then restart all other threads
5383 (except the event thread). We can't do this in all-stop, as then
5384 e.g., we wouldn't be able to issue any other remote packet until
5385 these other threads stop. */
5386 if (had_step_over_info && !step_over_info_valid_p ())
5388 struct thread_info *pending;
5390 /* If we only have threads with pending statuses, the restart
5391 below won't restart any thread and so nothing re-inserts the
5392 breakpoint we just stepped over. But we need it inserted
5393 when we later process the pending events, otherwise if
5394 another thread has a pending event for this breakpoint too,
5395 we'd discard its event (because the breakpoint that
5396 originally caused the event was no longer inserted). */
5397 context_switch (ecs->ptid);
5398 insert_breakpoints ();
5400 restart_threads (ecs->event_thread);
5402 /* If we have events pending, go through handle_inferior_event
5403 again, picking up a pending event at random. This avoids
5404 thread starvation. */
5406 /* But not if we just stepped over a watchpoint in order to let
5407 the instruction execute so we can evaluate its expression.
5408 The set of watchpoints that triggered is recorded in the
5409 breakpoint objects themselves (see bp->watchpoint_triggered).
5410 If we processed another event first, that other event could
5411 clobber this info. */
5412 if (ecs->event_thread->stepping_over_watchpoint)
5415 pending = iterate_over_threads (resumed_thread_with_pending_status,
5417 if (pending != NULL)
5419 struct thread_info *tp = ecs->event_thread;
5420 struct regcache *regcache;
5424 fprintf_unfiltered (gdb_stdlog,
5425 "infrun: found resumed threads with "
5426 "pending events, saving status\n");
5429 gdb_assert (pending != tp);
5431 /* Record the event thread's event for later. */
5432 save_waitstatus (tp, &ecs->ws);
5433 /* This was cleared early, by handle_inferior_event. Set it
5434 so this pending event is considered by
5438 gdb_assert (!tp->executing);
5440 regcache = get_thread_regcache (tp->ptid);
5441 tp->suspend.stop_pc = regcache_read_pc (regcache);
5445 fprintf_unfiltered (gdb_stdlog,
5446 "infrun: saved stop_pc=%s for %s "
5447 "(currently_stepping=%d)\n",
5448 paddress (target_gdbarch (),
5449 tp->suspend.stop_pc),
5450 target_pid_to_str (tp->ptid),
5451 currently_stepping (tp));
5454 /* This in-line step-over finished; clear this so we won't
5455 start a new one. This is what handle_signal_stop would
5456 do, if we returned false. */
5457 tp->stepping_over_breakpoint = 0;
5459 /* Wake up the event loop again. */
5460 mark_async_event_handler (infrun_async_inferior_event_token);
5462 prepare_to_wait (ecs);
5470 /* Come here when the program has stopped with a signal. */
5473 handle_signal_stop (struct execution_control_state *ecs)
5475 struct frame_info *frame;
5476 struct gdbarch *gdbarch;
5477 int stopped_by_watchpoint;
5478 enum stop_kind stop_soon;
5481 gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
5483 /* Do we need to clean up the state of a thread that has
5484 completed a displaced single-step? (Doing so usually affects
5485 the PC, so do it here, before we set stop_pc.) */
5486 if (finish_step_over (ecs))
5489 /* If we either finished a single-step or hit a breakpoint, but
5490 the user wanted this thread to be stopped, pretend we got a
5491 SIG0 (generic unsignaled stop). */
5492 if (ecs->event_thread->stop_requested
5493 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5494 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5496 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5500 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5501 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5502 struct cleanup *old_chain = save_inferior_ptid ();
5504 inferior_ptid = ecs->ptid;
5506 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
5507 paddress (gdbarch, stop_pc));
5508 if (target_stopped_by_watchpoint ())
5512 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
5514 if (target_stopped_data_address (¤t_target, &addr))
5515 fprintf_unfiltered (gdb_stdlog,
5516 "infrun: stopped data address = %s\n",
5517 paddress (gdbarch, addr));
5519 fprintf_unfiltered (gdb_stdlog,
5520 "infrun: (no data address available)\n");
5523 do_cleanups (old_chain);
5526 /* This is originated from start_remote(), start_inferior() and
5527 shared libraries hook functions. */
5528 stop_soon = get_inferior_stop_soon (ecs->ptid);
5529 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
5531 if (!ptid_equal (ecs->ptid, inferior_ptid))
5532 context_switch (ecs->ptid);
5534 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
5535 stop_print_frame = 1;
5540 /* This originates from attach_command(). We need to overwrite
5541 the stop_signal here, because some kernels don't ignore a
5542 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5543 See more comments in inferior.h. On the other hand, if we
5544 get a non-SIGSTOP, report it to the user - assume the backend
5545 will handle the SIGSTOP if it should show up later.
5547 Also consider that the attach is complete when we see a
5548 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5549 target extended-remote report it instead of a SIGSTOP
5550 (e.g. gdbserver). We already rely on SIGTRAP being our
5551 signal, so this is no exception.
5553 Also consider that the attach is complete when we see a
5554 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5555 the target to stop all threads of the inferior, in case the
5556 low level attach operation doesn't stop them implicitly. If
5557 they weren't stopped implicitly, then the stub will report a
5558 GDB_SIGNAL_0, meaning: stopped for no particular reason
5559 other than GDB's request. */
5560 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5561 && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
5562 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5563 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
5565 stop_print_frame = 1;
5567 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5571 /* See if something interesting happened to the non-current thread. If
5572 so, then switch to that thread. */
5573 if (!ptid_equal (ecs->ptid, inferior_ptid))
5576 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
5578 context_switch (ecs->ptid);
5580 if (deprecated_context_hook)
5581 deprecated_context_hook (pid_to_thread_id (ecs->ptid));
5584 /* At this point, get hold of the now-current thread's frame. */
5585 frame = get_current_frame ();
5586 gdbarch = get_frame_arch (frame);
5588 /* Pull the single step breakpoints out of the target. */
5589 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5591 struct regcache *regcache;
5592 struct address_space *aspace;
5595 regcache = get_thread_regcache (ecs->ptid);
5596 aspace = get_regcache_aspace (regcache);
5597 pc = regcache_read_pc (regcache);
5599 /* However, before doing so, if this single-step breakpoint was
5600 actually for another thread, set this thread up for moving
5602 if (!thread_has_single_step_breakpoint_here (ecs->event_thread,
5605 if (single_step_breakpoint_inserted_here_p (aspace, pc))
5609 fprintf_unfiltered (gdb_stdlog,
5610 "infrun: [%s] hit another thread's "
5611 "single-step breakpoint\n",
5612 target_pid_to_str (ecs->ptid));
5614 ecs->hit_singlestep_breakpoint = 1;
5621 fprintf_unfiltered (gdb_stdlog,
5622 "infrun: [%s] hit its "
5623 "single-step breakpoint\n",
5624 target_pid_to_str (ecs->ptid));
5628 delete_just_stopped_threads_single_step_breakpoints ();
5630 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5631 && ecs->event_thread->control.trap_expected
5632 && ecs->event_thread->stepping_over_watchpoint)
5633 stopped_by_watchpoint = 0;
5635 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
5637 /* If necessary, step over this watchpoint. We'll be back to display
5639 if (stopped_by_watchpoint
5640 && (target_have_steppable_watchpoint
5641 || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
5643 /* At this point, we are stopped at an instruction which has
5644 attempted to write to a piece of memory under control of
5645 a watchpoint. The instruction hasn't actually executed
5646 yet. If we were to evaluate the watchpoint expression
5647 now, we would get the old value, and therefore no change
5648 would seem to have occurred.
5650 In order to make watchpoints work `right', we really need
5651 to complete the memory write, and then evaluate the
5652 watchpoint expression. We do this by single-stepping the
5655 It may not be necessary to disable the watchpoint to step over
5656 it. For example, the PA can (with some kernel cooperation)
5657 single step over a watchpoint without disabling the watchpoint.
5659 It is far more common to need to disable a watchpoint to step
5660 the inferior over it. If we have non-steppable watchpoints,
5661 we must disable the current watchpoint; it's simplest to
5662 disable all watchpoints.
5664 Any breakpoint at PC must also be stepped over -- if there's
5665 one, it will have already triggered before the watchpoint
5666 triggered, and we either already reported it to the user, or
5667 it didn't cause a stop and we called keep_going. In either
5668 case, if there was a breakpoint at PC, we must be trying to
5670 ecs->event_thread->stepping_over_watchpoint = 1;
5675 ecs->event_thread->stepping_over_breakpoint = 0;
5676 ecs->event_thread->stepping_over_watchpoint = 0;
5677 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
5678 ecs->event_thread->control.stop_step = 0;
5679 stop_print_frame = 1;
5680 stopped_by_random_signal = 0;
5682 /* Hide inlined functions starting here, unless we just performed stepi or
5683 nexti. After stepi and nexti, always show the innermost frame (not any
5684 inline function call sites). */
5685 if (ecs->event_thread->control.step_range_end != 1)
5687 struct address_space *aspace =
5688 get_regcache_aspace (get_thread_regcache (ecs->ptid));
5690 /* skip_inline_frames is expensive, so we avoid it if we can
5691 determine that the address is one where functions cannot have
5692 been inlined. This improves performance with inferiors that
5693 load a lot of shared libraries, because the solib event
5694 breakpoint is defined as the address of a function (i.e. not
5695 inline). Note that we have to check the previous PC as well
5696 as the current one to catch cases when we have just
5697 single-stepped off a breakpoint prior to reinstating it.
5698 Note that we're assuming that the code we single-step to is
5699 not inline, but that's not definitive: there's nothing
5700 preventing the event breakpoint function from containing
5701 inlined code, and the single-step ending up there. If the
5702 user had set a breakpoint on that inlined code, the missing
5703 skip_inline_frames call would break things. Fortunately
5704 that's an extremely unlikely scenario. */
5705 if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
5706 && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5707 && ecs->event_thread->control.trap_expected
5708 && pc_at_non_inline_function (aspace,
5709 ecs->event_thread->prev_pc,
5712 skip_inline_frames (ecs->ptid);
5714 /* Re-fetch current thread's frame in case that invalidated
5716 frame = get_current_frame ();
5717 gdbarch = get_frame_arch (frame);
5721 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5722 && ecs->event_thread->control.trap_expected
5723 && gdbarch_single_step_through_delay_p (gdbarch)
5724 && currently_stepping (ecs->event_thread))
5726 /* We're trying to step off a breakpoint. Turns out that we're
5727 also on an instruction that needs to be stepped multiple
5728 times before it's been fully executing. E.g., architectures
5729 with a delay slot. It needs to be stepped twice, once for
5730 the instruction and once for the delay slot. */
5731 int step_through_delay
5732 = gdbarch_single_step_through_delay (gdbarch, frame);
5734 if (debug_infrun && step_through_delay)
5735 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
5736 if (ecs->event_thread->control.step_range_end == 0
5737 && step_through_delay)
5739 /* The user issued a continue when stopped at a breakpoint.
5740 Set up for another trap and get out of here. */
5741 ecs->event_thread->stepping_over_breakpoint = 1;
5745 else if (step_through_delay)
5747 /* The user issued a step when stopped at a breakpoint.
5748 Maybe we should stop, maybe we should not - the delay
5749 slot *might* correspond to a line of source. In any
5750 case, don't decide that here, just set
5751 ecs->stepping_over_breakpoint, making sure we
5752 single-step again before breakpoints are re-inserted. */
5753 ecs->event_thread->stepping_over_breakpoint = 1;
5757 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5758 handles this event. */
5759 ecs->event_thread->control.stop_bpstat
5760 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5761 stop_pc, ecs->ptid, &ecs->ws);
5763 /* Following in case break condition called a
5765 stop_print_frame = 1;
5767 /* This is where we handle "moribund" watchpoints. Unlike
5768 software breakpoints traps, hardware watchpoint traps are
5769 always distinguishable from random traps. If no high-level
5770 watchpoint is associated with the reported stop data address
5771 anymore, then the bpstat does not explain the signal ---
5772 simply make sure to ignore it if `stopped_by_watchpoint' is
5776 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5777 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5779 && stopped_by_watchpoint)
5780 fprintf_unfiltered (gdb_stdlog,
5781 "infrun: no user watchpoint explains "
5782 "watchpoint SIGTRAP, ignoring\n");
5784 /* NOTE: cagney/2003-03-29: These checks for a random signal
5785 at one stage in the past included checks for an inferior
5786 function call's call dummy's return breakpoint. The original
5787 comment, that went with the test, read:
5789 ``End of a stack dummy. Some systems (e.g. Sony news) give
5790 another signal besides SIGTRAP, so check here as well as
5793 If someone ever tries to get call dummys on a
5794 non-executable stack to work (where the target would stop
5795 with something like a SIGSEGV), then those tests might need
5796 to be re-instated. Given, however, that the tests were only
5797 enabled when momentary breakpoints were not being used, I
5798 suspect that it won't be the case.
5800 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5801 be necessary for call dummies on a non-executable stack on
5804 /* See if the breakpoints module can explain the signal. */
5806 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5807 ecs->event_thread->suspend.stop_signal);
5809 /* Maybe this was a trap for a software breakpoint that has since
5811 if (random_signal && target_stopped_by_sw_breakpoint ())
5813 if (program_breakpoint_here_p (gdbarch, stop_pc))
5815 struct regcache *regcache;
5818 /* Re-adjust PC to what the program would see if GDB was not
5820 regcache = get_thread_regcache (ecs->event_thread->ptid);
5821 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
5824 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
5826 if (record_full_is_used ())
5827 record_full_gdb_operation_disable_set ();
5829 regcache_write_pc (regcache, stop_pc + decr_pc);
5831 do_cleanups (old_cleanups);
5836 /* A delayed software breakpoint event. Ignore the trap. */
5838 fprintf_unfiltered (gdb_stdlog,
5839 "infrun: delayed software breakpoint "
5840 "trap, ignoring\n");
5845 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
5846 has since been removed. */
5847 if (random_signal && target_stopped_by_hw_breakpoint ())
5849 /* A delayed hardware breakpoint event. Ignore the trap. */
5851 fprintf_unfiltered (gdb_stdlog,
5852 "infrun: delayed hardware breakpoint/watchpoint "
5853 "trap, ignoring\n");
5857 /* If not, perhaps stepping/nexting can. */
5859 random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5860 && currently_stepping (ecs->event_thread));
5862 /* Perhaps the thread hit a single-step breakpoint of _another_
5863 thread. Single-step breakpoints are transparent to the
5864 breakpoints module. */
5866 random_signal = !ecs->hit_singlestep_breakpoint;
5868 /* No? Perhaps we got a moribund watchpoint. */
5870 random_signal = !stopped_by_watchpoint;
5872 /* For the program's own signals, act according to
5873 the signal handling tables. */
5877 /* Signal not for debugging purposes. */
5878 struct inferior *inf = find_inferior_ptid (ecs->ptid);
5879 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
5882 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
5883 gdb_signal_to_symbol_string (stop_signal));
5885 stopped_by_random_signal = 1;
5887 /* Always stop on signals if we're either just gaining control
5888 of the program, or the user explicitly requested this thread
5889 to remain stopped. */
5890 if (stop_soon != NO_STOP_QUIETLY
5891 || ecs->event_thread->stop_requested
5893 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
5899 /* Notify observers the signal has "handle print" set. Note we
5900 returned early above if stopping; normal_stop handles the
5901 printing in that case. */
5902 if (signal_print[ecs->event_thread->suspend.stop_signal])
5904 /* The signal table tells us to print about this signal. */
5905 target_terminal_ours_for_output ();
5906 observer_notify_signal_received (ecs->event_thread->suspend.stop_signal);
5907 target_terminal_inferior ();
5910 /* Clear the signal if it should not be passed. */
5911 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
5912 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5914 if (ecs->event_thread->prev_pc == stop_pc
5915 && ecs->event_thread->control.trap_expected
5916 && ecs->event_thread->control.step_resume_breakpoint == NULL)
5920 /* We were just starting a new sequence, attempting to
5921 single-step off of a breakpoint and expecting a SIGTRAP.
5922 Instead this signal arrives. This signal will take us out
5923 of the stepping range so GDB needs to remember to, when
5924 the signal handler returns, resume stepping off that
5926 /* To simplify things, "continue" is forced to use the same
5927 code paths as single-step - set a breakpoint at the
5928 signal return address and then, once hit, step off that
5931 fprintf_unfiltered (gdb_stdlog,
5932 "infrun: signal arrived while stepping over "
5935 was_in_line = step_over_info_valid_p ();
5936 clear_step_over_info ();
5937 insert_hp_step_resume_breakpoint_at_frame (frame);
5938 ecs->event_thread->step_after_step_resume_breakpoint = 1;
5939 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5940 ecs->event_thread->control.trap_expected = 0;
5942 if (target_is_non_stop_p ())
5944 /* Either "set non-stop" is "on", or the target is
5945 always in non-stop mode. In this case, we have a bit
5946 more work to do. Resume the current thread, and if
5947 we had paused all threads, restart them while the
5948 signal handler runs. */
5953 restart_threads (ecs->event_thread);
5955 else if (debug_infrun)
5957 fprintf_unfiltered (gdb_stdlog,
5958 "infrun: no need to restart threads\n");
5963 /* If we were nexting/stepping some other thread, switch to
5964 it, so that we don't continue it, losing control. */
5965 if (!switch_back_to_stepped_thread (ecs))
5970 if (ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
5971 && (pc_in_thread_step_range (stop_pc, ecs->event_thread)
5972 || ecs->event_thread->control.step_range_end == 1)
5973 && frame_id_eq (get_stack_frame_id (frame),
5974 ecs->event_thread->control.step_stack_frame_id)
5975 && ecs->event_thread->control.step_resume_breakpoint == NULL)
5977 /* The inferior is about to take a signal that will take it
5978 out of the single step range. Set a breakpoint at the
5979 current PC (which is presumably where the signal handler
5980 will eventually return) and then allow the inferior to
5983 Note that this is only needed for a signal delivered
5984 while in the single-step range. Nested signals aren't a
5985 problem as they eventually all return. */
5987 fprintf_unfiltered (gdb_stdlog,
5988 "infrun: signal may take us out of "
5989 "single-step range\n");
5991 clear_step_over_info ();
5992 insert_hp_step_resume_breakpoint_at_frame (frame);
5993 ecs->event_thread->step_after_step_resume_breakpoint = 1;
5994 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5995 ecs->event_thread->control.trap_expected = 0;
6000 /* Note: step_resume_breakpoint may be non-NULL. This occures
6001 when either there's a nested signal, or when there's a
6002 pending signal enabled just as the signal handler returns
6003 (leaving the inferior at the step-resume-breakpoint without
6004 actually executing it). Either way continue until the
6005 breakpoint is really hit. */
6007 if (!switch_back_to_stepped_thread (ecs))
6010 fprintf_unfiltered (gdb_stdlog,
6011 "infrun: random signal, keep going\n");
6018 process_event_stop_test (ecs);
6021 /* Come here when we've got some debug event / signal we can explain
6022 (IOW, not a random signal), and test whether it should cause a
6023 stop, or whether we should resume the inferior (transparently).
6024 E.g., could be a breakpoint whose condition evaluates false; we
6025 could be still stepping within the line; etc. */
6028 process_event_stop_test (struct execution_control_state *ecs)
6030 struct symtab_and_line stop_pc_sal;
6031 struct frame_info *frame;
6032 struct gdbarch *gdbarch;
6033 CORE_ADDR jmp_buf_pc;
6034 struct bpstat_what what;
6036 /* Handle cases caused by hitting a breakpoint. */
6038 frame = get_current_frame ();
6039 gdbarch = get_frame_arch (frame);
6041 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
6043 if (what.call_dummy)
6045 stop_stack_dummy = what.call_dummy;
6048 /* A few breakpoint types have callbacks associated (e.g.,
6049 bp_jit_event). Run them now. */
6050 bpstat_run_callbacks (ecs->event_thread->control.stop_bpstat);
6052 /* If we hit an internal event that triggers symbol changes, the
6053 current frame will be invalidated within bpstat_what (e.g., if we
6054 hit an internal solib event). Re-fetch it. */
6055 frame = get_current_frame ();
6056 gdbarch = get_frame_arch (frame);
6058 switch (what.main_action)
6060 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
6061 /* If we hit the breakpoint at longjmp while stepping, we
6062 install a momentary breakpoint at the target of the
6066 fprintf_unfiltered (gdb_stdlog,
6067 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
6069 ecs->event_thread->stepping_over_breakpoint = 1;
6071 if (what.is_longjmp)
6073 struct value *arg_value;
6075 /* If we set the longjmp breakpoint via a SystemTap probe,
6076 then use it to extract the arguments. The destination PC
6077 is the third argument to the probe. */
6078 arg_value = probe_safe_evaluate_at_pc (frame, 2);
6081 jmp_buf_pc = value_as_address (arg_value);
6082 jmp_buf_pc = gdbarch_addr_bits_remove (gdbarch, jmp_buf_pc);
6084 else if (!gdbarch_get_longjmp_target_p (gdbarch)
6085 || !gdbarch_get_longjmp_target (gdbarch,
6086 frame, &jmp_buf_pc))
6089 fprintf_unfiltered (gdb_stdlog,
6090 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
6091 "(!gdbarch_get_longjmp_target)\n");
6096 /* Insert a breakpoint at resume address. */
6097 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
6100 check_exception_resume (ecs, frame);
6104 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
6106 struct frame_info *init_frame;
6108 /* There are several cases to consider.
6110 1. The initiating frame no longer exists. In this case we
6111 must stop, because the exception or longjmp has gone too
6114 2. The initiating frame exists, and is the same as the
6115 current frame. We stop, because the exception or longjmp
6118 3. The initiating frame exists and is different from the
6119 current frame. This means the exception or longjmp has
6120 been caught beneath the initiating frame, so keep going.
6122 4. longjmp breakpoint has been placed just to protect
6123 against stale dummy frames and user is not interested in
6124 stopping around longjmps. */
6127 fprintf_unfiltered (gdb_stdlog,
6128 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
6130 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
6132 delete_exception_resume_breakpoint (ecs->event_thread);
6134 if (what.is_longjmp)
6136 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
6138 if (!frame_id_p (ecs->event_thread->initiating_frame))
6146 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
6150 struct frame_id current_id
6151 = get_frame_id (get_current_frame ());
6152 if (frame_id_eq (current_id,
6153 ecs->event_thread->initiating_frame))
6155 /* Case 2. Fall through. */
6165 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6167 delete_step_resume_breakpoint (ecs->event_thread);
6169 end_stepping_range (ecs);
6173 case BPSTAT_WHAT_SINGLE:
6175 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
6176 ecs->event_thread->stepping_over_breakpoint = 1;
6177 /* Still need to check other stuff, at least the case where we
6178 are stepping and step out of the right range. */
6181 case BPSTAT_WHAT_STEP_RESUME:
6183 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6185 delete_step_resume_breakpoint (ecs->event_thread);
6186 if (ecs->event_thread->control.proceed_to_finish
6187 && execution_direction == EXEC_REVERSE)
6189 struct thread_info *tp = ecs->event_thread;
6191 /* We are finishing a function in reverse, and just hit the
6192 step-resume breakpoint at the start address of the
6193 function, and we're almost there -- just need to back up
6194 by one more single-step, which should take us back to the
6196 tp->control.step_range_start = tp->control.step_range_end = 1;
6200 fill_in_stop_func (gdbarch, ecs);
6201 if (stop_pc == ecs->stop_func_start
6202 && execution_direction == EXEC_REVERSE)
6204 /* We are stepping over a function call in reverse, and just
6205 hit the step-resume breakpoint at the start address of
6206 the function. Go back to single-stepping, which should
6207 take us back to the function call. */
6208 ecs->event_thread->stepping_over_breakpoint = 1;
6214 case BPSTAT_WHAT_STOP_NOISY:
6216 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6217 stop_print_frame = 1;
6219 /* Assume the thread stopped for a breapoint. We'll still check
6220 whether a/the breakpoint is there when the thread is next
6222 ecs->event_thread->stepping_over_breakpoint = 1;
6227 case BPSTAT_WHAT_STOP_SILENT:
6229 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6230 stop_print_frame = 0;
6232 /* Assume the thread stopped for a breapoint. We'll still check
6233 whether a/the breakpoint is there when the thread is next
6235 ecs->event_thread->stepping_over_breakpoint = 1;
6239 case BPSTAT_WHAT_HP_STEP_RESUME:
6241 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6243 delete_step_resume_breakpoint (ecs->event_thread);
6244 if (ecs->event_thread->step_after_step_resume_breakpoint)
6246 /* Back when the step-resume breakpoint was inserted, we
6247 were trying to single-step off a breakpoint. Go back to
6249 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6250 ecs->event_thread->stepping_over_breakpoint = 1;
6256 case BPSTAT_WHAT_KEEP_CHECKING:
6260 /* If we stepped a permanent breakpoint and we had a high priority
6261 step-resume breakpoint for the address we stepped, but we didn't
6262 hit it, then we must have stepped into the signal handler. The
6263 step-resume was only necessary to catch the case of _not_
6264 stepping into the handler, so delete it, and fall through to
6265 checking whether the step finished. */
6266 if (ecs->event_thread->stepped_breakpoint)
6268 struct breakpoint *sr_bp
6269 = ecs->event_thread->control.step_resume_breakpoint;
6272 && sr_bp->loc->permanent
6273 && sr_bp->type == bp_hp_step_resume
6274 && sr_bp->loc->address == ecs->event_thread->prev_pc)
6277 fprintf_unfiltered (gdb_stdlog,
6278 "infrun: stepped permanent breakpoint, stopped in "
6280 delete_step_resume_breakpoint (ecs->event_thread);
6281 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6285 /* We come here if we hit a breakpoint but should not stop for it.
6286 Possibly we also were stepping and should stop for that. So fall
6287 through and test for stepping. But, if not stepping, do not
6290 /* In all-stop mode, if we're currently stepping but have stopped in
6291 some other thread, we need to switch back to the stepped thread. */
6292 if (switch_back_to_stepped_thread (ecs))
6295 if (ecs->event_thread->control.step_resume_breakpoint)
6298 fprintf_unfiltered (gdb_stdlog,
6299 "infrun: step-resume breakpoint is inserted\n");
6301 /* Having a step-resume breakpoint overrides anything
6302 else having to do with stepping commands until
6303 that breakpoint is reached. */
6308 if (ecs->event_thread->control.step_range_end == 0)
6311 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
6312 /* Likewise if we aren't even stepping. */
6317 /* Re-fetch current thread's frame in case the code above caused
6318 the frame cache to be re-initialized, making our FRAME variable
6319 a dangling pointer. */
6320 frame = get_current_frame ();
6321 gdbarch = get_frame_arch (frame);
6322 fill_in_stop_func (gdbarch, ecs);
6324 /* If stepping through a line, keep going if still within it.
6326 Note that step_range_end is the address of the first instruction
6327 beyond the step range, and NOT the address of the last instruction
6330 Note also that during reverse execution, we may be stepping
6331 through a function epilogue and therefore must detect when
6332 the current-frame changes in the middle of a line. */
6334 if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
6335 && (execution_direction != EXEC_REVERSE
6336 || frame_id_eq (get_frame_id (frame),
6337 ecs->event_thread->control.step_frame_id)))
6341 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
6342 paddress (gdbarch, ecs->event_thread->control.step_range_start),
6343 paddress (gdbarch, ecs->event_thread->control.step_range_end));
6345 /* Tentatively re-enable range stepping; `resume' disables it if
6346 necessary (e.g., if we're stepping over a breakpoint or we
6347 have software watchpoints). */
6348 ecs->event_thread->control.may_range_step = 1;
6350 /* When stepping backward, stop at beginning of line range
6351 (unless it's the function entry point, in which case
6352 keep going back to the call point). */
6353 if (stop_pc == ecs->event_thread->control.step_range_start
6354 && stop_pc != ecs->stop_func_start
6355 && execution_direction == EXEC_REVERSE)
6356 end_stepping_range (ecs);
6363 /* We stepped out of the stepping range. */
6365 /* If we are stepping at the source level and entered the runtime
6366 loader dynamic symbol resolution code...
6368 EXEC_FORWARD: we keep on single stepping until we exit the run
6369 time loader code and reach the callee's address.
6371 EXEC_REVERSE: we've already executed the callee (backward), and
6372 the runtime loader code is handled just like any other
6373 undebuggable function call. Now we need only keep stepping
6374 backward through the trampoline code, and that's handled further
6375 down, so there is nothing for us to do here. */
6377 if (execution_direction != EXEC_REVERSE
6378 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6379 && in_solib_dynsym_resolve_code (stop_pc))
6381 CORE_ADDR pc_after_resolver =
6382 gdbarch_skip_solib_resolver (gdbarch, stop_pc);
6385 fprintf_unfiltered (gdb_stdlog,
6386 "infrun: stepped into dynsym resolve code\n");
6388 if (pc_after_resolver)
6390 /* Set up a step-resume breakpoint at the address
6391 indicated by SKIP_SOLIB_RESOLVER. */
6392 struct symtab_and_line sr_sal;
6395 sr_sal.pc = pc_after_resolver;
6396 sr_sal.pspace = get_frame_program_space (frame);
6398 insert_step_resume_breakpoint_at_sal (gdbarch,
6399 sr_sal, null_frame_id);
6406 if (ecs->event_thread->control.step_range_end != 1
6407 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6408 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6409 && get_frame_type (frame) == SIGTRAMP_FRAME)
6412 fprintf_unfiltered (gdb_stdlog,
6413 "infrun: stepped into signal trampoline\n");
6414 /* The inferior, while doing a "step" or "next", has ended up in
6415 a signal trampoline (either by a signal being delivered or by
6416 the signal handler returning). Just single-step until the
6417 inferior leaves the trampoline (either by calling the handler
6423 /* If we're in the return path from a shared library trampoline,
6424 we want to proceed through the trampoline when stepping. */
6425 /* macro/2012-04-25: This needs to come before the subroutine
6426 call check below as on some targets return trampolines look
6427 like subroutine calls (MIPS16 return thunks). */
6428 if (gdbarch_in_solib_return_trampoline (gdbarch,
6429 stop_pc, ecs->stop_func_name)
6430 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6432 /* Determine where this trampoline returns. */
6433 CORE_ADDR real_stop_pc;
6435 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6438 fprintf_unfiltered (gdb_stdlog,
6439 "infrun: stepped into solib return tramp\n");
6441 /* Only proceed through if we know where it's going. */
6444 /* And put the step-breakpoint there and go until there. */
6445 struct symtab_and_line sr_sal;
6447 init_sal (&sr_sal); /* initialize to zeroes */
6448 sr_sal.pc = real_stop_pc;
6449 sr_sal.section = find_pc_overlay (sr_sal.pc);
6450 sr_sal.pspace = get_frame_program_space (frame);
6452 /* Do not specify what the fp should be when we stop since
6453 on some machines the prologue is where the new fp value
6455 insert_step_resume_breakpoint_at_sal (gdbarch,
6456 sr_sal, null_frame_id);
6458 /* Restart without fiddling with the step ranges or
6465 /* Check for subroutine calls. The check for the current frame
6466 equalling the step ID is not necessary - the check of the
6467 previous frame's ID is sufficient - but it is a common case and
6468 cheaper than checking the previous frame's ID.
6470 NOTE: frame_id_eq will never report two invalid frame IDs as
6471 being equal, so to get into this block, both the current and
6472 previous frame must have valid frame IDs. */
6473 /* The outer_frame_id check is a heuristic to detect stepping
6474 through startup code. If we step over an instruction which
6475 sets the stack pointer from an invalid value to a valid value,
6476 we may detect that as a subroutine call from the mythical
6477 "outermost" function. This could be fixed by marking
6478 outermost frames as !stack_p,code_p,special_p. Then the
6479 initial outermost frame, before sp was valid, would
6480 have code_addr == &_start. See the comment in frame_id_eq
6482 if (!frame_id_eq (get_stack_frame_id (frame),
6483 ecs->event_thread->control.step_stack_frame_id)
6484 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6485 ecs->event_thread->control.step_stack_frame_id)
6486 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
6488 || (ecs->event_thread->control.step_start_function
6489 != find_pc_function (stop_pc)))))
6491 CORE_ADDR real_stop_pc;
6494 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
6496 if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
6498 /* I presume that step_over_calls is only 0 when we're
6499 supposed to be stepping at the assembly language level
6500 ("stepi"). Just stop. */
6501 /* And this works the same backward as frontward. MVS */
6502 end_stepping_range (ecs);
6506 /* Reverse stepping through solib trampolines. */
6508 if (execution_direction == EXEC_REVERSE
6509 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
6510 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6511 || (ecs->stop_func_start == 0
6512 && in_solib_dynsym_resolve_code (stop_pc))))
6514 /* Any solib trampoline code can be handled in reverse
6515 by simply continuing to single-step. We have already
6516 executed the solib function (backwards), and a few
6517 steps will take us back through the trampoline to the
6523 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6525 /* We're doing a "next".
6527 Normal (forward) execution: set a breakpoint at the
6528 callee's return address (the address at which the caller
6531 Reverse (backward) execution. set the step-resume
6532 breakpoint at the start of the function that we just
6533 stepped into (backwards), and continue to there. When we
6534 get there, we'll need to single-step back to the caller. */
6536 if (execution_direction == EXEC_REVERSE)
6538 /* If we're already at the start of the function, we've either
6539 just stepped backward into a single instruction function,
6540 or stepped back out of a signal handler to the first instruction
6541 of the function. Just keep going, which will single-step back
6543 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
6545 struct symtab_and_line sr_sal;
6547 /* Normal function call return (static or dynamic). */
6549 sr_sal.pc = ecs->stop_func_start;
6550 sr_sal.pspace = get_frame_program_space (frame);
6551 insert_step_resume_breakpoint_at_sal (gdbarch,
6552 sr_sal, null_frame_id);
6556 insert_step_resume_breakpoint_at_caller (frame);
6562 /* If we are in a function call trampoline (a stub between the
6563 calling routine and the real function), locate the real
6564 function. That's what tells us (a) whether we want to step
6565 into it at all, and (b) what prologue we want to run to the
6566 end of, if we do step into it. */
6567 real_stop_pc = skip_language_trampoline (frame, stop_pc);
6568 if (real_stop_pc == 0)
6569 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6570 if (real_stop_pc != 0)
6571 ecs->stop_func_start = real_stop_pc;
6573 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
6575 struct symtab_and_line sr_sal;
6578 sr_sal.pc = ecs->stop_func_start;
6579 sr_sal.pspace = get_frame_program_space (frame);
6581 insert_step_resume_breakpoint_at_sal (gdbarch,
6582 sr_sal, null_frame_id);
6587 /* If we have line number information for the function we are
6588 thinking of stepping into and the function isn't on the skip
6591 If there are several symtabs at that PC (e.g. with include
6592 files), just want to know whether *any* of them have line
6593 numbers. find_pc_line handles this. */
6595 struct symtab_and_line tmp_sal;
6597 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
6598 if (tmp_sal.line != 0
6599 && !function_name_is_marked_for_skip (ecs->stop_func_name,
6602 if (execution_direction == EXEC_REVERSE)
6603 handle_step_into_function_backward (gdbarch, ecs);
6605 handle_step_into_function (gdbarch, ecs);
6610 /* If we have no line number and the step-stop-if-no-debug is
6611 set, we stop the step so that the user has a chance to switch
6612 in assembly mode. */
6613 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6614 && step_stop_if_no_debug)
6616 end_stepping_range (ecs);
6620 if (execution_direction == EXEC_REVERSE)
6622 /* If we're already at the start of the function, we've either just
6623 stepped backward into a single instruction function without line
6624 number info, or stepped back out of a signal handler to the first
6625 instruction of the function without line number info. Just keep
6626 going, which will single-step back to the caller. */
6627 if (ecs->stop_func_start != stop_pc)
6629 /* Set a breakpoint at callee's start address.
6630 From there we can step once and be back in the caller. */
6631 struct symtab_and_line sr_sal;
6634 sr_sal.pc = ecs->stop_func_start;
6635 sr_sal.pspace = get_frame_program_space (frame);
6636 insert_step_resume_breakpoint_at_sal (gdbarch,
6637 sr_sal, null_frame_id);
6641 /* Set a breakpoint at callee's return address (the address
6642 at which the caller will resume). */
6643 insert_step_resume_breakpoint_at_caller (frame);
6649 /* Reverse stepping through solib trampolines. */
6651 if (execution_direction == EXEC_REVERSE
6652 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6654 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6655 || (ecs->stop_func_start == 0
6656 && in_solib_dynsym_resolve_code (stop_pc)))
6658 /* Any solib trampoline code can be handled in reverse
6659 by simply continuing to single-step. We have already
6660 executed the solib function (backwards), and a few
6661 steps will take us back through the trampoline to the
6666 else if (in_solib_dynsym_resolve_code (stop_pc))
6668 /* Stepped backward into the solib dynsym resolver.
6669 Set a breakpoint at its start and continue, then
6670 one more step will take us out. */
6671 struct symtab_and_line sr_sal;
6674 sr_sal.pc = ecs->stop_func_start;
6675 sr_sal.pspace = get_frame_program_space (frame);
6676 insert_step_resume_breakpoint_at_sal (gdbarch,
6677 sr_sal, null_frame_id);
6683 stop_pc_sal = find_pc_line (stop_pc, 0);
6685 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6686 the trampoline processing logic, however, there are some trampolines
6687 that have no names, so we should do trampoline handling first. */
6688 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6689 && ecs->stop_func_name == NULL
6690 && stop_pc_sal.line == 0)
6693 fprintf_unfiltered (gdb_stdlog,
6694 "infrun: stepped into undebuggable function\n");
6696 /* The inferior just stepped into, or returned to, an
6697 undebuggable function (where there is no debugging information
6698 and no line number corresponding to the address where the
6699 inferior stopped). Since we want to skip this kind of code,
6700 we keep going until the inferior returns from this
6701 function - unless the user has asked us not to (via
6702 set step-mode) or we no longer know how to get back
6703 to the call site. */
6704 if (step_stop_if_no_debug
6705 || !frame_id_p (frame_unwind_caller_id (frame)))
6707 /* If we have no line number and the step-stop-if-no-debug
6708 is set, we stop the step so that the user has a chance to
6709 switch in assembly mode. */
6710 end_stepping_range (ecs);
6715 /* Set a breakpoint at callee's return address (the address
6716 at which the caller will resume). */
6717 insert_step_resume_breakpoint_at_caller (frame);
6723 if (ecs->event_thread->control.step_range_end == 1)
6725 /* It is stepi or nexti. We always want to stop stepping after
6728 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
6729 end_stepping_range (ecs);
6733 if (stop_pc_sal.line == 0)
6735 /* We have no line number information. That means to stop
6736 stepping (does this always happen right after one instruction,
6737 when we do "s" in a function with no line numbers,
6738 or can this happen as a result of a return or longjmp?). */
6740 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
6741 end_stepping_range (ecs);
6745 /* Look for "calls" to inlined functions, part one. If the inline
6746 frame machinery detected some skipped call sites, we have entered
6747 a new inline function. */
6749 if (frame_id_eq (get_frame_id (get_current_frame ()),
6750 ecs->event_thread->control.step_frame_id)
6751 && inline_skipped_frames (ecs->ptid))
6753 struct symtab_and_line call_sal;
6756 fprintf_unfiltered (gdb_stdlog,
6757 "infrun: stepped into inlined function\n");
6759 find_frame_sal (get_current_frame (), &call_sal);
6761 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
6763 /* For "step", we're going to stop. But if the call site
6764 for this inlined function is on the same source line as
6765 we were previously stepping, go down into the function
6766 first. Otherwise stop at the call site. */
6768 if (call_sal.line == ecs->event_thread->current_line
6769 && call_sal.symtab == ecs->event_thread->current_symtab)
6770 step_into_inline_frame (ecs->ptid);
6772 end_stepping_range (ecs);
6777 /* For "next", we should stop at the call site if it is on a
6778 different source line. Otherwise continue through the
6779 inlined function. */
6780 if (call_sal.line == ecs->event_thread->current_line
6781 && call_sal.symtab == ecs->event_thread->current_symtab)
6784 end_stepping_range (ecs);
6789 /* Look for "calls" to inlined functions, part two. If we are still
6790 in the same real function we were stepping through, but we have
6791 to go further up to find the exact frame ID, we are stepping
6792 through a more inlined call beyond its call site. */
6794 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6795 && !frame_id_eq (get_frame_id (get_current_frame ()),
6796 ecs->event_thread->control.step_frame_id)
6797 && stepped_in_from (get_current_frame (),
6798 ecs->event_thread->control.step_frame_id))
6801 fprintf_unfiltered (gdb_stdlog,
6802 "infrun: stepping through inlined function\n");
6804 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6807 end_stepping_range (ecs);
6811 if ((stop_pc == stop_pc_sal.pc)
6812 && (ecs->event_thread->current_line != stop_pc_sal.line
6813 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
6815 /* We are at the start of a different line. So stop. Note that
6816 we don't stop if we step into the middle of a different line.
6817 That is said to make things like for (;;) statements work
6820 fprintf_unfiltered (gdb_stdlog,
6821 "infrun: stepped to a different line\n");
6822 end_stepping_range (ecs);
6826 /* We aren't done stepping.
6828 Optimize by setting the stepping range to the line.
6829 (We might not be in the original line, but if we entered a
6830 new line in mid-statement, we continue stepping. This makes
6831 things like for(;;) statements work better.) */
6833 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
6834 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
6835 ecs->event_thread->control.may_range_step = 1;
6836 set_step_info (frame, stop_pc_sal);
6839 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
6843 /* In all-stop mode, if we're currently stepping but have stopped in
6844 some other thread, we may need to switch back to the stepped
6845 thread. Returns true we set the inferior running, false if we left
6846 it stopped (and the event needs further processing). */
6849 switch_back_to_stepped_thread (struct execution_control_state *ecs)
6851 if (!target_is_non_stop_p ())
6853 struct thread_info *tp;
6854 struct thread_info *stepping_thread;
6856 /* If any thread is blocked on some internal breakpoint, and we
6857 simply need to step over that breakpoint to get it going
6858 again, do that first. */
6860 /* However, if we see an event for the stepping thread, then we
6861 know all other threads have been moved past their breakpoints
6862 already. Let the caller check whether the step is finished,
6863 etc., before deciding to move it past a breakpoint. */
6864 if (ecs->event_thread->control.step_range_end != 0)
6867 /* Check if the current thread is blocked on an incomplete
6868 step-over, interrupted by a random signal. */
6869 if (ecs->event_thread->control.trap_expected
6870 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
6874 fprintf_unfiltered (gdb_stdlog,
6875 "infrun: need to finish step-over of [%s]\n",
6876 target_pid_to_str (ecs->event_thread->ptid));
6882 /* Check if the current thread is blocked by a single-step
6883 breakpoint of another thread. */
6884 if (ecs->hit_singlestep_breakpoint)
6888 fprintf_unfiltered (gdb_stdlog,
6889 "infrun: need to step [%s] over single-step "
6891 target_pid_to_str (ecs->ptid));
6897 /* If this thread needs yet another step-over (e.g., stepping
6898 through a delay slot), do it first before moving on to
6900 if (thread_still_needs_step_over (ecs->event_thread))
6904 fprintf_unfiltered (gdb_stdlog,
6905 "infrun: thread [%s] still needs step-over\n",
6906 target_pid_to_str (ecs->event_thread->ptid));
6912 /* If scheduler locking applies even if not stepping, there's no
6913 need to walk over threads. Above we've checked whether the
6914 current thread is stepping. If some other thread not the
6915 event thread is stepping, then it must be that scheduler
6916 locking is not in effect. */
6917 if (schedlock_applies (ecs->event_thread))
6920 /* Otherwise, we no longer expect a trap in the current thread.
6921 Clear the trap_expected flag before switching back -- this is
6922 what keep_going does as well, if we call it. */
6923 ecs->event_thread->control.trap_expected = 0;
6925 /* Likewise, clear the signal if it should not be passed. */
6926 if (!signal_program[ecs->event_thread->suspend.stop_signal])
6927 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6929 /* Do all pending step-overs before actually proceeding with
6931 if (start_step_over ())
6933 prepare_to_wait (ecs);
6937 /* Look for the stepping/nexting thread. */
6938 stepping_thread = NULL;
6940 ALL_NON_EXITED_THREADS (tp)
6942 /* Ignore threads of processes the caller is not
6945 && ptid_get_pid (tp->ptid) != ptid_get_pid (ecs->ptid))
6948 /* When stepping over a breakpoint, we lock all threads
6949 except the one that needs to move past the breakpoint.
6950 If a non-event thread has this set, the "incomplete
6951 step-over" check above should have caught it earlier. */
6952 if (tp->control.trap_expected)
6954 internal_error (__FILE__, __LINE__,
6955 "[%s] has inconsistent state: "
6956 "trap_expected=%d\n",
6957 target_pid_to_str (tp->ptid),
6958 tp->control.trap_expected);
6961 /* Did we find the stepping thread? */
6962 if (tp->control.step_range_end)
6964 /* Yep. There should only one though. */
6965 gdb_assert (stepping_thread == NULL);
6967 /* The event thread is handled at the top, before we
6969 gdb_assert (tp != ecs->event_thread);
6971 /* If some thread other than the event thread is
6972 stepping, then scheduler locking can't be in effect,
6973 otherwise we wouldn't have resumed the current event
6974 thread in the first place. */
6975 gdb_assert (!schedlock_applies (tp));
6977 stepping_thread = tp;
6981 if (stepping_thread != NULL)
6984 fprintf_unfiltered (gdb_stdlog,
6985 "infrun: switching back to stepped thread\n");
6987 if (keep_going_stepped_thread (stepping_thread))
6989 prepare_to_wait (ecs);
6998 /* Set a previously stepped thread back to stepping. Returns true on
6999 success, false if the resume is not possible (e.g., the thread
7003 keep_going_stepped_thread (struct thread_info *tp)
7005 struct frame_info *frame;
7006 struct gdbarch *gdbarch;
7007 struct execution_control_state ecss;
7008 struct execution_control_state *ecs = &ecss;
7010 /* If the stepping thread exited, then don't try to switch back and
7011 resume it, which could fail in several different ways depending
7012 on the target. Instead, just keep going.
7014 We can find a stepping dead thread in the thread list in two
7017 - The target supports thread exit events, and when the target
7018 tries to delete the thread from the thread list, inferior_ptid
7019 pointed at the exiting thread. In such case, calling
7020 delete_thread does not really remove the thread from the list;
7021 instead, the thread is left listed, with 'exited' state.
7023 - The target's debug interface does not support thread exit
7024 events, and so we have no idea whatsoever if the previously
7025 stepping thread is still alive. For that reason, we need to
7026 synchronously query the target now. */
7028 if (is_exited (tp->ptid)
7029 || !target_thread_alive (tp->ptid))
7032 fprintf_unfiltered (gdb_stdlog,
7033 "infrun: not resuming previously "
7034 "stepped thread, it has vanished\n");
7036 delete_thread (tp->ptid);
7041 fprintf_unfiltered (gdb_stdlog,
7042 "infrun: resuming previously stepped thread\n");
7044 reset_ecs (ecs, tp);
7045 switch_to_thread (tp->ptid);
7047 stop_pc = regcache_read_pc (get_thread_regcache (tp->ptid));
7048 frame = get_current_frame ();
7049 gdbarch = get_frame_arch (frame);
7051 /* If the PC of the thread we were trying to single-step has
7052 changed, then that thread has trapped or been signaled, but the
7053 event has not been reported to GDB yet. Re-poll the target
7054 looking for this particular thread's event (i.e. temporarily
7055 enable schedlock) by:
7057 - setting a break at the current PC
7058 - resuming that particular thread, only (by setting trap
7061 This prevents us continuously moving the single-step breakpoint
7062 forward, one instruction at a time, overstepping. */
7064 if (stop_pc != tp->prev_pc)
7069 fprintf_unfiltered (gdb_stdlog,
7070 "infrun: expected thread advanced also (%s -> %s)\n",
7071 paddress (target_gdbarch (), tp->prev_pc),
7072 paddress (target_gdbarch (), stop_pc));
7074 /* Clear the info of the previous step-over, as it's no longer
7075 valid (if the thread was trying to step over a breakpoint, it
7076 has already succeeded). It's what keep_going would do too,
7077 if we called it. Do this before trying to insert the sss
7078 breakpoint, otherwise if we were previously trying to step
7079 over this exact address in another thread, the breakpoint is
7081 clear_step_over_info ();
7082 tp->control.trap_expected = 0;
7084 insert_single_step_breakpoint (get_frame_arch (frame),
7085 get_frame_address_space (frame),
7089 resume_ptid = internal_resume_ptid (tp->control.stepping_command);
7090 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
7095 fprintf_unfiltered (gdb_stdlog,
7096 "infrun: expected thread still hasn't advanced\n");
7098 keep_going_pass_signal (ecs);
7103 /* Is thread TP in the middle of (software or hardware)
7104 single-stepping? (Note the result of this function must never be
7105 passed directly as target_resume's STEP parameter.) */
7108 currently_stepping (struct thread_info *tp)
7110 return ((tp->control.step_range_end
7111 && tp->control.step_resume_breakpoint == NULL)
7112 || tp->control.trap_expected
7113 || tp->stepped_breakpoint
7114 || bpstat_should_step ());
7117 /* Inferior has stepped into a subroutine call with source code that
7118 we should not step over. Do step to the first line of code in
7122 handle_step_into_function (struct gdbarch *gdbarch,
7123 struct execution_control_state *ecs)
7125 struct compunit_symtab *cust;
7126 struct symtab_and_line stop_func_sal, sr_sal;
7128 fill_in_stop_func (gdbarch, ecs);
7130 cust = find_pc_compunit_symtab (stop_pc);
7131 if (cust != NULL && compunit_language (cust) != language_asm)
7132 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
7133 ecs->stop_func_start);
7135 stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
7136 /* Use the step_resume_break to step until the end of the prologue,
7137 even if that involves jumps (as it seems to on the vax under
7139 /* If the prologue ends in the middle of a source line, continue to
7140 the end of that source line (if it is still within the function).
7141 Otherwise, just go to end of prologue. */
7142 if (stop_func_sal.end
7143 && stop_func_sal.pc != ecs->stop_func_start
7144 && stop_func_sal.end < ecs->stop_func_end)
7145 ecs->stop_func_start = stop_func_sal.end;
7147 /* Architectures which require breakpoint adjustment might not be able
7148 to place a breakpoint at the computed address. If so, the test
7149 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7150 ecs->stop_func_start to an address at which a breakpoint may be
7151 legitimately placed.
7153 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7154 made, GDB will enter an infinite loop when stepping through
7155 optimized code consisting of VLIW instructions which contain
7156 subinstructions corresponding to different source lines. On
7157 FR-V, it's not permitted to place a breakpoint on any but the
7158 first subinstruction of a VLIW instruction. When a breakpoint is
7159 set, GDB will adjust the breakpoint address to the beginning of
7160 the VLIW instruction. Thus, we need to make the corresponding
7161 adjustment here when computing the stop address. */
7163 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
7165 ecs->stop_func_start
7166 = gdbarch_adjust_breakpoint_address (gdbarch,
7167 ecs->stop_func_start);
7170 if (ecs->stop_func_start == stop_pc)
7172 /* We are already there: stop now. */
7173 end_stepping_range (ecs);
7178 /* Put the step-breakpoint there and go until there. */
7179 init_sal (&sr_sal); /* initialize to zeroes */
7180 sr_sal.pc = ecs->stop_func_start;
7181 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
7182 sr_sal.pspace = get_frame_program_space (get_current_frame ());
7184 /* Do not specify what the fp should be when we stop since on
7185 some machines the prologue is where the new fp value is
7187 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
7189 /* And make sure stepping stops right away then. */
7190 ecs->event_thread->control.step_range_end
7191 = ecs->event_thread->control.step_range_start;
7196 /* Inferior has stepped backward into a subroutine call with source
7197 code that we should not step over. Do step to the beginning of the
7198 last line of code in it. */
7201 handle_step_into_function_backward (struct gdbarch *gdbarch,
7202 struct execution_control_state *ecs)
7204 struct compunit_symtab *cust;
7205 struct symtab_and_line stop_func_sal;
7207 fill_in_stop_func (gdbarch, ecs);
7209 cust = find_pc_compunit_symtab (stop_pc);
7210 if (cust != NULL && compunit_language (cust) != language_asm)
7211 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
7212 ecs->stop_func_start);
7214 stop_func_sal = find_pc_line (stop_pc, 0);
7216 /* OK, we're just going to keep stepping here. */
7217 if (stop_func_sal.pc == stop_pc)
7219 /* We're there already. Just stop stepping now. */
7220 end_stepping_range (ecs);
7224 /* Else just reset the step range and keep going.
7225 No step-resume breakpoint, they don't work for
7226 epilogues, which can have multiple entry paths. */
7227 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
7228 ecs->event_thread->control.step_range_end = stop_func_sal.end;
7234 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7235 This is used to both functions and to skip over code. */
7238 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
7239 struct symtab_and_line sr_sal,
7240 struct frame_id sr_id,
7241 enum bptype sr_type)
7243 /* There should never be more than one step-resume or longjmp-resume
7244 breakpoint per thread, so we should never be setting a new
7245 step_resume_breakpoint when one is already active. */
7246 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
7247 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
7250 fprintf_unfiltered (gdb_stdlog,
7251 "infrun: inserting step-resume breakpoint at %s\n",
7252 paddress (gdbarch, sr_sal.pc));
7254 inferior_thread ()->control.step_resume_breakpoint
7255 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
7259 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
7260 struct symtab_and_line sr_sal,
7261 struct frame_id sr_id)
7263 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
7268 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7269 This is used to skip a potential signal handler.
7271 This is called with the interrupted function's frame. The signal
7272 handler, when it returns, will resume the interrupted function at
7276 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
7278 struct symtab_and_line sr_sal;
7279 struct gdbarch *gdbarch;
7281 gdb_assert (return_frame != NULL);
7282 init_sal (&sr_sal); /* initialize to zeros */
7284 gdbarch = get_frame_arch (return_frame);
7285 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
7286 sr_sal.section = find_pc_overlay (sr_sal.pc);
7287 sr_sal.pspace = get_frame_program_space (return_frame);
7289 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
7290 get_stack_frame_id (return_frame),
7294 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7295 is used to skip a function after stepping into it (for "next" or if
7296 the called function has no debugging information).
7298 The current function has almost always been reached by single
7299 stepping a call or return instruction. NEXT_FRAME belongs to the
7300 current function, and the breakpoint will be set at the caller's
7303 This is a separate function rather than reusing
7304 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7305 get_prev_frame, which may stop prematurely (see the implementation
7306 of frame_unwind_caller_id for an example). */
7309 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
7311 struct symtab_and_line sr_sal;
7312 struct gdbarch *gdbarch;
7314 /* We shouldn't have gotten here if we don't know where the call site
7316 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
7318 init_sal (&sr_sal); /* initialize to zeros */
7320 gdbarch = frame_unwind_caller_arch (next_frame);
7321 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
7322 frame_unwind_caller_pc (next_frame));
7323 sr_sal.section = find_pc_overlay (sr_sal.pc);
7324 sr_sal.pspace = frame_unwind_program_space (next_frame);
7326 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
7327 frame_unwind_caller_id (next_frame));
7330 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7331 new breakpoint at the target of a jmp_buf. The handling of
7332 longjmp-resume uses the same mechanisms used for handling
7333 "step-resume" breakpoints. */
7336 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
7338 /* There should never be more than one longjmp-resume breakpoint per
7339 thread, so we should never be setting a new
7340 longjmp_resume_breakpoint when one is already active. */
7341 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
7344 fprintf_unfiltered (gdb_stdlog,
7345 "infrun: inserting longjmp-resume breakpoint at %s\n",
7346 paddress (gdbarch, pc));
7348 inferior_thread ()->control.exception_resume_breakpoint =
7349 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
7352 /* Insert an exception resume breakpoint. TP is the thread throwing
7353 the exception. The block B is the block of the unwinder debug hook
7354 function. FRAME is the frame corresponding to the call to this
7355 function. SYM is the symbol of the function argument holding the
7356 target PC of the exception. */
7359 insert_exception_resume_breakpoint (struct thread_info *tp,
7360 const struct block *b,
7361 struct frame_info *frame,
7366 struct block_symbol vsym;
7367 struct value *value;
7369 struct breakpoint *bp;
7371 vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
7372 value = read_var_value (vsym.symbol, vsym.block, frame);
7373 /* If the value was optimized out, revert to the old behavior. */
7374 if (! value_optimized_out (value))
7376 handler = value_as_address (value);
7379 fprintf_unfiltered (gdb_stdlog,
7380 "infrun: exception resume at %lx\n",
7381 (unsigned long) handler);
7383 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7384 handler, bp_exception_resume);
7386 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7389 bp->thread = tp->num;
7390 inferior_thread ()->control.exception_resume_breakpoint = bp;
7393 CATCH (e, RETURN_MASK_ERROR)
7395 /* We want to ignore errors here. */
7400 /* A helper for check_exception_resume that sets an
7401 exception-breakpoint based on a SystemTap probe. */
7404 insert_exception_resume_from_probe (struct thread_info *tp,
7405 const struct bound_probe *probe,
7406 struct frame_info *frame)
7408 struct value *arg_value;
7410 struct breakpoint *bp;
7412 arg_value = probe_safe_evaluate_at_pc (frame, 1);
7416 handler = value_as_address (arg_value);
7419 fprintf_unfiltered (gdb_stdlog,
7420 "infrun: exception resume at %s\n",
7421 paddress (get_objfile_arch (probe->objfile),
7424 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7425 handler, bp_exception_resume);
7426 bp->thread = tp->num;
7427 inferior_thread ()->control.exception_resume_breakpoint = bp;
7430 /* This is called when an exception has been intercepted. Check to
7431 see whether the exception's destination is of interest, and if so,
7432 set an exception resume breakpoint there. */
7435 check_exception_resume (struct execution_control_state *ecs,
7436 struct frame_info *frame)
7438 struct bound_probe probe;
7439 struct symbol *func;
7441 /* First see if this exception unwinding breakpoint was set via a
7442 SystemTap probe point. If so, the probe has two arguments: the
7443 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7444 set a breakpoint there. */
7445 probe = find_probe_by_pc (get_frame_pc (frame));
7448 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
7452 func = get_frame_function (frame);
7458 const struct block *b;
7459 struct block_iterator iter;
7463 /* The exception breakpoint is a thread-specific breakpoint on
7464 the unwinder's debug hook, declared as:
7466 void _Unwind_DebugHook (void *cfa, void *handler);
7468 The CFA argument indicates the frame to which control is
7469 about to be transferred. HANDLER is the destination PC.
7471 We ignore the CFA and set a temporary breakpoint at HANDLER.
7472 This is not extremely efficient but it avoids issues in gdb
7473 with computing the DWARF CFA, and it also works even in weird
7474 cases such as throwing an exception from inside a signal
7477 b = SYMBOL_BLOCK_VALUE (func);
7478 ALL_BLOCK_SYMBOLS (b, iter, sym)
7480 if (!SYMBOL_IS_ARGUMENT (sym))
7487 insert_exception_resume_breakpoint (ecs->event_thread,
7493 CATCH (e, RETURN_MASK_ERROR)
7500 stop_waiting (struct execution_control_state *ecs)
7503 fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
7505 clear_step_over_info ();
7507 /* Let callers know we don't want to wait for the inferior anymore. */
7508 ecs->wait_some_more = 0;
7510 /* If all-stop, but the target is always in non-stop mode, stop all
7511 threads now that we're presenting the stop to the user. */
7512 if (!non_stop && target_is_non_stop_p ())
7513 stop_all_threads ();
7516 /* Like keep_going, but passes the signal to the inferior, even if the
7517 signal is set to nopass. */
7520 keep_going_pass_signal (struct execution_control_state *ecs)
7522 /* Make sure normal_stop is called if we get a QUIT handled before
7524 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
7526 gdb_assert (ptid_equal (ecs->event_thread->ptid, inferior_ptid));
7527 gdb_assert (!ecs->event_thread->resumed);
7529 /* Save the pc before execution, to compare with pc after stop. */
7530 ecs->event_thread->prev_pc
7531 = regcache_read_pc (get_thread_regcache (ecs->ptid));
7533 if (ecs->event_thread->control.trap_expected)
7535 struct thread_info *tp = ecs->event_thread;
7538 fprintf_unfiltered (gdb_stdlog,
7539 "infrun: %s has trap_expected set, "
7540 "resuming to collect trap\n",
7541 target_pid_to_str (tp->ptid));
7543 /* We haven't yet gotten our trap, and either: intercepted a
7544 non-signal event (e.g., a fork); or took a signal which we
7545 are supposed to pass through to the inferior. Simply
7547 discard_cleanups (old_cleanups);
7548 resume (ecs->event_thread->suspend.stop_signal);
7550 else if (step_over_info_valid_p ())
7552 /* Another thread is stepping over a breakpoint in-line. If
7553 this thread needs a step-over too, queue the request. In
7554 either case, this resume must be deferred for later. */
7555 struct thread_info *tp = ecs->event_thread;
7557 if (ecs->hit_singlestep_breakpoint
7558 || thread_still_needs_step_over (tp))
7561 fprintf_unfiltered (gdb_stdlog,
7562 "infrun: step-over already in progress: "
7563 "step-over for %s deferred\n",
7564 target_pid_to_str (tp->ptid));
7565 thread_step_over_chain_enqueue (tp);
7570 fprintf_unfiltered (gdb_stdlog,
7571 "infrun: step-over in progress: "
7572 "resume of %s deferred\n",
7573 target_pid_to_str (tp->ptid));
7576 discard_cleanups (old_cleanups);
7580 struct regcache *regcache = get_current_regcache ();
7583 step_over_what step_what;
7585 /* Either the trap was not expected, but we are continuing
7586 anyway (if we got a signal, the user asked it be passed to
7589 We got our expected trap, but decided we should resume from
7592 We're going to run this baby now!
7594 Note that insert_breakpoints won't try to re-insert
7595 already inserted breakpoints. Therefore, we don't
7596 care if breakpoints were already inserted, or not. */
7598 /* If we need to step over a breakpoint, and we're not using
7599 displaced stepping to do so, insert all breakpoints
7600 (watchpoints, etc.) but the one we're stepping over, step one
7601 instruction, and then re-insert the breakpoint when that step
7604 step_what = thread_still_needs_step_over (ecs->event_thread);
7606 remove_bp = (ecs->hit_singlestep_breakpoint
7607 || (step_what & STEP_OVER_BREAKPOINT));
7608 remove_wps = (step_what & STEP_OVER_WATCHPOINT);
7610 /* We can't use displaced stepping if we need to step past a
7611 watchpoint. The instruction copied to the scratch pad would
7612 still trigger the watchpoint. */
7614 && (remove_wps || !use_displaced_stepping (ecs->event_thread)))
7616 set_step_over_info (get_regcache_aspace (regcache),
7617 regcache_read_pc (regcache), remove_wps);
7619 else if (remove_wps)
7620 set_step_over_info (NULL, 0, remove_wps);
7622 /* If we now need to do an in-line step-over, we need to stop
7623 all other threads. Note this must be done before
7624 insert_breakpoints below, because that removes the breakpoint
7625 we're about to step over, otherwise other threads could miss
7627 if (step_over_info_valid_p () && target_is_non_stop_p ())
7628 stop_all_threads ();
7630 /* Stop stepping if inserting breakpoints fails. */
7633 insert_breakpoints ();
7635 CATCH (e, RETURN_MASK_ERROR)
7637 exception_print (gdb_stderr, e);
7639 discard_cleanups (old_cleanups);
7644 ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
7646 discard_cleanups (old_cleanups);
7647 resume (ecs->event_thread->suspend.stop_signal);
7650 prepare_to_wait (ecs);
7653 /* Called when we should continue running the inferior, because the
7654 current event doesn't cause a user visible stop. This does the
7655 resuming part; waiting for the next event is done elsewhere. */
7658 keep_going (struct execution_control_state *ecs)
7660 if (ecs->event_thread->control.trap_expected
7661 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
7662 ecs->event_thread->control.trap_expected = 0;
7664 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7665 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7666 keep_going_pass_signal (ecs);
7669 /* This function normally comes after a resume, before
7670 handle_inferior_event exits. It takes care of any last bits of
7671 housekeeping, and sets the all-important wait_some_more flag. */
7674 prepare_to_wait (struct execution_control_state *ecs)
7677 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
7679 ecs->wait_some_more = 1;
7681 if (!target_is_async_p ())
7682 mark_infrun_async_event_handler ();
7685 /* We are done with the step range of a step/next/si/ni command.
7686 Called once for each n of a "step n" operation. */
7689 end_stepping_range (struct execution_control_state *ecs)
7691 ecs->event_thread->control.stop_step = 1;
7695 /* Several print_*_reason functions to print why the inferior has stopped.
7696 We always print something when the inferior exits, or receives a signal.
7697 The rest of the cases are dealt with later on in normal_stop and
7698 print_it_typical. Ideally there should be a call to one of these
7699 print_*_reason functions functions from handle_inferior_event each time
7700 stop_waiting is called.
7702 Note that we don't call these directly, instead we delegate that to
7703 the interpreters, through observers. Interpreters then call these
7704 with whatever uiout is right. */
7707 print_end_stepping_range_reason (struct ui_out *uiout)
7709 /* For CLI-like interpreters, print nothing. */
7711 if (ui_out_is_mi_like_p (uiout))
7713 ui_out_field_string (uiout, "reason",
7714 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
7719 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7721 annotate_signalled ();
7722 if (ui_out_is_mi_like_p (uiout))
7724 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
7725 ui_out_text (uiout, "\nProgram terminated with signal ");
7726 annotate_signal_name ();
7727 ui_out_field_string (uiout, "signal-name",
7728 gdb_signal_to_name (siggnal));
7729 annotate_signal_name_end ();
7730 ui_out_text (uiout, ", ");
7731 annotate_signal_string ();
7732 ui_out_field_string (uiout, "signal-meaning",
7733 gdb_signal_to_string (siggnal));
7734 annotate_signal_string_end ();
7735 ui_out_text (uiout, ".\n");
7736 ui_out_text (uiout, "The program no longer exists.\n");
7740 print_exited_reason (struct ui_out *uiout, int exitstatus)
7742 struct inferior *inf = current_inferior ();
7743 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
7745 annotate_exited (exitstatus);
7748 if (ui_out_is_mi_like_p (uiout))
7749 ui_out_field_string (uiout, "reason",
7750 async_reason_lookup (EXEC_ASYNC_EXITED));
7751 ui_out_text (uiout, "[Inferior ");
7752 ui_out_text (uiout, plongest (inf->num));
7753 ui_out_text (uiout, " (");
7754 ui_out_text (uiout, pidstr);
7755 ui_out_text (uiout, ") exited with code ");
7756 ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
7757 ui_out_text (uiout, "]\n");
7761 if (ui_out_is_mi_like_p (uiout))
7763 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
7764 ui_out_text (uiout, "[Inferior ");
7765 ui_out_text (uiout, plongest (inf->num));
7766 ui_out_text (uiout, " (");
7767 ui_out_text (uiout, pidstr);
7768 ui_out_text (uiout, ") exited normally]\n");
7773 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7777 if (siggnal == GDB_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
7779 struct thread_info *t = inferior_thread ();
7781 ui_out_text (uiout, "\n[");
7782 ui_out_field_string (uiout, "thread-name",
7783 target_pid_to_str (t->ptid));
7784 ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
7785 ui_out_text (uiout, " stopped");
7789 ui_out_text (uiout, "\nProgram received signal ");
7790 annotate_signal_name ();
7791 if (ui_out_is_mi_like_p (uiout))
7793 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
7794 ui_out_field_string (uiout, "signal-name",
7795 gdb_signal_to_name (siggnal));
7796 annotate_signal_name_end ();
7797 ui_out_text (uiout, ", ");
7798 annotate_signal_string ();
7799 ui_out_field_string (uiout, "signal-meaning",
7800 gdb_signal_to_string (siggnal));
7801 annotate_signal_string_end ();
7803 ui_out_text (uiout, ".\n");
7807 print_no_history_reason (struct ui_out *uiout)
7809 ui_out_text (uiout, "\nNo more reverse-execution history.\n");
7812 /* Print current location without a level number, if we have changed
7813 functions or hit a breakpoint. Print source line if we have one.
7814 bpstat_print contains the logic deciding in detail what to print,
7815 based on the event(s) that just occurred. */
7818 print_stop_location (struct target_waitstatus *ws)
7821 enum print_what source_flag;
7822 int do_frame_printing = 1;
7823 struct thread_info *tp = inferior_thread ();
7825 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
7829 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
7830 should) carry around the function and does (or should) use
7831 that when doing a frame comparison. */
7832 if (tp->control.stop_step
7833 && frame_id_eq (tp->control.step_frame_id,
7834 get_frame_id (get_current_frame ()))
7835 && tp->control.step_start_function == find_pc_function (stop_pc))
7837 /* Finished step, just print source line. */
7838 source_flag = SRC_LINE;
7842 /* Print location and source line. */
7843 source_flag = SRC_AND_LOC;
7846 case PRINT_SRC_AND_LOC:
7847 /* Print location and source line. */
7848 source_flag = SRC_AND_LOC;
7850 case PRINT_SRC_ONLY:
7851 source_flag = SRC_LINE;
7854 /* Something bogus. */
7855 source_flag = SRC_LINE;
7856 do_frame_printing = 0;
7859 internal_error (__FILE__, __LINE__, _("Unknown value."));
7862 /* The behavior of this routine with respect to the source
7864 SRC_LINE: Print only source line
7865 LOCATION: Print only location
7866 SRC_AND_LOC: Print location and source line. */
7867 if (do_frame_printing)
7868 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
7871 /* Cleanup that restores a previous current uiout. */
7874 restore_current_uiout_cleanup (void *arg)
7876 struct ui_out *saved_uiout = (struct ui_out *) arg;
7878 current_uiout = saved_uiout;
7884 print_stop_event (struct ui_out *uiout)
7886 struct cleanup *old_chain;
7887 struct target_waitstatus last;
7889 struct thread_info *tp;
7891 get_last_target_status (&last_ptid, &last);
7893 old_chain = make_cleanup (restore_current_uiout_cleanup, current_uiout);
7894 current_uiout = uiout;
7896 print_stop_location (&last);
7898 /* Display the auto-display expressions. */
7901 do_cleanups (old_chain);
7903 tp = inferior_thread ();
7904 if (tp->thread_fsm != NULL
7905 && thread_fsm_finished_p (tp->thread_fsm))
7907 struct return_value_info *rv;
7909 rv = thread_fsm_return_value (tp->thread_fsm);
7911 print_return_value (uiout, rv);
7918 maybe_remove_breakpoints (void)
7920 if (!breakpoints_should_be_inserted_now () && target_has_execution)
7922 if (remove_breakpoints ())
7924 target_terminal_ours_for_output ();
7925 printf_filtered (_("Cannot remove breakpoints because "
7926 "program is no longer writable.\nFurther "
7927 "execution is probably impossible.\n"));
7932 /* The execution context that just caused a normal stop. */
7939 /* The event PTID. */
7943 /* If stopp for a thread event, this is the thread that caused the
7945 struct thread_info *thread;
7947 /* The inferior that caused the stop. */
7951 /* Returns a new stop context. If stopped for a thread event, this
7952 takes a strong reference to the thread. */
7954 static struct stop_context *
7955 save_stop_context (void)
7957 struct stop_context *sc = XNEW (struct stop_context);
7959 sc->stop_id = get_stop_id ();
7960 sc->ptid = inferior_ptid;
7961 sc->inf_num = current_inferior ()->num;
7963 if (!ptid_equal (inferior_ptid, null_ptid))
7965 /* Take a strong reference so that the thread can't be deleted
7967 sc->thread = inferior_thread ();
7968 sc->thread->refcount++;
7976 /* Release a stop context previously created with save_stop_context.
7977 Releases the strong reference to the thread as well. */
7980 release_stop_context_cleanup (void *arg)
7982 struct stop_context *sc = (struct stop_context *) arg;
7984 if (sc->thread != NULL)
7985 sc->thread->refcount--;
7989 /* Return true if the current context no longer matches the saved stop
7993 stop_context_changed (struct stop_context *prev)
7995 if (!ptid_equal (prev->ptid, inferior_ptid))
7997 if (prev->inf_num != current_inferior ()->num)
7999 if (prev->thread != NULL && prev->thread->state != THREAD_STOPPED)
8001 if (get_stop_id () != prev->stop_id)
8011 struct target_waitstatus last;
8013 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
8016 get_last_target_status (&last_ptid, &last);
8020 /* If an exception is thrown from this point on, make sure to
8021 propagate GDB's knowledge of the executing state to the
8022 frontend/user running state. A QUIT is an easy exception to see
8023 here, so do this before any filtered output. */
8025 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
8026 else if (last.kind == TARGET_WAITKIND_SIGNALLED
8027 || last.kind == TARGET_WAITKIND_EXITED)
8029 /* On some targets, we may still have live threads in the
8030 inferior when we get a process exit event. E.g., for
8031 "checkpoint", when the current checkpoint/fork exits,
8032 linux-fork.c automatically switches to another fork from
8033 within target_mourn_inferior. */
8034 if (!ptid_equal (inferior_ptid, null_ptid))
8036 pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
8037 make_cleanup (finish_thread_state_cleanup, &pid_ptid);
8040 else if (last.kind != TARGET_WAITKIND_NO_RESUMED)
8041 make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
8043 /* As we're presenting a stop, and potentially removing breakpoints,
8044 update the thread list so we can tell whether there are threads
8045 running on the target. With target remote, for example, we can
8046 only learn about new threads when we explicitly update the thread
8047 list. Do this before notifying the interpreters about signal
8048 stops, end of stepping ranges, etc., so that the "new thread"
8049 output is emitted before e.g., "Program received signal FOO",
8050 instead of after. */
8051 update_thread_list ();
8053 if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
8054 observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
8056 /* As with the notification of thread events, we want to delay
8057 notifying the user that we've switched thread context until
8058 the inferior actually stops.
8060 There's no point in saying anything if the inferior has exited.
8061 Note that SIGNALLED here means "exited with a signal", not
8062 "received a signal".
8064 Also skip saying anything in non-stop mode. In that mode, as we
8065 don't want GDB to switch threads behind the user's back, to avoid
8066 races where the user is typing a command to apply to thread x,
8067 but GDB switches to thread y before the user finishes entering
8068 the command, fetch_inferior_event installs a cleanup to restore
8069 the current thread back to the thread the user had selected right
8070 after this event is handled, so we're not really switching, only
8071 informing of a stop. */
8073 && !ptid_equal (previous_inferior_ptid, inferior_ptid)
8074 && target_has_execution
8075 && last.kind != TARGET_WAITKIND_SIGNALLED
8076 && last.kind != TARGET_WAITKIND_EXITED
8077 && last.kind != TARGET_WAITKIND_NO_RESUMED)
8079 target_terminal_ours_for_output ();
8080 printf_filtered (_("[Switching to %s]\n"),
8081 target_pid_to_str (inferior_ptid));
8082 annotate_thread_changed ();
8083 previous_inferior_ptid = inferior_ptid;
8086 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
8088 gdb_assert (sync_execution || !target_can_async_p ());
8090 target_terminal_ours_for_output ();
8091 printf_filtered (_("No unwaited-for children left.\n"));
8094 /* Note: this depends on the update_thread_list call above. */
8095 maybe_remove_breakpoints ();
8097 /* If an auto-display called a function and that got a signal,
8098 delete that auto-display to avoid an infinite recursion. */
8100 if (stopped_by_random_signal)
8101 disable_current_display ();
8103 target_terminal_ours ();
8104 async_enable_stdin ();
8106 /* Let the user/frontend see the threads as stopped. */
8107 do_cleanups (old_chain);
8109 /* Select innermost stack frame - i.e., current frame is frame 0,
8110 and current location is based on that. Handle the case where the
8111 dummy call is returning after being stopped. E.g. the dummy call
8112 previously hit a breakpoint. (If the dummy call returns
8113 normally, we won't reach here.) Do this before the stop hook is
8114 run, so that it doesn't get to see the temporary dummy frame,
8115 which is not where we'll present the stop. */
8116 if (has_stack_frames ())
8118 if (stop_stack_dummy == STOP_STACK_DUMMY)
8120 /* Pop the empty frame that contains the stack dummy. This
8121 also restores inferior state prior to the call (struct
8122 infcall_suspend_state). */
8123 struct frame_info *frame = get_current_frame ();
8125 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
8127 /* frame_pop calls reinit_frame_cache as the last thing it
8128 does which means there's now no selected frame. */
8131 select_frame (get_current_frame ());
8133 /* Set the current source location. */
8134 set_current_sal_from_frame (get_current_frame ());
8137 /* Look up the hook_stop and run it (CLI internally handles problem
8138 of stop_command's pre-hook not existing). */
8139 if (stop_command != NULL)
8141 struct stop_context *saved_context = save_stop_context ();
8142 struct cleanup *old_chain
8143 = make_cleanup (release_stop_context_cleanup, saved_context);
8145 catch_errors (hook_stop_stub, stop_command,
8146 "Error while running hook_stop:\n", RETURN_MASK_ALL);
8148 /* If the stop hook resumes the target, then there's no point in
8149 trying to notify about the previous stop; its context is
8150 gone. Likewise if the command switches thread or inferior --
8151 the observers would print a stop for the wrong
8153 if (stop_context_changed (saved_context))
8155 do_cleanups (old_chain);
8158 do_cleanups (old_chain);
8161 /* Notify observers about the stop. This is where the interpreters
8162 print the stop event. */
8163 if (!ptid_equal (inferior_ptid, null_ptid))
8164 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
8167 observer_notify_normal_stop (NULL, stop_print_frame);
8169 annotate_stopped ();
8171 if (target_has_execution)
8173 if (last.kind != TARGET_WAITKIND_SIGNALLED
8174 && last.kind != TARGET_WAITKIND_EXITED)
8175 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8176 Delete any breakpoint that is to be deleted at the next stop. */
8177 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
8180 /* Try to get rid of automatically added inferiors that are no
8181 longer needed. Keeping those around slows down things linearly.
8182 Note that this never removes the current inferior. */
8189 hook_stop_stub (void *cmd)
8191 execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
8196 signal_stop_state (int signo)
8198 return signal_stop[signo];
8202 signal_print_state (int signo)
8204 return signal_print[signo];
8208 signal_pass_state (int signo)
8210 return signal_program[signo];
8214 signal_cache_update (int signo)
8218 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
8219 signal_cache_update (signo);
8224 signal_pass[signo] = (signal_stop[signo] == 0
8225 && signal_print[signo] == 0
8226 && signal_program[signo] == 1
8227 && signal_catch[signo] == 0);
8231 signal_stop_update (int signo, int state)
8233 int ret = signal_stop[signo];
8235 signal_stop[signo] = state;
8236 signal_cache_update (signo);
8241 signal_print_update (int signo, int state)
8243 int ret = signal_print[signo];
8245 signal_print[signo] = state;
8246 signal_cache_update (signo);
8251 signal_pass_update (int signo, int state)
8253 int ret = signal_program[signo];
8255 signal_program[signo] = state;
8256 signal_cache_update (signo);
8260 /* Update the global 'signal_catch' from INFO and notify the
8264 signal_catch_update (const unsigned int *info)
8268 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
8269 signal_catch[i] = info[i] > 0;
8270 signal_cache_update (-1);
8271 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8275 sig_print_header (void)
8277 printf_filtered (_("Signal Stop\tPrint\tPass "
8278 "to program\tDescription\n"));
8282 sig_print_info (enum gdb_signal oursig)
8284 const char *name = gdb_signal_to_name (oursig);
8285 int name_padding = 13 - strlen (name);
8287 if (name_padding <= 0)
8290 printf_filtered ("%s", name);
8291 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
8292 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
8293 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
8294 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
8295 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
8298 /* Specify how various signals in the inferior should be handled. */
8301 handle_command (char *args, int from_tty)
8304 int digits, wordlen;
8305 int sigfirst, signum, siglast;
8306 enum gdb_signal oursig;
8309 unsigned char *sigs;
8310 struct cleanup *old_chain;
8314 error_no_arg (_("signal to handle"));
8317 /* Allocate and zero an array of flags for which signals to handle. */
8319 nsigs = (int) GDB_SIGNAL_LAST;
8320 sigs = (unsigned char *) alloca (nsigs);
8321 memset (sigs, 0, nsigs);
8323 /* Break the command line up into args. */
8325 argv = gdb_buildargv (args);
8326 old_chain = make_cleanup_freeargv (argv);
8328 /* Walk through the args, looking for signal oursigs, signal names, and
8329 actions. Signal numbers and signal names may be interspersed with
8330 actions, with the actions being performed for all signals cumulatively
8331 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8333 while (*argv != NULL)
8335 wordlen = strlen (*argv);
8336 for (digits = 0; isdigit ((*argv)[digits]); digits++)
8340 sigfirst = siglast = -1;
8342 if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
8344 /* Apply action to all signals except those used by the
8345 debugger. Silently skip those. */
8348 siglast = nsigs - 1;
8350 else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
8352 SET_SIGS (nsigs, sigs, signal_stop);
8353 SET_SIGS (nsigs, sigs, signal_print);
8355 else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
8357 UNSET_SIGS (nsigs, sigs, signal_program);
8359 else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
8361 SET_SIGS (nsigs, sigs, signal_print);
8363 else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
8365 SET_SIGS (nsigs, sigs, signal_program);
8367 else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
8369 UNSET_SIGS (nsigs, sigs, signal_stop);
8371 else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
8373 SET_SIGS (nsigs, sigs, signal_program);
8375 else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
8377 UNSET_SIGS (nsigs, sigs, signal_print);
8378 UNSET_SIGS (nsigs, sigs, signal_stop);
8380 else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
8382 UNSET_SIGS (nsigs, sigs, signal_program);
8384 else if (digits > 0)
8386 /* It is numeric. The numeric signal refers to our own
8387 internal signal numbering from target.h, not to host/target
8388 signal number. This is a feature; users really should be
8389 using symbolic names anyway, and the common ones like
8390 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8392 sigfirst = siglast = (int)
8393 gdb_signal_from_command (atoi (*argv));
8394 if ((*argv)[digits] == '-')
8397 gdb_signal_from_command (atoi ((*argv) + digits + 1));
8399 if (sigfirst > siglast)
8401 /* Bet he didn't figure we'd think of this case... */
8409 oursig = gdb_signal_from_name (*argv);
8410 if (oursig != GDB_SIGNAL_UNKNOWN)
8412 sigfirst = siglast = (int) oursig;
8416 /* Not a number and not a recognized flag word => complain. */
8417 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv);
8421 /* If any signal numbers or symbol names were found, set flags for
8422 which signals to apply actions to. */
8424 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
8426 switch ((enum gdb_signal) signum)
8428 case GDB_SIGNAL_TRAP:
8429 case GDB_SIGNAL_INT:
8430 if (!allsigs && !sigs[signum])
8432 if (query (_("%s is used by the debugger.\n\
8433 Are you sure you want to change it? "),
8434 gdb_signal_to_name ((enum gdb_signal) signum)))
8440 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8441 gdb_flush (gdb_stdout);
8446 case GDB_SIGNAL_DEFAULT:
8447 case GDB_SIGNAL_UNKNOWN:
8448 /* Make sure that "all" doesn't print these. */
8459 for (signum = 0; signum < nsigs; signum++)
8462 signal_cache_update (-1);
8463 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8464 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
8468 /* Show the results. */
8469 sig_print_header ();
8470 for (; signum < nsigs; signum++)
8472 sig_print_info ((enum gdb_signal) signum);
8478 do_cleanups (old_chain);
8481 /* Complete the "handle" command. */
8483 static VEC (char_ptr) *
8484 handle_completer (struct cmd_list_element *ignore,
8485 const char *text, const char *word)
8487 VEC (char_ptr) *vec_signals, *vec_keywords, *return_val;
8488 static const char * const keywords[] =
8502 vec_signals = signal_completer (ignore, text, word);
8503 vec_keywords = complete_on_enum (keywords, word, word);
8505 return_val = VEC_merge (char_ptr, vec_signals, vec_keywords);
8506 VEC_free (char_ptr, vec_signals);
8507 VEC_free (char_ptr, vec_keywords);
8512 gdb_signal_from_command (int num)
8514 if (num >= 1 && num <= 15)
8515 return (enum gdb_signal) num;
8516 error (_("Only signals 1-15 are valid as numeric signals.\n\
8517 Use \"info signals\" for a list of symbolic signals."));
8520 /* Print current contents of the tables set by the handle command.
8521 It is possible we should just be printing signals actually used
8522 by the current target (but for things to work right when switching
8523 targets, all signals should be in the signal tables). */
8526 signals_info (char *signum_exp, int from_tty)
8528 enum gdb_signal oursig;
8530 sig_print_header ();
8534 /* First see if this is a symbol name. */
8535 oursig = gdb_signal_from_name (signum_exp);
8536 if (oursig == GDB_SIGNAL_UNKNOWN)
8538 /* No, try numeric. */
8540 gdb_signal_from_command (parse_and_eval_long (signum_exp));
8542 sig_print_info (oursig);
8546 printf_filtered ("\n");
8547 /* These ugly casts brought to you by the native VAX compiler. */
8548 for (oursig = GDB_SIGNAL_FIRST;
8549 (int) oursig < (int) GDB_SIGNAL_LAST;
8550 oursig = (enum gdb_signal) ((int) oursig + 1))
8554 if (oursig != GDB_SIGNAL_UNKNOWN
8555 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
8556 sig_print_info (oursig);
8559 printf_filtered (_("\nUse the \"handle\" command "
8560 "to change these tables.\n"));
8563 /* Check if it makes sense to read $_siginfo from the current thread
8564 at this point. If not, throw an error. */
8567 validate_siginfo_access (void)
8569 /* No current inferior, no siginfo. */
8570 if (ptid_equal (inferior_ptid, null_ptid))
8571 error (_("No thread selected."));
8573 /* Don't try to read from a dead thread. */
8574 if (is_exited (inferior_ptid))
8575 error (_("The current thread has terminated"));
8577 /* ... or from a spinning thread. */
8578 if (is_running (inferior_ptid))
8579 error (_("Selected thread is running."));
8582 /* The $_siginfo convenience variable is a bit special. We don't know
8583 for sure the type of the value until we actually have a chance to
8584 fetch the data. The type can change depending on gdbarch, so it is
8585 also dependent on which thread you have selected.
8587 1. making $_siginfo be an internalvar that creates a new value on
8590 2. making the value of $_siginfo be an lval_computed value. */
8592 /* This function implements the lval_computed support for reading a
8596 siginfo_value_read (struct value *v)
8598 LONGEST transferred;
8600 validate_siginfo_access ();
8603 target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO,
8605 value_contents_all_raw (v),
8607 TYPE_LENGTH (value_type (v)));
8609 if (transferred != TYPE_LENGTH (value_type (v)))
8610 error (_("Unable to read siginfo"));
8613 /* This function implements the lval_computed support for writing a
8617 siginfo_value_write (struct value *v, struct value *fromval)
8619 LONGEST transferred;
8621 validate_siginfo_access ();
8623 transferred = target_write (¤t_target,
8624 TARGET_OBJECT_SIGNAL_INFO,
8626 value_contents_all_raw (fromval),
8628 TYPE_LENGTH (value_type (fromval)));
8630 if (transferred != TYPE_LENGTH (value_type (fromval)))
8631 error (_("Unable to write siginfo"));
8634 static const struct lval_funcs siginfo_value_funcs =
8640 /* Return a new value with the correct type for the siginfo object of
8641 the current thread using architecture GDBARCH. Return a void value
8642 if there's no object available. */
8644 static struct value *
8645 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
8648 if (target_has_stack
8649 && !ptid_equal (inferior_ptid, null_ptid)
8650 && gdbarch_get_siginfo_type_p (gdbarch))
8652 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8654 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
8657 return allocate_value (builtin_type (gdbarch)->builtin_void);
8661 /* infcall_suspend_state contains state about the program itself like its
8662 registers and any signal it received when it last stopped.
8663 This state must be restored regardless of how the inferior function call
8664 ends (either successfully, or after it hits a breakpoint or signal)
8665 if the program is to properly continue where it left off. */
8667 struct infcall_suspend_state
8669 struct thread_suspend_state thread_suspend;
8673 struct regcache *registers;
8675 /* Format of SIGINFO_DATA or NULL if it is not present. */
8676 struct gdbarch *siginfo_gdbarch;
8678 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8679 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8680 content would be invalid. */
8681 gdb_byte *siginfo_data;
8684 struct infcall_suspend_state *
8685 save_infcall_suspend_state (void)
8687 struct infcall_suspend_state *inf_state;
8688 struct thread_info *tp = inferior_thread ();
8689 struct regcache *regcache = get_current_regcache ();
8690 struct gdbarch *gdbarch = get_regcache_arch (regcache);
8691 gdb_byte *siginfo_data = NULL;
8693 if (gdbarch_get_siginfo_type_p (gdbarch))
8695 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8696 size_t len = TYPE_LENGTH (type);
8697 struct cleanup *back_to;
8699 siginfo_data = (gdb_byte *) xmalloc (len);
8700 back_to = make_cleanup (xfree, siginfo_data);
8702 if (target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
8703 siginfo_data, 0, len) == len)
8704 discard_cleanups (back_to);
8707 /* Errors ignored. */
8708 do_cleanups (back_to);
8709 siginfo_data = NULL;
8713 inf_state = XCNEW (struct infcall_suspend_state);
8717 inf_state->siginfo_gdbarch = gdbarch;
8718 inf_state->siginfo_data = siginfo_data;
8721 inf_state->thread_suspend = tp->suspend;
8723 /* run_inferior_call will not use the signal due to its `proceed' call with
8724 GDB_SIGNAL_0 anyway. */
8725 tp->suspend.stop_signal = GDB_SIGNAL_0;
8727 inf_state->stop_pc = stop_pc;
8729 inf_state->registers = regcache_dup (regcache);
8734 /* Restore inferior session state to INF_STATE. */
8737 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8739 struct thread_info *tp = inferior_thread ();
8740 struct regcache *regcache = get_current_regcache ();
8741 struct gdbarch *gdbarch = get_regcache_arch (regcache);
8743 tp->suspend = inf_state->thread_suspend;
8745 stop_pc = inf_state->stop_pc;
8747 if (inf_state->siginfo_gdbarch == gdbarch)
8749 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8751 /* Errors ignored. */
8752 target_write (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
8753 inf_state->siginfo_data, 0, TYPE_LENGTH (type));
8756 /* The inferior can be gone if the user types "print exit(0)"
8757 (and perhaps other times). */
8758 if (target_has_execution)
8759 /* NB: The register write goes through to the target. */
8760 regcache_cpy (regcache, inf_state->registers);
8762 discard_infcall_suspend_state (inf_state);
8766 do_restore_infcall_suspend_state_cleanup (void *state)
8768 restore_infcall_suspend_state ((struct infcall_suspend_state *) state);
8772 make_cleanup_restore_infcall_suspend_state
8773 (struct infcall_suspend_state *inf_state)
8775 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
8779 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8781 regcache_xfree (inf_state->registers);
8782 xfree (inf_state->siginfo_data);
8787 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
8789 return inf_state->registers;
8792 /* infcall_control_state contains state regarding gdb's control of the
8793 inferior itself like stepping control. It also contains session state like
8794 the user's currently selected frame. */
8796 struct infcall_control_state
8798 struct thread_control_state thread_control;
8799 struct inferior_control_state inferior_control;
8802 enum stop_stack_kind stop_stack_dummy;
8803 int stopped_by_random_signal;
8805 /* ID if the selected frame when the inferior function call was made. */
8806 struct frame_id selected_frame_id;
8809 /* Save all of the information associated with the inferior<==>gdb
8812 struct infcall_control_state *
8813 save_infcall_control_state (void)
8815 struct infcall_control_state *inf_status =
8816 XNEW (struct infcall_control_state);
8817 struct thread_info *tp = inferior_thread ();
8818 struct inferior *inf = current_inferior ();
8820 inf_status->thread_control = tp->control;
8821 inf_status->inferior_control = inf->control;
8823 tp->control.step_resume_breakpoint = NULL;
8824 tp->control.exception_resume_breakpoint = NULL;
8826 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8827 chain. If caller's caller is walking the chain, they'll be happier if we
8828 hand them back the original chain when restore_infcall_control_state is
8830 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
8833 inf_status->stop_stack_dummy = stop_stack_dummy;
8834 inf_status->stopped_by_random_signal = stopped_by_random_signal;
8836 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
8842 restore_selected_frame (void *args)
8844 struct frame_id *fid = (struct frame_id *) args;
8845 struct frame_info *frame;
8847 frame = frame_find_by_id (*fid);
8849 /* If inf_status->selected_frame_id is NULL, there was no previously
8853 warning (_("Unable to restore previously selected frame."));
8857 select_frame (frame);
8862 /* Restore inferior session state to INF_STATUS. */
8865 restore_infcall_control_state (struct infcall_control_state *inf_status)
8867 struct thread_info *tp = inferior_thread ();
8868 struct inferior *inf = current_inferior ();
8870 if (tp->control.step_resume_breakpoint)
8871 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
8873 if (tp->control.exception_resume_breakpoint)
8874 tp->control.exception_resume_breakpoint->disposition
8875 = disp_del_at_next_stop;
8877 /* Handle the bpstat_copy of the chain. */
8878 bpstat_clear (&tp->control.stop_bpstat);
8880 tp->control = inf_status->thread_control;
8881 inf->control = inf_status->inferior_control;
8884 stop_stack_dummy = inf_status->stop_stack_dummy;
8885 stopped_by_random_signal = inf_status->stopped_by_random_signal;
8887 if (target_has_stack)
8889 /* The point of catch_errors is that if the stack is clobbered,
8890 walking the stack might encounter a garbage pointer and
8891 error() trying to dereference it. */
8893 (restore_selected_frame, &inf_status->selected_frame_id,
8894 "Unable to restore previously selected frame:\n",
8895 RETURN_MASK_ERROR) == 0)
8896 /* Error in restoring the selected frame. Select the innermost
8898 select_frame (get_current_frame ());
8905 do_restore_infcall_control_state_cleanup (void *sts)
8907 restore_infcall_control_state ((struct infcall_control_state *) sts);
8911 make_cleanup_restore_infcall_control_state
8912 (struct infcall_control_state *inf_status)
8914 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
8918 discard_infcall_control_state (struct infcall_control_state *inf_status)
8920 if (inf_status->thread_control.step_resume_breakpoint)
8921 inf_status->thread_control.step_resume_breakpoint->disposition
8922 = disp_del_at_next_stop;
8924 if (inf_status->thread_control.exception_resume_breakpoint)
8925 inf_status->thread_control.exception_resume_breakpoint->disposition
8926 = disp_del_at_next_stop;
8928 /* See save_infcall_control_state for info on stop_bpstat. */
8929 bpstat_clear (&inf_status->thread_control.stop_bpstat);
8934 /* restore_inferior_ptid() will be used by the cleanup machinery
8935 to restore the inferior_ptid value saved in a call to
8936 save_inferior_ptid(). */
8939 restore_inferior_ptid (void *arg)
8941 ptid_t *saved_ptid_ptr = (ptid_t *) arg;
8943 inferior_ptid = *saved_ptid_ptr;
8947 /* Save the value of inferior_ptid so that it may be restored by a
8948 later call to do_cleanups(). Returns the struct cleanup pointer
8949 needed for later doing the cleanup. */
8952 save_inferior_ptid (void)
8954 ptid_t *saved_ptid_ptr = XNEW (ptid_t);
8956 *saved_ptid_ptr = inferior_ptid;
8957 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
8963 clear_exit_convenience_vars (void)
8965 clear_internalvar (lookup_internalvar ("_exitsignal"));
8966 clear_internalvar (lookup_internalvar ("_exitcode"));
8970 /* User interface for reverse debugging:
8971 Set exec-direction / show exec-direction commands
8972 (returns error unless target implements to_set_exec_direction method). */
8974 enum exec_direction_kind execution_direction = EXEC_FORWARD;
8975 static const char exec_forward[] = "forward";
8976 static const char exec_reverse[] = "reverse";
8977 static const char *exec_direction = exec_forward;
8978 static const char *const exec_direction_names[] = {
8985 set_exec_direction_func (char *args, int from_tty,
8986 struct cmd_list_element *cmd)
8988 if (target_can_execute_reverse)
8990 if (!strcmp (exec_direction, exec_forward))
8991 execution_direction = EXEC_FORWARD;
8992 else if (!strcmp (exec_direction, exec_reverse))
8993 execution_direction = EXEC_REVERSE;
8997 exec_direction = exec_forward;
8998 error (_("Target does not support this operation."));
9003 show_exec_direction_func (struct ui_file *out, int from_tty,
9004 struct cmd_list_element *cmd, const char *value)
9006 switch (execution_direction) {
9008 fprintf_filtered (out, _("Forward.\n"));
9011 fprintf_filtered (out, _("Reverse.\n"));
9014 internal_error (__FILE__, __LINE__,
9015 _("bogus execution_direction value: %d"),
9016 (int) execution_direction);
9021 show_schedule_multiple (struct ui_file *file, int from_tty,
9022 struct cmd_list_element *c, const char *value)
9024 fprintf_filtered (file, _("Resuming the execution of threads "
9025 "of all processes is %s.\n"), value);
9028 /* Implementation of `siginfo' variable. */
9030 static const struct internalvar_funcs siginfo_funcs =
9037 /* Callback for infrun's target events source. This is marked when a
9038 thread has a pending status to process. */
9041 infrun_async_inferior_event_handler (gdb_client_data data)
9043 inferior_event_handler (INF_REG_EVENT, NULL);
9047 _initialize_infrun (void)
9051 struct cmd_list_element *c;
9053 /* Register extra event sources in the event loop. */
9054 infrun_async_inferior_event_token
9055 = create_async_event_handler (infrun_async_inferior_event_handler, NULL);
9057 add_info ("signals", signals_info, _("\
9058 What debugger does when program gets various signals.\n\
9059 Specify a signal as argument to print info on that signal only."));
9060 add_info_alias ("handle", "signals", 0);
9062 c = add_com ("handle", class_run, handle_command, _("\
9063 Specify how to handle signals.\n\
9064 Usage: handle SIGNAL [ACTIONS]\n\
9065 Args are signals and actions to apply to those signals.\n\
9066 If no actions are specified, the current settings for the specified signals\n\
9067 will be displayed instead.\n\
9069 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9070 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9071 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9072 The special arg \"all\" is recognized to mean all signals except those\n\
9073 used by the debugger, typically SIGTRAP and SIGINT.\n\
9075 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9076 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9077 Stop means reenter debugger if this signal happens (implies print).\n\
9078 Print means print a message if this signal happens.\n\
9079 Pass means let program see this signal; otherwise program doesn't know.\n\
9080 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9081 Pass and Stop may be combined.\n\
9083 Multiple signals may be specified. Signal numbers and signal names\n\
9084 may be interspersed with actions, with the actions being performed for\n\
9085 all signals cumulatively specified."));
9086 set_cmd_completer (c, handle_completer);
9089 stop_command = add_cmd ("stop", class_obscure,
9090 not_just_help_class_command, _("\
9091 There is no `stop' command, but you can set a hook on `stop'.\n\
9092 This allows you to set a list of commands to be run each time execution\n\
9093 of the program stops."), &cmdlist);
9095 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
9096 Set inferior debugging."), _("\
9097 Show inferior debugging."), _("\
9098 When non-zero, inferior specific debugging is enabled."),
9101 &setdebuglist, &showdebuglist);
9103 add_setshow_boolean_cmd ("displaced", class_maintenance,
9104 &debug_displaced, _("\
9105 Set displaced stepping debugging."), _("\
9106 Show displaced stepping debugging."), _("\
9107 When non-zero, displaced stepping specific debugging is enabled."),
9109 show_debug_displaced,
9110 &setdebuglist, &showdebuglist);
9112 add_setshow_boolean_cmd ("non-stop", no_class,
9114 Set whether gdb controls the inferior in non-stop mode."), _("\
9115 Show whether gdb controls the inferior in non-stop mode."), _("\
9116 When debugging a multi-threaded program and this setting is\n\
9117 off (the default, also called all-stop mode), when one thread stops\n\
9118 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9119 all other threads in the program while you interact with the thread of\n\
9120 interest. When you continue or step a thread, you can allow the other\n\
9121 threads to run, or have them remain stopped, but while you inspect any\n\
9122 thread's state, all threads stop.\n\
9124 In non-stop mode, when one thread stops, other threads can continue\n\
9125 to run freely. You'll be able to step each thread independently,\n\
9126 leave it stopped or free to run as needed."),
9132 numsigs = (int) GDB_SIGNAL_LAST;
9133 signal_stop = XNEWVEC (unsigned char, numsigs);
9134 signal_print = XNEWVEC (unsigned char, numsigs);
9135 signal_program = XNEWVEC (unsigned char, numsigs);
9136 signal_catch = XNEWVEC (unsigned char, numsigs);
9137 signal_pass = XNEWVEC (unsigned char, numsigs);
9138 for (i = 0; i < numsigs; i++)
9141 signal_print[i] = 1;
9142 signal_program[i] = 1;
9143 signal_catch[i] = 0;
9146 /* Signals caused by debugger's own actions should not be given to
9147 the program afterwards.
9149 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9150 explicitly specifies that it should be delivered to the target
9151 program. Typically, that would occur when a user is debugging a
9152 target monitor on a simulator: the target monitor sets a
9153 breakpoint; the simulator encounters this breakpoint and halts
9154 the simulation handing control to GDB; GDB, noting that the stop
9155 address doesn't map to any known breakpoint, returns control back
9156 to the simulator; the simulator then delivers the hardware
9157 equivalent of a GDB_SIGNAL_TRAP to the program being
9159 signal_program[GDB_SIGNAL_TRAP] = 0;
9160 signal_program[GDB_SIGNAL_INT] = 0;
9162 /* Signals that are not errors should not normally enter the debugger. */
9163 signal_stop[GDB_SIGNAL_ALRM] = 0;
9164 signal_print[GDB_SIGNAL_ALRM] = 0;
9165 signal_stop[GDB_SIGNAL_VTALRM] = 0;
9166 signal_print[GDB_SIGNAL_VTALRM] = 0;
9167 signal_stop[GDB_SIGNAL_PROF] = 0;
9168 signal_print[GDB_SIGNAL_PROF] = 0;
9169 signal_stop[GDB_SIGNAL_CHLD] = 0;
9170 signal_print[GDB_SIGNAL_CHLD] = 0;
9171 signal_stop[GDB_SIGNAL_IO] = 0;
9172 signal_print[GDB_SIGNAL_IO] = 0;
9173 signal_stop[GDB_SIGNAL_POLL] = 0;
9174 signal_print[GDB_SIGNAL_POLL] = 0;
9175 signal_stop[GDB_SIGNAL_URG] = 0;
9176 signal_print[GDB_SIGNAL_URG] = 0;
9177 signal_stop[GDB_SIGNAL_WINCH] = 0;
9178 signal_print[GDB_SIGNAL_WINCH] = 0;
9179 signal_stop[GDB_SIGNAL_PRIO] = 0;
9180 signal_print[GDB_SIGNAL_PRIO] = 0;
9182 /* These signals are used internally by user-level thread
9183 implementations. (See signal(5) on Solaris.) Like the above
9184 signals, a healthy program receives and handles them as part of
9185 its normal operation. */
9186 signal_stop[GDB_SIGNAL_LWP] = 0;
9187 signal_print[GDB_SIGNAL_LWP] = 0;
9188 signal_stop[GDB_SIGNAL_WAITING] = 0;
9189 signal_print[GDB_SIGNAL_WAITING] = 0;
9190 signal_stop[GDB_SIGNAL_CANCEL] = 0;
9191 signal_print[GDB_SIGNAL_CANCEL] = 0;
9193 /* Update cached state. */
9194 signal_cache_update (-1);
9196 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
9197 &stop_on_solib_events, _("\
9198 Set stopping for shared library events."), _("\
9199 Show stopping for shared library events."), _("\
9200 If nonzero, gdb will give control to the user when the dynamic linker\n\
9201 notifies gdb of shared library events. The most common event of interest\n\
9202 to the user would be loading/unloading of a new library."),
9203 set_stop_on_solib_events,
9204 show_stop_on_solib_events,
9205 &setlist, &showlist);
9207 add_setshow_enum_cmd ("follow-fork-mode", class_run,
9208 follow_fork_mode_kind_names,
9209 &follow_fork_mode_string, _("\
9210 Set debugger response to a program call of fork or vfork."), _("\
9211 Show debugger response to a program call of fork or vfork."), _("\
9212 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9213 parent - the original process is debugged after a fork\n\
9214 child - the new process is debugged after a fork\n\
9215 The unfollowed process will continue to run.\n\
9216 By default, the debugger will follow the parent process."),
9218 show_follow_fork_mode_string,
9219 &setlist, &showlist);
9221 add_setshow_enum_cmd ("follow-exec-mode", class_run,
9222 follow_exec_mode_names,
9223 &follow_exec_mode_string, _("\
9224 Set debugger response to a program call of exec."), _("\
9225 Show debugger response to a program call of exec."), _("\
9226 An exec call replaces the program image of a process.\n\
9228 follow-exec-mode can be:\n\
9230 new - the debugger creates a new inferior and rebinds the process\n\
9231 to this new inferior. The program the process was running before\n\
9232 the exec call can be restarted afterwards by restarting the original\n\
9235 same - the debugger keeps the process bound to the same inferior.\n\
9236 The new executable image replaces the previous executable loaded in\n\
9237 the inferior. Restarting the inferior after the exec call restarts\n\
9238 the executable the process was running after the exec call.\n\
9240 By default, the debugger will use the same inferior."),
9242 show_follow_exec_mode_string,
9243 &setlist, &showlist);
9245 add_setshow_enum_cmd ("scheduler-locking", class_run,
9246 scheduler_enums, &scheduler_mode, _("\
9247 Set mode for locking scheduler during execution."), _("\
9248 Show mode for locking scheduler during execution."), _("\
9249 off == no locking (threads may preempt at any time)\n\
9250 on == full locking (no thread except the current thread may run)\n\
9251 This applies to both normal execution and replay mode.\n\
9252 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9253 In this mode, other threads may run during other commands.\n\
9254 This applies to both normal execution and replay mode.\n\
9255 replay == scheduler locked in replay mode and unlocked during normal execution."),
9256 set_schedlock_func, /* traps on target vector */
9257 show_scheduler_mode,
9258 &setlist, &showlist);
9260 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
9261 Set mode for resuming threads of all processes."), _("\
9262 Show mode for resuming threads of all processes."), _("\
9263 When on, execution commands (such as 'continue' or 'next') resume all\n\
9264 threads of all processes. When off (which is the default), execution\n\
9265 commands only resume the threads of the current process. The set of\n\
9266 threads that are resumed is further refined by the scheduler-locking\n\
9267 mode (see help set scheduler-locking)."),
9269 show_schedule_multiple,
9270 &setlist, &showlist);
9272 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
9273 Set mode of the step operation."), _("\
9274 Show mode of the step operation."), _("\
9275 When set, doing a step over a function without debug line information\n\
9276 will stop at the first instruction of that function. Otherwise, the\n\
9277 function is skipped and the step command stops at a different source line."),
9279 show_step_stop_if_no_debug,
9280 &setlist, &showlist);
9282 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
9283 &can_use_displaced_stepping, _("\
9284 Set debugger's willingness to use displaced stepping."), _("\
9285 Show debugger's willingness to use displaced stepping."), _("\
9286 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9287 supported by the target architecture. If off, gdb will not use displaced\n\
9288 stepping to step over breakpoints, even if such is supported by the target\n\
9289 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9290 if the target architecture supports it and non-stop mode is active, but will not\n\
9291 use it in all-stop mode (see help set non-stop)."),
9293 show_can_use_displaced_stepping,
9294 &setlist, &showlist);
9296 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
9297 &exec_direction, _("Set direction of execution.\n\
9298 Options are 'forward' or 'reverse'."),
9299 _("Show direction of execution (forward/reverse)."),
9300 _("Tells gdb whether to execute forward or backward."),
9301 set_exec_direction_func, show_exec_direction_func,
9302 &setlist, &showlist);
9304 /* Set/show detach-on-fork: user-settable mode. */
9306 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
9307 Set whether gdb will detach the child of a fork."), _("\
9308 Show whether gdb will detach the child of a fork."), _("\
9309 Tells gdb whether to detach the child of a fork."),
9310 NULL, NULL, &setlist, &showlist);
9312 /* Set/show disable address space randomization mode. */
9314 add_setshow_boolean_cmd ("disable-randomization", class_support,
9315 &disable_randomization, _("\
9316 Set disabling of debuggee's virtual address space randomization."), _("\
9317 Show disabling of debuggee's virtual address space randomization."), _("\
9318 When this mode is on (which is the default), randomization of the virtual\n\
9319 address space is disabled. Standalone programs run with the randomization\n\
9320 enabled by default on some platforms."),
9321 &set_disable_randomization,
9322 &show_disable_randomization,
9323 &setlist, &showlist);
9325 /* ptid initializations */
9326 inferior_ptid = null_ptid;
9327 target_last_wait_ptid = minus_one_ptid;
9329 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
9330 observer_attach_thread_stop_requested (infrun_thread_stop_requested);
9331 observer_attach_thread_exit (infrun_thread_thread_exit);
9332 observer_attach_inferior_exit (infrun_inferior_exit);
9334 /* Explicitly create without lookup, since that tries to create a
9335 value with a void typed value, and when we get here, gdbarch
9336 isn't initialized yet. At this point, we're quite sure there
9337 isn't another convenience variable of the same name. */
9338 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
9340 add_setshow_boolean_cmd ("observer", no_class,
9341 &observer_mode_1, _("\
9342 Set whether gdb controls the inferior in observer mode."), _("\
9343 Show whether gdb controls the inferior in observer mode."), _("\
9344 In observer mode, GDB can get data from the inferior, but not\n\
9345 affect its execution. Registers and memory may not be changed,\n\
9346 breakpoints may not be set, and the program cannot be interrupted\n\