1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2018 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"
41 #include "observable.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"
67 #include "progspace-and-thread.h"
68 #include "common/gdb_optional.h"
69 #include "arch-utils.h"
71 /* Prototypes for local functions */
73 static void sig_print_info (enum gdb_signal);
75 static void sig_print_header (void);
77 static int follow_fork (void);
79 static int follow_fork_inferior (int follow_child, int detach_fork);
81 static void follow_inferior_reset_breakpoints (void);
83 static int currently_stepping (struct thread_info *tp);
85 void nullify_last_target_wait_ptid (void);
87 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
89 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
91 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
93 static int maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc);
95 static void resume (gdb_signal sig);
97 /* Asynchronous signal handler registered as event loop source for
98 when we have pending events ready to be passed to the core. */
99 static struct async_event_handler *infrun_async_inferior_event_token;
101 /* Stores whether infrun_async was previously enabled or disabled.
102 Starts off as -1, indicating "never enabled/disabled". */
103 static int infrun_is_async = -1;
108 infrun_async (int enable)
110 if (infrun_is_async != enable)
112 infrun_is_async = enable;
115 fprintf_unfiltered (gdb_stdlog,
116 "infrun: infrun_async(%d)\n",
120 mark_async_event_handler (infrun_async_inferior_event_token);
122 clear_async_event_handler (infrun_async_inferior_event_token);
129 mark_infrun_async_event_handler (void)
131 mark_async_event_handler (infrun_async_inferior_event_token);
134 /* When set, stop the 'step' command if we enter a function which has
135 no line number information. The normal behavior is that we step
136 over such function. */
137 int step_stop_if_no_debug = 0;
139 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
140 struct cmd_list_element *c, const char *value)
142 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
145 /* proceed and normal_stop use this to notify the user when the
146 inferior stopped in a different thread than it had been running
149 static ptid_t previous_inferior_ptid;
151 /* If set (default for legacy reasons), when following a fork, GDB
152 will detach from one of the fork branches, child or parent.
153 Exactly which branch is detached depends on 'set follow-fork-mode'
156 static int detach_fork = 1;
158 int debug_displaced = 0;
160 show_debug_displaced (struct ui_file *file, int from_tty,
161 struct cmd_list_element *c, const char *value)
163 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
166 unsigned int debug_infrun = 0;
168 show_debug_infrun (struct ui_file *file, int from_tty,
169 struct cmd_list_element *c, const char *value)
171 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
175 /* Support for disabling address space randomization. */
177 int disable_randomization = 1;
180 show_disable_randomization (struct ui_file *file, int from_tty,
181 struct cmd_list_element *c, const char *value)
183 if (target_supports_disable_randomization ())
184 fprintf_filtered (file,
185 _("Disabling randomization of debuggee's "
186 "virtual address space is %s.\n"),
189 fputs_filtered (_("Disabling randomization of debuggee's "
190 "virtual address space is unsupported on\n"
191 "this platform.\n"), file);
195 set_disable_randomization (const char *args, int from_tty,
196 struct cmd_list_element *c)
198 if (!target_supports_disable_randomization ())
199 error (_("Disabling randomization of debuggee's "
200 "virtual address space is unsupported on\n"
204 /* User interface for non-stop mode. */
207 static int non_stop_1 = 0;
210 set_non_stop (const char *args, int from_tty,
211 struct cmd_list_element *c)
213 if (target_has_execution)
215 non_stop_1 = non_stop;
216 error (_("Cannot change this setting while the inferior is running."));
219 non_stop = non_stop_1;
223 show_non_stop (struct ui_file *file, int from_tty,
224 struct cmd_list_element *c, const char *value)
226 fprintf_filtered (file,
227 _("Controlling the inferior in non-stop mode is %s.\n"),
231 /* "Observer mode" is somewhat like a more extreme version of
232 non-stop, in which all GDB operations that might affect the
233 target's execution have been disabled. */
235 int observer_mode = 0;
236 static int observer_mode_1 = 0;
239 set_observer_mode (const char *args, int from_tty,
240 struct cmd_list_element *c)
242 if (target_has_execution)
244 observer_mode_1 = observer_mode;
245 error (_("Cannot change this setting while the inferior is running."));
248 observer_mode = observer_mode_1;
250 may_write_registers = !observer_mode;
251 may_write_memory = !observer_mode;
252 may_insert_breakpoints = !observer_mode;
253 may_insert_tracepoints = !observer_mode;
254 /* We can insert fast tracepoints in or out of observer mode,
255 but enable them if we're going into this mode. */
257 may_insert_fast_tracepoints = 1;
258 may_stop = !observer_mode;
259 update_target_permissions ();
261 /* Going *into* observer mode we must force non-stop, then
262 going out we leave it that way. */
265 pagination_enabled = 0;
266 non_stop = non_stop_1 = 1;
270 printf_filtered (_("Observer mode is now %s.\n"),
271 (observer_mode ? "on" : "off"));
275 show_observer_mode (struct ui_file *file, int from_tty,
276 struct cmd_list_element *c, const char *value)
278 fprintf_filtered (file, _("Observer mode is %s.\n"), value);
281 /* This updates the value of observer mode based on changes in
282 permissions. Note that we are deliberately ignoring the values of
283 may-write-registers and may-write-memory, since the user may have
284 reason to enable these during a session, for instance to turn on a
285 debugging-related global. */
288 update_observer_mode (void)
292 newval = (!may_insert_breakpoints
293 && !may_insert_tracepoints
294 && may_insert_fast_tracepoints
298 /* Let the user know if things change. */
299 if (newval != observer_mode)
300 printf_filtered (_("Observer mode is now %s.\n"),
301 (newval ? "on" : "off"));
303 observer_mode = observer_mode_1 = newval;
306 /* Tables of how to react to signals; the user sets them. */
308 static unsigned char *signal_stop;
309 static unsigned char *signal_print;
310 static unsigned char *signal_program;
312 /* Table of signals that are registered with "catch signal". A
313 non-zero entry indicates that the signal is caught by some "catch
314 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
316 static unsigned char *signal_catch;
318 /* Table of signals that the target may silently handle.
319 This is automatically determined from the flags above,
320 and simply cached here. */
321 static unsigned char *signal_pass;
323 #define SET_SIGS(nsigs,sigs,flags) \
325 int signum = (nsigs); \
326 while (signum-- > 0) \
327 if ((sigs)[signum]) \
328 (flags)[signum] = 1; \
331 #define UNSET_SIGS(nsigs,sigs,flags) \
333 int signum = (nsigs); \
334 while (signum-- > 0) \
335 if ((sigs)[signum]) \
336 (flags)[signum] = 0; \
339 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
340 this function is to avoid exporting `signal_program'. */
343 update_signals_program_target (void)
345 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
348 /* Value to pass to target_resume() to cause all threads to resume. */
350 #define RESUME_ALL minus_one_ptid
352 /* Command list pointer for the "stop" placeholder. */
354 static struct cmd_list_element *stop_command;
356 /* Nonzero if we want to give control to the user when we're notified
357 of shared library events by the dynamic linker. */
358 int stop_on_solib_events;
360 /* Enable or disable optional shared library event breakpoints
361 as appropriate when the above flag is changed. */
364 set_stop_on_solib_events (const char *args,
365 int from_tty, struct cmd_list_element *c)
367 update_solib_breakpoints ();
371 show_stop_on_solib_events (struct ui_file *file, int from_tty,
372 struct cmd_list_element *c, const char *value)
374 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
378 /* Nonzero after stop if current stack frame should be printed. */
380 static int stop_print_frame;
382 /* This is a cached copy of the pid/waitstatus of the last event
383 returned by target_wait()/deprecated_target_wait_hook(). This
384 information is returned by get_last_target_status(). */
385 static ptid_t target_last_wait_ptid;
386 static struct target_waitstatus target_last_waitstatus;
388 void init_thread_stepping_state (struct thread_info *tss);
390 static const char follow_fork_mode_child[] = "child";
391 static const char follow_fork_mode_parent[] = "parent";
393 static const char *const follow_fork_mode_kind_names[] = {
394 follow_fork_mode_child,
395 follow_fork_mode_parent,
399 static const char *follow_fork_mode_string = follow_fork_mode_parent;
401 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
402 struct cmd_list_element *c, const char *value)
404 fprintf_filtered (file,
405 _("Debugger response to a program "
406 "call of fork or vfork is \"%s\".\n"),
411 /* Handle changes to the inferior list based on the type of fork,
412 which process is being followed, and whether the other process
413 should be detached. On entry inferior_ptid must be the ptid of
414 the fork parent. At return inferior_ptid is the ptid of the
415 followed inferior. */
418 follow_fork_inferior (int follow_child, int detach_fork)
421 ptid_t parent_ptid, child_ptid;
423 has_vforked = (inferior_thread ()->pending_follow.kind
424 == TARGET_WAITKIND_VFORKED);
425 parent_ptid = inferior_ptid;
426 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
429 && !non_stop /* Non-stop always resumes both branches. */
430 && current_ui->prompt_state == PROMPT_BLOCKED
431 && !(follow_child || detach_fork || sched_multi))
433 /* The parent stays blocked inside the vfork syscall until the
434 child execs or exits. If we don't let the child run, then
435 the parent stays blocked. If we're telling the parent to run
436 in the foreground, the user will not be able to ctrl-c to get
437 back the terminal, effectively hanging the debug session. */
438 fprintf_filtered (gdb_stderr, _("\
439 Can not resume the parent process over vfork in the foreground while\n\
440 holding the child stopped. Try \"set detach-on-fork\" or \
441 \"set schedule-multiple\".\n"));
442 /* FIXME output string > 80 columns. */
448 /* Detach new forked process? */
451 /* Before detaching from the child, remove all breakpoints
452 from it. If we forked, then this has already been taken
453 care of by infrun.c. If we vforked however, any
454 breakpoint inserted in the parent is visible in the
455 child, even those added while stopped in a vfork
456 catchpoint. This will remove the breakpoints from the
457 parent also, but they'll be reinserted below. */
460 /* Keep breakpoints list in sync. */
461 remove_breakpoints_inf (current_inferior ());
464 if (print_inferior_events)
466 /* Ensure that we have a process ptid. */
467 ptid_t process_ptid = ptid_t (child_ptid.pid ());
469 target_terminal::ours_for_output ();
470 fprintf_filtered (gdb_stdlog,
471 _("[Detaching after %s from child %s]\n"),
472 has_vforked ? "vfork" : "fork",
473 target_pid_to_str (process_ptid));
478 struct inferior *parent_inf, *child_inf;
480 /* Add process to GDB's tables. */
481 child_inf = add_inferior (child_ptid.pid ());
483 parent_inf = current_inferior ();
484 child_inf->attach_flag = parent_inf->attach_flag;
485 copy_terminal_info (child_inf, parent_inf);
486 child_inf->gdbarch = parent_inf->gdbarch;
487 copy_inferior_target_desc_info (child_inf, parent_inf);
489 scoped_restore_current_pspace_and_thread restore_pspace_thread;
491 inferior_ptid = child_ptid;
492 add_thread_silent (inferior_ptid);
493 set_current_inferior (child_inf);
494 child_inf->symfile_flags = SYMFILE_NO_READ;
496 /* If this is a vfork child, then the address-space is
497 shared with the parent. */
500 child_inf->pspace = parent_inf->pspace;
501 child_inf->aspace = parent_inf->aspace;
503 /* The parent will be frozen until the child is done
504 with the shared region. Keep track of the
506 child_inf->vfork_parent = parent_inf;
507 child_inf->pending_detach = 0;
508 parent_inf->vfork_child = child_inf;
509 parent_inf->pending_detach = 0;
513 child_inf->aspace = new_address_space ();
514 child_inf->pspace = new program_space (child_inf->aspace);
515 child_inf->removable = 1;
516 set_current_program_space (child_inf->pspace);
517 clone_program_space (child_inf->pspace, parent_inf->pspace);
519 /* Let the shared library layer (e.g., solib-svr4) learn
520 about this new process, relocate the cloned exec, pull
521 in shared libraries, and install the solib event
522 breakpoint. If a "cloned-VM" event was propagated
523 better throughout the core, this wouldn't be
525 solib_create_inferior_hook (0);
531 struct inferior *parent_inf;
533 parent_inf = current_inferior ();
535 /* If we detached from the child, then we have to be careful
536 to not insert breakpoints in the parent until the child
537 is done with the shared memory region. However, if we're
538 staying attached to the child, then we can and should
539 insert breakpoints, so that we can debug it. A
540 subsequent child exec or exit is enough to know when does
541 the child stops using the parent's address space. */
542 parent_inf->waiting_for_vfork_done = detach_fork;
543 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
548 /* Follow the child. */
549 struct inferior *parent_inf, *child_inf;
550 struct program_space *parent_pspace;
552 if (print_inferior_events)
554 std::string parent_pid = target_pid_to_str (parent_ptid);
555 std::string child_pid = target_pid_to_str (child_ptid);
557 target_terminal::ours_for_output ();
558 fprintf_filtered (gdb_stdlog,
559 _("[Attaching after %s %s to child %s]\n"),
561 has_vforked ? "vfork" : "fork",
565 /* Add the new inferior first, so that the target_detach below
566 doesn't unpush the target. */
568 child_inf = add_inferior (child_ptid.pid ());
570 parent_inf = current_inferior ();
571 child_inf->attach_flag = parent_inf->attach_flag;
572 copy_terminal_info (child_inf, parent_inf);
573 child_inf->gdbarch = parent_inf->gdbarch;
574 copy_inferior_target_desc_info (child_inf, parent_inf);
576 parent_pspace = parent_inf->pspace;
578 /* If we're vforking, we want to hold on to the parent until the
579 child exits or execs. At child exec or exit time we can
580 remove the old breakpoints from the parent and detach or
581 resume debugging it. Otherwise, detach the parent now; we'll
582 want to reuse it's program/address spaces, but we can't set
583 them to the child before removing breakpoints from the
584 parent, otherwise, the breakpoints module could decide to
585 remove breakpoints from the wrong process (since they'd be
586 assigned to the same address space). */
590 gdb_assert (child_inf->vfork_parent == NULL);
591 gdb_assert (parent_inf->vfork_child == NULL);
592 child_inf->vfork_parent = parent_inf;
593 child_inf->pending_detach = 0;
594 parent_inf->vfork_child = child_inf;
595 parent_inf->pending_detach = detach_fork;
596 parent_inf->waiting_for_vfork_done = 0;
598 else if (detach_fork)
600 if (print_inferior_events)
602 /* Ensure that we have a process ptid. */
603 ptid_t process_ptid = ptid_t (parent_ptid.pid ());
605 target_terminal::ours_for_output ();
606 fprintf_filtered (gdb_stdlog,
607 _("[Detaching after fork from "
609 target_pid_to_str (process_ptid));
612 target_detach (parent_inf, 0);
615 /* Note that the detach above makes PARENT_INF dangling. */
617 /* Add the child thread to the appropriate lists, and switch to
618 this new thread, before cloning the program space, and
619 informing the solib layer about this new process. */
621 inferior_ptid = child_ptid;
622 add_thread_silent (inferior_ptid);
623 set_current_inferior (child_inf);
625 /* If this is a vfork child, then the address-space is shared
626 with the parent. If we detached from the parent, then we can
627 reuse the parent's program/address spaces. */
628 if (has_vforked || detach_fork)
630 child_inf->pspace = parent_pspace;
631 child_inf->aspace = child_inf->pspace->aspace;
635 child_inf->aspace = new_address_space ();
636 child_inf->pspace = new program_space (child_inf->aspace);
637 child_inf->removable = 1;
638 child_inf->symfile_flags = SYMFILE_NO_READ;
639 set_current_program_space (child_inf->pspace);
640 clone_program_space (child_inf->pspace, parent_pspace);
642 /* Let the shared library layer (e.g., solib-svr4) learn
643 about this new process, relocate the cloned exec, pull in
644 shared libraries, and install the solib event breakpoint.
645 If a "cloned-VM" event was propagated better throughout
646 the core, this wouldn't be required. */
647 solib_create_inferior_hook (0);
651 return target_follow_fork (follow_child, detach_fork);
654 /* Tell the target to follow the fork we're stopped at. Returns true
655 if the inferior should be resumed; false, if the target for some
656 reason decided it's best not to resume. */
661 int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
662 int should_resume = 1;
663 struct thread_info *tp;
665 /* Copy user stepping state to the new inferior thread. FIXME: the
666 followed fork child thread should have a copy of most of the
667 parent thread structure's run control related fields, not just these.
668 Initialized to avoid "may be used uninitialized" warnings from gcc. */
669 struct breakpoint *step_resume_breakpoint = NULL;
670 struct breakpoint *exception_resume_breakpoint = NULL;
671 CORE_ADDR step_range_start = 0;
672 CORE_ADDR step_range_end = 0;
673 struct frame_id step_frame_id = { 0 };
674 struct thread_fsm *thread_fsm = NULL;
679 struct target_waitstatus wait_status;
681 /* Get the last target status returned by target_wait(). */
682 get_last_target_status (&wait_ptid, &wait_status);
684 /* If not stopped at a fork event, then there's nothing else to
686 if (wait_status.kind != TARGET_WAITKIND_FORKED
687 && wait_status.kind != TARGET_WAITKIND_VFORKED)
690 /* Check if we switched over from WAIT_PTID, since the event was
692 if (wait_ptid != minus_one_ptid
693 && inferior_ptid != wait_ptid)
695 /* We did. Switch back to WAIT_PTID thread, to tell the
696 target to follow it (in either direction). We'll
697 afterwards refuse to resume, and inform the user what
699 thread_info *wait_thread
700 = find_thread_ptid (wait_ptid);
701 switch_to_thread (wait_thread);
706 tp = inferior_thread ();
708 /* If there were any forks/vforks that were caught and are now to be
709 followed, then do so now. */
710 switch (tp->pending_follow.kind)
712 case TARGET_WAITKIND_FORKED:
713 case TARGET_WAITKIND_VFORKED:
715 ptid_t parent, child;
717 /* If the user did a next/step, etc, over a fork call,
718 preserve the stepping state in the fork child. */
719 if (follow_child && should_resume)
721 step_resume_breakpoint = clone_momentary_breakpoint
722 (tp->control.step_resume_breakpoint);
723 step_range_start = tp->control.step_range_start;
724 step_range_end = tp->control.step_range_end;
725 step_frame_id = tp->control.step_frame_id;
726 exception_resume_breakpoint
727 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
728 thread_fsm = tp->thread_fsm;
730 /* For now, delete the parent's sr breakpoint, otherwise,
731 parent/child sr breakpoints are considered duplicates,
732 and the child version will not be installed. Remove
733 this when the breakpoints module becomes aware of
734 inferiors and address spaces. */
735 delete_step_resume_breakpoint (tp);
736 tp->control.step_range_start = 0;
737 tp->control.step_range_end = 0;
738 tp->control.step_frame_id = null_frame_id;
739 delete_exception_resume_breakpoint (tp);
740 tp->thread_fsm = NULL;
743 parent = inferior_ptid;
744 child = tp->pending_follow.value.related_pid;
746 /* Set up inferior(s) as specified by the caller, and tell the
747 target to do whatever is necessary to follow either parent
749 if (follow_fork_inferior (follow_child, detach_fork))
751 /* Target refused to follow, or there's some other reason
752 we shouldn't resume. */
757 /* This pending follow fork event is now handled, one way
758 or another. The previous selected thread may be gone
759 from the lists by now, but if it is still around, need
760 to clear the pending follow request. */
761 tp = find_thread_ptid (parent);
763 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
765 /* This makes sure we don't try to apply the "Switched
766 over from WAIT_PID" logic above. */
767 nullify_last_target_wait_ptid ();
769 /* If we followed the child, switch to it... */
772 thread_info *child_thr = find_thread_ptid (child);
773 switch_to_thread (child_thr);
775 /* ... and preserve the stepping state, in case the
776 user was stepping over the fork call. */
779 tp = inferior_thread ();
780 tp->control.step_resume_breakpoint
781 = step_resume_breakpoint;
782 tp->control.step_range_start = step_range_start;
783 tp->control.step_range_end = step_range_end;
784 tp->control.step_frame_id = step_frame_id;
785 tp->control.exception_resume_breakpoint
786 = exception_resume_breakpoint;
787 tp->thread_fsm = thread_fsm;
791 /* If we get here, it was because we're trying to
792 resume from a fork catchpoint, but, the user
793 has switched threads away from the thread that
794 forked. In that case, the resume command
795 issued is most likely not applicable to the
796 child, so just warn, and refuse to resume. */
797 warning (_("Not resuming: switched threads "
798 "before following fork child."));
801 /* Reset breakpoints in the child as appropriate. */
802 follow_inferior_reset_breakpoints ();
807 case TARGET_WAITKIND_SPURIOUS:
808 /* Nothing to follow. */
811 internal_error (__FILE__, __LINE__,
812 "Unexpected pending_follow.kind %d\n",
813 tp->pending_follow.kind);
817 return should_resume;
821 follow_inferior_reset_breakpoints (void)
823 struct thread_info *tp = inferior_thread ();
825 /* Was there a step_resume breakpoint? (There was if the user
826 did a "next" at the fork() call.) If so, explicitly reset its
827 thread number. Cloned step_resume breakpoints are disabled on
828 creation, so enable it here now that it is associated with the
831 step_resumes are a form of bp that are made to be per-thread.
832 Since we created the step_resume bp when the parent process
833 was being debugged, and now are switching to the child process,
834 from the breakpoint package's viewpoint, that's a switch of
835 "threads". We must update the bp's notion of which thread
836 it is for, or it'll be ignored when it triggers. */
838 if (tp->control.step_resume_breakpoint)
840 breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
841 tp->control.step_resume_breakpoint->loc->enabled = 1;
844 /* Treat exception_resume breakpoints like step_resume breakpoints. */
845 if (tp->control.exception_resume_breakpoint)
847 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
848 tp->control.exception_resume_breakpoint->loc->enabled = 1;
851 /* Reinsert all breakpoints in the child. The user may have set
852 breakpoints after catching the fork, in which case those
853 were never set in the child, but only in the parent. This makes
854 sure the inserted breakpoints match the breakpoint list. */
856 breakpoint_re_set ();
857 insert_breakpoints ();
860 /* The child has exited or execed: resume threads of the parent the
861 user wanted to be executing. */
864 proceed_after_vfork_done (struct thread_info *thread,
867 int pid = * (int *) arg;
869 if (thread->ptid.pid () == pid
870 && thread->state == THREAD_RUNNING
871 && !thread->executing
872 && !thread->stop_requested
873 && thread->suspend.stop_signal == GDB_SIGNAL_0)
876 fprintf_unfiltered (gdb_stdlog,
877 "infrun: resuming vfork parent thread %s\n",
878 target_pid_to_str (thread->ptid));
880 switch_to_thread (thread);
881 clear_proceed_status (0);
882 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
888 /* Save/restore inferior_ptid, current program space and current
889 inferior. Only use this if the current context points at an exited
890 inferior (and therefore there's no current thread to save). */
891 class scoped_restore_exited_inferior
894 scoped_restore_exited_inferior ()
895 : m_saved_ptid (&inferior_ptid)
899 scoped_restore_tmpl<ptid_t> m_saved_ptid;
900 scoped_restore_current_program_space m_pspace;
901 scoped_restore_current_inferior m_inferior;
904 /* Called whenever we notice an exec or exit event, to handle
905 detaching or resuming a vfork parent. */
908 handle_vfork_child_exec_or_exit (int exec)
910 struct inferior *inf = current_inferior ();
912 if (inf->vfork_parent)
914 int resume_parent = -1;
916 /* This exec or exit marks the end of the shared memory region
917 between the parent and the child. If the user wanted to
918 detach from the parent, now is the time. */
920 if (inf->vfork_parent->pending_detach)
922 struct thread_info *tp;
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;
930 gdb::optional<scoped_restore_exited_inferior>
931 maybe_restore_inferior;
932 gdb::optional<scoped_restore_current_pspace_and_thread>
933 maybe_restore_thread;
935 /* If we're handling a child exit, then inferior_ptid points
936 at the inferior's pid, not to a thread. */
938 maybe_restore_inferior.emplace ();
940 maybe_restore_thread.emplace ();
942 /* We're letting loose of the parent. */
943 tp = any_live_thread_of_inferior (inf->vfork_parent);
944 switch_to_thread (tp);
946 /* We're about to detach from the parent, which implicitly
947 removes breakpoints from its address space. There's a
948 catch here: we want to reuse the spaces for the child,
949 but, parent/child are still sharing the pspace at this
950 point, although the exec in reality makes the kernel give
951 the child a fresh set of new pages. The problem here is
952 that the breakpoints module being unaware of this, would
953 likely chose the child process to write to the parent
954 address space. Swapping the child temporarily away from
955 the spaces has the desired effect. Yes, this is "sort
958 pspace = inf->pspace;
959 aspace = inf->aspace;
963 if (print_inferior_events)
966 = target_pid_to_str (ptid_t (inf->vfork_parent->pid));
968 target_terminal::ours_for_output ();
972 fprintf_filtered (gdb_stdlog,
973 _("[Detaching vfork parent %s "
974 "after child exec]\n"), pidstr);
978 fprintf_filtered (gdb_stdlog,
979 _("[Detaching vfork parent %s "
980 "after child exit]\n"), pidstr);
984 target_detach (inf->vfork_parent, 0);
987 inf->pspace = pspace;
988 inf->aspace = aspace;
992 /* We're staying attached to the parent, so, really give the
993 child a new address space. */
994 inf->pspace = new 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 program_space *pspace;
1008 /* If this is a vfork child exiting, then the pspace and
1009 aspaces were shared with the parent. Since we're
1010 reporting the process exit, we'll be mourning all that is
1011 found in the address space, and switching to null_ptid,
1012 preparing to start a new inferior. But, since we don't
1013 want to clobber the parent's address/program spaces, we
1014 go ahead and create a new one for this exiting
1017 /* Switch to null_ptid while running clone_program_space, so
1018 that clone_program_space doesn't want to read the
1019 selected frame of a dead process. */
1020 scoped_restore restore_ptid
1021 = make_scoped_restore (&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 = new 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 resume_parent = inf->vfork_parent->pid;
1037 /* Break the bonds. */
1038 inf->vfork_parent->vfork_child = NULL;
1041 inf->vfork_parent = NULL;
1043 gdb_assert (current_program_space == inf->pspace);
1045 if (non_stop && resume_parent != -1)
1047 /* If the user wanted the parent to be running, let it go
1049 scoped_restore_current_thread restore_thread;
1052 fprintf_unfiltered (gdb_stdlog,
1053 "infrun: resuming vfork parent process %d\n",
1056 iterate_over_threads (proceed_after_vfork_done, &resume_parent);
1061 /* Enum strings for "set|show follow-exec-mode". */
1063 static const char follow_exec_mode_new[] = "new";
1064 static const char follow_exec_mode_same[] = "same";
1065 static const char *const follow_exec_mode_names[] =
1067 follow_exec_mode_new,
1068 follow_exec_mode_same,
1072 static const char *follow_exec_mode_string = follow_exec_mode_same;
1074 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1075 struct cmd_list_element *c, const char *value)
1077 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
1080 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1083 follow_exec (ptid_t ptid, char *exec_file_target)
1085 struct thread_info *th, *tmp;
1086 struct inferior *inf = current_inferior ();
1087 int pid = ptid.pid ();
1088 ptid_t process_ptid;
1090 /* This is an exec event that we actually wish to pay attention to.
1091 Refresh our symbol table to the newly exec'd program, remove any
1092 momentary bp's, etc.
1094 If there are breakpoints, they aren't really inserted now,
1095 since the exec() transformed our inferior into a fresh set
1098 We want to preserve symbolic breakpoints on the list, since
1099 we have hopes that they can be reset after the new a.out's
1100 symbol table is read.
1102 However, any "raw" breakpoints must be removed from the list
1103 (e.g., the solib bp's), since their address is probably invalid
1106 And, we DON'T want to call delete_breakpoints() here, since
1107 that may write the bp's "shadow contents" (the instruction
1108 value that was overwritten witha TRAP instruction). Since
1109 we now have a new a.out, those shadow contents aren't valid. */
1111 mark_breakpoints_out ();
1113 /* The target reports the exec event to the main thread, even if
1114 some other thread does the exec, and even if the main thread was
1115 stopped or already gone. We may still have non-leader threads of
1116 the process on our list. E.g., on targets that don't have thread
1117 exit events (like remote); or on native Linux in non-stop mode if
1118 there were only two threads in the inferior and the non-leader
1119 one is the one that execs (and nothing forces an update of the
1120 thread list up to here). When debugging remotely, it's best to
1121 avoid extra traffic, when possible, so avoid syncing the thread
1122 list with the target, and instead go ahead and delete all threads
1123 of the process but one that reported the event. Note this must
1124 be done before calling update_breakpoints_after_exec, as
1125 otherwise clearing the threads' resources would reference stale
1126 thread breakpoints -- it may have been one of these threads that
1127 stepped across the exec. We could just clear their stepping
1128 states, but as long as we're iterating, might as well delete
1129 them. Deleting them now rather than at the next user-visible
1130 stop provides a nicer sequence of events for user and MI
1132 ALL_THREADS_SAFE (th, tmp)
1133 if (th->ptid.pid () == pid && th->ptid != ptid)
1136 /* We also need to clear any left over stale state for the
1137 leader/event thread. E.g., if there was any step-resume
1138 breakpoint or similar, it's gone now. We cannot truly
1139 step-to-next statement through an exec(). */
1140 th = inferior_thread ();
1141 th->control.step_resume_breakpoint = NULL;
1142 th->control.exception_resume_breakpoint = NULL;
1143 th->control.single_step_breakpoints = NULL;
1144 th->control.step_range_start = 0;
1145 th->control.step_range_end = 0;
1147 /* The user may have had the main thread held stopped in the
1148 previous image (e.g., schedlock on, or non-stop). Release
1150 th->stop_requested = 0;
1152 update_breakpoints_after_exec ();
1154 /* What is this a.out's name? */
1155 process_ptid = ptid_t (pid);
1156 printf_unfiltered (_("%s is executing new program: %s\n"),
1157 target_pid_to_str (process_ptid),
1160 /* We've followed the inferior through an exec. Therefore, the
1161 inferior has essentially been killed & reborn. */
1163 gdb_flush (gdb_stdout);
1165 breakpoint_init_inferior (inf_execd);
1167 gdb::unique_xmalloc_ptr<char> exec_file_host
1168 = exec_file_find (exec_file_target, NULL);
1170 /* If we were unable to map the executable target pathname onto a host
1171 pathname, tell the user that. Otherwise GDB's subsequent behavior
1172 is confusing. Maybe it would even be better to stop at this point
1173 so that the user can specify a file manually before continuing. */
1174 if (exec_file_host == NULL)
1175 warning (_("Could not load symbols for executable %s.\n"
1176 "Do you need \"set sysroot\"?"),
1179 /* Reset the shared library package. This ensures that we get a
1180 shlib event when the child reaches "_start", at which point the
1181 dld will have had a chance to initialize the child. */
1182 /* Also, loading a symbol file below may trigger symbol lookups, and
1183 we don't want those to be satisfied by the libraries of the
1184 previous incarnation of this process. */
1185 no_shared_libraries (NULL, 0);
1187 if (follow_exec_mode_string == follow_exec_mode_new)
1189 /* The user wants to keep the old inferior and program spaces
1190 around. Create a new fresh one, and switch to it. */
1192 /* Do exit processing for the original inferior before setting the new
1193 inferior's pid. Having two inferiors with the same pid would confuse
1194 find_inferior_p(t)id. Transfer the terminal state and info from the
1195 old to the new inferior. */
1196 inf = add_inferior_with_spaces ();
1197 swap_terminal_info (inf, current_inferior ());
1198 exit_inferior_silent (current_inferior ());
1201 target_follow_exec (inf, exec_file_target);
1203 set_current_inferior (inf);
1204 set_current_program_space (inf->pspace);
1208 /* The old description may no longer be fit for the new image.
1209 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1210 old description; we'll read a new one below. No need to do
1211 this on "follow-exec-mode new", as the old inferior stays
1212 around (its description is later cleared/refetched on
1214 target_clear_description ();
1217 gdb_assert (current_program_space == inf->pspace);
1219 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1220 because the proper displacement for a PIE (Position Independent
1221 Executable) main symbol file will only be computed by
1222 solib_create_inferior_hook below. breakpoint_re_set would fail
1223 to insert the breakpoints with the zero displacement. */
1224 try_open_exec_file (exec_file_host.get (), inf, SYMFILE_DEFER_BP_RESET);
1226 /* If the target can specify a description, read it. Must do this
1227 after flipping to the new executable (because the target supplied
1228 description must be compatible with the executable's
1229 architecture, and the old executable may e.g., be 32-bit, while
1230 the new one 64-bit), and before anything involving memory or
1232 target_find_description ();
1234 /* The add_thread call ends up reading registers, so do it after updating the
1235 target description. */
1236 if (follow_exec_mode_string == follow_exec_mode_new)
1239 solib_create_inferior_hook (0);
1241 jit_inferior_created_hook ();
1243 breakpoint_re_set ();
1245 /* Reinsert all breakpoints. (Those which were symbolic have
1246 been reset to the proper address in the new a.out, thanks
1247 to symbol_file_command...). */
1248 insert_breakpoints ();
1250 /* The next resume of this inferior should bring it to the shlib
1251 startup breakpoints. (If the user had also set bp's on
1252 "main" from the old (parent) process, then they'll auto-
1253 matically get reset there in the new process.). */
1256 /* The queue of threads that need to do a step-over operation to get
1257 past e.g., a breakpoint. What technique is used to step over the
1258 breakpoint/watchpoint does not matter -- all threads end up in the
1259 same queue, to maintain rough temporal order of execution, in order
1260 to avoid starvation, otherwise, we could e.g., find ourselves
1261 constantly stepping the same couple threads past their breakpoints
1262 over and over, if the single-step finish fast enough. */
1263 struct thread_info *step_over_queue_head;
1265 /* Bit flags indicating what the thread needs to step over. */
1267 enum step_over_what_flag
1269 /* Step over a breakpoint. */
1270 STEP_OVER_BREAKPOINT = 1,
1272 /* Step past a non-continuable watchpoint, in order to let the
1273 instruction execute so we can evaluate the watchpoint
1275 STEP_OVER_WATCHPOINT = 2
1277 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag, step_over_what);
1279 /* Info about an instruction that is being stepped over. */
1281 struct step_over_info
1283 /* If we're stepping past a breakpoint, this is the address space
1284 and address of the instruction the breakpoint is set at. We'll
1285 skip inserting all breakpoints here. Valid iff ASPACE is
1287 const address_space *aspace;
1290 /* The instruction being stepped over triggers a nonsteppable
1291 watchpoint. If true, we'll skip inserting watchpoints. */
1292 int nonsteppable_watchpoint_p;
1294 /* The thread's global number. */
1298 /* The step-over info of the location that is being stepped over.
1300 Note that with async/breakpoint always-inserted mode, a user might
1301 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1302 being stepped over. As setting a new breakpoint inserts all
1303 breakpoints, we need to make sure the breakpoint being stepped over
1304 isn't inserted then. We do that by only clearing the step-over
1305 info when the step-over is actually finished (or aborted).
1307 Presently GDB can only step over one breakpoint at any given time.
1308 Given threads that can't run code in the same address space as the
1309 breakpoint's can't really miss the breakpoint, GDB could be taught
1310 to step-over at most one breakpoint per address space (so this info
1311 could move to the address space object if/when GDB is extended).
1312 The set of breakpoints being stepped over will normally be much
1313 smaller than the set of all breakpoints, so a flag in the
1314 breakpoint location structure would be wasteful. A separate list
1315 also saves complexity and run-time, as otherwise we'd have to go
1316 through all breakpoint locations clearing their flag whenever we
1317 start a new sequence. Similar considerations weigh against storing
1318 this info in the thread object. Plus, not all step overs actually
1319 have breakpoint locations -- e.g., stepping past a single-step
1320 breakpoint, or stepping to complete a non-continuable
1322 static struct step_over_info step_over_info;
1324 /* Record the address of the breakpoint/instruction we're currently
1326 N.B. We record the aspace and address now, instead of say just the thread,
1327 because when we need the info later the thread may be running. */
1330 set_step_over_info (const address_space *aspace, CORE_ADDR address,
1331 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;
1337 step_over_info.thread = thread;
1340 /* Called when we're not longer stepping over a breakpoint / an
1341 instruction, so all breakpoints are free to be (re)inserted. */
1344 clear_step_over_info (void)
1347 fprintf_unfiltered (gdb_stdlog,
1348 "infrun: clear_step_over_info\n");
1349 step_over_info.aspace = NULL;
1350 step_over_info.address = 0;
1351 step_over_info.nonsteppable_watchpoint_p = 0;
1352 step_over_info.thread = -1;
1358 stepping_past_instruction_at (struct address_space *aspace,
1361 return (step_over_info.aspace != NULL
1362 && breakpoint_address_match (aspace, address,
1363 step_over_info.aspace,
1364 step_over_info.address));
1370 thread_is_stepping_over_breakpoint (int thread)
1372 return (step_over_info.thread != -1
1373 && thread == step_over_info.thread);
1379 stepping_past_nonsteppable_watchpoint (void)
1381 return step_over_info.nonsteppable_watchpoint_p;
1384 /* Returns true if step-over info is valid. */
1387 step_over_info_valid_p (void)
1389 return (step_over_info.aspace != NULL
1390 || stepping_past_nonsteppable_watchpoint ());
1394 /* Displaced stepping. */
1396 /* In non-stop debugging mode, we must take special care to manage
1397 breakpoints properly; in particular, the traditional strategy for
1398 stepping a thread past a breakpoint it has hit is unsuitable.
1399 'Displaced stepping' is a tactic for stepping one thread past a
1400 breakpoint it has hit while ensuring that other threads running
1401 concurrently will hit the breakpoint as they should.
1403 The traditional way to step a thread T off a breakpoint in a
1404 multi-threaded program in all-stop mode is as follows:
1406 a0) Initially, all threads are stopped, and breakpoints are not
1408 a1) We single-step T, leaving breakpoints uninserted.
1409 a2) We insert breakpoints, and resume all threads.
1411 In non-stop debugging, however, this strategy is unsuitable: we
1412 don't want to have to stop all threads in the system in order to
1413 continue or step T past a breakpoint. Instead, we use displaced
1416 n0) Initially, T is stopped, other threads are running, and
1417 breakpoints are inserted.
1418 n1) We copy the instruction "under" the breakpoint to a separate
1419 location, outside the main code stream, making any adjustments
1420 to the instruction, register, and memory state as directed by
1422 n2) We single-step T over the instruction at its new location.
1423 n3) We adjust the resulting register and memory state as directed
1424 by T's architecture. This includes resetting T's PC to point
1425 back into the main instruction stream.
1428 This approach depends on the following gdbarch methods:
1430 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1431 indicate where to copy the instruction, and how much space must
1432 be reserved there. We use these in step n1.
1434 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1435 address, and makes any necessary adjustments to the instruction,
1436 register contents, and memory. We use this in step n1.
1438 - gdbarch_displaced_step_fixup adjusts registers and memory after
1439 we have successfuly single-stepped the instruction, to yield the
1440 same effect the instruction would have had if we had executed it
1441 at its original address. We use this in step n3.
1443 The gdbarch_displaced_step_copy_insn and
1444 gdbarch_displaced_step_fixup functions must be written so that
1445 copying an instruction with gdbarch_displaced_step_copy_insn,
1446 single-stepping across the copied instruction, and then applying
1447 gdbarch_displaced_insn_fixup should have the same effects on the
1448 thread's memory and registers as stepping the instruction in place
1449 would have. Exactly which responsibilities fall to the copy and
1450 which fall to the fixup is up to the author of those functions.
1452 See the comments in gdbarch.sh for details.
1454 Note that displaced stepping and software single-step cannot
1455 currently be used in combination, although with some care I think
1456 they could be made to. Software single-step works by placing
1457 breakpoints on all possible subsequent instructions; if the
1458 displaced instruction is a PC-relative jump, those breakpoints
1459 could fall in very strange places --- on pages that aren't
1460 executable, or at addresses that are not proper instruction
1461 boundaries. (We do generally let other threads run while we wait
1462 to hit the software single-step breakpoint, and they might
1463 encounter such a corrupted instruction.) One way to work around
1464 this would be to have gdbarch_displaced_step_copy_insn fully
1465 simulate the effect of PC-relative instructions (and return NULL)
1466 on architectures that use software single-stepping.
1468 In non-stop mode, we can have independent and simultaneous step
1469 requests, so more than one thread may need to simultaneously step
1470 over a breakpoint. The current implementation assumes there is
1471 only one scratch space per process. In this case, we have to
1472 serialize access to the scratch space. If thread A wants to step
1473 over a breakpoint, but we are currently waiting for some other
1474 thread to complete a displaced step, we leave thread A stopped and
1475 place it in the displaced_step_request_queue. Whenever a displaced
1476 step finishes, we pick the next thread in the queue and start a new
1477 displaced step operation on it. See displaced_step_prepare and
1478 displaced_step_fixup for details. */
1480 /* Default destructor for displaced_step_closure. */
1482 displaced_step_closure::~displaced_step_closure () = default;
1484 /* Per-inferior displaced stepping state. */
1485 struct displaced_step_inferior_state
1487 /* Pointer to next in linked list. */
1488 struct displaced_step_inferior_state *next;
1490 /* The process this displaced step state refers to. */
1493 /* True if preparing a displaced step ever failed. If so, we won't
1494 try displaced stepping for this inferior again. */
1497 /* If this is not nullptr, this is the thread carrying out a
1498 displaced single-step in process PID. This thread's state will
1499 require fixing up once it has completed its step. */
1500 thread_info *step_thread;
1502 /* The architecture the thread had when we stepped it. */
1503 struct gdbarch *step_gdbarch;
1505 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1506 for post-step cleanup. */
1507 struct displaced_step_closure *step_closure;
1509 /* The address of the original instruction, and the copy we
1511 CORE_ADDR step_original, step_copy;
1513 /* Saved contents of copy area. */
1514 gdb_byte *step_saved_copy;
1517 /* The list of states of processes involved in displaced stepping
1519 static std::forward_list<displaced_step_inferior_state *>
1520 displaced_step_inferior_states;
1522 /* Get the displaced stepping state of process PID. */
1524 static displaced_step_inferior_state *
1525 get_displaced_stepping_state (inferior *inf)
1527 for (auto *state : displaced_step_inferior_states)
1529 if (state->inf == inf)
1536 /* Returns true if any inferior has a thread doing a displaced
1540 displaced_step_in_progress_any_inferior ()
1542 for (auto *state : displaced_step_inferior_states)
1544 if (state->step_thread != nullptr)
1551 /* Return true if thread represented by PTID is doing a displaced
1555 displaced_step_in_progress_thread (thread_info *thread)
1557 struct displaced_step_inferior_state *displaced;
1559 gdb_assert (thread != NULL);
1561 displaced = get_displaced_stepping_state (thread->inf);
1563 return (displaced != NULL && displaced->step_thread == thread);
1566 /* Return true if process PID has a thread doing a displaced step. */
1569 displaced_step_in_progress (inferior *inf)
1571 struct displaced_step_inferior_state *displaced;
1573 displaced = get_displaced_stepping_state (inf);
1574 if (displaced != NULL && displaced->step_thread != nullptr)
1580 /* Add a new displaced stepping state for process PID to the displaced
1581 stepping state list, or return a pointer to an already existing
1582 entry, if it already exists. Never returns NULL. */
1584 static displaced_step_inferior_state *
1585 add_displaced_stepping_state (inferior *inf)
1587 displaced_step_inferior_state *state
1588 = get_displaced_stepping_state (inf);
1590 if (state != nullptr)
1593 state = XCNEW (struct displaced_step_inferior_state);
1596 displaced_step_inferior_states.push_front (state);
1601 /* If inferior is in displaced stepping, and ADDR equals to starting address
1602 of copy area, return corresponding displaced_step_closure. Otherwise,
1605 struct displaced_step_closure*
1606 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1608 struct displaced_step_inferior_state *displaced
1609 = get_displaced_stepping_state (current_inferior ());
1611 /* If checking the mode of displaced instruction in copy area. */
1612 if (displaced != NULL
1613 && displaced->step_thread != nullptr
1614 && displaced->step_copy == addr)
1615 return displaced->step_closure;
1620 /* Remove the displaced stepping state of process PID. */
1623 remove_displaced_stepping_state (inferior *inf)
1625 gdb_assert (inf != nullptr);
1627 displaced_step_inferior_states.remove_if
1628 ([inf] (displaced_step_inferior_state *state)
1630 if (state->inf == inf)
1641 infrun_inferior_exit (struct inferior *inf)
1643 remove_displaced_stepping_state (inf);
1646 /* If ON, and the architecture supports it, GDB will use displaced
1647 stepping to step over breakpoints. If OFF, or if the architecture
1648 doesn't support it, GDB will instead use the traditional
1649 hold-and-step approach. If AUTO (which is the default), GDB will
1650 decide which technique to use to step over breakpoints depending on
1651 which of all-stop or non-stop mode is active --- displaced stepping
1652 in non-stop mode; hold-and-step in all-stop mode. */
1654 static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
1657 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1658 struct cmd_list_element *c,
1661 if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1662 fprintf_filtered (file,
1663 _("Debugger's willingness to use displaced stepping "
1664 "to step over breakpoints is %s (currently %s).\n"),
1665 value, target_is_non_stop_p () ? "on" : "off");
1667 fprintf_filtered (file,
1668 _("Debugger's willingness to use displaced stepping "
1669 "to step over breakpoints is %s.\n"), value);
1672 /* Return non-zero if displaced stepping can/should be used to step
1673 over breakpoints of thread TP. */
1676 use_displaced_stepping (struct thread_info *tp)
1678 struct regcache *regcache = get_thread_regcache (tp);
1679 struct gdbarch *gdbarch = regcache->arch ();
1680 struct displaced_step_inferior_state *displaced_state;
1682 displaced_state = get_displaced_stepping_state (tp->inf);
1684 return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
1685 && target_is_non_stop_p ())
1686 || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1687 && gdbarch_displaced_step_copy_insn_p (gdbarch)
1688 && find_record_target () == NULL
1689 && (displaced_state == NULL
1690 || !displaced_state->failed_before));
1693 /* Clean out any stray displaced stepping state. */
1695 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1697 /* Indicate that there is no cleanup pending. */
1698 displaced->step_thread = nullptr;
1700 delete displaced->step_closure;
1701 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 (thread_info *tp)
1745 struct cleanup *ignore_cleanups;
1746 regcache *regcache = get_thread_regcache (tp);
1747 struct gdbarch *gdbarch = regcache->arch ();
1748 const address_space *aspace = regcache->aspace ();
1749 CORE_ADDR original, copy;
1751 struct displaced_step_closure *closure;
1752 struct displaced_step_inferior_state *displaced;
1755 /* We should never reach this function if the architecture does not
1756 support displaced stepping. */
1757 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1759 /* Nor if the thread isn't meant to step over a breakpoint. */
1760 gdb_assert (tp->control.trap_expected);
1762 /* Disable range stepping while executing in the scratch pad. We
1763 want a single-step even if executing the displaced instruction in
1764 the scratch buffer lands within the stepping range (e.g., a
1766 tp->control.may_range_step = 0;
1768 /* We have to displaced step one thread at a time, as we only have
1769 access to a single scratch space per inferior. */
1771 displaced = add_displaced_stepping_state (tp->inf);
1773 if (displaced->step_thread != nullptr)
1775 /* Already waiting for a displaced step to finish. Defer this
1776 request and place in queue. */
1778 if (debug_displaced)
1779 fprintf_unfiltered (gdb_stdlog,
1780 "displaced: deferring step of %s\n",
1781 target_pid_to_str (tp->ptid));
1783 thread_step_over_chain_enqueue (tp);
1788 if (debug_displaced)
1789 fprintf_unfiltered (gdb_stdlog,
1790 "displaced: stepping %s now\n",
1791 target_pid_to_str (tp->ptid));
1794 displaced_step_clear (displaced);
1796 scoped_restore_current_thread restore_thread;
1798 switch_to_thread (tp);
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");
1826 /* Save the original contents of the copy area. */
1827 displaced->step_saved_copy = (gdb_byte *) xmalloc (len);
1828 ignore_cleanups = make_cleanup (free_current_contents,
1829 &displaced->step_saved_copy);
1830 status = target_read_memory (copy, displaced->step_saved_copy, len);
1832 throw_error (MEMORY_ERROR,
1833 _("Error accessing memory address %s (%s) for "
1834 "displaced-stepping scratch space."),
1835 paddress (gdbarch, copy), safe_strerror (status));
1836 if (debug_displaced)
1838 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1839 paddress (gdbarch, copy));
1840 displaced_step_dump_bytes (gdb_stdlog,
1841 displaced->step_saved_copy,
1845 closure = gdbarch_displaced_step_copy_insn (gdbarch,
1846 original, copy, regcache);
1847 if (closure == NULL)
1849 /* The architecture doesn't know how or want to displaced step
1850 this instruction or instruction sequence. Fallback to
1851 stepping over the breakpoint in-line. */
1852 do_cleanups (ignore_cleanups);
1856 /* Save the information we need to fix things up if the step
1858 displaced->step_thread = tp;
1859 displaced->step_gdbarch = gdbarch;
1860 displaced->step_closure = closure;
1861 displaced->step_original = original;
1862 displaced->step_copy = copy;
1864 make_cleanup (displaced_step_clear_cleanup, displaced);
1866 /* Resume execution at the copy. */
1867 regcache_write_pc (regcache, copy);
1869 discard_cleanups (ignore_cleanups);
1871 if (debug_displaced)
1872 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1873 paddress (gdbarch, copy));
1878 /* Wrapper for displaced_step_prepare_throw that disabled further
1879 attempts at displaced stepping if we get a memory error. */
1882 displaced_step_prepare (thread_info *thread)
1888 prepared = displaced_step_prepare_throw (thread);
1890 CATCH (ex, RETURN_MASK_ERROR)
1892 struct displaced_step_inferior_state *displaced_state;
1894 if (ex.error != MEMORY_ERROR
1895 && ex.error != NOT_SUPPORTED_ERROR)
1896 throw_exception (ex);
1900 fprintf_unfiltered (gdb_stdlog,
1901 "infrun: disabling displaced stepping: %s\n",
1905 /* Be verbose if "set displaced-stepping" is "on", silent if
1907 if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1909 warning (_("disabling displaced stepping: %s"),
1913 /* Disable further displaced stepping attempts. */
1915 = get_displaced_stepping_state (thread->inf);
1916 displaced_state->failed_before = 1;
1924 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1925 const gdb_byte *myaddr, int len)
1927 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1929 inferior_ptid = ptid;
1930 write_memory (memaddr, myaddr, len);
1933 /* Restore the contents of the copy area for thread PTID. */
1936 displaced_step_restore (struct displaced_step_inferior_state *displaced,
1939 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1941 write_memory_ptid (ptid, displaced->step_copy,
1942 displaced->step_saved_copy, len);
1943 if (debug_displaced)
1944 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1945 target_pid_to_str (ptid),
1946 paddress (displaced->step_gdbarch,
1947 displaced->step_copy));
1950 /* If we displaced stepped an instruction successfully, adjust
1951 registers and memory to yield the same effect the instruction would
1952 have had if we had executed it at its original address, and return
1953 1. If the instruction didn't complete, relocate the PC and return
1954 -1. If the thread wasn't displaced stepping, return 0. */
1957 displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal)
1959 struct cleanup *old_cleanups;
1960 struct displaced_step_inferior_state *displaced
1961 = get_displaced_stepping_state (event_thread->inf);
1964 /* Was any thread of this process doing a displaced step? */
1965 if (displaced == NULL)
1968 /* Was this event for the thread we displaced? */
1969 if (displaced->step_thread != event_thread)
1972 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1974 displaced_step_restore (displaced, displaced->step_thread->ptid);
1976 /* Fixup may need to read memory/registers. Switch to the thread
1977 that we're fixing up. Also, target_stopped_by_watchpoint checks
1978 the current thread. */
1979 switch_to_thread (event_thread);
1981 /* Did the instruction complete successfully? */
1982 if (signal == GDB_SIGNAL_TRAP
1983 && !(target_stopped_by_watchpoint ()
1984 && (gdbarch_have_nonsteppable_watchpoint (displaced->step_gdbarch)
1985 || target_have_steppable_watchpoint)))
1987 /* Fix up the resulting state. */
1988 gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1989 displaced->step_closure,
1990 displaced->step_original,
1991 displaced->step_copy,
1992 get_thread_regcache (displaced->step_thread));
1997 /* Since the instruction didn't complete, all we can do is
1999 struct regcache *regcache = get_thread_regcache (event_thread);
2000 CORE_ADDR pc = regcache_read_pc (regcache);
2002 pc = displaced->step_original + (pc - displaced->step_copy);
2003 regcache_write_pc (regcache, pc);
2007 do_cleanups (old_cleanups);
2009 displaced->step_thread = nullptr;
2014 /* Data to be passed around while handling an event. This data is
2015 discarded between events. */
2016 struct execution_control_state
2019 /* The thread that got the event, if this was a thread event; NULL
2021 struct thread_info *event_thread;
2023 struct target_waitstatus ws;
2024 int stop_func_filled_in;
2025 CORE_ADDR stop_func_start;
2026 CORE_ADDR stop_func_end;
2027 const char *stop_func_name;
2030 /* True if the event thread hit the single-step breakpoint of
2031 another thread. Thus the event doesn't cause a stop, the thread
2032 needs to be single-stepped past the single-step breakpoint before
2033 we can switch back to the original stepping thread. */
2034 int hit_singlestep_breakpoint;
2037 /* Clear ECS and set it to point at TP. */
2040 reset_ecs (struct execution_control_state *ecs, struct thread_info *tp)
2042 memset (ecs, 0, sizeof (*ecs));
2043 ecs->event_thread = tp;
2044 ecs->ptid = tp->ptid;
2047 static void keep_going_pass_signal (struct execution_control_state *ecs);
2048 static void prepare_to_wait (struct execution_control_state *ecs);
2049 static int keep_going_stepped_thread (struct thread_info *tp);
2050 static step_over_what thread_still_needs_step_over (struct thread_info *tp);
2052 /* Are there any pending step-over requests? If so, run all we can
2053 now and return true. Otherwise, return false. */
2056 start_step_over (void)
2058 struct thread_info *tp, *next;
2060 /* Don't start a new step-over if we already have an in-line
2061 step-over operation ongoing. */
2062 if (step_over_info_valid_p ())
2065 for (tp = step_over_queue_head; tp != NULL; tp = next)
2067 struct execution_control_state ecss;
2068 struct execution_control_state *ecs = &ecss;
2069 step_over_what step_what;
2070 int must_be_in_line;
2072 gdb_assert (!tp->stop_requested);
2074 next = thread_step_over_chain_next (tp);
2076 /* If this inferior already has a displaced step in process,
2077 don't start a new one. */
2078 if (displaced_step_in_progress (tp->inf))
2081 step_what = thread_still_needs_step_over (tp);
2082 must_be_in_line = ((step_what & STEP_OVER_WATCHPOINT)
2083 || ((step_what & STEP_OVER_BREAKPOINT)
2084 && !use_displaced_stepping (tp)));
2086 /* We currently stop all threads of all processes to step-over
2087 in-line. If we need to start a new in-line step-over, let
2088 any pending displaced steps finish first. */
2089 if (must_be_in_line && displaced_step_in_progress_any_inferior ())
2092 thread_step_over_chain_remove (tp);
2094 if (step_over_queue_head == NULL)
2097 fprintf_unfiltered (gdb_stdlog,
2098 "infrun: step-over queue now empty\n");
2101 if (tp->control.trap_expected
2105 internal_error (__FILE__, __LINE__,
2106 "[%s] has inconsistent state: "
2107 "trap_expected=%d, resumed=%d, executing=%d\n",
2108 target_pid_to_str (tp->ptid),
2109 tp->control.trap_expected,
2115 fprintf_unfiltered (gdb_stdlog,
2116 "infrun: resuming [%s] for step-over\n",
2117 target_pid_to_str (tp->ptid));
2119 /* keep_going_pass_signal skips the step-over if the breakpoint
2120 is no longer inserted. In all-stop, we want to keep looking
2121 for a thread that needs a step-over instead of resuming TP,
2122 because we wouldn't be able to resume anything else until the
2123 target stops again. In non-stop, the resume always resumes
2124 only TP, so it's OK to let the thread resume freely. */
2125 if (!target_is_non_stop_p () && !step_what)
2128 switch_to_thread (tp);
2129 reset_ecs (ecs, tp);
2130 keep_going_pass_signal (ecs);
2132 if (!ecs->wait_some_more)
2133 error (_("Command aborted."));
2135 gdb_assert (tp->resumed);
2137 /* If we started a new in-line step-over, we're done. */
2138 if (step_over_info_valid_p ())
2140 gdb_assert (tp->control.trap_expected);
2144 if (!target_is_non_stop_p ())
2146 /* On all-stop, shouldn't have resumed unless we needed a
2148 gdb_assert (tp->control.trap_expected
2149 || tp->step_after_step_resume_breakpoint);
2151 /* With remote targets (at least), in all-stop, we can't
2152 issue any further remote commands until the program stops
2157 /* Either the thread no longer needed a step-over, or a new
2158 displaced stepping sequence started. Even in the latter
2159 case, continue looking. Maybe we can also start another
2160 displaced step on a thread of other process. */
2166 /* Update global variables holding ptids to hold NEW_PTID if they were
2167 holding OLD_PTID. */
2169 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
2171 if (inferior_ptid == old_ptid)
2172 inferior_ptid = new_ptid;
2177 static const char schedlock_off[] = "off";
2178 static const char schedlock_on[] = "on";
2179 static const char schedlock_step[] = "step";
2180 static const char schedlock_replay[] = "replay";
2181 static const char *const scheduler_enums[] = {
2188 static const char *scheduler_mode = schedlock_replay;
2190 show_scheduler_mode (struct ui_file *file, int from_tty,
2191 struct cmd_list_element *c, const char *value)
2193 fprintf_filtered (file,
2194 _("Mode for locking scheduler "
2195 "during execution is \"%s\".\n"),
2200 set_schedlock_func (const char *args, int from_tty, struct cmd_list_element *c)
2202 if (!target_can_lock_scheduler)
2204 scheduler_mode = schedlock_off;
2205 error (_("Target '%s' cannot support this command."), target_shortname);
2209 /* True if execution commands resume all threads of all processes by
2210 default; otherwise, resume only threads of the current inferior
2212 int sched_multi = 0;
2214 /* Try to setup for software single stepping over the specified location.
2215 Return 1 if target_resume() should use hardware single step.
2217 GDBARCH the current gdbarch.
2218 PC the location to step over. */
2221 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
2225 if (execution_direction == EXEC_FORWARD
2226 && gdbarch_software_single_step_p (gdbarch))
2227 hw_step = !insert_single_step_breakpoints (gdbarch);
2235 user_visible_resume_ptid (int step)
2241 /* With non-stop mode on, threads are always handled
2243 resume_ptid = inferior_ptid;
2245 else if ((scheduler_mode == schedlock_on)
2246 || (scheduler_mode == schedlock_step && step))
2248 /* User-settable 'scheduler' mode requires solo thread
2250 resume_ptid = inferior_ptid;
2252 else if ((scheduler_mode == schedlock_replay)
2253 && target_record_will_replay (minus_one_ptid, execution_direction))
2255 /* User-settable 'scheduler' mode requires solo thread resume in replay
2257 resume_ptid = inferior_ptid;
2259 else if (!sched_multi && target_supports_multi_process ())
2261 /* Resume all threads of the current process (and none of other
2263 resume_ptid = ptid_t (inferior_ptid.pid ());
2267 /* Resume all threads of all processes. */
2268 resume_ptid = RESUME_ALL;
2274 /* Return a ptid representing the set of threads that we will resume,
2275 in the perspective of the target, assuming run control handling
2276 does not require leaving some threads stopped (e.g., stepping past
2277 breakpoint). USER_STEP indicates whether we're about to start the
2278 target for a stepping command. */
2281 internal_resume_ptid (int user_step)
2283 /* In non-stop, we always control threads individually. Note that
2284 the target may always work in non-stop mode even with "set
2285 non-stop off", in which case user_visible_resume_ptid could
2286 return a wildcard ptid. */
2287 if (target_is_non_stop_p ())
2288 return inferior_ptid;
2290 return user_visible_resume_ptid (user_step);
2293 /* Wrapper for target_resume, that handles infrun-specific
2297 do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig)
2299 struct thread_info *tp = inferior_thread ();
2301 gdb_assert (!tp->stop_requested);
2303 /* Install inferior's terminal modes. */
2304 target_terminal::inferior ();
2306 /* Avoid confusing the next resume, if the next stop/resume
2307 happens to apply to another thread. */
2308 tp->suspend.stop_signal = GDB_SIGNAL_0;
2310 /* Advise target which signals may be handled silently.
2312 If we have removed breakpoints because we are stepping over one
2313 in-line (in any thread), we need to receive all signals to avoid
2314 accidentally skipping a breakpoint during execution of a signal
2317 Likewise if we're displaced stepping, otherwise a trap for a
2318 breakpoint in a signal handler might be confused with the
2319 displaced step finishing. We don't make the displaced_step_fixup
2320 step distinguish the cases instead, because:
2322 - a backtrace while stopped in the signal handler would show the
2323 scratch pad as frame older than the signal handler, instead of
2324 the real mainline code.
2326 - when the thread is later resumed, the signal handler would
2327 return to the scratch pad area, which would no longer be
2329 if (step_over_info_valid_p ()
2330 || displaced_step_in_progress (tp->inf))
2331 target_pass_signals (0, NULL);
2333 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2335 target_resume (resume_ptid, step, sig);
2337 target_commit_resume ();
2340 /* Resume the inferior. SIG is the signal to give the inferior
2341 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2342 call 'resume', which handles exceptions. */
2345 resume_1 (enum gdb_signal sig)
2347 struct regcache *regcache = get_current_regcache ();
2348 struct gdbarch *gdbarch = regcache->arch ();
2349 struct thread_info *tp = inferior_thread ();
2350 CORE_ADDR pc = regcache_read_pc (regcache);
2351 const address_space *aspace = regcache->aspace ();
2353 /* This represents the user's step vs continue request. When
2354 deciding whether "set scheduler-locking step" applies, it's the
2355 user's intention that counts. */
2356 const int user_step = tp->control.stepping_command;
2357 /* This represents what we'll actually request the target to do.
2358 This can decay from a step to a continue, if e.g., we need to
2359 implement single-stepping with breakpoints (software
2363 gdb_assert (!tp->stop_requested);
2364 gdb_assert (!thread_is_in_step_over_chain (tp));
2366 if (tp->suspend.waitstatus_pending_p)
2371 = target_waitstatus_to_string (&tp->suspend.waitstatus);
2373 fprintf_unfiltered (gdb_stdlog,
2374 "infrun: resume: thread %s has pending wait "
2375 "status %s (currently_stepping=%d).\n",
2376 target_pid_to_str (tp->ptid), statstr.c_str (),
2377 currently_stepping (tp));
2382 /* FIXME: What should we do if we are supposed to resume this
2383 thread with a signal? Maybe we should maintain a queue of
2384 pending signals to deliver. */
2385 if (sig != GDB_SIGNAL_0)
2387 warning (_("Couldn't deliver signal %s to %s."),
2388 gdb_signal_to_name (sig), target_pid_to_str (tp->ptid));
2391 tp->suspend.stop_signal = GDB_SIGNAL_0;
2393 if (target_can_async_p ())
2396 /* Tell the event loop we have an event to process. */
2397 mark_async_event_handler (infrun_async_inferior_event_token);
2402 tp->stepped_breakpoint = 0;
2404 /* Depends on stepped_breakpoint. */
2405 step = currently_stepping (tp);
2407 if (current_inferior ()->waiting_for_vfork_done)
2409 /* Don't try to single-step a vfork parent that is waiting for
2410 the child to get out of the shared memory region (by exec'ing
2411 or exiting). This is particularly important on software
2412 single-step archs, as the child process would trip on the
2413 software single step breakpoint inserted for the parent
2414 process. Since the parent will not actually execute any
2415 instruction until the child is out of the shared region (such
2416 are vfork's semantics), it is safe to simply continue it.
2417 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2418 the parent, and tell it to `keep_going', which automatically
2419 re-sets it stepping. */
2421 fprintf_unfiltered (gdb_stdlog,
2422 "infrun: resume : clear step\n");
2427 fprintf_unfiltered (gdb_stdlog,
2428 "infrun: resume (step=%d, signal=%s), "
2429 "trap_expected=%d, current thread [%s] at %s\n",
2430 step, gdb_signal_to_symbol_string (sig),
2431 tp->control.trap_expected,
2432 target_pid_to_str (inferior_ptid),
2433 paddress (gdbarch, pc));
2435 /* Normally, by the time we reach `resume', the breakpoints are either
2436 removed or inserted, as appropriate. The exception is if we're sitting
2437 at a permanent breakpoint; we need to step over it, but permanent
2438 breakpoints can't be removed. So we have to test for it here. */
2439 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
2441 if (sig != GDB_SIGNAL_0)
2443 /* We have a signal to pass to the inferior. The resume
2444 may, or may not take us to the signal handler. If this
2445 is a step, we'll need to stop in the signal handler, if
2446 there's one, (if the target supports stepping into
2447 handlers), or in the next mainline instruction, if
2448 there's no handler. If this is a continue, we need to be
2449 sure to run the handler with all breakpoints inserted.
2450 In all cases, set a breakpoint at the current address
2451 (where the handler returns to), and once that breakpoint
2452 is hit, resume skipping the permanent breakpoint. If
2453 that breakpoint isn't hit, then we've stepped into the
2454 signal handler (or hit some other event). We'll delete
2455 the step-resume breakpoint then. */
2458 fprintf_unfiltered (gdb_stdlog,
2459 "infrun: resume: skipping permanent breakpoint, "
2460 "deliver signal first\n");
2462 clear_step_over_info ();
2463 tp->control.trap_expected = 0;
2465 if (tp->control.step_resume_breakpoint == NULL)
2467 /* Set a "high-priority" step-resume, as we don't want
2468 user breakpoints at PC to trigger (again) when this
2470 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2471 gdb_assert (tp->control.step_resume_breakpoint->loc->permanent);
2473 tp->step_after_step_resume_breakpoint = step;
2476 insert_breakpoints ();
2480 /* There's no signal to pass, we can go ahead and skip the
2481 permanent breakpoint manually. */
2483 fprintf_unfiltered (gdb_stdlog,
2484 "infrun: resume: skipping permanent breakpoint\n");
2485 gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2486 /* Update pc to reflect the new address from which we will
2487 execute instructions. */
2488 pc = regcache_read_pc (regcache);
2492 /* We've already advanced the PC, so the stepping part
2493 is done. Now we need to arrange for a trap to be
2494 reported to handle_inferior_event. Set a breakpoint
2495 at the current PC, and run to it. Don't update
2496 prev_pc, because if we end in
2497 switch_back_to_stepped_thread, we want the "expected
2498 thread advanced also" branch to be taken. IOW, we
2499 don't want this thread to step further from PC
2501 gdb_assert (!step_over_info_valid_p ());
2502 insert_single_step_breakpoint (gdbarch, aspace, pc);
2503 insert_breakpoints ();
2505 resume_ptid = internal_resume_ptid (user_step);
2506 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
2513 /* If we have a breakpoint to step over, make sure to do a single
2514 step only. Same if we have software watchpoints. */
2515 if (tp->control.trap_expected || bpstat_should_step ())
2516 tp->control.may_range_step = 0;
2518 /* If enabled, step over breakpoints by executing a copy of the
2519 instruction at a different address.
2521 We can't use displaced stepping when we have a signal to deliver;
2522 the comments for displaced_step_prepare explain why. The
2523 comments in the handle_inferior event for dealing with 'random
2524 signals' explain what we do instead.
2526 We can't use displaced stepping when we are waiting for vfork_done
2527 event, displaced stepping breaks the vfork child similarly as single
2528 step software breakpoint. */
2529 if (tp->control.trap_expected
2530 && use_displaced_stepping (tp)
2531 && !step_over_info_valid_p ()
2532 && sig == GDB_SIGNAL_0
2533 && !current_inferior ()->waiting_for_vfork_done)
2535 int prepared = displaced_step_prepare (tp);
2540 fprintf_unfiltered (gdb_stdlog,
2541 "Got placed in step-over queue\n");
2543 tp->control.trap_expected = 0;
2546 else if (prepared < 0)
2548 /* Fallback to stepping over the breakpoint in-line. */
2550 if (target_is_non_stop_p ())
2551 stop_all_threads ();
2553 set_step_over_info (regcache->aspace (),
2554 regcache_read_pc (regcache), 0, tp->global_num);
2556 step = maybe_software_singlestep (gdbarch, pc);
2558 insert_breakpoints ();
2560 else if (prepared > 0)
2562 struct displaced_step_inferior_state *displaced;
2564 /* Update pc to reflect the new address from which we will
2565 execute instructions due to displaced stepping. */
2566 pc = regcache_read_pc (get_thread_regcache (tp));
2568 displaced = get_displaced_stepping_state (tp->inf);
2569 step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2570 displaced->step_closure);
2574 /* Do we need to do it the hard way, w/temp breakpoints? */
2576 step = maybe_software_singlestep (gdbarch, pc);
2578 /* Currently, our software single-step implementation leads to different
2579 results than hardware single-stepping in one situation: when stepping
2580 into delivering a signal which has an associated signal handler,
2581 hardware single-step will stop at the first instruction of the handler,
2582 while software single-step will simply skip execution of the handler.
2584 For now, this difference in behavior is accepted since there is no
2585 easy way to actually implement single-stepping into a signal handler
2586 without kernel support.
2588 However, there is one scenario where this difference leads to follow-on
2589 problems: if we're stepping off a breakpoint by removing all breakpoints
2590 and then single-stepping. In this case, the software single-step
2591 behavior means that even if there is a *breakpoint* in the signal
2592 handler, GDB still would not stop.
2594 Fortunately, we can at least fix this particular issue. We detect
2595 here the case where we are about to deliver a signal while software
2596 single-stepping with breakpoints removed. In this situation, we
2597 revert the decisions to remove all breakpoints and insert single-
2598 step breakpoints, and instead we install a step-resume breakpoint
2599 at the current address, deliver the signal without stepping, and
2600 once we arrive back at the step-resume breakpoint, actually step
2601 over the breakpoint we originally wanted to step over. */
2602 if (thread_has_single_step_breakpoints_set (tp)
2603 && sig != GDB_SIGNAL_0
2604 && step_over_info_valid_p ())
2606 /* If we have nested signals or a pending signal is delivered
2607 immediately after a handler returns, might might already have
2608 a step-resume breakpoint set on the earlier handler. We cannot
2609 set another step-resume breakpoint; just continue on until the
2610 original breakpoint is hit. */
2611 if (tp->control.step_resume_breakpoint == NULL)
2613 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2614 tp->step_after_step_resume_breakpoint = 1;
2617 delete_single_step_breakpoints (tp);
2619 clear_step_over_info ();
2620 tp->control.trap_expected = 0;
2622 insert_breakpoints ();
2625 /* If STEP is set, it's a request to use hardware stepping
2626 facilities. But in that case, we should never
2627 use singlestep breakpoint. */
2628 gdb_assert (!(thread_has_single_step_breakpoints_set (tp) && step));
2630 /* Decide the set of threads to ask the target to resume. */
2631 if (tp->control.trap_expected)
2633 /* We're allowing a thread to run past a breakpoint it has
2634 hit, either by single-stepping the thread with the breakpoint
2635 removed, or by displaced stepping, with the breakpoint inserted.
2636 In the former case, we need to single-step only this thread,
2637 and keep others stopped, as they can miss this breakpoint if
2638 allowed to run. That's not really a problem for displaced
2639 stepping, but, we still keep other threads stopped, in case
2640 another thread is also stopped for a breakpoint waiting for
2641 its turn in the displaced stepping queue. */
2642 resume_ptid = inferior_ptid;
2645 resume_ptid = internal_resume_ptid (user_step);
2647 if (execution_direction != EXEC_REVERSE
2648 && step && breakpoint_inserted_here_p (aspace, pc))
2650 /* There are two cases where we currently need to step a
2651 breakpoint instruction when we have a signal to deliver:
2653 - See handle_signal_stop where we handle random signals that
2654 could take out us out of the stepping range. Normally, in
2655 that case we end up continuing (instead of stepping) over the
2656 signal handler with a breakpoint at PC, but there are cases
2657 where we should _always_ single-step, even if we have a
2658 step-resume breakpoint, like when a software watchpoint is
2659 set. Assuming single-stepping and delivering a signal at the
2660 same time would takes us to the signal handler, then we could
2661 have removed the breakpoint at PC to step over it. However,
2662 some hardware step targets (like e.g., Mac OS) can't step
2663 into signal handlers, and for those, we need to leave the
2664 breakpoint at PC inserted, as otherwise if the handler
2665 recurses and executes PC again, it'll miss the breakpoint.
2666 So we leave the breakpoint inserted anyway, but we need to
2667 record that we tried to step a breakpoint instruction, so
2668 that adjust_pc_after_break doesn't end up confused.
2670 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2671 in one thread after another thread that was stepping had been
2672 momentarily paused for a step-over. When we re-resume the
2673 stepping thread, it may be resumed from that address with a
2674 breakpoint that hasn't trapped yet. Seen with
2675 gdb.threads/non-stop-fair-events.exp, on targets that don't
2676 do displaced stepping. */
2679 fprintf_unfiltered (gdb_stdlog,
2680 "infrun: resume: [%s] stepped breakpoint\n",
2681 target_pid_to_str (tp->ptid));
2683 tp->stepped_breakpoint = 1;
2685 /* Most targets can step a breakpoint instruction, thus
2686 executing it normally. But if this one cannot, just
2687 continue and we will hit it anyway. */
2688 if (gdbarch_cannot_step_breakpoint (gdbarch))
2693 && tp->control.trap_expected
2694 && use_displaced_stepping (tp)
2695 && !step_over_info_valid_p ())
2697 struct regcache *resume_regcache = get_thread_regcache (tp);
2698 struct gdbarch *resume_gdbarch = resume_regcache->arch ();
2699 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2702 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2703 paddress (resume_gdbarch, actual_pc));
2704 read_memory (actual_pc, buf, sizeof (buf));
2705 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2708 if (tp->control.may_range_step)
2710 /* If we're resuming a thread with the PC out of the step
2711 range, then we're doing some nested/finer run control
2712 operation, like stepping the thread out of the dynamic
2713 linker or the displaced stepping scratch pad. We
2714 shouldn't have allowed a range step then. */
2715 gdb_assert (pc_in_thread_step_range (pc, tp));
2718 do_target_resume (resume_ptid, step, sig);
2722 /* Resume the inferior. SIG is the signal to give the inferior
2723 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2724 rolls back state on error. */
2727 resume (gdb_signal sig)
2733 CATCH (ex, RETURN_MASK_ALL)
2735 /* If resuming is being aborted for any reason, delete any
2736 single-step breakpoint resume_1 may have created, to avoid
2737 confusing the following resumption, and to avoid leaving
2738 single-step breakpoints perturbing other threads, in case
2739 we're running in non-stop mode. */
2740 if (inferior_ptid != null_ptid)
2741 delete_single_step_breakpoints (inferior_thread ());
2742 throw_exception (ex);
2752 /* Counter that tracks number of user visible stops. This can be used
2753 to tell whether a command has proceeded the inferior past the
2754 current location. This allows e.g., inferior function calls in
2755 breakpoint commands to not interrupt the command list. When the
2756 call finishes successfully, the inferior is standing at the same
2757 breakpoint as if nothing happened (and so we don't call
2759 static ULONGEST current_stop_id;
2766 return current_stop_id;
2769 /* Called when we report a user visible stop. */
2777 /* Clear out all variables saying what to do when inferior is continued.
2778 First do this, then set the ones you want, then call `proceed'. */
2781 clear_proceed_status_thread (struct thread_info *tp)
2784 fprintf_unfiltered (gdb_stdlog,
2785 "infrun: clear_proceed_status_thread (%s)\n",
2786 target_pid_to_str (tp->ptid));
2788 /* If we're starting a new sequence, then the previous finished
2789 single-step is no longer relevant. */
2790 if (tp->suspend.waitstatus_pending_p)
2792 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
2795 fprintf_unfiltered (gdb_stdlog,
2796 "infrun: clear_proceed_status: pending "
2797 "event of %s was a finished step. "
2799 target_pid_to_str (tp->ptid));
2801 tp->suspend.waitstatus_pending_p = 0;
2802 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
2804 else if (debug_infrun)
2807 = target_waitstatus_to_string (&tp->suspend.waitstatus);
2809 fprintf_unfiltered (gdb_stdlog,
2810 "infrun: clear_proceed_status_thread: thread %s "
2811 "has pending wait status %s "
2812 "(currently_stepping=%d).\n",
2813 target_pid_to_str (tp->ptid), statstr.c_str (),
2814 currently_stepping (tp));
2818 /* If this signal should not be seen by program, give it zero.
2819 Used for debugging signals. */
2820 if (!signal_pass_state (tp->suspend.stop_signal))
2821 tp->suspend.stop_signal = GDB_SIGNAL_0;
2823 thread_fsm_delete (tp->thread_fsm);
2824 tp->thread_fsm = NULL;
2826 tp->control.trap_expected = 0;
2827 tp->control.step_range_start = 0;
2828 tp->control.step_range_end = 0;
2829 tp->control.may_range_step = 0;
2830 tp->control.step_frame_id = null_frame_id;
2831 tp->control.step_stack_frame_id = null_frame_id;
2832 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
2833 tp->control.step_start_function = NULL;
2834 tp->stop_requested = 0;
2836 tp->control.stop_step = 0;
2838 tp->control.proceed_to_finish = 0;
2840 tp->control.stepping_command = 0;
2842 /* Discard any remaining commands or status from previous stop. */
2843 bpstat_clear (&tp->control.stop_bpstat);
2847 clear_proceed_status (int step)
2849 /* With scheduler-locking replay, stop replaying other threads if we're
2850 not replaying the user-visible resume ptid.
2852 This is a convenience feature to not require the user to explicitly
2853 stop replaying the other threads. We're assuming that the user's
2854 intent is to resume tracing the recorded process. */
2855 if (!non_stop && scheduler_mode == schedlock_replay
2856 && target_record_is_replaying (minus_one_ptid)
2857 && !target_record_will_replay (user_visible_resume_ptid (step),
2858 execution_direction))
2859 target_record_stop_replaying ();
2863 struct thread_info *tp;
2866 resume_ptid = user_visible_resume_ptid (step);
2868 /* In all-stop mode, delete the per-thread status of all threads
2869 we're about to resume, implicitly and explicitly. */
2870 ALL_NON_EXITED_THREADS (tp)
2872 if (!tp->ptid.matches (resume_ptid))
2874 clear_proceed_status_thread (tp);
2878 if (inferior_ptid != null_ptid)
2880 struct inferior *inferior;
2884 /* If in non-stop mode, only delete the per-thread status of
2885 the current thread. */
2886 clear_proceed_status_thread (inferior_thread ());
2889 inferior = current_inferior ();
2890 inferior->control.stop_soon = NO_STOP_QUIETLY;
2893 gdb::observers::about_to_proceed.notify ();
2896 /* Returns true if TP is still stopped at a breakpoint that needs
2897 stepping-over in order to make progress. If the breakpoint is gone
2898 meanwhile, we can skip the whole step-over dance. */
2901 thread_still_needs_step_over_bp (struct thread_info *tp)
2903 if (tp->stepping_over_breakpoint)
2905 struct regcache *regcache = get_thread_regcache (tp);
2907 if (breakpoint_here_p (regcache->aspace (),
2908 regcache_read_pc (regcache))
2909 == ordinary_breakpoint_here)
2912 tp->stepping_over_breakpoint = 0;
2918 /* Check whether thread TP still needs to start a step-over in order
2919 to make progress when resumed. Returns an bitwise or of enum
2920 step_over_what bits, indicating what needs to be stepped over. */
2922 static step_over_what
2923 thread_still_needs_step_over (struct thread_info *tp)
2925 step_over_what what = 0;
2927 if (thread_still_needs_step_over_bp (tp))
2928 what |= STEP_OVER_BREAKPOINT;
2930 if (tp->stepping_over_watchpoint
2931 && !target_have_steppable_watchpoint)
2932 what |= STEP_OVER_WATCHPOINT;
2937 /* Returns true if scheduler locking applies. STEP indicates whether
2938 we're about to do a step/next-like command to a thread. */
2941 schedlock_applies (struct thread_info *tp)
2943 return (scheduler_mode == schedlock_on
2944 || (scheduler_mode == schedlock_step
2945 && tp->control.stepping_command)
2946 || (scheduler_mode == schedlock_replay
2947 && target_record_will_replay (minus_one_ptid,
2948 execution_direction)));
2951 /* Basic routine for continuing the program in various fashions.
2953 ADDR is the address to resume at, or -1 for resume where stopped.
2954 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
2955 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
2957 You should call clear_proceed_status before calling proceed. */
2960 proceed (CORE_ADDR addr, enum gdb_signal siggnal)
2962 struct regcache *regcache;
2963 struct gdbarch *gdbarch;
2964 struct thread_info *tp;
2967 struct execution_control_state ecss;
2968 struct execution_control_state *ecs = &ecss;
2971 /* If we're stopped at a fork/vfork, follow the branch set by the
2972 "set follow-fork-mode" command; otherwise, we'll just proceed
2973 resuming the current thread. */
2974 if (!follow_fork ())
2976 /* The target for some reason decided not to resume. */
2978 if (target_can_async_p ())
2979 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2983 /* We'll update this if & when we switch to a new thread. */
2984 previous_inferior_ptid = inferior_ptid;
2986 regcache = get_current_regcache ();
2987 gdbarch = regcache->arch ();
2988 const address_space *aspace = regcache->aspace ();
2990 pc = regcache_read_pc (regcache);
2991 tp = inferior_thread ();
2993 /* Fill in with reasonable starting values. */
2994 init_thread_stepping_state (tp);
2996 gdb_assert (!thread_is_in_step_over_chain (tp));
2998 if (addr == (CORE_ADDR) -1)
3000 if (pc == tp->suspend.stop_pc
3001 && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
3002 && execution_direction != EXEC_REVERSE)
3003 /* There is a breakpoint at the address we will resume at,
3004 step one instruction before inserting breakpoints so that
3005 we do not stop right away (and report a second hit at this
3008 Note, we don't do this in reverse, because we won't
3009 actually be executing the breakpoint insn anyway.
3010 We'll be (un-)executing the previous instruction. */
3011 tp->stepping_over_breakpoint = 1;
3012 else if (gdbarch_single_step_through_delay_p (gdbarch)
3013 && gdbarch_single_step_through_delay (gdbarch,
3014 get_current_frame ()))
3015 /* We stepped onto an instruction that needs to be stepped
3016 again before re-inserting the breakpoint, do so. */
3017 tp->stepping_over_breakpoint = 1;
3021 regcache_write_pc (regcache, addr);
3024 if (siggnal != GDB_SIGNAL_DEFAULT)
3025 tp->suspend.stop_signal = siggnal;
3027 resume_ptid = user_visible_resume_ptid (tp->control.stepping_command);
3029 /* If an exception is thrown from this point on, make sure to
3030 propagate GDB's knowledge of the executing state to the
3031 frontend/user running state. */
3032 scoped_finish_thread_state finish_state (resume_ptid);
3034 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3035 threads (e.g., we might need to set threads stepping over
3036 breakpoints first), from the user/frontend's point of view, all
3037 threads in RESUME_PTID are now running. Unless we're calling an
3038 inferior function, as in that case we pretend the inferior
3039 doesn't run at all. */
3040 if (!tp->control.in_infcall)
3041 set_running (resume_ptid, 1);
3044 fprintf_unfiltered (gdb_stdlog,
3045 "infrun: proceed (addr=%s, signal=%s)\n",
3046 paddress (gdbarch, addr),
3047 gdb_signal_to_symbol_string (siggnal));
3049 annotate_starting ();
3051 /* Make sure that output from GDB appears before output from the
3053 gdb_flush (gdb_stdout);
3055 /* Since we've marked the inferior running, give it the terminal. A
3056 QUIT/Ctrl-C from here on is forwarded to the target (which can
3057 still detect attempts to unblock a stuck connection with repeated
3058 Ctrl-C from within target_pass_ctrlc). */
3059 target_terminal::inferior ();
3061 /* In a multi-threaded task we may select another thread and
3062 then continue or step.
3064 But if a thread that we're resuming had stopped at a breakpoint,
3065 it will immediately cause another breakpoint stop without any
3066 execution (i.e. it will report a breakpoint hit incorrectly). So
3067 we must step over it first.
3069 Look for threads other than the current (TP) that reported a
3070 breakpoint hit and haven't been resumed yet since. */
3072 /* If scheduler locking applies, we can avoid iterating over all
3074 if (!non_stop && !schedlock_applies (tp))
3076 struct thread_info *current = tp;
3078 ALL_NON_EXITED_THREADS (tp)
3080 /* Ignore the current thread here. It's handled
3085 /* Ignore threads of processes we're not resuming. */
3086 if (!tp->ptid.matches (resume_ptid))
3089 if (!thread_still_needs_step_over (tp))
3092 gdb_assert (!thread_is_in_step_over_chain (tp));
3095 fprintf_unfiltered (gdb_stdlog,
3096 "infrun: need to step-over [%s] first\n",
3097 target_pid_to_str (tp->ptid));
3099 thread_step_over_chain_enqueue (tp);
3105 /* Enqueue the current thread last, so that we move all other
3106 threads over their breakpoints first. */
3107 if (tp->stepping_over_breakpoint)
3108 thread_step_over_chain_enqueue (tp);
3110 /* If the thread isn't started, we'll still need to set its prev_pc,
3111 so that switch_back_to_stepped_thread knows the thread hasn't
3112 advanced. Must do this before resuming any thread, as in
3113 all-stop/remote, once we resume we can't send any other packet
3114 until the target stops again. */
3115 tp->prev_pc = regcache_read_pc (regcache);
3118 scoped_restore save_defer_tc = make_scoped_defer_target_commit_resume ();
3120 started = start_step_over ();
3122 if (step_over_info_valid_p ())
3124 /* Either this thread started a new in-line step over, or some
3125 other thread was already doing one. In either case, don't
3126 resume anything else until the step-over is finished. */
3128 else if (started && !target_is_non_stop_p ())
3130 /* A new displaced stepping sequence was started. In all-stop,
3131 we can't talk to the target anymore until it next stops. */
3133 else if (!non_stop && target_is_non_stop_p ())
3135 /* In all-stop, but the target is always in non-stop mode.
3136 Start all other threads that are implicitly resumed too. */
3137 ALL_NON_EXITED_THREADS (tp)
3139 /* Ignore threads of processes we're not resuming. */
3140 if (!tp->ptid.matches (resume_ptid))
3146 fprintf_unfiltered (gdb_stdlog,
3147 "infrun: proceed: [%s] resumed\n",
3148 target_pid_to_str (tp->ptid));
3149 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
3153 if (thread_is_in_step_over_chain (tp))
3156 fprintf_unfiltered (gdb_stdlog,
3157 "infrun: proceed: [%s] needs step-over\n",
3158 target_pid_to_str (tp->ptid));
3163 fprintf_unfiltered (gdb_stdlog,
3164 "infrun: proceed: resuming %s\n",
3165 target_pid_to_str (tp->ptid));
3167 reset_ecs (ecs, tp);
3168 switch_to_thread (tp);
3169 keep_going_pass_signal (ecs);
3170 if (!ecs->wait_some_more)
3171 error (_("Command aborted."));
3174 else if (!tp->resumed && !thread_is_in_step_over_chain (tp))
3176 /* The thread wasn't started, and isn't queued, run it now. */
3177 reset_ecs (ecs, tp);
3178 switch_to_thread (tp);
3179 keep_going_pass_signal (ecs);
3180 if (!ecs->wait_some_more)
3181 error (_("Command aborted."));
3185 target_commit_resume ();
3187 finish_state.release ();
3189 /* Tell the event loop to wait for it to stop. If the target
3190 supports asynchronous execution, it'll do this from within
3192 if (!target_can_async_p ())
3193 mark_async_event_handler (infrun_async_inferior_event_token);
3197 /* Start remote-debugging of a machine over a serial link. */
3200 start_remote (int from_tty)
3202 struct inferior *inferior;
3204 inferior = current_inferior ();
3205 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
3207 /* Always go on waiting for the target, regardless of the mode. */
3208 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3209 indicate to wait_for_inferior that a target should timeout if
3210 nothing is returned (instead of just blocking). Because of this,
3211 targets expecting an immediate response need to, internally, set
3212 things up so that the target_wait() is forced to eventually
3214 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3215 differentiate to its caller what the state of the target is after
3216 the initial open has been performed. Here we're assuming that
3217 the target has stopped. It should be possible to eventually have
3218 target_open() return to the caller an indication that the target
3219 is currently running and GDB state should be set to the same as
3220 for an async run. */
3221 wait_for_inferior ();
3223 /* Now that the inferior has stopped, do any bookkeeping like
3224 loading shared libraries. We want to do this before normal_stop,
3225 so that the displayed frame is up to date. */
3226 post_create_inferior (current_top_target (), from_tty);
3231 /* Initialize static vars when a new inferior begins. */
3234 init_wait_for_inferior (void)
3236 /* These are meaningless until the first time through wait_for_inferior. */
3238 breakpoint_init_inferior (inf_starting);
3240 clear_proceed_status (0);
3242 target_last_wait_ptid = minus_one_ptid;
3244 previous_inferior_ptid = inferior_ptid;
3246 /* Discard any skipped inlined frames. */
3247 clear_inline_frame_state (minus_one_ptid);
3252 static void handle_inferior_event (struct execution_control_state *ecs);
3254 static void handle_step_into_function (struct gdbarch *gdbarch,
3255 struct execution_control_state *ecs);
3256 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
3257 struct execution_control_state *ecs);
3258 static void handle_signal_stop (struct execution_control_state *ecs);
3259 static void check_exception_resume (struct execution_control_state *,
3260 struct frame_info *);
3262 static void end_stepping_range (struct execution_control_state *ecs);
3263 static void stop_waiting (struct execution_control_state *ecs);
3264 static void keep_going (struct execution_control_state *ecs);
3265 static void process_event_stop_test (struct execution_control_state *ecs);
3266 static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
3268 /* This function is attached as a "thread_stop_requested" observer.
3269 Cleanup local state that assumed the PTID was to be resumed, and
3270 report the stop to the frontend. */
3273 infrun_thread_stop_requested (ptid_t ptid)
3275 struct thread_info *tp;
3277 /* PTID was requested to stop. If the thread was already stopped,
3278 but the user/frontend doesn't know about that yet (e.g., the
3279 thread had been temporarily paused for some step-over), set up
3280 for reporting the stop now. */
3281 ALL_NON_EXITED_THREADS (tp)
3282 if (tp->ptid.matches (ptid))
3284 if (tp->state != THREAD_RUNNING)
3289 /* Remove matching threads from the step-over queue, so
3290 start_step_over doesn't try to resume them
3292 if (thread_is_in_step_over_chain (tp))
3293 thread_step_over_chain_remove (tp);
3295 /* If the thread is stopped, but the user/frontend doesn't
3296 know about that yet, queue a pending event, as if the
3297 thread had just stopped now. Unless the thread already had
3299 if (!tp->suspend.waitstatus_pending_p)
3301 tp->suspend.waitstatus_pending_p = 1;
3302 tp->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
3303 tp->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
3306 /* Clear the inline-frame state, since we're re-processing the
3308 clear_inline_frame_state (tp->ptid);
3310 /* If this thread was paused because some other thread was
3311 doing an inline-step over, let that finish first. Once
3312 that happens, we'll restart all threads and consume pending
3313 stop events then. */
3314 if (step_over_info_valid_p ())
3317 /* Otherwise we can process the (new) pending event now. Set
3318 it so this pending event is considered by
3325 infrun_thread_thread_exit (struct thread_info *tp, int silent)
3327 if (target_last_wait_ptid == tp->ptid)
3328 nullify_last_target_wait_ptid ();
3331 /* Delete the step resume, single-step and longjmp/exception resume
3332 breakpoints of TP. */
3335 delete_thread_infrun_breakpoints (struct thread_info *tp)
3337 delete_step_resume_breakpoint (tp);
3338 delete_exception_resume_breakpoint (tp);
3339 delete_single_step_breakpoints (tp);
3342 /* If the target still has execution, call FUNC for each thread that
3343 just stopped. In all-stop, that's all the non-exited threads; in
3344 non-stop, that's the current thread, only. */
3346 typedef void (*for_each_just_stopped_thread_callback_func)
3347 (struct thread_info *tp);
3350 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
3352 if (!target_has_execution || inferior_ptid == null_ptid)
3355 if (target_is_non_stop_p ())
3357 /* If in non-stop mode, only the current thread stopped. */
3358 func (inferior_thread ());
3362 struct thread_info *tp;
3364 /* In all-stop mode, all threads have stopped. */
3365 ALL_NON_EXITED_THREADS (tp)
3372 /* Delete the step resume and longjmp/exception resume breakpoints of
3373 the threads that just stopped. */
3376 delete_just_stopped_threads_infrun_breakpoints (void)
3378 for_each_just_stopped_thread (delete_thread_infrun_breakpoints);
3381 /* Delete the single-step breakpoints of the threads that just
3385 delete_just_stopped_threads_single_step_breakpoints (void)
3387 for_each_just_stopped_thread (delete_single_step_breakpoints);
3390 /* A cleanup wrapper. */
3393 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg)
3395 delete_just_stopped_threads_infrun_breakpoints ();
3401 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
3402 const struct target_waitstatus *ws)
3404 std::string status_string = target_waitstatus_to_string (ws);
3407 /* The text is split over several lines because it was getting too long.
3408 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3409 output as a unit; we want only one timestamp printed if debug_timestamp
3412 stb.printf ("infrun: target_wait (%d.%ld.%ld",
3415 waiton_ptid.tid ());
3416 if (waiton_ptid.pid () != -1)
3417 stb.printf (" [%s]", target_pid_to_str (waiton_ptid));
3418 stb.printf (", status) =\n");
3419 stb.printf ("infrun: %d.%ld.%ld [%s],\n",
3423 target_pid_to_str (result_ptid));
3424 stb.printf ("infrun: %s\n", status_string.c_str ());
3426 /* This uses %s in part to handle %'s in the text, but also to avoid
3427 a gcc error: the format attribute requires a string literal. */
3428 fprintf_unfiltered (gdb_stdlog, "%s", stb.c_str ());
3431 /* Select a thread at random, out of those which are resumed and have
3434 static struct thread_info *
3435 random_pending_event_thread (ptid_t waiton_ptid)
3437 struct thread_info *event_tp;
3439 int random_selector;
3441 /* First see how many events we have. Count only resumed threads
3442 that have an event pending. */
3443 ALL_NON_EXITED_THREADS (event_tp)
3444 if (event_tp->ptid.matches (waiton_ptid)
3445 && event_tp->resumed
3446 && event_tp->suspend.waitstatus_pending_p)
3449 if (num_events == 0)
3452 /* Now randomly pick a thread out of those that have had events. */
3453 random_selector = (int)
3454 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
3456 if (debug_infrun && num_events > 1)
3457 fprintf_unfiltered (gdb_stdlog,
3458 "infrun: Found %d events, selecting #%d\n",
3459 num_events, random_selector);
3461 /* Select the Nth thread that has had an event. */
3462 ALL_NON_EXITED_THREADS (event_tp)
3463 if (event_tp->ptid.matches (waiton_ptid)
3464 && event_tp->resumed
3465 && event_tp->suspend.waitstatus_pending_p)
3466 if (random_selector-- == 0)
3472 /* Wrapper for target_wait that first checks whether threads have
3473 pending statuses to report before actually asking the target for
3477 do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
3480 struct thread_info *tp;
3482 /* First check if there is a resumed thread with a wait status
3484 if (ptid == minus_one_ptid || ptid.is_pid ())
3486 tp = random_pending_event_thread (ptid);
3491 fprintf_unfiltered (gdb_stdlog,
3492 "infrun: Waiting for specific thread %s.\n",
3493 target_pid_to_str (ptid));
3495 /* We have a specific thread to check. */
3496 tp = find_thread_ptid (ptid);
3497 gdb_assert (tp != NULL);
3498 if (!tp->suspend.waitstatus_pending_p)
3503 && (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3504 || tp->suspend.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
3506 struct regcache *regcache = get_thread_regcache (tp);
3507 struct gdbarch *gdbarch = regcache->arch ();
3511 pc = regcache_read_pc (regcache);
3513 if (pc != tp->suspend.stop_pc)
3516 fprintf_unfiltered (gdb_stdlog,
3517 "infrun: PC of %s changed. was=%s, now=%s\n",
3518 target_pid_to_str (tp->ptid),
3519 paddress (gdbarch, tp->suspend.stop_pc),
3520 paddress (gdbarch, pc));
3523 else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
3526 fprintf_unfiltered (gdb_stdlog,
3527 "infrun: previous breakpoint of %s, at %s gone\n",
3528 target_pid_to_str (tp->ptid),
3529 paddress (gdbarch, pc));
3537 fprintf_unfiltered (gdb_stdlog,
3538 "infrun: pending event of %s cancelled.\n",
3539 target_pid_to_str (tp->ptid));
3541 tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
3542 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3551 = target_waitstatus_to_string (&tp->suspend.waitstatus);
3553 fprintf_unfiltered (gdb_stdlog,
3554 "infrun: Using pending wait status %s for %s.\n",
3556 target_pid_to_str (tp->ptid));
3559 /* Now that we've selected our final event LWP, un-adjust its PC
3560 if it was a software breakpoint (and the target doesn't
3561 always adjust the PC itself). */
3562 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3563 && !target_supports_stopped_by_sw_breakpoint ())
3565 struct regcache *regcache;
3566 struct gdbarch *gdbarch;
3569 regcache = get_thread_regcache (tp);
3570 gdbarch = regcache->arch ();
3572 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3577 pc = regcache_read_pc (regcache);
3578 regcache_write_pc (regcache, pc + decr_pc);
3582 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3583 *status = tp->suspend.waitstatus;
3584 tp->suspend.waitstatus_pending_p = 0;
3586 /* Wake up the event loop again, until all pending events are
3588 if (target_is_async_p ())
3589 mark_async_event_handler (infrun_async_inferior_event_token);
3593 /* But if we don't find one, we'll have to wait. */
3595 if (deprecated_target_wait_hook)
3596 event_ptid = deprecated_target_wait_hook (ptid, status, options);
3598 event_ptid = target_wait (ptid, status, options);
3603 /* Prepare and stabilize the inferior for detaching it. E.g.,
3604 detaching while a thread is displaced stepping is a recipe for
3605 crashing it, as nothing would readjust the PC out of the scratch
3609 prepare_for_detach (void)
3611 struct inferior *inf = current_inferior ();
3612 ptid_t pid_ptid = ptid_t (inf->pid);
3614 displaced_step_inferior_state *displaced = get_displaced_stepping_state (inf);
3616 /* Is any thread of this process displaced stepping? If not,
3617 there's nothing else to do. */
3618 if (displaced == NULL || displaced->step_thread == nullptr)
3622 fprintf_unfiltered (gdb_stdlog,
3623 "displaced-stepping in-process while detaching");
3625 scoped_restore restore_detaching = make_scoped_restore (&inf->detaching, true);
3627 while (displaced->step_thread != nullptr)
3629 struct execution_control_state ecss;
3630 struct execution_control_state *ecs;
3633 memset (ecs, 0, sizeof (*ecs));
3635 overlay_cache_invalid = 1;
3636 /* Flush target cache before starting to handle each event.
3637 Target was running and cache could be stale. This is just a
3638 heuristic. Running threads may modify target memory, but we
3639 don't get any event. */
3640 target_dcache_invalidate ();
3642 ecs->ptid = do_target_wait (pid_ptid, &ecs->ws, 0);
3645 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
3647 /* If an error happens while handling the event, propagate GDB's
3648 knowledge of the executing state to the frontend/user running
3650 scoped_finish_thread_state finish_state (minus_one_ptid);
3652 /* Now figure out what to do with the result of the result. */
3653 handle_inferior_event (ecs);
3655 /* No error, don't finish the state yet. */
3656 finish_state.release ();
3658 /* Breakpoints and watchpoints are not installed on the target
3659 at this point, and signals are passed directly to the
3660 inferior, so this must mean the process is gone. */
3661 if (!ecs->wait_some_more)
3663 restore_detaching.release ();
3664 error (_("Program exited while detaching"));
3668 restore_detaching.release ();
3671 /* Wait for control to return from inferior to debugger.
3673 If inferior gets a signal, we may decide to start it up again
3674 instead of returning. That is why there is a loop in this function.
3675 When this function actually returns it means the inferior
3676 should be left stopped and GDB should read more commands. */
3679 wait_for_inferior (void)
3681 struct cleanup *old_cleanups;
3685 (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3688 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup,
3691 /* If an error happens while handling the event, propagate GDB's
3692 knowledge of the executing state to the frontend/user running
3694 scoped_finish_thread_state finish_state (minus_one_ptid);
3698 struct execution_control_state ecss;
3699 struct execution_control_state *ecs = &ecss;
3700 ptid_t waiton_ptid = minus_one_ptid;
3702 memset (ecs, 0, sizeof (*ecs));
3704 overlay_cache_invalid = 1;
3706 /* Flush target cache before starting to handle each event.
3707 Target was running and cache could be stale. This is just a
3708 heuristic. Running threads may modify target memory, but we
3709 don't get any event. */
3710 target_dcache_invalidate ();
3712 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws, 0);
3715 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3717 /* Now figure out what to do with the result of the result. */
3718 handle_inferior_event (ecs);
3720 if (!ecs->wait_some_more)
3724 /* No error, don't finish the state yet. */
3725 finish_state.release ();
3727 do_cleanups (old_cleanups);
3730 /* Cleanup that reinstalls the readline callback handler, if the
3731 target is running in the background. If while handling the target
3732 event something triggered a secondary prompt, like e.g., a
3733 pagination prompt, we'll have removed the callback handler (see
3734 gdb_readline_wrapper_line). Need to do this as we go back to the
3735 event loop, ready to process further input. Note this has no
3736 effect if the handler hasn't actually been removed, because calling
3737 rl_callback_handler_install resets the line buffer, thus losing
3741 reinstall_readline_callback_handler_cleanup (void *arg)
3743 struct ui *ui = current_ui;
3747 /* We're not going back to the top level event loop yet. Don't
3748 install the readline callback, as it'd prep the terminal,
3749 readline-style (raw, noecho) (e.g., --batch). We'll install
3750 it the next time the prompt is displayed, when we're ready
3755 if (ui->command_editing && ui->prompt_state != PROMPT_BLOCKED)
3756 gdb_rl_callback_handler_reinstall ();
3759 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3760 that's just the event thread. In all-stop, that's all threads. */
3763 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
3765 struct thread_info *thr = ecs->event_thread;
3767 if (thr != NULL && thr->thread_fsm != NULL)
3768 thread_fsm_clean_up (thr->thread_fsm, thr);
3772 ALL_NON_EXITED_THREADS (thr)
3774 if (thr->thread_fsm == NULL)
3776 if (thr == ecs->event_thread)
3779 switch_to_thread (thr);
3780 thread_fsm_clean_up (thr->thread_fsm, thr);
3783 if (ecs->event_thread != NULL)
3784 switch_to_thread (ecs->event_thread);
3788 /* Helper for all_uis_check_sync_execution_done that works on the
3792 check_curr_ui_sync_execution_done (void)
3794 struct ui *ui = current_ui;
3796 if (ui->prompt_state == PROMPT_NEEDED
3798 && !gdb_in_secondary_prompt_p (ui))
3800 target_terminal::ours ();
3801 gdb::observers::sync_execution_done.notify ();
3802 ui_register_input_event_handler (ui);
3809 all_uis_check_sync_execution_done (void)
3811 SWITCH_THRU_ALL_UIS ()
3813 check_curr_ui_sync_execution_done ();
3820 all_uis_on_sync_execution_starting (void)
3822 SWITCH_THRU_ALL_UIS ()
3824 if (current_ui->prompt_state == PROMPT_NEEDED)
3825 async_disable_stdin ();
3829 /* Asynchronous version of wait_for_inferior. It is called by the
3830 event loop whenever a change of state is detected on the file
3831 descriptor corresponding to the target. It can be called more than
3832 once to complete a single execution command. In such cases we need
3833 to keep the state in a global variable ECSS. If it is the last time
3834 that this function is called for a single execution command, then
3835 report to the user that the inferior has stopped, and do the
3836 necessary cleanups. */
3839 fetch_inferior_event (void *client_data)
3841 struct execution_control_state ecss;
3842 struct execution_control_state *ecs = &ecss;
3843 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3845 ptid_t waiton_ptid = minus_one_ptid;
3847 memset (ecs, 0, sizeof (*ecs));
3849 /* Events are always processed with the main UI as current UI. This
3850 way, warnings, debug output, etc. are always consistently sent to
3851 the main console. */
3852 scoped_restore save_ui = make_scoped_restore (¤t_ui, main_ui);
3854 /* End up with readline processing input, if necessary. */
3855 make_cleanup (reinstall_readline_callback_handler_cleanup, NULL);
3857 /* We're handling a live event, so make sure we're doing live
3858 debugging. If we're looking at traceframes while the target is
3859 running, we're going to need to get back to that mode after
3860 handling the event. */
3861 gdb::optional<scoped_restore_current_traceframe> maybe_restore_traceframe;
3864 maybe_restore_traceframe.emplace ();
3865 set_current_traceframe (-1);
3868 gdb::optional<scoped_restore_current_thread> maybe_restore_thread;
3871 /* In non-stop mode, the user/frontend should not notice a thread
3872 switch due to internal events. Make sure we reverse to the
3873 user selected thread and frame after handling the event and
3874 running any breakpoint commands. */
3875 maybe_restore_thread.emplace ();
3877 overlay_cache_invalid = 1;
3878 /* Flush target cache before starting to handle each event. Target
3879 was running and cache could be stale. This is just a heuristic.
3880 Running threads may modify target memory, but we don't get any
3882 target_dcache_invalidate ();
3884 scoped_restore save_exec_dir
3885 = make_scoped_restore (&execution_direction, target_execution_direction ());
3887 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
3888 target_can_async_p () ? TARGET_WNOHANG : 0);
3891 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3893 /* If an error happens while handling the event, propagate GDB's
3894 knowledge of the executing state to the frontend/user running
3896 ptid_t finish_ptid = !target_is_non_stop_p () ? minus_one_ptid : ecs->ptid;
3897 scoped_finish_thread_state finish_state (finish_ptid);
3899 /* Get executed before make_cleanup_restore_current_thread above to apply
3900 still for the thread which has thrown the exception. */
3901 struct cleanup *ts_old_chain = make_bpstat_clear_actions_cleanup ();
3903 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
3905 /* Now figure out what to do with the result of the result. */
3906 handle_inferior_event (ecs);
3908 if (!ecs->wait_some_more)
3910 struct inferior *inf = find_inferior_ptid (ecs->ptid);
3911 int should_stop = 1;
3912 struct thread_info *thr = ecs->event_thread;
3914 delete_just_stopped_threads_infrun_breakpoints ();
3918 struct thread_fsm *thread_fsm = thr->thread_fsm;
3920 if (thread_fsm != NULL)
3921 should_stop = thread_fsm_should_stop (thread_fsm, thr);
3930 int should_notify_stop = 1;
3933 clean_up_just_stopped_threads_fsms (ecs);
3935 if (thr != NULL && thr->thread_fsm != NULL)
3938 = thread_fsm_should_notify_stop (thr->thread_fsm);
3941 if (should_notify_stop)
3943 /* We may not find an inferior if this was a process exit. */
3944 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3945 proceeded = normal_stop ();
3950 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3956 discard_cleanups (ts_old_chain);
3958 /* No error, don't finish the thread states yet. */
3959 finish_state.release ();
3961 /* Revert thread and frame. */
3962 do_cleanups (old_chain);
3964 /* If a UI was in sync execution mode, and now isn't, restore its
3965 prompt (a synchronous execution command has finished, and we're
3966 ready for input). */
3967 all_uis_check_sync_execution_done ();
3970 && exec_done_display_p
3971 && (inferior_ptid == null_ptid
3972 || inferior_thread ()->state != THREAD_RUNNING))
3973 printf_unfiltered (_("completed.\n"));
3976 /* Record the frame and location we're currently stepping through. */
3978 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3980 struct thread_info *tp = inferior_thread ();
3982 tp->control.step_frame_id = get_frame_id (frame);
3983 tp->control.step_stack_frame_id = get_stack_frame_id (frame);
3985 tp->current_symtab = sal.symtab;
3986 tp->current_line = sal.line;
3989 /* Clear context switchable stepping state. */
3992 init_thread_stepping_state (struct thread_info *tss)
3994 tss->stepped_breakpoint = 0;
3995 tss->stepping_over_breakpoint = 0;
3996 tss->stepping_over_watchpoint = 0;
3997 tss->step_after_step_resume_breakpoint = 0;
4000 /* Set the cached copy of the last ptid/waitstatus. */
4003 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
4005 target_last_wait_ptid = ptid;
4006 target_last_waitstatus = status;
4009 /* Return the cached copy of the last pid/waitstatus returned by
4010 target_wait()/deprecated_target_wait_hook(). The data is actually
4011 cached by handle_inferior_event(), which gets called immediately
4012 after target_wait()/deprecated_target_wait_hook(). */
4015 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
4017 *ptidp = target_last_wait_ptid;
4018 *status = target_last_waitstatus;
4022 nullify_last_target_wait_ptid (void)
4024 target_last_wait_ptid = minus_one_ptid;
4027 /* Switch thread contexts. */
4030 context_switch (execution_control_state *ecs)
4033 && ecs->ptid != inferior_ptid
4034 && ecs->event_thread != inferior_thread ())
4036 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
4037 target_pid_to_str (inferior_ptid));
4038 fprintf_unfiltered (gdb_stdlog, "to %s\n",
4039 target_pid_to_str (ecs->ptid));
4042 switch_to_thread (ecs->event_thread);
4045 /* If the target can't tell whether we've hit breakpoints
4046 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4047 check whether that could have been caused by a breakpoint. If so,
4048 adjust the PC, per gdbarch_decr_pc_after_break. */
4051 adjust_pc_after_break (struct thread_info *thread,
4052 struct target_waitstatus *ws)
4054 struct regcache *regcache;
4055 struct gdbarch *gdbarch;
4056 CORE_ADDR breakpoint_pc, decr_pc;
4058 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4059 we aren't, just return.
4061 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4062 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4063 implemented by software breakpoints should be handled through the normal
4066 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4067 different signals (SIGILL or SIGEMT for instance), but it is less
4068 clear where the PC is pointing afterwards. It may not match
4069 gdbarch_decr_pc_after_break. I don't know any specific target that
4070 generates these signals at breakpoints (the code has been in GDB since at
4071 least 1992) so I can not guess how to handle them here.
4073 In earlier versions of GDB, a target with
4074 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4075 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4076 target with both of these set in GDB history, and it seems unlikely to be
4077 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4079 if (ws->kind != TARGET_WAITKIND_STOPPED)
4082 if (ws->value.sig != GDB_SIGNAL_TRAP)
4085 /* In reverse execution, when a breakpoint is hit, the instruction
4086 under it has already been de-executed. The reported PC always
4087 points at the breakpoint address, so adjusting it further would
4088 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4091 B1 0x08000000 : INSN1
4092 B2 0x08000001 : INSN2
4094 PC -> 0x08000003 : INSN4
4096 Say you're stopped at 0x08000003 as above. Reverse continuing
4097 from that point should hit B2 as below. Reading the PC when the
4098 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4099 been de-executed already.
4101 B1 0x08000000 : INSN1
4102 B2 PC -> 0x08000001 : INSN2
4106 We can't apply the same logic as for forward execution, because
4107 we would wrongly adjust the PC to 0x08000000, since there's a
4108 breakpoint at PC - 1. We'd then report a hit on B1, although
4109 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4111 if (execution_direction == EXEC_REVERSE)
4114 /* If the target can tell whether the thread hit a SW breakpoint,
4115 trust it. Targets that can tell also adjust the PC
4117 if (target_supports_stopped_by_sw_breakpoint ())
4120 /* Note that relying on whether a breakpoint is planted in memory to
4121 determine this can fail. E.g,. the breakpoint could have been
4122 removed since. Or the thread could have been told to step an
4123 instruction the size of a breakpoint instruction, and only
4124 _after_ was a breakpoint inserted at its address. */
4126 /* If this target does not decrement the PC after breakpoints, then
4127 we have nothing to do. */
4128 regcache = get_thread_regcache (thread);
4129 gdbarch = regcache->arch ();
4131 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
4135 const address_space *aspace = regcache->aspace ();
4137 /* Find the location where (if we've hit a breakpoint) the
4138 breakpoint would be. */
4139 breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
4141 /* If the target can't tell whether a software breakpoint triggered,
4142 fallback to figuring it out based on breakpoints we think were
4143 inserted in the target, and on whether the thread was stepped or
4146 /* Check whether there actually is a software breakpoint inserted at
4149 If in non-stop mode, a race condition is possible where we've
4150 removed a breakpoint, but stop events for that breakpoint were
4151 already queued and arrive later. To suppress those spurious
4152 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4153 and retire them after a number of stop events are reported. Note
4154 this is an heuristic and can thus get confused. The real fix is
4155 to get the "stopped by SW BP and needs adjustment" info out of
4156 the target/kernel (and thus never reach here; see above). */
4157 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
4158 || (target_is_non_stop_p ()
4159 && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
4161 gdb::optional<scoped_restore_tmpl<int>> restore_operation_disable;
4163 if (record_full_is_used ())
4164 restore_operation_disable.emplace
4165 (record_full_gdb_operation_disable_set ());
4167 /* When using hardware single-step, a SIGTRAP is reported for both
4168 a completed single-step and a software breakpoint. Need to
4169 differentiate between the two, as the latter needs adjusting
4170 but the former does not.
4172 The SIGTRAP can be due to a completed hardware single-step only if
4173 - we didn't insert software single-step breakpoints
4174 - this thread is currently being stepped
4176 If any of these events did not occur, we must have stopped due
4177 to hitting a software breakpoint, and have to back up to the
4180 As a special case, we could have hardware single-stepped a
4181 software breakpoint. In this case (prev_pc == breakpoint_pc),
4182 we also need to back up to the breakpoint address. */
4184 if (thread_has_single_step_breakpoints_set (thread)
4185 || !currently_stepping (thread)
4186 || (thread->stepped_breakpoint
4187 && thread->prev_pc == breakpoint_pc))
4188 regcache_write_pc (regcache, breakpoint_pc);
4193 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
4195 for (frame = get_prev_frame (frame);
4197 frame = get_prev_frame (frame))
4199 if (frame_id_eq (get_frame_id (frame), step_frame_id))
4201 if (get_frame_type (frame) != INLINE_FRAME)
4208 /* If the event thread has the stop requested flag set, pretend it
4209 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4213 handle_stop_requested (struct execution_control_state *ecs)
4215 if (ecs->event_thread->stop_requested)
4217 ecs->ws.kind = TARGET_WAITKIND_STOPPED;
4218 ecs->ws.value.sig = GDB_SIGNAL_0;
4219 handle_signal_stop (ecs);
4225 /* Auxiliary function that handles syscall entry/return events.
4226 It returns 1 if the inferior should keep going (and GDB
4227 should ignore the event), or 0 if the event deserves to be
4231 handle_syscall_event (struct execution_control_state *ecs)
4233 struct regcache *regcache;
4236 context_switch (ecs);
4238 regcache = get_thread_regcache (ecs->event_thread);
4239 syscall_number = ecs->ws.value.syscall_number;
4240 ecs->event_thread->suspend.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 (regcache->aspace (),
4251 ecs->event_thread->suspend.stop_pc,
4252 ecs->event_thread, &ecs->ws);
4254 if (handle_stop_requested (ecs))
4257 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4259 /* Catchpoint hit. */
4264 if (handle_stop_requested (ecs))
4267 /* If no catchpoint triggered for this, then keep going. */
4272 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4275 fill_in_stop_func (struct gdbarch *gdbarch,
4276 struct execution_control_state *ecs)
4278 if (!ecs->stop_func_filled_in)
4280 /* Don't care about return value; stop_func_start and stop_func_name
4281 will both be 0 if it doesn't work. */
4282 find_function_entry_range_from_pc (ecs->event_thread->suspend.stop_pc,
4283 &ecs->stop_func_name,
4284 &ecs->stop_func_start,
4285 &ecs->stop_func_end);
4286 ecs->stop_func_start
4287 += gdbarch_deprecated_function_start_offset (gdbarch);
4289 if (gdbarch_skip_entrypoint_p (gdbarch))
4290 ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
4291 ecs->stop_func_start);
4293 ecs->stop_func_filled_in = 1;
4298 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
4300 static enum stop_kind
4301 get_inferior_stop_soon (execution_control_state *ecs)
4303 struct inferior *inf = find_inferior_ptid (ecs->ptid);
4305 gdb_assert (inf != NULL);
4306 return inf->control.stop_soon;
4309 /* Wait for one event. Store the resulting waitstatus in WS, and
4310 return the event ptid. */
4313 wait_one (struct target_waitstatus *ws)
4316 ptid_t wait_ptid = minus_one_ptid;
4318 overlay_cache_invalid = 1;
4320 /* Flush target cache before starting to handle each event.
4321 Target was running and cache could be stale. This is just a
4322 heuristic. Running threads may modify target memory, but we
4323 don't get any event. */
4324 target_dcache_invalidate ();
4326 if (deprecated_target_wait_hook)
4327 event_ptid = deprecated_target_wait_hook (wait_ptid, ws, 0);
4329 event_ptid = target_wait (wait_ptid, ws, 0);
4332 print_target_wait_results (wait_ptid, event_ptid, ws);
4337 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4338 instead of the current thread. */
4339 #define THREAD_STOPPED_BY(REASON) \
4341 thread_stopped_by_ ## REASON (ptid_t ptid) \
4343 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); \
4344 inferior_ptid = ptid; \
4346 return target_stopped_by_ ## REASON (); \
4349 /* Generate thread_stopped_by_watchpoint. */
4350 THREAD_STOPPED_BY (watchpoint)
4351 /* Generate thread_stopped_by_sw_breakpoint. */
4352 THREAD_STOPPED_BY (sw_breakpoint)
4353 /* Generate thread_stopped_by_hw_breakpoint. */
4354 THREAD_STOPPED_BY (hw_breakpoint)
4356 /* Save the thread's event and stop reason to process it later. */
4359 save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws)
4363 std::string statstr = target_waitstatus_to_string (ws);
4365 fprintf_unfiltered (gdb_stdlog,
4366 "infrun: saving status %s for %d.%ld.%ld\n",
4373 /* Record for later. */
4374 tp->suspend.waitstatus = *ws;
4375 tp->suspend.waitstatus_pending_p = 1;
4377 struct regcache *regcache = get_thread_regcache (tp);
4378 const address_space *aspace = regcache->aspace ();
4380 if (ws->kind == TARGET_WAITKIND_STOPPED
4381 && ws->value.sig == GDB_SIGNAL_TRAP)
4383 CORE_ADDR pc = regcache_read_pc (regcache);
4385 adjust_pc_after_break (tp, &tp->suspend.waitstatus);
4387 if (thread_stopped_by_watchpoint (tp->ptid))
4389 tp->suspend.stop_reason
4390 = TARGET_STOPPED_BY_WATCHPOINT;
4392 else if (target_supports_stopped_by_sw_breakpoint ()
4393 && thread_stopped_by_sw_breakpoint (tp->ptid))
4395 tp->suspend.stop_reason
4396 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4398 else if (target_supports_stopped_by_hw_breakpoint ()
4399 && thread_stopped_by_hw_breakpoint (tp->ptid))
4401 tp->suspend.stop_reason
4402 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4404 else if (!target_supports_stopped_by_hw_breakpoint ()
4405 && hardware_breakpoint_inserted_here_p (aspace,
4408 tp->suspend.stop_reason
4409 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4411 else if (!target_supports_stopped_by_sw_breakpoint ()
4412 && software_breakpoint_inserted_here_p (aspace,
4415 tp->suspend.stop_reason
4416 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4418 else if (!thread_has_single_step_breakpoints_set (tp)
4419 && currently_stepping (tp))
4421 tp->suspend.stop_reason
4422 = TARGET_STOPPED_BY_SINGLE_STEP;
4427 /* A cleanup that disables thread create/exit events. */
4430 disable_thread_events (void *arg)
4432 target_thread_events (0);
4438 stop_all_threads (void)
4440 /* We may need multiple passes to discover all threads. */
4443 struct cleanup *old_chain;
4445 gdb_assert (target_is_non_stop_p ());
4448 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
4450 scoped_restore_current_thread restore_thread;
4452 target_thread_events (1);
4453 old_chain = make_cleanup (disable_thread_events, NULL);
4455 /* Request threads to stop, and then wait for the stops. Because
4456 threads we already know about can spawn more threads while we're
4457 trying to stop them, and we only learn about new threads when we
4458 update the thread list, do this in a loop, and keep iterating
4459 until two passes find no threads that need to be stopped. */
4460 for (pass = 0; pass < 2; pass++, iterations++)
4463 fprintf_unfiltered (gdb_stdlog,
4464 "infrun: stop_all_threads, pass=%d, "
4465 "iterations=%d\n", pass, iterations);
4469 struct target_waitstatus ws;
4471 struct thread_info *t;
4473 update_thread_list ();
4475 /* Go through all threads looking for threads that we need
4476 to tell the target to stop. */
4477 ALL_NON_EXITED_THREADS (t)
4481 /* If already stopping, don't request a stop again.
4482 We just haven't seen the notification yet. */
4483 if (!t->stop_requested)
4486 fprintf_unfiltered (gdb_stdlog,
4487 "infrun: %s executing, "
4489 target_pid_to_str (t->ptid));
4490 target_stop (t->ptid);
4491 t->stop_requested = 1;
4496 fprintf_unfiltered (gdb_stdlog,
4497 "infrun: %s executing, "
4498 "already stopping\n",
4499 target_pid_to_str (t->ptid));
4502 if (t->stop_requested)
4508 fprintf_unfiltered (gdb_stdlog,
4509 "infrun: %s not executing\n",
4510 target_pid_to_str (t->ptid));
4512 /* The thread may be not executing, but still be
4513 resumed with a pending status to process. */
4521 /* If we find new threads on the second iteration, restart
4522 over. We want to see two iterations in a row with all
4527 event_ptid = wait_one (&ws);
4529 if (ws.kind == TARGET_WAITKIND_NO_RESUMED)
4531 /* All resumed threads exited. */
4533 else if (ws.kind == TARGET_WAITKIND_THREAD_EXITED
4534 || ws.kind == TARGET_WAITKIND_EXITED
4535 || ws.kind == TARGET_WAITKIND_SIGNALLED)
4539 ptid_t ptid = ptid_t (ws.value.integer);
4541 fprintf_unfiltered (gdb_stdlog,
4542 "infrun: %s exited while "
4543 "stopping threads\n",
4544 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 /* This may be the first time we see the inferior report
4562 inf = find_inferior_ptid (event_ptid);
4563 if (inf->needs_setup)
4565 switch_to_thread_no_regs (t);
4569 if (ws.kind == TARGET_WAITKIND_STOPPED
4570 && ws.value.sig == GDB_SIGNAL_0)
4572 /* We caught the event that we intended to catch, so
4573 there's no event pending. */
4574 t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
4575 t->suspend.waitstatus_pending_p = 0;
4577 if (displaced_step_fixup (t, GDB_SIGNAL_0) < 0)
4579 /* Add it back to the step-over queue. */
4582 fprintf_unfiltered (gdb_stdlog,
4583 "infrun: displaced-step of %s "
4584 "canceled: adding back to the "
4585 "step-over queue\n",
4586 target_pid_to_str (t->ptid));
4588 t->control.trap_expected = 0;
4589 thread_step_over_chain_enqueue (t);
4594 enum gdb_signal sig;
4595 struct regcache *regcache;
4599 std::string statstr = target_waitstatus_to_string (&ws);
4601 fprintf_unfiltered (gdb_stdlog,
4602 "infrun: target_wait %s, saving "
4603 "status for %d.%ld.%ld\n",
4610 /* Record for later. */
4611 save_waitstatus (t, &ws);
4613 sig = (ws.kind == TARGET_WAITKIND_STOPPED
4614 ? ws.value.sig : GDB_SIGNAL_0);
4616 if (displaced_step_fixup (t, sig) < 0)
4618 /* Add it back to the step-over queue. */
4619 t->control.trap_expected = 0;
4620 thread_step_over_chain_enqueue (t);
4623 regcache = get_thread_regcache (t);
4624 t->suspend.stop_pc = regcache_read_pc (regcache);
4628 fprintf_unfiltered (gdb_stdlog,
4629 "infrun: saved stop_pc=%s for %s "
4630 "(currently_stepping=%d)\n",
4631 paddress (target_gdbarch (),
4632 t->suspend.stop_pc),
4633 target_pid_to_str (t->ptid),
4634 currently_stepping (t));
4641 do_cleanups (old_chain);
4644 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
4647 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
4650 handle_no_resumed (struct execution_control_state *ecs)
4652 struct inferior *inf;
4653 struct thread_info *thread;
4655 if (target_can_async_p ())
4662 if (ui->prompt_state == PROMPT_BLOCKED)
4670 /* There were no unwaited-for children left in the target, but,
4671 we're not synchronously waiting for events either. Just
4675 fprintf_unfiltered (gdb_stdlog,
4676 "infrun: TARGET_WAITKIND_NO_RESUMED "
4677 "(ignoring: bg)\n");
4678 prepare_to_wait (ecs);
4683 /* Otherwise, if we were running a synchronous execution command, we
4684 may need to cancel it and give the user back the terminal.
4686 In non-stop mode, the target can't tell whether we've already
4687 consumed previous stop events, so it can end up sending us a
4688 no-resumed event like so:
4690 #0 - thread 1 is left stopped
4692 #1 - thread 2 is resumed and hits breakpoint
4693 -> TARGET_WAITKIND_STOPPED
4695 #2 - thread 3 is resumed and exits
4696 this is the last resumed thread, so
4697 -> TARGET_WAITKIND_NO_RESUMED
4699 #3 - gdb processes stop for thread 2 and decides to re-resume
4702 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
4703 thread 2 is now resumed, so the event should be ignored.
4705 IOW, if the stop for thread 2 doesn't end a foreground command,
4706 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
4707 event. But it could be that the event meant that thread 2 itself
4708 (or whatever other thread was the last resumed thread) exited.
4710 To address this we refresh the thread list and check whether we
4711 have resumed threads _now_. In the example above, this removes
4712 thread 3 from the thread list. If thread 2 was re-resumed, we
4713 ignore this event. If we find no thread resumed, then we cancel
4714 the synchronous command show "no unwaited-for " to the user. */
4715 update_thread_list ();
4717 ALL_NON_EXITED_THREADS (thread)
4719 if (thread->executing
4720 || thread->suspend.waitstatus_pending_p)
4722 /* There were no unwaited-for children left in the target at
4723 some point, but there are now. Just ignore. */
4725 fprintf_unfiltered (gdb_stdlog,
4726 "infrun: TARGET_WAITKIND_NO_RESUMED "
4727 "(ignoring: found resumed)\n");
4728 prepare_to_wait (ecs);
4733 /* Note however that we may find no resumed thread because the whole
4734 process exited meanwhile (thus updating the thread list results
4735 in an empty thread list). In this case we know we'll be getting
4736 a process exit event shortly. */
4742 thread = any_live_thread_of_inferior (inf);
4746 fprintf_unfiltered (gdb_stdlog,
4747 "infrun: TARGET_WAITKIND_NO_RESUMED "
4748 "(expect process exit)\n");
4749 prepare_to_wait (ecs);
4754 /* Go ahead and report the event. */
4758 /* Given an execution control state that has been freshly filled in by
4759 an event from the inferior, figure out what it means and take
4762 The alternatives are:
4764 1) stop_waiting and return; to really stop and return to the
4767 2) keep_going and return; to wait for the next event (set
4768 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4772 handle_inferior_event_1 (struct execution_control_state *ecs)
4774 enum stop_kind stop_soon;
4776 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
4778 /* We had an event in the inferior, but we are not interested in
4779 handling it at this level. The lower layers have already
4780 done what needs to be done, if anything.
4782 One of the possible circumstances for this is when the
4783 inferior produces output for the console. The inferior has
4784 not stopped, and we are ignoring the event. Another possible
4785 circumstance is any event which the lower level knows will be
4786 reported multiple times without an intervening resume. */
4788 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
4789 prepare_to_wait (ecs);
4793 if (ecs->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
4796 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_EXITED\n");
4797 prepare_to_wait (ecs);
4801 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
4802 && handle_no_resumed (ecs))
4805 /* Cache the last pid/waitstatus. */
4806 set_last_target_status (ecs->ptid, ecs->ws);
4808 /* Always clear state belonging to the previous time we stopped. */
4809 stop_stack_dummy = STOP_NONE;
4811 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
4813 /* No unwaited-for children left. IOW, all resumed children
4816 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4818 stop_print_frame = 0;
4823 if (ecs->ws.kind != TARGET_WAITKIND_EXITED
4824 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
4826 ecs->event_thread = find_thread_ptid (ecs->ptid);
4827 /* If it's a new thread, add it to the thread database. */
4828 if (ecs->event_thread == NULL)
4829 ecs->event_thread = add_thread (ecs->ptid);
4831 /* Disable range stepping. If the next step request could use a
4832 range, this will be end up re-enabled then. */
4833 ecs->event_thread->control.may_range_step = 0;
4836 /* Dependent on valid ECS->EVENT_THREAD. */
4837 adjust_pc_after_break (ecs->event_thread, &ecs->ws);
4839 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4840 reinit_frame_cache ();
4842 breakpoint_retire_moribund ();
4844 /* First, distinguish signals caused by the debugger from signals
4845 that have to do with the program's own actions. Note that
4846 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4847 on the operating system version. Here we detect when a SIGILL or
4848 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4849 something similar for SIGSEGV, since a SIGSEGV will be generated
4850 when we're trying to execute a breakpoint instruction on a
4851 non-executable stack. This happens for call dummy breakpoints
4852 for architectures like SPARC that place call dummies on the
4854 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
4855 && (ecs->ws.value.sig == GDB_SIGNAL_ILL
4856 || ecs->ws.value.sig == GDB_SIGNAL_SEGV
4857 || ecs->ws.value.sig == GDB_SIGNAL_EMT))
4859 struct regcache *regcache = get_thread_regcache (ecs->event_thread);
4861 if (breakpoint_inserted_here_p (regcache->aspace (),
4862 regcache_read_pc (regcache)))
4865 fprintf_unfiltered (gdb_stdlog,
4866 "infrun: Treating signal as SIGTRAP\n");
4867 ecs->ws.value.sig = GDB_SIGNAL_TRAP;
4871 /* Mark the non-executing threads accordingly. In all-stop, all
4872 threads of all processes are stopped when we get any event
4873 reported. In non-stop mode, only the event thread stops. */
4877 if (!target_is_non_stop_p ())
4878 mark_ptid = minus_one_ptid;
4879 else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
4880 || ecs->ws.kind == TARGET_WAITKIND_EXITED)
4882 /* If we're handling a process exit in non-stop mode, even
4883 though threads haven't been deleted yet, one would think
4884 that there is nothing to do, as threads of the dead process
4885 will be soon deleted, and threads of any other process were
4886 left running. However, on some targets, threads survive a
4887 process exit event. E.g., for the "checkpoint" command,
4888 when the current checkpoint/fork exits, linux-fork.c
4889 automatically switches to another fork from within
4890 target_mourn_inferior, by associating the same
4891 inferior/thread to another fork. We haven't mourned yet at
4892 this point, but we must mark any threads left in the
4893 process as not-executing so that finish_thread_state marks
4894 them stopped (in the user's perspective) if/when we present
4895 the stop to the user. */
4896 mark_ptid = ptid_t (ecs->ptid.pid ());
4899 mark_ptid = ecs->ptid;
4901 set_executing (mark_ptid, 0);
4903 /* Likewise the resumed flag. */
4904 set_resumed (mark_ptid, 0);
4907 switch (ecs->ws.kind)
4909 case TARGET_WAITKIND_LOADED:
4911 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
4912 context_switch (ecs);
4913 /* Ignore gracefully during startup of the inferior, as it might
4914 be the shell which has just loaded some objects, otherwise
4915 add the symbols for the newly loaded objects. Also ignore at
4916 the beginning of an attach or remote session; we will query
4917 the full list of libraries once the connection is
4920 stop_soon = get_inferior_stop_soon (ecs);
4921 if (stop_soon == NO_STOP_QUIETLY)
4923 struct regcache *regcache;
4925 regcache = get_thread_regcache (ecs->event_thread);
4927 handle_solib_event ();
4929 ecs->event_thread->control.stop_bpstat
4930 = bpstat_stop_status (regcache->aspace (),
4931 ecs->event_thread->suspend.stop_pc,
4932 ecs->event_thread, &ecs->ws);
4934 if (handle_stop_requested (ecs))
4937 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4939 /* A catchpoint triggered. */
4940 process_event_stop_test (ecs);
4944 /* If requested, stop when the dynamic linker notifies
4945 gdb of events. This allows the user to get control
4946 and place breakpoints in initializer routines for
4947 dynamically loaded objects (among other things). */
4948 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4949 if (stop_on_solib_events)
4951 /* Make sure we print "Stopped due to solib-event" in
4953 stop_print_frame = 1;
4960 /* If we are skipping through a shell, or through shared library
4961 loading that we aren't interested in, resume the program. If
4962 we're running the program normally, also resume. */
4963 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
4965 /* Loading of shared libraries might have changed breakpoint
4966 addresses. Make sure new breakpoints are inserted. */
4967 if (stop_soon == NO_STOP_QUIETLY)
4968 insert_breakpoints ();
4969 resume (GDB_SIGNAL_0);
4970 prepare_to_wait (ecs);
4974 /* But stop if we're attaching or setting up a remote
4976 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
4977 || stop_soon == STOP_QUIETLY_REMOTE)
4980 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
4985 internal_error (__FILE__, __LINE__,
4986 _("unhandled stop_soon: %d"), (int) stop_soon);
4988 case TARGET_WAITKIND_SPURIOUS:
4990 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
4991 if (handle_stop_requested (ecs))
4993 context_switch (ecs);
4994 resume (GDB_SIGNAL_0);
4995 prepare_to_wait (ecs);
4998 case TARGET_WAITKIND_THREAD_CREATED:
5000 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_CREATED\n");
5001 if (handle_stop_requested (ecs))
5003 context_switch (ecs);
5004 if (!switch_back_to_stepped_thread (ecs))
5008 case TARGET_WAITKIND_EXITED:
5009 case TARGET_WAITKIND_SIGNALLED:
5012 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
5013 fprintf_unfiltered (gdb_stdlog,
5014 "infrun: TARGET_WAITKIND_EXITED\n");
5016 fprintf_unfiltered (gdb_stdlog,
5017 "infrun: TARGET_WAITKIND_SIGNALLED\n");
5020 inferior_ptid = ecs->ptid;
5021 set_current_inferior (find_inferior_ptid (ecs->ptid));
5022 set_current_program_space (current_inferior ()->pspace);
5023 handle_vfork_child_exec_or_exit (0);
5024 target_terminal::ours (); /* Must do this before mourn anyway. */
5026 /* Clearing any previous state of convenience variables. */
5027 clear_exit_convenience_vars ();
5029 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
5031 /* Record the exit code in the convenience variable $_exitcode, so
5032 that the user can inspect this again later. */
5033 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5034 (LONGEST) ecs->ws.value.integer);
5036 /* Also record this in the inferior itself. */
5037 current_inferior ()->has_exit_code = 1;
5038 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
5040 /* Support the --return-child-result option. */
5041 return_child_result_value = ecs->ws.value.integer;
5043 gdb::observers::exited.notify (ecs->ws.value.integer);
5047 struct gdbarch *gdbarch = current_inferior ()->gdbarch;
5049 if (gdbarch_gdb_signal_to_target_p (gdbarch))
5051 /* Set the value of the internal variable $_exitsignal,
5052 which holds the signal uncaught by the inferior. */
5053 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5054 gdbarch_gdb_signal_to_target (gdbarch,
5055 ecs->ws.value.sig));
5059 /* We don't have access to the target's method used for
5060 converting between signal numbers (GDB's internal
5061 representation <-> target's representation).
5062 Therefore, we cannot do a good job at displaying this
5063 information to the user. It's better to just warn
5064 her about it (if infrun debugging is enabled), and
5067 fprintf_filtered (gdb_stdlog, _("\
5068 Cannot fill $_exitsignal with the correct signal number.\n"));
5071 gdb::observers::signal_exited.notify (ecs->ws.value.sig);
5074 gdb_flush (gdb_stdout);
5075 target_mourn_inferior (inferior_ptid);
5076 stop_print_frame = 0;
5080 /* The following are the only cases in which we keep going;
5081 the above cases end in a continue or goto. */
5082 case TARGET_WAITKIND_FORKED:
5083 case TARGET_WAITKIND_VFORKED:
5086 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
5087 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
5089 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
5092 /* Check whether the inferior is displaced stepping. */
5094 struct regcache *regcache = get_thread_regcache (ecs->event_thread);
5095 struct gdbarch *gdbarch = regcache->arch ();
5097 /* If checking displaced stepping is supported, and thread
5098 ecs->ptid is displaced stepping. */
5099 if (displaced_step_in_progress_thread (ecs->event_thread))
5101 struct inferior *parent_inf
5102 = find_inferior_ptid (ecs->ptid);
5103 struct regcache *child_regcache;
5104 CORE_ADDR parent_pc;
5106 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5107 indicating that the displaced stepping of syscall instruction
5108 has been done. Perform cleanup for parent process here. Note
5109 that this operation also cleans up the child process for vfork,
5110 because their pages are shared. */
5111 displaced_step_fixup (ecs->event_thread, GDB_SIGNAL_TRAP);
5112 /* Start a new step-over in another thread if there's one
5116 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
5118 struct displaced_step_inferior_state *displaced
5119 = get_displaced_stepping_state (parent_inf);
5121 /* Restore scratch pad for child process. */
5122 displaced_step_restore (displaced, ecs->ws.value.related_pid);
5125 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5126 the child's PC is also within the scratchpad. Set the child's PC
5127 to the parent's PC value, which has already been fixed up.
5128 FIXME: we use the parent's aspace here, although we're touching
5129 the child, because the child hasn't been added to the inferior
5130 list yet at this point. */
5133 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
5135 parent_inf->aspace);
5136 /* Read PC value of parent process. */
5137 parent_pc = regcache_read_pc (regcache);
5139 if (debug_displaced)
5140 fprintf_unfiltered (gdb_stdlog,
5141 "displaced: write child pc from %s to %s\n",
5143 regcache_read_pc (child_regcache)),
5144 paddress (gdbarch, parent_pc));
5146 regcache_write_pc (child_regcache, parent_pc);
5150 context_switch (ecs);
5152 /* Immediately detach breakpoints from the child before there's
5153 any chance of letting the user delete breakpoints from the
5154 breakpoint lists. If we don't do this early, it's easy to
5155 leave left over traps in the child, vis: "break foo; catch
5156 fork; c; <fork>; del; c; <child calls foo>". We only follow
5157 the fork on the last `continue', and by that time the
5158 breakpoint at "foo" is long gone from the breakpoint table.
5159 If we vforked, then we don't need to unpatch here, since both
5160 parent and child are sharing the same memory pages; we'll
5161 need to unpatch at follow/detach time instead to be certain
5162 that new breakpoints added between catchpoint hit time and
5163 vfork follow are detached. */
5164 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
5166 /* This won't actually modify the breakpoint list, but will
5167 physically remove the breakpoints from the child. */
5168 detach_breakpoints (ecs->ws.value.related_pid);
5171 delete_just_stopped_threads_single_step_breakpoints ();
5173 /* In case the event is caught by a catchpoint, remember that
5174 the event is to be followed at the next resume of the thread,
5175 and not immediately. */
5176 ecs->event_thread->pending_follow = ecs->ws;
5178 ecs->event_thread->suspend.stop_pc
5179 = regcache_read_pc (get_thread_regcache (ecs->event_thread));
5181 ecs->event_thread->control.stop_bpstat
5182 = bpstat_stop_status (get_current_regcache ()->aspace (),
5183 ecs->event_thread->suspend.stop_pc,
5184 ecs->event_thread, &ecs->ws);
5186 if (handle_stop_requested (ecs))
5189 /* If no catchpoint triggered for this, then keep going. Note
5190 that we're interested in knowing the bpstat actually causes a
5191 stop, not just if it may explain the signal. Software
5192 watchpoints, for example, always appear in the bpstat. */
5193 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5197 = (follow_fork_mode_string == follow_fork_mode_child);
5199 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5201 should_resume = follow_fork ();
5203 thread_info *parent = ecs->event_thread;
5204 thread_info *child = find_thread_ptid (ecs->ws.value.related_pid);
5206 /* At this point, the parent is marked running, and the
5207 child is marked stopped. */
5209 /* If not resuming the parent, mark it stopped. */
5210 if (follow_child && !detach_fork && !non_stop && !sched_multi)
5211 parent->set_running (false);
5213 /* If resuming the child, mark it running. */
5214 if (follow_child || (!detach_fork && (non_stop || sched_multi)))
5215 child->set_running (true);
5217 /* In non-stop mode, also resume the other branch. */
5218 if (!detach_fork && (non_stop
5219 || (sched_multi && target_is_non_stop_p ())))
5222 switch_to_thread (parent);
5224 switch_to_thread (child);
5226 ecs->event_thread = inferior_thread ();
5227 ecs->ptid = inferior_ptid;
5232 switch_to_thread (child);
5234 switch_to_thread (parent);
5236 ecs->event_thread = inferior_thread ();
5237 ecs->ptid = inferior_ptid;
5245 process_event_stop_test (ecs);
5248 case TARGET_WAITKIND_VFORK_DONE:
5249 /* Done with the shared memory region. Re-insert breakpoints in
5250 the parent, and keep going. */
5253 fprintf_unfiltered (gdb_stdlog,
5254 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
5256 context_switch (ecs);
5258 current_inferior ()->waiting_for_vfork_done = 0;
5259 current_inferior ()->pspace->breakpoints_not_allowed = 0;
5261 if (handle_stop_requested (ecs))
5264 /* This also takes care of reinserting breakpoints in the
5265 previously locked inferior. */
5269 case TARGET_WAITKIND_EXECD:
5271 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
5273 /* Note we can't read registers yet (the stop_pc), because we
5274 don't yet know the inferior's post-exec architecture.
5275 'stop_pc' is explicitly read below instead. */
5276 switch_to_thread_no_regs (ecs->event_thread);
5278 /* Do whatever is necessary to the parent branch of the vfork. */
5279 handle_vfork_child_exec_or_exit (1);
5281 /* This causes the eventpoints and symbol table to be reset.
5282 Must do this now, before trying to determine whether to
5284 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
5286 /* In follow_exec we may have deleted the original thread and
5287 created a new one. Make sure that the event thread is the
5288 execd thread for that case (this is a nop otherwise). */
5289 ecs->event_thread = inferior_thread ();
5291 ecs->event_thread->suspend.stop_pc
5292 = regcache_read_pc (get_thread_regcache (ecs->event_thread));
5294 ecs->event_thread->control.stop_bpstat
5295 = bpstat_stop_status (get_current_regcache ()->aspace (),
5296 ecs->event_thread->suspend.stop_pc,
5297 ecs->event_thread, &ecs->ws);
5299 /* Note that this may be referenced from inside
5300 bpstat_stop_status above, through inferior_has_execd. */
5301 xfree (ecs->ws.value.execd_pathname);
5302 ecs->ws.value.execd_pathname = NULL;
5304 if (handle_stop_requested (ecs))
5307 /* If no catchpoint triggered for this, then keep going. */
5308 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5310 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5314 process_event_stop_test (ecs);
5317 /* Be careful not to try to gather much state about a thread
5318 that's in a syscall. It's frequently a losing proposition. */
5319 case TARGET_WAITKIND_SYSCALL_ENTRY:
5321 fprintf_unfiltered (gdb_stdlog,
5322 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
5323 /* Getting the current syscall number. */
5324 if (handle_syscall_event (ecs) == 0)
5325 process_event_stop_test (ecs);
5328 /* Before examining the threads further, step this thread to
5329 get it entirely out of the syscall. (We get notice of the
5330 event when the thread is just on the verge of exiting a
5331 syscall. Stepping one instruction seems to get it back
5333 case TARGET_WAITKIND_SYSCALL_RETURN:
5335 fprintf_unfiltered (gdb_stdlog,
5336 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5337 if (handle_syscall_event (ecs) == 0)
5338 process_event_stop_test (ecs);
5341 case TARGET_WAITKIND_STOPPED:
5343 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
5344 handle_signal_stop (ecs);
5347 case TARGET_WAITKIND_NO_HISTORY:
5349 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5350 /* Reverse execution: target ran out of history info. */
5352 /* Switch to the stopped thread. */
5353 context_switch (ecs);
5355 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
5357 delete_just_stopped_threads_single_step_breakpoints ();
5358 ecs->event_thread->suspend.stop_pc
5359 = regcache_read_pc (get_thread_regcache (inferior_thread ()));
5361 if (handle_stop_requested (ecs))
5364 gdb::observers::no_history.notify ();
5370 /* A wrapper around handle_inferior_event_1, which also makes sure
5371 that all temporary struct value objects that were created during
5372 the handling of the event get deleted at the end. */
5375 handle_inferior_event (struct execution_control_state *ecs)
5377 struct value *mark = value_mark ();
5379 handle_inferior_event_1 (ecs);
5380 /* Purge all temporary values created during the event handling,
5381 as it could be a long time before we return to the command level
5382 where such values would otherwise be purged. */
5383 value_free_to_mark (mark);
5386 /* Restart threads back to what they were trying to do back when we
5387 paused them for an in-line step-over. The EVENT_THREAD thread is
5391 restart_threads (struct thread_info *event_thread)
5393 struct thread_info *tp;
5395 /* In case the instruction just stepped spawned a new thread. */
5396 update_thread_list ();
5398 ALL_NON_EXITED_THREADS (tp)
5400 if (tp == event_thread)
5403 fprintf_unfiltered (gdb_stdlog,
5404 "infrun: restart threads: "
5405 "[%s] is event thread\n",
5406 target_pid_to_str (tp->ptid));
5410 if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
5413 fprintf_unfiltered (gdb_stdlog,
5414 "infrun: restart threads: "
5415 "[%s] not meant to be running\n",
5416 target_pid_to_str (tp->ptid));
5423 fprintf_unfiltered (gdb_stdlog,
5424 "infrun: restart threads: [%s] resumed\n",
5425 target_pid_to_str (tp->ptid));
5426 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
5430 if (thread_is_in_step_over_chain (tp))
5433 fprintf_unfiltered (gdb_stdlog,
5434 "infrun: restart threads: "
5435 "[%s] needs step-over\n",
5436 target_pid_to_str (tp->ptid));
5437 gdb_assert (!tp->resumed);
5442 if (tp->suspend.waitstatus_pending_p)
5445 fprintf_unfiltered (gdb_stdlog,
5446 "infrun: restart threads: "
5447 "[%s] has pending status\n",
5448 target_pid_to_str (tp->ptid));
5453 gdb_assert (!tp->stop_requested);
5455 /* If some thread needs to start a step-over at this point, it
5456 should still be in the step-over queue, and thus skipped
5458 if (thread_still_needs_step_over (tp))
5460 internal_error (__FILE__, __LINE__,
5461 "thread [%s] needs a step-over, but not in "
5462 "step-over queue\n",
5463 target_pid_to_str (tp->ptid));
5466 if (currently_stepping (tp))
5469 fprintf_unfiltered (gdb_stdlog,
5470 "infrun: restart threads: [%s] was stepping\n",
5471 target_pid_to_str (tp->ptid));
5472 keep_going_stepped_thread (tp);
5476 struct execution_control_state ecss;
5477 struct execution_control_state *ecs = &ecss;
5480 fprintf_unfiltered (gdb_stdlog,
5481 "infrun: restart threads: [%s] continuing\n",
5482 target_pid_to_str (tp->ptid));
5483 reset_ecs (ecs, tp);
5484 switch_to_thread (tp);
5485 keep_going_pass_signal (ecs);
5490 /* Callback for iterate_over_threads. Find a resumed thread that has
5491 a pending waitstatus. */
5494 resumed_thread_with_pending_status (struct thread_info *tp,
5498 && tp->suspend.waitstatus_pending_p);
5501 /* Called when we get an event that may finish an in-line or
5502 out-of-line (displaced stepping) step-over started previously.
5503 Return true if the event is processed and we should go back to the
5504 event loop; false if the caller should continue processing the
5508 finish_step_over (struct execution_control_state *ecs)
5510 int had_step_over_info;
5512 displaced_step_fixup (ecs->event_thread,
5513 ecs->event_thread->suspend.stop_signal);
5515 had_step_over_info = step_over_info_valid_p ();
5517 if (had_step_over_info)
5519 /* If we're stepping over a breakpoint with all threads locked,
5520 then only the thread that was stepped should be reporting
5522 gdb_assert (ecs->event_thread->control.trap_expected);
5524 clear_step_over_info ();
5527 if (!target_is_non_stop_p ())
5530 /* Start a new step-over in another thread if there's one that
5534 /* If we were stepping over a breakpoint before, and haven't started
5535 a new in-line step-over sequence, then restart all other threads
5536 (except the event thread). We can't do this in all-stop, as then
5537 e.g., we wouldn't be able to issue any other remote packet until
5538 these other threads stop. */
5539 if (had_step_over_info && !step_over_info_valid_p ())
5541 struct thread_info *pending;
5543 /* If we only have threads with pending statuses, the restart
5544 below won't restart any thread and so nothing re-inserts the
5545 breakpoint we just stepped over. But we need it inserted
5546 when we later process the pending events, otherwise if
5547 another thread has a pending event for this breakpoint too,
5548 we'd discard its event (because the breakpoint that
5549 originally caused the event was no longer inserted). */
5550 context_switch (ecs);
5551 insert_breakpoints ();
5553 restart_threads (ecs->event_thread);
5555 /* If we have events pending, go through handle_inferior_event
5556 again, picking up a pending event at random. This avoids
5557 thread starvation. */
5559 /* But not if we just stepped over a watchpoint in order to let
5560 the instruction execute so we can evaluate its expression.
5561 The set of watchpoints that triggered is recorded in the
5562 breakpoint objects themselves (see bp->watchpoint_triggered).
5563 If we processed another event first, that other event could
5564 clobber this info. */
5565 if (ecs->event_thread->stepping_over_watchpoint)
5568 pending = iterate_over_threads (resumed_thread_with_pending_status,
5570 if (pending != NULL)
5572 struct thread_info *tp = ecs->event_thread;
5573 struct regcache *regcache;
5577 fprintf_unfiltered (gdb_stdlog,
5578 "infrun: found resumed threads with "
5579 "pending events, saving status\n");
5582 gdb_assert (pending != tp);
5584 /* Record the event thread's event for later. */
5585 save_waitstatus (tp, &ecs->ws);
5586 /* This was cleared early, by handle_inferior_event. Set it
5587 so this pending event is considered by
5591 gdb_assert (!tp->executing);
5593 regcache = get_thread_regcache (tp);
5594 tp->suspend.stop_pc = regcache_read_pc (regcache);
5598 fprintf_unfiltered (gdb_stdlog,
5599 "infrun: saved stop_pc=%s for %s "
5600 "(currently_stepping=%d)\n",
5601 paddress (target_gdbarch (),
5602 tp->suspend.stop_pc),
5603 target_pid_to_str (tp->ptid),
5604 currently_stepping (tp));
5607 /* This in-line step-over finished; clear this so we won't
5608 start a new one. This is what handle_signal_stop would
5609 do, if we returned false. */
5610 tp->stepping_over_breakpoint = 0;
5612 /* Wake up the event loop again. */
5613 mark_async_event_handler (infrun_async_inferior_event_token);
5615 prepare_to_wait (ecs);
5623 /* Come here when the program has stopped with a signal. */
5626 handle_signal_stop (struct execution_control_state *ecs)
5628 struct frame_info *frame;
5629 struct gdbarch *gdbarch;
5630 int stopped_by_watchpoint;
5631 enum stop_kind stop_soon;
5634 gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
5636 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
5638 /* Do we need to clean up the state of a thread that has
5639 completed a displaced single-step? (Doing so usually affects
5640 the PC, so do it here, before we set stop_pc.) */
5641 if (finish_step_over (ecs))
5644 /* If we either finished a single-step or hit a breakpoint, but
5645 the user wanted this thread to be stopped, pretend we got a
5646 SIG0 (generic unsignaled stop). */
5647 if (ecs->event_thread->stop_requested
5648 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5649 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5651 ecs->event_thread->suspend.stop_pc
5652 = regcache_read_pc (get_thread_regcache (ecs->event_thread));
5656 struct regcache *regcache = get_thread_regcache (ecs->event_thread);
5657 struct gdbarch *reg_gdbarch = regcache->arch ();
5658 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
5660 inferior_ptid = ecs->ptid;
5662 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
5663 paddress (reg_gdbarch,
5664 ecs->event_thread->suspend.stop_pc));
5665 if (target_stopped_by_watchpoint ())
5669 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
5671 if (target_stopped_data_address (current_top_target (), &addr))
5672 fprintf_unfiltered (gdb_stdlog,
5673 "infrun: stopped data address = %s\n",
5674 paddress (reg_gdbarch, addr));
5676 fprintf_unfiltered (gdb_stdlog,
5677 "infrun: (no data address available)\n");
5681 /* This is originated from start_remote(), start_inferior() and
5682 shared libraries hook functions. */
5683 stop_soon = get_inferior_stop_soon (ecs);
5684 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
5686 context_switch (ecs);
5688 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
5689 stop_print_frame = 1;
5694 /* This originates from attach_command(). We need to overwrite
5695 the stop_signal here, because some kernels don't ignore a
5696 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5697 See more comments in inferior.h. On the other hand, if we
5698 get a non-SIGSTOP, report it to the user - assume the backend
5699 will handle the SIGSTOP if it should show up later.
5701 Also consider that the attach is complete when we see a
5702 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5703 target extended-remote report it instead of a SIGSTOP
5704 (e.g. gdbserver). We already rely on SIGTRAP being our
5705 signal, so this is no exception.
5707 Also consider that the attach is complete when we see a
5708 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5709 the target to stop all threads of the inferior, in case the
5710 low level attach operation doesn't stop them implicitly. If
5711 they weren't stopped implicitly, then the stub will report a
5712 GDB_SIGNAL_0, meaning: stopped for no particular reason
5713 other than GDB's request. */
5714 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5715 && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
5716 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5717 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
5719 stop_print_frame = 1;
5721 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5725 /* See if something interesting happened to the non-current thread. If
5726 so, then switch to that thread. */
5727 if (ecs->ptid != inferior_ptid)
5730 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
5732 context_switch (ecs);
5734 if (deprecated_context_hook)
5735 deprecated_context_hook (ecs->event_thread->global_num);
5738 /* At this point, get hold of the now-current thread's frame. */
5739 frame = get_current_frame ();
5740 gdbarch = get_frame_arch (frame);
5742 /* Pull the single step breakpoints out of the target. */
5743 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5745 struct regcache *regcache;
5748 regcache = get_thread_regcache (ecs->event_thread);
5749 const address_space *aspace = regcache->aspace ();
5751 pc = regcache_read_pc (regcache);
5753 /* However, before doing so, if this single-step breakpoint was
5754 actually for another thread, set this thread up for moving
5756 if (!thread_has_single_step_breakpoint_here (ecs->event_thread,
5759 if (single_step_breakpoint_inserted_here_p (aspace, pc))
5763 fprintf_unfiltered (gdb_stdlog,
5764 "infrun: [%s] hit another thread's "
5765 "single-step breakpoint\n",
5766 target_pid_to_str (ecs->ptid));
5768 ecs->hit_singlestep_breakpoint = 1;
5775 fprintf_unfiltered (gdb_stdlog,
5776 "infrun: [%s] hit its "
5777 "single-step breakpoint\n",
5778 target_pid_to_str (ecs->ptid));
5782 delete_just_stopped_threads_single_step_breakpoints ();
5784 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5785 && ecs->event_thread->control.trap_expected
5786 && ecs->event_thread->stepping_over_watchpoint)
5787 stopped_by_watchpoint = 0;
5789 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
5791 /* If necessary, step over this watchpoint. We'll be back to display
5793 if (stopped_by_watchpoint
5794 && (target_have_steppable_watchpoint
5795 || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
5797 /* At this point, we are stopped at an instruction which has
5798 attempted to write to a piece of memory under control of
5799 a watchpoint. The instruction hasn't actually executed
5800 yet. If we were to evaluate the watchpoint expression
5801 now, we would get the old value, and therefore no change
5802 would seem to have occurred.
5804 In order to make watchpoints work `right', we really need
5805 to complete the memory write, and then evaluate the
5806 watchpoint expression. We do this by single-stepping the
5809 It may not be necessary to disable the watchpoint to step over
5810 it. For example, the PA can (with some kernel cooperation)
5811 single step over a watchpoint without disabling the watchpoint.
5813 It is far more common to need to disable a watchpoint to step
5814 the inferior over it. If we have non-steppable watchpoints,
5815 we must disable the current watchpoint; it's simplest to
5816 disable all watchpoints.
5818 Any breakpoint at PC must also be stepped over -- if there's
5819 one, it will have already triggered before the watchpoint
5820 triggered, and we either already reported it to the user, or
5821 it didn't cause a stop and we called keep_going. In either
5822 case, if there was a breakpoint at PC, we must be trying to
5824 ecs->event_thread->stepping_over_watchpoint = 1;
5829 ecs->event_thread->stepping_over_breakpoint = 0;
5830 ecs->event_thread->stepping_over_watchpoint = 0;
5831 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
5832 ecs->event_thread->control.stop_step = 0;
5833 stop_print_frame = 1;
5834 stopped_by_random_signal = 0;
5835 bpstat stop_chain = NULL;
5837 /* Hide inlined functions starting here, unless we just performed stepi or
5838 nexti. After stepi and nexti, always show the innermost frame (not any
5839 inline function call sites). */
5840 if (ecs->event_thread->control.step_range_end != 1)
5842 const address_space *aspace
5843 = get_thread_regcache (ecs->event_thread)->aspace ();
5845 /* skip_inline_frames is expensive, so we avoid it if we can
5846 determine that the address is one where functions cannot have
5847 been inlined. This improves performance with inferiors that
5848 load a lot of shared libraries, because the solib event
5849 breakpoint is defined as the address of a function (i.e. not
5850 inline). Note that we have to check the previous PC as well
5851 as the current one to catch cases when we have just
5852 single-stepped off a breakpoint prior to reinstating it.
5853 Note that we're assuming that the code we single-step to is
5854 not inline, but that's not definitive: there's nothing
5855 preventing the event breakpoint function from containing
5856 inlined code, and the single-step ending up there. If the
5857 user had set a breakpoint on that inlined code, the missing
5858 skip_inline_frames call would break things. Fortunately
5859 that's an extremely unlikely scenario. */
5860 if (!pc_at_non_inline_function (aspace,
5861 ecs->event_thread->suspend.stop_pc,
5863 && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5864 && ecs->event_thread->control.trap_expected
5865 && pc_at_non_inline_function (aspace,
5866 ecs->event_thread->prev_pc,
5869 stop_chain = build_bpstat_chain (aspace,
5870 ecs->event_thread->suspend.stop_pc,
5872 skip_inline_frames (ecs->event_thread, stop_chain);
5874 /* Re-fetch current thread's frame in case that invalidated
5876 frame = get_current_frame ();
5877 gdbarch = get_frame_arch (frame);
5881 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5882 && ecs->event_thread->control.trap_expected
5883 && gdbarch_single_step_through_delay_p (gdbarch)
5884 && currently_stepping (ecs->event_thread))
5886 /* We're trying to step off a breakpoint. Turns out that we're
5887 also on an instruction that needs to be stepped multiple
5888 times before it's been fully executing. E.g., architectures
5889 with a delay slot. It needs to be stepped twice, once for
5890 the instruction and once for the delay slot. */
5891 int step_through_delay
5892 = gdbarch_single_step_through_delay (gdbarch, frame);
5894 if (debug_infrun && step_through_delay)
5895 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
5896 if (ecs->event_thread->control.step_range_end == 0
5897 && step_through_delay)
5899 /* The user issued a continue when stopped at a breakpoint.
5900 Set up for another trap and get out of here. */
5901 ecs->event_thread->stepping_over_breakpoint = 1;
5905 else if (step_through_delay)
5907 /* The user issued a step when stopped at a breakpoint.
5908 Maybe we should stop, maybe we should not - the delay
5909 slot *might* correspond to a line of source. In any
5910 case, don't decide that here, just set
5911 ecs->stepping_over_breakpoint, making sure we
5912 single-step again before breakpoints are re-inserted. */
5913 ecs->event_thread->stepping_over_breakpoint = 1;
5917 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5918 handles this event. */
5919 ecs->event_thread->control.stop_bpstat
5920 = bpstat_stop_status (get_current_regcache ()->aspace (),
5921 ecs->event_thread->suspend.stop_pc,
5922 ecs->event_thread, &ecs->ws, stop_chain);
5924 /* Following in case break condition called a
5926 stop_print_frame = 1;
5928 /* This is where we handle "moribund" watchpoints. Unlike
5929 software breakpoints traps, hardware watchpoint traps are
5930 always distinguishable from random traps. If no high-level
5931 watchpoint is associated with the reported stop data address
5932 anymore, then the bpstat does not explain the signal ---
5933 simply make sure to ignore it if `stopped_by_watchpoint' is
5937 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5938 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5940 && stopped_by_watchpoint)
5941 fprintf_unfiltered (gdb_stdlog,
5942 "infrun: no user watchpoint explains "
5943 "watchpoint SIGTRAP, ignoring\n");
5945 /* NOTE: cagney/2003-03-29: These checks for a random signal
5946 at one stage in the past included checks for an inferior
5947 function call's call dummy's return breakpoint. The original
5948 comment, that went with the test, read:
5950 ``End of a stack dummy. Some systems (e.g. Sony news) give
5951 another signal besides SIGTRAP, so check here as well as
5954 If someone ever tries to get call dummys on a
5955 non-executable stack to work (where the target would stop
5956 with something like a SIGSEGV), then those tests might need
5957 to be re-instated. Given, however, that the tests were only
5958 enabled when momentary breakpoints were not being used, I
5959 suspect that it won't be the case.
5961 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5962 be necessary for call dummies on a non-executable stack on
5965 /* See if the breakpoints module can explain the signal. */
5967 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5968 ecs->event_thread->suspend.stop_signal);
5970 /* Maybe this was a trap for a software breakpoint that has since
5972 if (random_signal && target_stopped_by_sw_breakpoint ())
5974 if (program_breakpoint_here_p (gdbarch,
5975 ecs->event_thread->suspend.stop_pc))
5977 struct regcache *regcache;
5980 /* Re-adjust PC to what the program would see if GDB was not
5982 regcache = get_thread_regcache (ecs->event_thread);
5983 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
5986 gdb::optional<scoped_restore_tmpl<int>>
5987 restore_operation_disable;
5989 if (record_full_is_used ())
5990 restore_operation_disable.emplace
5991 (record_full_gdb_operation_disable_set ());
5993 regcache_write_pc (regcache,
5994 ecs->event_thread->suspend.stop_pc + decr_pc);
5999 /* A delayed software breakpoint event. Ignore the trap. */
6001 fprintf_unfiltered (gdb_stdlog,
6002 "infrun: delayed software breakpoint "
6003 "trap, ignoring\n");
6008 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6009 has since been removed. */
6010 if (random_signal && target_stopped_by_hw_breakpoint ())
6012 /* A delayed hardware breakpoint event. Ignore the trap. */
6014 fprintf_unfiltered (gdb_stdlog,
6015 "infrun: delayed hardware breakpoint/watchpoint "
6016 "trap, ignoring\n");
6020 /* If not, perhaps stepping/nexting can. */
6022 random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6023 && currently_stepping (ecs->event_thread));
6025 /* Perhaps the thread hit a single-step breakpoint of _another_
6026 thread. Single-step breakpoints are transparent to the
6027 breakpoints module. */
6029 random_signal = !ecs->hit_singlestep_breakpoint;
6031 /* No? Perhaps we got a moribund watchpoint. */
6033 random_signal = !stopped_by_watchpoint;
6035 /* Always stop if the user explicitly requested this thread to
6037 if (ecs->event_thread->stop_requested)
6041 fprintf_unfiltered (gdb_stdlog, "infrun: user-requested stop\n");
6044 /* For the program's own signals, act according to
6045 the signal handling tables. */
6049 /* Signal not for debugging purposes. */
6050 struct inferior *inf = find_inferior_ptid (ecs->ptid);
6051 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
6054 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
6055 gdb_signal_to_symbol_string (stop_signal));
6057 stopped_by_random_signal = 1;
6059 /* Always stop on signals if we're either just gaining control
6060 of the program, or the user explicitly requested this thread
6061 to remain stopped. */
6062 if (stop_soon != NO_STOP_QUIETLY
6063 || ecs->event_thread->stop_requested
6065 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
6071 /* Notify observers the signal has "handle print" set. Note we
6072 returned early above if stopping; normal_stop handles the
6073 printing in that case. */
6074 if (signal_print[ecs->event_thread->suspend.stop_signal])
6076 /* The signal table tells us to print about this signal. */
6077 target_terminal::ours_for_output ();
6078 gdb::observers::signal_received.notify (ecs->event_thread->suspend.stop_signal);
6079 target_terminal::inferior ();
6082 /* Clear the signal if it should not be passed. */
6083 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
6084 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6086 if (ecs->event_thread->prev_pc == ecs->event_thread->suspend.stop_pc
6087 && ecs->event_thread->control.trap_expected
6088 && ecs->event_thread->control.step_resume_breakpoint == NULL)
6090 /* We were just starting a new sequence, attempting to
6091 single-step off of a breakpoint and expecting a SIGTRAP.
6092 Instead this signal arrives. This signal will take us out
6093 of the stepping range so GDB needs to remember to, when
6094 the signal handler returns, resume stepping off that
6096 /* To simplify things, "continue" is forced to use the same
6097 code paths as single-step - set a breakpoint at the
6098 signal return address and then, once hit, step off that
6101 fprintf_unfiltered (gdb_stdlog,
6102 "infrun: signal arrived while stepping over "
6105 insert_hp_step_resume_breakpoint_at_frame (frame);
6106 ecs->event_thread->step_after_step_resume_breakpoint = 1;
6107 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6108 ecs->event_thread->control.trap_expected = 0;
6110 /* If we were nexting/stepping some other thread, switch to
6111 it, so that we don't continue it, losing control. */
6112 if (!switch_back_to_stepped_thread (ecs))
6117 if (ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
6118 && (pc_in_thread_step_range (ecs->event_thread->suspend.stop_pc,
6120 || ecs->event_thread->control.step_range_end == 1)
6121 && frame_id_eq (get_stack_frame_id (frame),
6122 ecs->event_thread->control.step_stack_frame_id)
6123 && ecs->event_thread->control.step_resume_breakpoint == NULL)
6125 /* The inferior is about to take a signal that will take it
6126 out of the single step range. Set a breakpoint at the
6127 current PC (which is presumably where the signal handler
6128 will eventually return) and then allow the inferior to
6131 Note that this is only needed for a signal delivered
6132 while in the single-step range. Nested signals aren't a
6133 problem as they eventually all return. */
6135 fprintf_unfiltered (gdb_stdlog,
6136 "infrun: signal may take us out of "
6137 "single-step range\n");
6139 clear_step_over_info ();
6140 insert_hp_step_resume_breakpoint_at_frame (frame);
6141 ecs->event_thread->step_after_step_resume_breakpoint = 1;
6142 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6143 ecs->event_thread->control.trap_expected = 0;
6148 /* Note: step_resume_breakpoint may be non-NULL. This occures
6149 when either there's a nested signal, or when there's a
6150 pending signal enabled just as the signal handler returns
6151 (leaving the inferior at the step-resume-breakpoint without
6152 actually executing it). Either way continue until the
6153 breakpoint is really hit. */
6155 if (!switch_back_to_stepped_thread (ecs))
6158 fprintf_unfiltered (gdb_stdlog,
6159 "infrun: random signal, keep going\n");
6166 process_event_stop_test (ecs);
6169 /* Come here when we've got some debug event / signal we can explain
6170 (IOW, not a random signal), and test whether it should cause a
6171 stop, or whether we should resume the inferior (transparently).
6172 E.g., could be a breakpoint whose condition evaluates false; we
6173 could be still stepping within the line; etc. */
6176 process_event_stop_test (struct execution_control_state *ecs)
6178 struct symtab_and_line stop_pc_sal;
6179 struct frame_info *frame;
6180 struct gdbarch *gdbarch;
6181 CORE_ADDR jmp_buf_pc;
6182 struct bpstat_what what;
6184 /* Handle cases caused by hitting a breakpoint. */
6186 frame = get_current_frame ();
6187 gdbarch = get_frame_arch (frame);
6189 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
6191 if (what.call_dummy)
6193 stop_stack_dummy = what.call_dummy;
6196 /* A few breakpoint types have callbacks associated (e.g.,
6197 bp_jit_event). Run them now. */
6198 bpstat_run_callbacks (ecs->event_thread->control.stop_bpstat);
6200 /* If we hit an internal event that triggers symbol changes, the
6201 current frame will be invalidated within bpstat_what (e.g., if we
6202 hit an internal solib event). Re-fetch it. */
6203 frame = get_current_frame ();
6204 gdbarch = get_frame_arch (frame);
6206 switch (what.main_action)
6208 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
6209 /* If we hit the breakpoint at longjmp while stepping, we
6210 install a momentary breakpoint at the target of the
6214 fprintf_unfiltered (gdb_stdlog,
6215 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
6217 ecs->event_thread->stepping_over_breakpoint = 1;
6219 if (what.is_longjmp)
6221 struct value *arg_value;
6223 /* If we set the longjmp breakpoint via a SystemTap probe,
6224 then use it to extract the arguments. The destination PC
6225 is the third argument to the probe. */
6226 arg_value = probe_safe_evaluate_at_pc (frame, 2);
6229 jmp_buf_pc = value_as_address (arg_value);
6230 jmp_buf_pc = gdbarch_addr_bits_remove (gdbarch, jmp_buf_pc);
6232 else if (!gdbarch_get_longjmp_target_p (gdbarch)
6233 || !gdbarch_get_longjmp_target (gdbarch,
6234 frame, &jmp_buf_pc))
6237 fprintf_unfiltered (gdb_stdlog,
6238 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
6239 "(!gdbarch_get_longjmp_target)\n");
6244 /* Insert a breakpoint at resume address. */
6245 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
6248 check_exception_resume (ecs, frame);
6252 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
6254 struct frame_info *init_frame;
6256 /* There are several cases to consider.
6258 1. The initiating frame no longer exists. In this case we
6259 must stop, because the exception or longjmp has gone too
6262 2. The initiating frame exists, and is the same as the
6263 current frame. We stop, because the exception or longjmp
6266 3. The initiating frame exists and is different from the
6267 current frame. This means the exception or longjmp has
6268 been caught beneath the initiating frame, so keep going.
6270 4. longjmp breakpoint has been placed just to protect
6271 against stale dummy frames and user is not interested in
6272 stopping around longjmps. */
6275 fprintf_unfiltered (gdb_stdlog,
6276 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
6278 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
6280 delete_exception_resume_breakpoint (ecs->event_thread);
6282 if (what.is_longjmp)
6284 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
6286 if (!frame_id_p (ecs->event_thread->initiating_frame))
6294 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
6298 struct frame_id current_id
6299 = get_frame_id (get_current_frame ());
6300 if (frame_id_eq (current_id,
6301 ecs->event_thread->initiating_frame))
6303 /* Case 2. Fall through. */
6313 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6315 delete_step_resume_breakpoint (ecs->event_thread);
6317 end_stepping_range (ecs);
6321 case BPSTAT_WHAT_SINGLE:
6323 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
6324 ecs->event_thread->stepping_over_breakpoint = 1;
6325 /* Still need to check other stuff, at least the case where we
6326 are stepping and step out of the right range. */
6329 case BPSTAT_WHAT_STEP_RESUME:
6331 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6333 delete_step_resume_breakpoint (ecs->event_thread);
6334 if (ecs->event_thread->control.proceed_to_finish
6335 && execution_direction == EXEC_REVERSE)
6337 struct thread_info *tp = ecs->event_thread;
6339 /* We are finishing a function in reverse, and just hit the
6340 step-resume breakpoint at the start address of the
6341 function, and we're almost there -- just need to back up
6342 by one more single-step, which should take us back to the
6344 tp->control.step_range_start = tp->control.step_range_end = 1;
6348 fill_in_stop_func (gdbarch, ecs);
6349 if (ecs->event_thread->suspend.stop_pc == ecs->stop_func_start
6350 && execution_direction == EXEC_REVERSE)
6352 /* We are stepping over a function call in reverse, and just
6353 hit the step-resume breakpoint at the start address of
6354 the function. Go back to single-stepping, which should
6355 take us back to the function call. */
6356 ecs->event_thread->stepping_over_breakpoint = 1;
6362 case BPSTAT_WHAT_STOP_NOISY:
6364 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6365 stop_print_frame = 1;
6367 /* Assume the thread stopped for a breapoint. We'll still check
6368 whether a/the breakpoint is there when the thread is next
6370 ecs->event_thread->stepping_over_breakpoint = 1;
6375 case BPSTAT_WHAT_STOP_SILENT:
6377 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6378 stop_print_frame = 0;
6380 /* Assume the thread stopped for a breapoint. We'll still check
6381 whether a/the breakpoint is there when the thread is next
6383 ecs->event_thread->stepping_over_breakpoint = 1;
6387 case BPSTAT_WHAT_HP_STEP_RESUME:
6389 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6391 delete_step_resume_breakpoint (ecs->event_thread);
6392 if (ecs->event_thread->step_after_step_resume_breakpoint)
6394 /* Back when the step-resume breakpoint was inserted, we
6395 were trying to single-step off a breakpoint. Go back to
6397 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6398 ecs->event_thread->stepping_over_breakpoint = 1;
6404 case BPSTAT_WHAT_KEEP_CHECKING:
6408 /* If we stepped a permanent breakpoint and we had a high priority
6409 step-resume breakpoint for the address we stepped, but we didn't
6410 hit it, then we must have stepped into the signal handler. The
6411 step-resume was only necessary to catch the case of _not_
6412 stepping into the handler, so delete it, and fall through to
6413 checking whether the step finished. */
6414 if (ecs->event_thread->stepped_breakpoint)
6416 struct breakpoint *sr_bp
6417 = ecs->event_thread->control.step_resume_breakpoint;
6420 && sr_bp->loc->permanent
6421 && sr_bp->type == bp_hp_step_resume
6422 && sr_bp->loc->address == ecs->event_thread->prev_pc)
6425 fprintf_unfiltered (gdb_stdlog,
6426 "infrun: stepped permanent breakpoint, stopped in "
6428 delete_step_resume_breakpoint (ecs->event_thread);
6429 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6433 /* We come here if we hit a breakpoint but should not stop for it.
6434 Possibly we also were stepping and should stop for that. So fall
6435 through and test for stepping. But, if not stepping, do not
6438 /* In all-stop mode, if we're currently stepping but have stopped in
6439 some other thread, we need to switch back to the stepped thread. */
6440 if (switch_back_to_stepped_thread (ecs))
6443 if (ecs->event_thread->control.step_resume_breakpoint)
6446 fprintf_unfiltered (gdb_stdlog,
6447 "infrun: step-resume breakpoint is inserted\n");
6449 /* Having a step-resume breakpoint overrides anything
6450 else having to do with stepping commands until
6451 that breakpoint is reached. */
6456 if (ecs->event_thread->control.step_range_end == 0)
6459 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
6460 /* Likewise if we aren't even stepping. */
6465 /* Re-fetch current thread's frame in case the code above caused
6466 the frame cache to be re-initialized, making our FRAME variable
6467 a dangling pointer. */
6468 frame = get_current_frame ();
6469 gdbarch = get_frame_arch (frame);
6470 fill_in_stop_func (gdbarch, ecs);
6472 /* If stepping through a line, keep going if still within it.
6474 Note that step_range_end is the address of the first instruction
6475 beyond the step range, and NOT the address of the last instruction
6478 Note also that during reverse execution, we may be stepping
6479 through a function epilogue and therefore must detect when
6480 the current-frame changes in the middle of a line. */
6482 if (pc_in_thread_step_range (ecs->event_thread->suspend.stop_pc,
6484 && (execution_direction != EXEC_REVERSE
6485 || frame_id_eq (get_frame_id (frame),
6486 ecs->event_thread->control.step_frame_id)))
6490 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
6491 paddress (gdbarch, ecs->event_thread->control.step_range_start),
6492 paddress (gdbarch, ecs->event_thread->control.step_range_end));
6494 /* Tentatively re-enable range stepping; `resume' disables it if
6495 necessary (e.g., if we're stepping over a breakpoint or we
6496 have software watchpoints). */
6497 ecs->event_thread->control.may_range_step = 1;
6499 /* When stepping backward, stop at beginning of line range
6500 (unless it's the function entry point, in which case
6501 keep going back to the call point). */
6502 CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6503 if (stop_pc == ecs->event_thread->control.step_range_start
6504 && stop_pc != ecs->stop_func_start
6505 && execution_direction == EXEC_REVERSE)
6506 end_stepping_range (ecs);
6513 /* We stepped out of the stepping range. */
6515 /* If we are stepping at the source level and entered the runtime
6516 loader dynamic symbol resolution code...
6518 EXEC_FORWARD: we keep on single stepping until we exit the run
6519 time loader code and reach the callee's address.
6521 EXEC_REVERSE: we've already executed the callee (backward), and
6522 the runtime loader code is handled just like any other
6523 undebuggable function call. Now we need only keep stepping
6524 backward through the trampoline code, and that's handled further
6525 down, so there is nothing for us to do here. */
6527 if (execution_direction != EXEC_REVERSE
6528 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6529 && in_solib_dynsym_resolve_code (ecs->event_thread->suspend.stop_pc))
6531 CORE_ADDR pc_after_resolver =
6532 gdbarch_skip_solib_resolver (gdbarch,
6533 ecs->event_thread->suspend.stop_pc);
6536 fprintf_unfiltered (gdb_stdlog,
6537 "infrun: stepped into dynsym resolve code\n");
6539 if (pc_after_resolver)
6541 /* Set up a step-resume breakpoint at the address
6542 indicated by SKIP_SOLIB_RESOLVER. */
6543 symtab_and_line sr_sal;
6544 sr_sal.pc = pc_after_resolver;
6545 sr_sal.pspace = get_frame_program_space (frame);
6547 insert_step_resume_breakpoint_at_sal (gdbarch,
6548 sr_sal, null_frame_id);
6555 /* Step through an indirect branch thunk. */
6556 if (ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
6557 && gdbarch_in_indirect_branch_thunk (gdbarch,
6558 ecs->event_thread->suspend.stop_pc))
6561 fprintf_unfiltered (gdb_stdlog,
6562 "infrun: stepped into indirect branch thunk\n");
6567 if (ecs->event_thread->control.step_range_end != 1
6568 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6569 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6570 && get_frame_type (frame) == SIGTRAMP_FRAME)
6573 fprintf_unfiltered (gdb_stdlog,
6574 "infrun: stepped into signal trampoline\n");
6575 /* The inferior, while doing a "step" or "next", has ended up in
6576 a signal trampoline (either by a signal being delivered or by
6577 the signal handler returning). Just single-step until the
6578 inferior leaves the trampoline (either by calling the handler
6584 /* If we're in the return path from a shared library trampoline,
6585 we want to proceed through the trampoline when stepping. */
6586 /* macro/2012-04-25: This needs to come before the subroutine
6587 call check below as on some targets return trampolines look
6588 like subroutine calls (MIPS16 return thunks). */
6589 if (gdbarch_in_solib_return_trampoline (gdbarch,
6590 ecs->event_thread->suspend.stop_pc,
6591 ecs->stop_func_name)
6592 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6594 /* Determine where this trampoline returns. */
6595 CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6596 CORE_ADDR real_stop_pc
6597 = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6600 fprintf_unfiltered (gdb_stdlog,
6601 "infrun: stepped into solib return tramp\n");
6603 /* Only proceed through if we know where it's going. */
6606 /* And put the step-breakpoint there and go until there. */
6607 symtab_and_line sr_sal;
6608 sr_sal.pc = real_stop_pc;
6609 sr_sal.section = find_pc_overlay (sr_sal.pc);
6610 sr_sal.pspace = get_frame_program_space (frame);
6612 /* Do not specify what the fp should be when we stop since
6613 on some machines the prologue is where the new fp value
6615 insert_step_resume_breakpoint_at_sal (gdbarch,
6616 sr_sal, null_frame_id);
6618 /* Restart without fiddling with the step ranges or
6625 /* Check for subroutine calls. The check for the current frame
6626 equalling the step ID is not necessary - the check of the
6627 previous frame's ID is sufficient - but it is a common case and
6628 cheaper than checking the previous frame's ID.
6630 NOTE: frame_id_eq will never report two invalid frame IDs as
6631 being equal, so to get into this block, both the current and
6632 previous frame must have valid frame IDs. */
6633 /* The outer_frame_id check is a heuristic to detect stepping
6634 through startup code. If we step over an instruction which
6635 sets the stack pointer from an invalid value to a valid value,
6636 we may detect that as a subroutine call from the mythical
6637 "outermost" function. This could be fixed by marking
6638 outermost frames as !stack_p,code_p,special_p. Then the
6639 initial outermost frame, before sp was valid, would
6640 have code_addr == &_start. See the comment in frame_id_eq
6642 if (!frame_id_eq (get_stack_frame_id (frame),
6643 ecs->event_thread->control.step_stack_frame_id)
6644 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6645 ecs->event_thread->control.step_stack_frame_id)
6646 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
6648 || (ecs->event_thread->control.step_start_function
6649 != find_pc_function (ecs->event_thread->suspend.stop_pc)))))
6651 CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6652 CORE_ADDR real_stop_pc;
6655 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
6657 if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
6659 /* I presume that step_over_calls is only 0 when we're
6660 supposed to be stepping at the assembly language level
6661 ("stepi"). Just stop. */
6662 /* And this works the same backward as frontward. MVS */
6663 end_stepping_range (ecs);
6667 /* Reverse stepping through solib trampolines. */
6669 if (execution_direction == EXEC_REVERSE
6670 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
6671 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6672 || (ecs->stop_func_start == 0
6673 && in_solib_dynsym_resolve_code (stop_pc))))
6675 /* Any solib trampoline code can be handled in reverse
6676 by simply continuing to single-step. We have already
6677 executed the solib function (backwards), and a few
6678 steps will take us back through the trampoline to the
6684 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6686 /* We're doing a "next".
6688 Normal (forward) execution: set a breakpoint at the
6689 callee's return address (the address at which the caller
6692 Reverse (backward) execution. set the step-resume
6693 breakpoint at the start of the function that we just
6694 stepped into (backwards), and continue to there. When we
6695 get there, we'll need to single-step back to the caller. */
6697 if (execution_direction == EXEC_REVERSE)
6699 /* If we're already at the start of the function, we've either
6700 just stepped backward into a single instruction function,
6701 or stepped back out of a signal handler to the first instruction
6702 of the function. Just keep going, which will single-step back
6704 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
6706 /* Normal function call return (static or dynamic). */
6707 symtab_and_line sr_sal;
6708 sr_sal.pc = ecs->stop_func_start;
6709 sr_sal.pspace = get_frame_program_space (frame);
6710 insert_step_resume_breakpoint_at_sal (gdbarch,
6711 sr_sal, null_frame_id);
6715 insert_step_resume_breakpoint_at_caller (frame);
6721 /* If we are in a function call trampoline (a stub between the
6722 calling routine and the real function), locate the real
6723 function. That's what tells us (a) whether we want to step
6724 into it at all, and (b) what prologue we want to run to the
6725 end of, if we do step into it. */
6726 real_stop_pc = skip_language_trampoline (frame, stop_pc);
6727 if (real_stop_pc == 0)
6728 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6729 if (real_stop_pc != 0)
6730 ecs->stop_func_start = real_stop_pc;
6732 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
6734 symtab_and_line sr_sal;
6735 sr_sal.pc = ecs->stop_func_start;
6736 sr_sal.pspace = get_frame_program_space (frame);
6738 insert_step_resume_breakpoint_at_sal (gdbarch,
6739 sr_sal, null_frame_id);
6744 /* If we have line number information for the function we are
6745 thinking of stepping into and the function isn't on the skip
6748 If there are several symtabs at that PC (e.g. with include
6749 files), just want to know whether *any* of them have line
6750 numbers. find_pc_line handles this. */
6752 struct symtab_and_line tmp_sal;
6754 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
6755 if (tmp_sal.line != 0
6756 && !function_name_is_marked_for_skip (ecs->stop_func_name,
6759 if (execution_direction == EXEC_REVERSE)
6760 handle_step_into_function_backward (gdbarch, ecs);
6762 handle_step_into_function (gdbarch, ecs);
6767 /* If we have no line number and the step-stop-if-no-debug is
6768 set, we stop the step so that the user has a chance to switch
6769 in assembly mode. */
6770 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6771 && step_stop_if_no_debug)
6773 end_stepping_range (ecs);
6777 if (execution_direction == EXEC_REVERSE)
6779 /* If we're already at the start of the function, we've either just
6780 stepped backward into a single instruction function without line
6781 number info, or stepped back out of a signal handler to the first
6782 instruction of the function without line number info. Just keep
6783 going, which will single-step back to the caller. */
6784 if (ecs->stop_func_start != stop_pc)
6786 /* Set a breakpoint at callee's start address.
6787 From there we can step once and be back in the caller. */
6788 symtab_and_line sr_sal;
6789 sr_sal.pc = ecs->stop_func_start;
6790 sr_sal.pspace = get_frame_program_space (frame);
6791 insert_step_resume_breakpoint_at_sal (gdbarch,
6792 sr_sal, null_frame_id);
6796 /* Set a breakpoint at callee's return address (the address
6797 at which the caller will resume). */
6798 insert_step_resume_breakpoint_at_caller (frame);
6804 /* Reverse stepping through solib trampolines. */
6806 if (execution_direction == EXEC_REVERSE
6807 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6809 CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6811 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6812 || (ecs->stop_func_start == 0
6813 && in_solib_dynsym_resolve_code (stop_pc)))
6815 /* Any solib trampoline code can be handled in reverse
6816 by simply continuing to single-step. We have already
6817 executed the solib function (backwards), and a few
6818 steps will take us back through the trampoline to the
6823 else if (in_solib_dynsym_resolve_code (stop_pc))
6825 /* Stepped backward into the solib dynsym resolver.
6826 Set a breakpoint at its start and continue, then
6827 one more step will take us out. */
6828 symtab_and_line sr_sal;
6829 sr_sal.pc = ecs->stop_func_start;
6830 sr_sal.pspace = get_frame_program_space (frame);
6831 insert_step_resume_breakpoint_at_sal (gdbarch,
6832 sr_sal, null_frame_id);
6838 stop_pc_sal = find_pc_line (ecs->event_thread->suspend.stop_pc, 0);
6840 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6841 the trampoline processing logic, however, there are some trampolines
6842 that have no names, so we should do trampoline handling first. */
6843 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6844 && ecs->stop_func_name == NULL
6845 && stop_pc_sal.line == 0)
6848 fprintf_unfiltered (gdb_stdlog,
6849 "infrun: stepped into undebuggable function\n");
6851 /* The inferior just stepped into, or returned to, an
6852 undebuggable function (where there is no debugging information
6853 and no line number corresponding to the address where the
6854 inferior stopped). Since we want to skip this kind of code,
6855 we keep going until the inferior returns from this
6856 function - unless the user has asked us not to (via
6857 set step-mode) or we no longer know how to get back
6858 to the call site. */
6859 if (step_stop_if_no_debug
6860 || !frame_id_p (frame_unwind_caller_id (frame)))
6862 /* If we have no line number and the step-stop-if-no-debug
6863 is set, we stop the step so that the user has a chance to
6864 switch in assembly mode. */
6865 end_stepping_range (ecs);
6870 /* Set a breakpoint at callee's return address (the address
6871 at which the caller will resume). */
6872 insert_step_resume_breakpoint_at_caller (frame);
6878 if (ecs->event_thread->control.step_range_end == 1)
6880 /* It is stepi or nexti. We always want to stop stepping after
6883 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
6884 end_stepping_range (ecs);
6888 if (stop_pc_sal.line == 0)
6890 /* We have no line number information. That means to stop
6891 stepping (does this always happen right after one instruction,
6892 when we do "s" in a function with no line numbers,
6893 or can this happen as a result of a return or longjmp?). */
6895 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
6896 end_stepping_range (ecs);
6900 /* Look for "calls" to inlined functions, part one. If the inline
6901 frame machinery detected some skipped call sites, we have entered
6902 a new inline function. */
6904 if (frame_id_eq (get_frame_id (get_current_frame ()),
6905 ecs->event_thread->control.step_frame_id)
6906 && inline_skipped_frames (ecs->event_thread))
6909 fprintf_unfiltered (gdb_stdlog,
6910 "infrun: stepped into inlined function\n");
6912 symtab_and_line call_sal = find_frame_sal (get_current_frame ());
6914 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
6916 /* For "step", we're going to stop. But if the call site
6917 for this inlined function is on the same source line as
6918 we were previously stepping, go down into the function
6919 first. Otherwise stop at the call site. */
6921 if (call_sal.line == ecs->event_thread->current_line
6922 && call_sal.symtab == ecs->event_thread->current_symtab)
6923 step_into_inline_frame (ecs->event_thread);
6925 end_stepping_range (ecs);
6930 /* For "next", we should stop at the call site if it is on a
6931 different source line. Otherwise continue through the
6932 inlined function. */
6933 if (call_sal.line == ecs->event_thread->current_line
6934 && call_sal.symtab == ecs->event_thread->current_symtab)
6937 end_stepping_range (ecs);
6942 /* Look for "calls" to inlined functions, part two. If we are still
6943 in the same real function we were stepping through, but we have
6944 to go further up to find the exact frame ID, we are stepping
6945 through a more inlined call beyond its call site. */
6947 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6948 && !frame_id_eq (get_frame_id (get_current_frame ()),
6949 ecs->event_thread->control.step_frame_id)
6950 && stepped_in_from (get_current_frame (),
6951 ecs->event_thread->control.step_frame_id))
6954 fprintf_unfiltered (gdb_stdlog,
6955 "infrun: stepping through inlined function\n");
6957 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6960 end_stepping_range (ecs);
6964 if ((ecs->event_thread->suspend.stop_pc == stop_pc_sal.pc)
6965 && (ecs->event_thread->current_line != stop_pc_sal.line
6966 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
6968 /* We are at the start of a different line. So stop. Note that
6969 we don't stop if we step into the middle of a different line.
6970 That is said to make things like for (;;) statements work
6973 fprintf_unfiltered (gdb_stdlog,
6974 "infrun: stepped to a different line\n");
6975 end_stepping_range (ecs);
6979 /* We aren't done stepping.
6981 Optimize by setting the stepping range to the line.
6982 (We might not be in the original line, but if we entered a
6983 new line in mid-statement, we continue stepping. This makes
6984 things like for(;;) statements work better.) */
6986 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
6987 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
6988 ecs->event_thread->control.may_range_step = 1;
6989 set_step_info (frame, stop_pc_sal);
6992 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
6996 /* In all-stop mode, if we're currently stepping but have stopped in
6997 some other thread, we may need to switch back to the stepped
6998 thread. Returns true we set the inferior running, false if we left
6999 it stopped (and the event needs further processing). */
7002 switch_back_to_stepped_thread (struct execution_control_state *ecs)
7004 if (!target_is_non_stop_p ())
7006 struct thread_info *tp;
7007 struct thread_info *stepping_thread;
7009 /* If any thread is blocked on some internal breakpoint, and we
7010 simply need to step over that breakpoint to get it going
7011 again, do that first. */
7013 /* However, if we see an event for the stepping thread, then we
7014 know all other threads have been moved past their breakpoints
7015 already. Let the caller check whether the step is finished,
7016 etc., before deciding to move it past a breakpoint. */
7017 if (ecs->event_thread->control.step_range_end != 0)
7020 /* Check if the current thread is blocked on an incomplete
7021 step-over, interrupted by a random signal. */
7022 if (ecs->event_thread->control.trap_expected
7023 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
7027 fprintf_unfiltered (gdb_stdlog,
7028 "infrun: need to finish step-over of [%s]\n",
7029 target_pid_to_str (ecs->event_thread->ptid));
7035 /* Check if the current thread is blocked by a single-step
7036 breakpoint of another thread. */
7037 if (ecs->hit_singlestep_breakpoint)
7041 fprintf_unfiltered (gdb_stdlog,
7042 "infrun: need to step [%s] over single-step "
7044 target_pid_to_str (ecs->ptid));
7050 /* If this thread needs yet another step-over (e.g., stepping
7051 through a delay slot), do it first before moving on to
7053 if (thread_still_needs_step_over (ecs->event_thread))
7057 fprintf_unfiltered (gdb_stdlog,
7058 "infrun: thread [%s] still needs step-over\n",
7059 target_pid_to_str (ecs->event_thread->ptid));
7065 /* If scheduler locking applies even if not stepping, there's no
7066 need to walk over threads. Above we've checked whether the
7067 current thread is stepping. If some other thread not the
7068 event thread is stepping, then it must be that scheduler
7069 locking is not in effect. */
7070 if (schedlock_applies (ecs->event_thread))
7073 /* Otherwise, we no longer expect a trap in the current thread.
7074 Clear the trap_expected flag before switching back -- this is
7075 what keep_going does as well, if we call it. */
7076 ecs->event_thread->control.trap_expected = 0;
7078 /* Likewise, clear the signal if it should not be passed. */
7079 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7080 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7082 /* Do all pending step-overs before actually proceeding with
7084 if (start_step_over ())
7086 prepare_to_wait (ecs);
7090 /* Look for the stepping/nexting thread. */
7091 stepping_thread = NULL;
7093 ALL_NON_EXITED_THREADS (tp)
7095 /* Ignore threads of processes the caller is not
7098 && tp->ptid.pid () != ecs->ptid.pid ())
7101 /* When stepping over a breakpoint, we lock all threads
7102 except the one that needs to move past the breakpoint.
7103 If a non-event thread has this set, the "incomplete
7104 step-over" check above should have caught it earlier. */
7105 if (tp->control.trap_expected)
7107 internal_error (__FILE__, __LINE__,
7108 "[%s] has inconsistent state: "
7109 "trap_expected=%d\n",
7110 target_pid_to_str (tp->ptid),
7111 tp->control.trap_expected);
7114 /* Did we find the stepping thread? */
7115 if (tp->control.step_range_end)
7117 /* Yep. There should only one though. */
7118 gdb_assert (stepping_thread == NULL);
7120 /* The event thread is handled at the top, before we
7122 gdb_assert (tp != ecs->event_thread);
7124 /* If some thread other than the event thread is
7125 stepping, then scheduler locking can't be in effect,
7126 otherwise we wouldn't have resumed the current event
7127 thread in the first place. */
7128 gdb_assert (!schedlock_applies (tp));
7130 stepping_thread = tp;
7134 if (stepping_thread != NULL)
7137 fprintf_unfiltered (gdb_stdlog,
7138 "infrun: switching back to stepped thread\n");
7140 if (keep_going_stepped_thread (stepping_thread))
7142 prepare_to_wait (ecs);
7151 /* Set a previously stepped thread back to stepping. Returns true on
7152 success, false if the resume is not possible (e.g., the thread
7156 keep_going_stepped_thread (struct thread_info *tp)
7158 struct frame_info *frame;
7159 struct execution_control_state ecss;
7160 struct execution_control_state *ecs = &ecss;
7162 /* If the stepping thread exited, then don't try to switch back and
7163 resume it, which could fail in several different ways depending
7164 on the target. Instead, just keep going.
7166 We can find a stepping dead thread in the thread list in two
7169 - The target supports thread exit events, and when the target
7170 tries to delete the thread from the thread list, inferior_ptid
7171 pointed at the exiting thread. In such case, calling
7172 delete_thread does not really remove the thread from the list;
7173 instead, the thread is left listed, with 'exited' state.
7175 - The target's debug interface does not support thread exit
7176 events, and so we have no idea whatsoever if the previously
7177 stepping thread is still alive. For that reason, we need to
7178 synchronously query the target now. */
7180 if (tp->state == THREAD_EXITED || !target_thread_alive (tp->ptid))
7183 fprintf_unfiltered (gdb_stdlog,
7184 "infrun: not resuming previously "
7185 "stepped thread, it has vanished\n");
7192 fprintf_unfiltered (gdb_stdlog,
7193 "infrun: resuming previously stepped thread\n");
7195 reset_ecs (ecs, tp);
7196 switch_to_thread (tp);
7198 tp->suspend.stop_pc = regcache_read_pc (get_thread_regcache (tp));
7199 frame = get_current_frame ();
7201 /* If the PC of the thread we were trying to single-step has
7202 changed, then that thread has trapped or been signaled, but the
7203 event has not been reported to GDB yet. Re-poll the target
7204 looking for this particular thread's event (i.e. temporarily
7205 enable schedlock) by:
7207 - setting a break at the current PC
7208 - resuming that particular thread, only (by setting trap
7211 This prevents us continuously moving the single-step breakpoint
7212 forward, one instruction at a time, overstepping. */
7214 if (tp->suspend.stop_pc != tp->prev_pc)
7219 fprintf_unfiltered (gdb_stdlog,
7220 "infrun: expected thread advanced also (%s -> %s)\n",
7221 paddress (target_gdbarch (), tp->prev_pc),
7222 paddress (target_gdbarch (), tp->suspend.stop_pc));
7224 /* Clear the info of the previous step-over, as it's no longer
7225 valid (if the thread was trying to step over a breakpoint, it
7226 has already succeeded). It's what keep_going would do too,
7227 if we called it. Do this before trying to insert the sss
7228 breakpoint, otherwise if we were previously trying to step
7229 over this exact address in another thread, the breakpoint is
7231 clear_step_over_info ();
7232 tp->control.trap_expected = 0;
7234 insert_single_step_breakpoint (get_frame_arch (frame),
7235 get_frame_address_space (frame),
7236 tp->suspend.stop_pc);
7239 resume_ptid = internal_resume_ptid (tp->control.stepping_command);
7240 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
7245 fprintf_unfiltered (gdb_stdlog,
7246 "infrun: expected thread still hasn't advanced\n");
7248 keep_going_pass_signal (ecs);
7253 /* Is thread TP in the middle of (software or hardware)
7254 single-stepping? (Note the result of this function must never be
7255 passed directly as target_resume's STEP parameter.) */
7258 currently_stepping (struct thread_info *tp)
7260 return ((tp->control.step_range_end
7261 && tp->control.step_resume_breakpoint == NULL)
7262 || tp->control.trap_expected
7263 || tp->stepped_breakpoint
7264 || bpstat_should_step ());
7267 /* Inferior has stepped into a subroutine call with source code that
7268 we should not step over. Do step to the first line of code in
7272 handle_step_into_function (struct gdbarch *gdbarch,
7273 struct execution_control_state *ecs)
7275 fill_in_stop_func (gdbarch, ecs);
7277 compunit_symtab *cust
7278 = find_pc_compunit_symtab (ecs->event_thread->suspend.stop_pc);
7279 if (cust != NULL && compunit_language (cust) != language_asm)
7280 ecs->stop_func_start
7281 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
7283 symtab_and_line stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
7284 /* Use the step_resume_break to step until the end of the prologue,
7285 even if that involves jumps (as it seems to on the vax under
7287 /* If the prologue ends in the middle of a source line, continue to
7288 the end of that source line (if it is still within the function).
7289 Otherwise, just go to end of prologue. */
7290 if (stop_func_sal.end
7291 && stop_func_sal.pc != ecs->stop_func_start
7292 && stop_func_sal.end < ecs->stop_func_end)
7293 ecs->stop_func_start = stop_func_sal.end;
7295 /* Architectures which require breakpoint adjustment might not be able
7296 to place a breakpoint at the computed address. If so, the test
7297 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7298 ecs->stop_func_start to an address at which a breakpoint may be
7299 legitimately placed.
7301 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7302 made, GDB will enter an infinite loop when stepping through
7303 optimized code consisting of VLIW instructions which contain
7304 subinstructions corresponding to different source lines. On
7305 FR-V, it's not permitted to place a breakpoint on any but the
7306 first subinstruction of a VLIW instruction. When a breakpoint is
7307 set, GDB will adjust the breakpoint address to the beginning of
7308 the VLIW instruction. Thus, we need to make the corresponding
7309 adjustment here when computing the stop address. */
7311 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
7313 ecs->stop_func_start
7314 = gdbarch_adjust_breakpoint_address (gdbarch,
7315 ecs->stop_func_start);
7318 if (ecs->stop_func_start == ecs->event_thread->suspend.stop_pc)
7320 /* We are already there: stop now. */
7321 end_stepping_range (ecs);
7326 /* Put the step-breakpoint there and go until there. */
7327 symtab_and_line sr_sal;
7328 sr_sal.pc = ecs->stop_func_start;
7329 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
7330 sr_sal.pspace = get_frame_program_space (get_current_frame ());
7332 /* Do not specify what the fp should be when we stop since on
7333 some machines the prologue is where the new fp value is
7335 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
7337 /* And make sure stepping stops right away then. */
7338 ecs->event_thread->control.step_range_end
7339 = ecs->event_thread->control.step_range_start;
7344 /* Inferior has stepped backward into a subroutine call with source
7345 code that we should not step over. Do step to the beginning of the
7346 last line of code in it. */
7349 handle_step_into_function_backward (struct gdbarch *gdbarch,
7350 struct execution_control_state *ecs)
7352 struct compunit_symtab *cust;
7353 struct symtab_and_line stop_func_sal;
7355 fill_in_stop_func (gdbarch, ecs);
7357 cust = find_pc_compunit_symtab (ecs->event_thread->suspend.stop_pc);
7358 if (cust != NULL && compunit_language (cust) != language_asm)
7359 ecs->stop_func_start
7360 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
7362 stop_func_sal = find_pc_line (ecs->event_thread->suspend.stop_pc, 0);
7364 /* OK, we're just going to keep stepping here. */
7365 if (stop_func_sal.pc == ecs->event_thread->suspend.stop_pc)
7367 /* We're there already. Just stop stepping now. */
7368 end_stepping_range (ecs);
7372 /* Else just reset the step range and keep going.
7373 No step-resume breakpoint, they don't work for
7374 epilogues, which can have multiple entry paths. */
7375 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
7376 ecs->event_thread->control.step_range_end = stop_func_sal.end;
7382 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7383 This is used to both functions and to skip over code. */
7386 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
7387 struct symtab_and_line sr_sal,
7388 struct frame_id sr_id,
7389 enum bptype sr_type)
7391 /* There should never be more than one step-resume or longjmp-resume
7392 breakpoint per thread, so we should never be setting a new
7393 step_resume_breakpoint when one is already active. */
7394 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
7395 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
7398 fprintf_unfiltered (gdb_stdlog,
7399 "infrun: inserting step-resume breakpoint at %s\n",
7400 paddress (gdbarch, sr_sal.pc));
7402 inferior_thread ()->control.step_resume_breakpoint
7403 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type).release ();
7407 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
7408 struct symtab_and_line sr_sal,
7409 struct frame_id sr_id)
7411 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
7416 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7417 This is used to skip a potential signal handler.
7419 This is called with the interrupted function's frame. The signal
7420 handler, when it returns, will resume the interrupted function at
7424 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
7426 gdb_assert (return_frame != NULL);
7428 struct gdbarch *gdbarch = get_frame_arch (return_frame);
7430 symtab_and_line sr_sal;
7431 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
7432 sr_sal.section = find_pc_overlay (sr_sal.pc);
7433 sr_sal.pspace = get_frame_program_space (return_frame);
7435 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
7436 get_stack_frame_id (return_frame),
7440 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7441 is used to skip a function after stepping into it (for "next" or if
7442 the called function has no debugging information).
7444 The current function has almost always been reached by single
7445 stepping a call or return instruction. NEXT_FRAME belongs to the
7446 current function, and the breakpoint will be set at the caller's
7449 This is a separate function rather than reusing
7450 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7451 get_prev_frame, which may stop prematurely (see the implementation
7452 of frame_unwind_caller_id for an example). */
7455 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
7457 /* We shouldn't have gotten here if we don't know where the call site
7459 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
7461 struct gdbarch *gdbarch = frame_unwind_caller_arch (next_frame);
7463 symtab_and_line sr_sal;
7464 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
7465 frame_unwind_caller_pc (next_frame));
7466 sr_sal.section = find_pc_overlay (sr_sal.pc);
7467 sr_sal.pspace = frame_unwind_program_space (next_frame);
7469 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
7470 frame_unwind_caller_id (next_frame));
7473 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7474 new breakpoint at the target of a jmp_buf. The handling of
7475 longjmp-resume uses the same mechanisms used for handling
7476 "step-resume" breakpoints. */
7479 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
7481 /* There should never be more than one longjmp-resume breakpoint per
7482 thread, so we should never be setting a new
7483 longjmp_resume_breakpoint when one is already active. */
7484 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
7487 fprintf_unfiltered (gdb_stdlog,
7488 "infrun: inserting longjmp-resume breakpoint at %s\n",
7489 paddress (gdbarch, pc));
7491 inferior_thread ()->control.exception_resume_breakpoint =
7492 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume).release ();
7495 /* Insert an exception resume breakpoint. TP is the thread throwing
7496 the exception. The block B is the block of the unwinder debug hook
7497 function. FRAME is the frame corresponding to the call to this
7498 function. SYM is the symbol of the function argument holding the
7499 target PC of the exception. */
7502 insert_exception_resume_breakpoint (struct thread_info *tp,
7503 const struct block *b,
7504 struct frame_info *frame,
7509 struct block_symbol vsym;
7510 struct value *value;
7512 struct breakpoint *bp;
7514 vsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
7516 value = read_var_value (vsym.symbol, vsym.block, frame);
7517 /* If the value was optimized out, revert to the old behavior. */
7518 if (! value_optimized_out (value))
7520 handler = value_as_address (value);
7523 fprintf_unfiltered (gdb_stdlog,
7524 "infrun: exception resume at %lx\n",
7525 (unsigned long) handler);
7527 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7529 bp_exception_resume).release ();
7531 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7534 bp->thread = tp->global_num;
7535 inferior_thread ()->control.exception_resume_breakpoint = bp;
7538 CATCH (e, RETURN_MASK_ERROR)
7540 /* We want to ignore errors here. */
7545 /* A helper for check_exception_resume that sets an
7546 exception-breakpoint based on a SystemTap probe. */
7549 insert_exception_resume_from_probe (struct thread_info *tp,
7550 const struct bound_probe *probe,
7551 struct frame_info *frame)
7553 struct value *arg_value;
7555 struct breakpoint *bp;
7557 arg_value = probe_safe_evaluate_at_pc (frame, 1);
7561 handler = value_as_address (arg_value);
7564 fprintf_unfiltered (gdb_stdlog,
7565 "infrun: exception resume at %s\n",
7566 paddress (get_objfile_arch (probe->objfile),
7569 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7570 handler, bp_exception_resume).release ();
7571 bp->thread = tp->global_num;
7572 inferior_thread ()->control.exception_resume_breakpoint = bp;
7575 /* This is called when an exception has been intercepted. Check to
7576 see whether the exception's destination is of interest, and if so,
7577 set an exception resume breakpoint there. */
7580 check_exception_resume (struct execution_control_state *ecs,
7581 struct frame_info *frame)
7583 struct bound_probe probe;
7584 struct symbol *func;
7586 /* First see if this exception unwinding breakpoint was set via a
7587 SystemTap probe point. If so, the probe has two arguments: the
7588 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7589 set a breakpoint there. */
7590 probe = find_probe_by_pc (get_frame_pc (frame));
7593 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
7597 func = get_frame_function (frame);
7603 const struct block *b;
7604 struct block_iterator iter;
7608 /* The exception breakpoint is a thread-specific breakpoint on
7609 the unwinder's debug hook, declared as:
7611 void _Unwind_DebugHook (void *cfa, void *handler);
7613 The CFA argument indicates the frame to which control is
7614 about to be transferred. HANDLER is the destination PC.
7616 We ignore the CFA and set a temporary breakpoint at HANDLER.
7617 This is not extremely efficient but it avoids issues in gdb
7618 with computing the DWARF CFA, and it also works even in weird
7619 cases such as throwing an exception from inside a signal
7622 b = SYMBOL_BLOCK_VALUE (func);
7623 ALL_BLOCK_SYMBOLS (b, iter, sym)
7625 if (!SYMBOL_IS_ARGUMENT (sym))
7632 insert_exception_resume_breakpoint (ecs->event_thread,
7638 CATCH (e, RETURN_MASK_ERROR)
7645 stop_waiting (struct execution_control_state *ecs)
7648 fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
7650 /* Let callers know we don't want to wait for the inferior anymore. */
7651 ecs->wait_some_more = 0;
7653 /* If all-stop, but the target is always in non-stop mode, stop all
7654 threads now that we're presenting the stop to the user. */
7655 if (!non_stop && target_is_non_stop_p ())
7656 stop_all_threads ();
7659 /* Like keep_going, but passes the signal to the inferior, even if the
7660 signal is set to nopass. */
7663 keep_going_pass_signal (struct execution_control_state *ecs)
7665 gdb_assert (ecs->event_thread->ptid == inferior_ptid);
7666 gdb_assert (!ecs->event_thread->resumed);
7668 /* Save the pc before execution, to compare with pc after stop. */
7669 ecs->event_thread->prev_pc
7670 = regcache_read_pc (get_thread_regcache (ecs->event_thread));
7672 if (ecs->event_thread->control.trap_expected)
7674 struct thread_info *tp = ecs->event_thread;
7677 fprintf_unfiltered (gdb_stdlog,
7678 "infrun: %s has trap_expected set, "
7679 "resuming to collect trap\n",
7680 target_pid_to_str (tp->ptid));
7682 /* We haven't yet gotten our trap, and either: intercepted a
7683 non-signal event (e.g., a fork); or took a signal which we
7684 are supposed to pass through to the inferior. Simply
7686 resume (ecs->event_thread->suspend.stop_signal);
7688 else if (step_over_info_valid_p ())
7690 /* Another thread is stepping over a breakpoint in-line. If
7691 this thread needs a step-over too, queue the request. In
7692 either case, this resume must be deferred for later. */
7693 struct thread_info *tp = ecs->event_thread;
7695 if (ecs->hit_singlestep_breakpoint
7696 || thread_still_needs_step_over (tp))
7699 fprintf_unfiltered (gdb_stdlog,
7700 "infrun: step-over already in progress: "
7701 "step-over for %s deferred\n",
7702 target_pid_to_str (tp->ptid));
7703 thread_step_over_chain_enqueue (tp);
7708 fprintf_unfiltered (gdb_stdlog,
7709 "infrun: step-over in progress: "
7710 "resume of %s deferred\n",
7711 target_pid_to_str (tp->ptid));
7716 struct regcache *regcache = get_current_regcache ();
7719 step_over_what step_what;
7721 /* Either the trap was not expected, but we are continuing
7722 anyway (if we got a signal, the user asked it be passed to
7725 We got our expected trap, but decided we should resume from
7728 We're going to run this baby now!
7730 Note that insert_breakpoints won't try to re-insert
7731 already inserted breakpoints. Therefore, we don't
7732 care if breakpoints were already inserted, or not. */
7734 /* If we need to step over a breakpoint, and we're not using
7735 displaced stepping to do so, insert all breakpoints
7736 (watchpoints, etc.) but the one we're stepping over, step one
7737 instruction, and then re-insert the breakpoint when that step
7740 step_what = thread_still_needs_step_over (ecs->event_thread);
7742 remove_bp = (ecs->hit_singlestep_breakpoint
7743 || (step_what & STEP_OVER_BREAKPOINT));
7744 remove_wps = (step_what & STEP_OVER_WATCHPOINT);
7746 /* We can't use displaced stepping if we need to step past a
7747 watchpoint. The instruction copied to the scratch pad would
7748 still trigger the watchpoint. */
7750 && (remove_wps || !use_displaced_stepping (ecs->event_thread)))
7752 set_step_over_info (regcache->aspace (),
7753 regcache_read_pc (regcache), remove_wps,
7754 ecs->event_thread->global_num);
7756 else if (remove_wps)
7757 set_step_over_info (NULL, 0, remove_wps, -1);
7759 /* If we now need to do an in-line step-over, we need to stop
7760 all other threads. Note this must be done before
7761 insert_breakpoints below, because that removes the breakpoint
7762 we're about to step over, otherwise other threads could miss
7764 if (step_over_info_valid_p () && target_is_non_stop_p ())
7765 stop_all_threads ();
7767 /* Stop stepping if inserting breakpoints fails. */
7770 insert_breakpoints ();
7772 CATCH (e, RETURN_MASK_ERROR)
7774 exception_print (gdb_stderr, e);
7776 clear_step_over_info ();
7781 ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
7783 resume (ecs->event_thread->suspend.stop_signal);
7786 prepare_to_wait (ecs);
7789 /* Called when we should continue running the inferior, because the
7790 current event doesn't cause a user visible stop. This does the
7791 resuming part; waiting for the next event is done elsewhere. */
7794 keep_going (struct execution_control_state *ecs)
7796 if (ecs->event_thread->control.trap_expected
7797 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
7798 ecs->event_thread->control.trap_expected = 0;
7800 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7801 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7802 keep_going_pass_signal (ecs);
7805 /* This function normally comes after a resume, before
7806 handle_inferior_event exits. It takes care of any last bits of
7807 housekeeping, and sets the all-important wait_some_more flag. */
7810 prepare_to_wait (struct execution_control_state *ecs)
7813 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
7815 ecs->wait_some_more = 1;
7817 if (!target_is_async_p ())
7818 mark_infrun_async_event_handler ();
7821 /* We are done with the step range of a step/next/si/ni command.
7822 Called once for each n of a "step n" operation. */
7825 end_stepping_range (struct execution_control_state *ecs)
7827 ecs->event_thread->control.stop_step = 1;
7831 /* Several print_*_reason functions to print why the inferior has stopped.
7832 We always print something when the inferior exits, or receives a signal.
7833 The rest of the cases are dealt with later on in normal_stop and
7834 print_it_typical. Ideally there should be a call to one of these
7835 print_*_reason functions functions from handle_inferior_event each time
7836 stop_waiting is called.
7838 Note that we don't call these directly, instead we delegate that to
7839 the interpreters, through observers. Interpreters then call these
7840 with whatever uiout is right. */
7843 print_end_stepping_range_reason (struct ui_out *uiout)
7845 /* For CLI-like interpreters, print nothing. */
7847 if (uiout->is_mi_like_p ())
7849 uiout->field_string ("reason",
7850 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
7855 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7857 annotate_signalled ();
7858 if (uiout->is_mi_like_p ())
7860 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
7861 uiout->text ("\nProgram terminated with signal ");
7862 annotate_signal_name ();
7863 uiout->field_string ("signal-name",
7864 gdb_signal_to_name (siggnal));
7865 annotate_signal_name_end ();
7867 annotate_signal_string ();
7868 uiout->field_string ("signal-meaning",
7869 gdb_signal_to_string (siggnal));
7870 annotate_signal_string_end ();
7871 uiout->text (".\n");
7872 uiout->text ("The program no longer exists.\n");
7876 print_exited_reason (struct ui_out *uiout, int exitstatus)
7878 struct inferior *inf = current_inferior ();
7879 const char *pidstr = target_pid_to_str (ptid_t (inf->pid));
7881 annotate_exited (exitstatus);
7884 if (uiout->is_mi_like_p ())
7885 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));
7886 uiout->text ("[Inferior ");
7887 uiout->text (plongest (inf->num));
7889 uiout->text (pidstr);
7890 uiout->text (") exited with code ");
7891 uiout->field_fmt ("exit-code", "0%o", (unsigned int) exitstatus);
7892 uiout->text ("]\n");
7896 if (uiout->is_mi_like_p ())
7898 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
7899 uiout->text ("[Inferior ");
7900 uiout->text (plongest (inf->num));
7902 uiout->text (pidstr);
7903 uiout->text (") exited normally]\n");
7907 /* Some targets/architectures can do extra processing/display of
7908 segmentation faults. E.g., Intel MPX boundary faults.
7909 Call the architecture dependent function to handle the fault. */
7912 handle_segmentation_fault (struct ui_out *uiout)
7914 struct regcache *regcache = get_current_regcache ();
7915 struct gdbarch *gdbarch = regcache->arch ();
7917 if (gdbarch_handle_segmentation_fault_p (gdbarch))
7918 gdbarch_handle_segmentation_fault (gdbarch, uiout);
7922 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7924 struct thread_info *thr = inferior_thread ();
7928 if (uiout->is_mi_like_p ())
7930 else if (show_thread_that_caused_stop ())
7934 uiout->text ("\nThread ");
7935 uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
7937 name = thr->name != NULL ? thr->name : target_thread_name (thr);
7940 uiout->text (" \"");
7941 uiout->field_fmt ("name", "%s", name);
7946 uiout->text ("\nProgram");
7948 if (siggnal == GDB_SIGNAL_0 && !uiout->is_mi_like_p ())
7949 uiout->text (" stopped");
7952 uiout->text (" received signal ");
7953 annotate_signal_name ();
7954 if (uiout->is_mi_like_p ())
7956 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
7957 uiout->field_string ("signal-name", gdb_signal_to_name (siggnal));
7958 annotate_signal_name_end ();
7960 annotate_signal_string ();
7961 uiout->field_string ("signal-meaning", gdb_signal_to_string (siggnal));
7963 if (siggnal == GDB_SIGNAL_SEGV)
7964 handle_segmentation_fault (uiout);
7966 annotate_signal_string_end ();
7968 uiout->text (".\n");
7972 print_no_history_reason (struct ui_out *uiout)
7974 uiout->text ("\nNo more reverse-execution history.\n");
7977 /* Print current location without a level number, if we have changed
7978 functions or hit a breakpoint. Print source line if we have one.
7979 bpstat_print contains the logic deciding in detail what to print,
7980 based on the event(s) that just occurred. */
7983 print_stop_location (struct target_waitstatus *ws)
7986 enum print_what source_flag;
7987 int do_frame_printing = 1;
7988 struct thread_info *tp = inferior_thread ();
7990 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
7994 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
7995 should) carry around the function and does (or should) use
7996 that when doing a frame comparison. */
7997 if (tp->control.stop_step
7998 && frame_id_eq (tp->control.step_frame_id,
7999 get_frame_id (get_current_frame ()))
8000 && (tp->control.step_start_function
8001 == find_pc_function (tp->suspend.stop_pc)))
8003 /* Finished step, just print source line. */
8004 source_flag = SRC_LINE;
8008 /* Print location and source line. */
8009 source_flag = SRC_AND_LOC;
8012 case PRINT_SRC_AND_LOC:
8013 /* Print location and source line. */
8014 source_flag = SRC_AND_LOC;
8016 case PRINT_SRC_ONLY:
8017 source_flag = SRC_LINE;
8020 /* Something bogus. */
8021 source_flag = SRC_LINE;
8022 do_frame_printing = 0;
8025 internal_error (__FILE__, __LINE__, _("Unknown value."));
8028 /* The behavior of this routine with respect to the source
8030 SRC_LINE: Print only source line
8031 LOCATION: Print only location
8032 SRC_AND_LOC: Print location and source line. */
8033 if (do_frame_printing)
8034 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
8040 print_stop_event (struct ui_out *uiout)
8042 struct target_waitstatus last;
8044 struct thread_info *tp;
8046 get_last_target_status (&last_ptid, &last);
8049 scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
8051 print_stop_location (&last);
8053 /* Display the auto-display expressions. */
8057 tp = inferior_thread ();
8058 if (tp->thread_fsm != NULL
8059 && thread_fsm_finished_p (tp->thread_fsm))
8061 struct return_value_info *rv;
8063 rv = thread_fsm_return_value (tp->thread_fsm);
8065 print_return_value (uiout, rv);
8072 maybe_remove_breakpoints (void)
8074 if (!breakpoints_should_be_inserted_now () && target_has_execution)
8076 if (remove_breakpoints ())
8078 target_terminal::ours_for_output ();
8079 printf_filtered (_("Cannot remove breakpoints because "
8080 "program is no longer writable.\nFurther "
8081 "execution is probably impossible.\n"));
8086 /* The execution context that just caused a normal stop. */
8093 DISABLE_COPY_AND_ASSIGN (stop_context);
8095 bool changed () const;
8100 /* The event PTID. */
8104 /* If stopp for a thread event, this is the thread that caused the
8106 struct thread_info *thread;
8108 /* The inferior that caused the stop. */
8112 /* Initializes a new stop context. If stopped for a thread event, this
8113 takes a strong reference to the thread. */
8115 stop_context::stop_context ()
8117 stop_id = get_stop_id ();
8118 ptid = inferior_ptid;
8119 inf_num = current_inferior ()->num;
8121 if (inferior_ptid != null_ptid)
8123 /* Take a strong reference so that the thread can't be deleted
8125 thread = inferior_thread ();
8132 /* Release a stop context previously created with save_stop_context.
8133 Releases the strong reference to the thread as well. */
8135 stop_context::~stop_context ()
8141 /* Return true if the current context no longer matches the saved stop
8145 stop_context::changed () const
8147 if (ptid != inferior_ptid)
8149 if (inf_num != current_inferior ()->num)
8151 if (thread != NULL && thread->state != THREAD_STOPPED)
8153 if (get_stop_id () != stop_id)
8163 struct target_waitstatus last;
8166 get_last_target_status (&last_ptid, &last);
8170 /* If an exception is thrown from this point on, make sure to
8171 propagate GDB's knowledge of the executing state to the
8172 frontend/user running state. A QUIT is an easy exception to see
8173 here, so do this before any filtered output. */
8175 gdb::optional<scoped_finish_thread_state> maybe_finish_thread_state;
8178 maybe_finish_thread_state.emplace (minus_one_ptid);
8179 else if (last.kind == TARGET_WAITKIND_SIGNALLED
8180 || last.kind == TARGET_WAITKIND_EXITED)
8182 /* On some targets, we may still have live threads in the
8183 inferior when we get a process exit event. E.g., for
8184 "checkpoint", when the current checkpoint/fork exits,
8185 linux-fork.c automatically switches to another fork from
8186 within target_mourn_inferior. */
8187 if (inferior_ptid != null_ptid)
8188 maybe_finish_thread_state.emplace (ptid_t (inferior_ptid.pid ()));
8190 else if (last.kind != TARGET_WAITKIND_NO_RESUMED)
8191 maybe_finish_thread_state.emplace (inferior_ptid);
8193 /* As we're presenting a stop, and potentially removing breakpoints,
8194 update the thread list so we can tell whether there are threads
8195 running on the target. With target remote, for example, we can
8196 only learn about new threads when we explicitly update the thread
8197 list. Do this before notifying the interpreters about signal
8198 stops, end of stepping ranges, etc., so that the "new thread"
8199 output is emitted before e.g., "Program received signal FOO",
8200 instead of after. */
8201 update_thread_list ();
8203 if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
8204 gdb::observers::signal_received.notify (inferior_thread ()->suspend.stop_signal);
8206 /* As with the notification of thread events, we want to delay
8207 notifying the user that we've switched thread context until
8208 the inferior actually stops.
8210 There's no point in saying anything if the inferior has exited.
8211 Note that SIGNALLED here means "exited with a signal", not
8212 "received a signal".
8214 Also skip saying anything in non-stop mode. In that mode, as we
8215 don't want GDB to switch threads behind the user's back, to avoid
8216 races where the user is typing a command to apply to thread x,
8217 but GDB switches to thread y before the user finishes entering
8218 the command, fetch_inferior_event installs a cleanup to restore
8219 the current thread back to the thread the user had selected right
8220 after this event is handled, so we're not really switching, only
8221 informing of a stop. */
8223 && previous_inferior_ptid != inferior_ptid
8224 && target_has_execution
8225 && last.kind != TARGET_WAITKIND_SIGNALLED
8226 && last.kind != TARGET_WAITKIND_EXITED
8227 && last.kind != TARGET_WAITKIND_NO_RESUMED)
8229 SWITCH_THRU_ALL_UIS ()
8231 target_terminal::ours_for_output ();
8232 printf_filtered (_("[Switching to %s]\n"),
8233 target_pid_to_str (inferior_ptid));
8234 annotate_thread_changed ();
8236 previous_inferior_ptid = inferior_ptid;
8239 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
8241 SWITCH_THRU_ALL_UIS ()
8242 if (current_ui->prompt_state == PROMPT_BLOCKED)
8244 target_terminal::ours_for_output ();
8245 printf_filtered (_("No unwaited-for children left.\n"));
8249 /* Note: this depends on the update_thread_list call above. */
8250 maybe_remove_breakpoints ();
8252 /* If an auto-display called a function and that got a signal,
8253 delete that auto-display to avoid an infinite recursion. */
8255 if (stopped_by_random_signal)
8256 disable_current_display ();
8258 SWITCH_THRU_ALL_UIS ()
8260 async_enable_stdin ();
8263 /* Let the user/frontend see the threads as stopped. */
8264 maybe_finish_thread_state.reset ();
8266 /* Select innermost stack frame - i.e., current frame is frame 0,
8267 and current location is based on that. Handle the case where the
8268 dummy call is returning after being stopped. E.g. the dummy call
8269 previously hit a breakpoint. (If the dummy call returns
8270 normally, we won't reach here.) Do this before the stop hook is
8271 run, so that it doesn't get to see the temporary dummy frame,
8272 which is not where we'll present the stop. */
8273 if (has_stack_frames ())
8275 if (stop_stack_dummy == STOP_STACK_DUMMY)
8277 /* Pop the empty frame that contains the stack dummy. This
8278 also restores inferior state prior to the call (struct
8279 infcall_suspend_state). */
8280 struct frame_info *frame = get_current_frame ();
8282 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
8284 /* frame_pop calls reinit_frame_cache as the last thing it
8285 does which means there's now no selected frame. */
8288 select_frame (get_current_frame ());
8290 /* Set the current source location. */
8291 set_current_sal_from_frame (get_current_frame ());
8294 /* Look up the hook_stop and run it (CLI internally handles problem
8295 of stop_command's pre-hook not existing). */
8296 if (stop_command != NULL)
8298 stop_context saved_context;
8302 execute_cmd_pre_hook (stop_command);
8304 CATCH (ex, RETURN_MASK_ALL)
8306 exception_fprintf (gdb_stderr, ex,
8307 "Error while running hook_stop:\n");
8311 /* If the stop hook resumes the target, then there's no point in
8312 trying to notify about the previous stop; its context is
8313 gone. Likewise if the command switches thread or inferior --
8314 the observers would print a stop for the wrong
8316 if (saved_context.changed ())
8320 /* Notify observers about the stop. This is where the interpreters
8321 print the stop event. */
8322 if (inferior_ptid != null_ptid)
8323 gdb::observers::normal_stop.notify (inferior_thread ()->control.stop_bpstat,
8326 gdb::observers::normal_stop.notify (NULL, stop_print_frame);
8328 annotate_stopped ();
8330 if (target_has_execution)
8332 if (last.kind != TARGET_WAITKIND_SIGNALLED
8333 && last.kind != TARGET_WAITKIND_EXITED)
8334 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8335 Delete any breakpoint that is to be deleted at the next stop. */
8336 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
8339 /* Try to get rid of automatically added inferiors that are no
8340 longer needed. Keeping those around slows down things linearly.
8341 Note that this never removes the current inferior. */
8348 signal_stop_state (int signo)
8350 return signal_stop[signo];
8354 signal_print_state (int signo)
8356 return signal_print[signo];
8360 signal_pass_state (int signo)
8362 return signal_program[signo];
8366 signal_cache_update (int signo)
8370 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
8371 signal_cache_update (signo);
8376 signal_pass[signo] = (signal_stop[signo] == 0
8377 && signal_print[signo] == 0
8378 && signal_program[signo] == 1
8379 && signal_catch[signo] == 0);
8383 signal_stop_update (int signo, int state)
8385 int ret = signal_stop[signo];
8387 signal_stop[signo] = state;
8388 signal_cache_update (signo);
8393 signal_print_update (int signo, int state)
8395 int ret = signal_print[signo];
8397 signal_print[signo] = state;
8398 signal_cache_update (signo);
8403 signal_pass_update (int signo, int state)
8405 int ret = signal_program[signo];
8407 signal_program[signo] = state;
8408 signal_cache_update (signo);
8412 /* Update the global 'signal_catch' from INFO and notify the
8416 signal_catch_update (const unsigned int *info)
8420 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
8421 signal_catch[i] = info[i] > 0;
8422 signal_cache_update (-1);
8423 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8427 sig_print_header (void)
8429 printf_filtered (_("Signal Stop\tPrint\tPass "
8430 "to program\tDescription\n"));
8434 sig_print_info (enum gdb_signal oursig)
8436 const char *name = gdb_signal_to_name (oursig);
8437 int name_padding = 13 - strlen (name);
8439 if (name_padding <= 0)
8442 printf_filtered ("%s", name);
8443 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
8444 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
8445 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
8446 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
8447 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
8450 /* Specify how various signals in the inferior should be handled. */
8453 handle_command (const char *args, int from_tty)
8455 int digits, wordlen;
8456 int sigfirst, siglast;
8457 enum gdb_signal oursig;
8460 unsigned char *sigs;
8464 error_no_arg (_("signal to handle"));
8467 /* Allocate and zero an array of flags for which signals to handle. */
8469 nsigs = (int) GDB_SIGNAL_LAST;
8470 sigs = (unsigned char *) alloca (nsigs);
8471 memset (sigs, 0, nsigs);
8473 /* Break the command line up into args. */
8475 gdb_argv built_argv (args);
8477 /* Walk through the args, looking for signal oursigs, signal names, and
8478 actions. Signal numbers and signal names may be interspersed with
8479 actions, with the actions being performed for all signals cumulatively
8480 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8482 for (char *arg : built_argv)
8484 wordlen = strlen (arg);
8485 for (digits = 0; isdigit (arg[digits]); digits++)
8489 sigfirst = siglast = -1;
8491 if (wordlen >= 1 && !strncmp (arg, "all", wordlen))
8493 /* Apply action to all signals except those used by the
8494 debugger. Silently skip those. */
8497 siglast = nsigs - 1;
8499 else if (wordlen >= 1 && !strncmp (arg, "stop", wordlen))
8501 SET_SIGS (nsigs, sigs, signal_stop);
8502 SET_SIGS (nsigs, sigs, signal_print);
8504 else if (wordlen >= 1 && !strncmp (arg, "ignore", wordlen))
8506 UNSET_SIGS (nsigs, sigs, signal_program);
8508 else if (wordlen >= 2 && !strncmp (arg, "print", wordlen))
8510 SET_SIGS (nsigs, sigs, signal_print);
8512 else if (wordlen >= 2 && !strncmp (arg, "pass", wordlen))
8514 SET_SIGS (nsigs, sigs, signal_program);
8516 else if (wordlen >= 3 && !strncmp (arg, "nostop", wordlen))
8518 UNSET_SIGS (nsigs, sigs, signal_stop);
8520 else if (wordlen >= 3 && !strncmp (arg, "noignore", wordlen))
8522 SET_SIGS (nsigs, sigs, signal_program);
8524 else if (wordlen >= 4 && !strncmp (arg, "noprint", wordlen))
8526 UNSET_SIGS (nsigs, sigs, signal_print);
8527 UNSET_SIGS (nsigs, sigs, signal_stop);
8529 else if (wordlen >= 4 && !strncmp (arg, "nopass", wordlen))
8531 UNSET_SIGS (nsigs, sigs, signal_program);
8533 else if (digits > 0)
8535 /* It is numeric. The numeric signal refers to our own
8536 internal signal numbering from target.h, not to host/target
8537 signal number. This is a feature; users really should be
8538 using symbolic names anyway, and the common ones like
8539 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8541 sigfirst = siglast = (int)
8542 gdb_signal_from_command (atoi (arg));
8543 if (arg[digits] == '-')
8546 gdb_signal_from_command (atoi (arg + digits + 1));
8548 if (sigfirst > siglast)
8550 /* Bet he didn't figure we'd think of this case... */
8551 std::swap (sigfirst, siglast);
8556 oursig = gdb_signal_from_name (arg);
8557 if (oursig != GDB_SIGNAL_UNKNOWN)
8559 sigfirst = siglast = (int) oursig;
8563 /* Not a number and not a recognized flag word => complain. */
8564 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg);
8568 /* If any signal numbers or symbol names were found, set flags for
8569 which signals to apply actions to. */
8571 for (int signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
8573 switch ((enum gdb_signal) signum)
8575 case GDB_SIGNAL_TRAP:
8576 case GDB_SIGNAL_INT:
8577 if (!allsigs && !sigs[signum])
8579 if (query (_("%s is used by the debugger.\n\
8580 Are you sure you want to change it? "),
8581 gdb_signal_to_name ((enum gdb_signal) signum)))
8587 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8588 gdb_flush (gdb_stdout);
8593 case GDB_SIGNAL_DEFAULT:
8594 case GDB_SIGNAL_UNKNOWN:
8595 /* Make sure that "all" doesn't print these. */
8604 for (int signum = 0; signum < nsigs; signum++)
8607 signal_cache_update (-1);
8608 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8609 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
8613 /* Show the results. */
8614 sig_print_header ();
8615 for (; signum < nsigs; signum++)
8617 sig_print_info ((enum gdb_signal) signum);
8624 /* Complete the "handle" command. */
8627 handle_completer (struct cmd_list_element *ignore,
8628 completion_tracker &tracker,
8629 const char *text, const char *word)
8631 static const char * const keywords[] =
8645 signal_completer (ignore, tracker, text, word);
8646 complete_on_enum (tracker, keywords, word, word);
8650 gdb_signal_from_command (int num)
8652 if (num >= 1 && num <= 15)
8653 return (enum gdb_signal) num;
8654 error (_("Only signals 1-15 are valid as numeric signals.\n\
8655 Use \"info signals\" for a list of symbolic signals."));
8658 /* Print current contents of the tables set by the handle command.
8659 It is possible we should just be printing signals actually used
8660 by the current target (but for things to work right when switching
8661 targets, all signals should be in the signal tables). */
8664 info_signals_command (const char *signum_exp, int from_tty)
8666 enum gdb_signal oursig;
8668 sig_print_header ();
8672 /* First see if this is a symbol name. */
8673 oursig = gdb_signal_from_name (signum_exp);
8674 if (oursig == GDB_SIGNAL_UNKNOWN)
8676 /* No, try numeric. */
8678 gdb_signal_from_command (parse_and_eval_long (signum_exp));
8680 sig_print_info (oursig);
8684 printf_filtered ("\n");
8685 /* These ugly casts brought to you by the native VAX compiler. */
8686 for (oursig = GDB_SIGNAL_FIRST;
8687 (int) oursig < (int) GDB_SIGNAL_LAST;
8688 oursig = (enum gdb_signal) ((int) oursig + 1))
8692 if (oursig != GDB_SIGNAL_UNKNOWN
8693 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
8694 sig_print_info (oursig);
8697 printf_filtered (_("\nUse the \"handle\" command "
8698 "to change these tables.\n"));
8701 /* The $_siginfo convenience variable is a bit special. We don't know
8702 for sure the type of the value until we actually have a chance to
8703 fetch the data. The type can change depending on gdbarch, so it is
8704 also dependent on which thread you have selected.
8706 1. making $_siginfo be an internalvar that creates a new value on
8709 2. making the value of $_siginfo be an lval_computed value. */
8711 /* This function implements the lval_computed support for reading a
8715 siginfo_value_read (struct value *v)
8717 LONGEST transferred;
8719 /* If we can access registers, so can we access $_siginfo. Likewise
8721 validate_registers_access ();
8724 target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO,
8726 value_contents_all_raw (v),
8728 TYPE_LENGTH (value_type (v)));
8730 if (transferred != TYPE_LENGTH (value_type (v)))
8731 error (_("Unable to read siginfo"));
8734 /* This function implements the lval_computed support for writing a
8738 siginfo_value_write (struct value *v, struct value *fromval)
8740 LONGEST transferred;
8742 /* If we can access registers, so can we access $_siginfo. Likewise
8744 validate_registers_access ();
8746 transferred = target_write (current_top_target (),
8747 TARGET_OBJECT_SIGNAL_INFO,
8749 value_contents_all_raw (fromval),
8751 TYPE_LENGTH (value_type (fromval)));
8753 if (transferred != TYPE_LENGTH (value_type (fromval)))
8754 error (_("Unable to write siginfo"));
8757 static const struct lval_funcs siginfo_value_funcs =
8763 /* Return a new value with the correct type for the siginfo object of
8764 the current thread using architecture GDBARCH. Return a void value
8765 if there's no object available. */
8767 static struct value *
8768 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
8771 if (target_has_stack
8772 && inferior_ptid != null_ptid
8773 && gdbarch_get_siginfo_type_p (gdbarch))
8775 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8777 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
8780 return allocate_value (builtin_type (gdbarch)->builtin_void);
8784 /* infcall_suspend_state contains state about the program itself like its
8785 registers and any signal it received when it last stopped.
8786 This state must be restored regardless of how the inferior function call
8787 ends (either successfully, or after it hits a breakpoint or signal)
8788 if the program is to properly continue where it left off. */
8790 struct infcall_suspend_state
8792 struct thread_suspend_state thread_suspend;
8795 std::unique_ptr<readonly_detached_regcache> registers;
8797 /* Format of SIGINFO_DATA or NULL if it is not present. */
8798 struct gdbarch *siginfo_gdbarch = nullptr;
8800 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8801 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8802 content would be invalid. */
8803 gdb::unique_xmalloc_ptr<gdb_byte> siginfo_data;
8806 infcall_suspend_state_up
8807 save_infcall_suspend_state ()
8809 struct thread_info *tp = inferior_thread ();
8810 struct regcache *regcache = get_current_regcache ();
8811 struct gdbarch *gdbarch = regcache->arch ();
8812 gdb::unique_xmalloc_ptr<gdb_byte> siginfo_data;
8814 if (gdbarch_get_siginfo_type_p (gdbarch))
8816 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8817 size_t len = TYPE_LENGTH (type);
8819 siginfo_data.reset ((gdb_byte *) xmalloc (len));
8821 if (target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
8822 siginfo_data.get (), 0, len) != len)
8824 /* Errors ignored. */
8825 siginfo_data.reset (nullptr);
8829 infcall_suspend_state_up inf_state (new struct infcall_suspend_state);
8833 inf_state->siginfo_gdbarch = gdbarch;
8834 inf_state->siginfo_data = std::move (siginfo_data);
8837 inf_state->thread_suspend = tp->suspend;
8839 /* run_inferior_call will not use the signal due to its `proceed' call with
8840 GDB_SIGNAL_0 anyway. */
8841 tp->suspend.stop_signal = GDB_SIGNAL_0;
8843 inf_state->registers.reset (new readonly_detached_regcache (*regcache));
8848 /* Restore inferior session state to INF_STATE. */
8851 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8853 struct thread_info *tp = inferior_thread ();
8854 struct regcache *regcache = get_current_regcache ();
8855 struct gdbarch *gdbarch = regcache->arch ();
8857 tp->suspend = inf_state->thread_suspend;
8859 if (inf_state->siginfo_gdbarch == gdbarch)
8861 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8863 /* Errors ignored. */
8864 target_write (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
8865 inf_state->siginfo_data.get (), 0, TYPE_LENGTH (type));
8868 /* The inferior can be gone if the user types "print exit(0)"
8869 (and perhaps other times). */
8870 if (target_has_execution)
8871 /* NB: The register write goes through to the target. */
8872 regcache->restore (inf_state->registers.get ());
8874 discard_infcall_suspend_state (inf_state);
8878 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8883 readonly_detached_regcache *
8884 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
8886 return inf_state->registers.get ();
8889 /* infcall_control_state contains state regarding gdb's control of the
8890 inferior itself like stepping control. It also contains session state like
8891 the user's currently selected frame. */
8893 struct infcall_control_state
8895 struct thread_control_state thread_control;
8896 struct inferior_control_state inferior_control;
8899 enum stop_stack_kind stop_stack_dummy = STOP_NONE;
8900 int stopped_by_random_signal = 0;
8902 /* ID if the selected frame when the inferior function call was made. */
8903 struct frame_id selected_frame_id {};
8906 /* Save all of the information associated with the inferior<==>gdb
8909 infcall_control_state_up
8910 save_infcall_control_state ()
8912 infcall_control_state_up inf_status (new struct infcall_control_state);
8913 struct thread_info *tp = inferior_thread ();
8914 struct inferior *inf = current_inferior ();
8916 inf_status->thread_control = tp->control;
8917 inf_status->inferior_control = inf->control;
8919 tp->control.step_resume_breakpoint = NULL;
8920 tp->control.exception_resume_breakpoint = NULL;
8922 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8923 chain. If caller's caller is walking the chain, they'll be happier if we
8924 hand them back the original chain when restore_infcall_control_state is
8926 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
8929 inf_status->stop_stack_dummy = stop_stack_dummy;
8930 inf_status->stopped_by_random_signal = stopped_by_random_signal;
8932 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
8938 restore_selected_frame (const frame_id &fid)
8940 frame_info *frame = frame_find_by_id (fid);
8942 /* If inf_status->selected_frame_id is NULL, there was no previously
8946 warning (_("Unable to restore previously selected frame."));
8950 select_frame (frame);
8953 /* Restore inferior session state to INF_STATUS. */
8956 restore_infcall_control_state (struct infcall_control_state *inf_status)
8958 struct thread_info *tp = inferior_thread ();
8959 struct inferior *inf = current_inferior ();
8961 if (tp->control.step_resume_breakpoint)
8962 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
8964 if (tp->control.exception_resume_breakpoint)
8965 tp->control.exception_resume_breakpoint->disposition
8966 = disp_del_at_next_stop;
8968 /* Handle the bpstat_copy of the chain. */
8969 bpstat_clear (&tp->control.stop_bpstat);
8971 tp->control = inf_status->thread_control;
8972 inf->control = inf_status->inferior_control;
8975 stop_stack_dummy = inf_status->stop_stack_dummy;
8976 stopped_by_random_signal = inf_status->stopped_by_random_signal;
8978 if (target_has_stack)
8980 /* The point of the try/catch is that if the stack is clobbered,
8981 walking the stack might encounter a garbage pointer and
8982 error() trying to dereference it. */
8985 restore_selected_frame (inf_status->selected_frame_id);
8987 CATCH (ex, RETURN_MASK_ERROR)
8989 exception_fprintf (gdb_stderr, ex,
8990 "Unable to restore previously selected frame:\n");
8991 /* Error in restoring the selected frame. Select the
8993 select_frame (get_current_frame ());
9002 discard_infcall_control_state (struct infcall_control_state *inf_status)
9004 if (inf_status->thread_control.step_resume_breakpoint)
9005 inf_status->thread_control.step_resume_breakpoint->disposition
9006 = disp_del_at_next_stop;
9008 if (inf_status->thread_control.exception_resume_breakpoint)
9009 inf_status->thread_control.exception_resume_breakpoint->disposition
9010 = disp_del_at_next_stop;
9012 /* See save_infcall_control_state for info on stop_bpstat. */
9013 bpstat_clear (&inf_status->thread_control.stop_bpstat);
9021 clear_exit_convenience_vars (void)
9023 clear_internalvar (lookup_internalvar ("_exitsignal"));
9024 clear_internalvar (lookup_internalvar ("_exitcode"));
9028 /* User interface for reverse debugging:
9029 Set exec-direction / show exec-direction commands
9030 (returns error unless target implements to_set_exec_direction method). */
9032 enum exec_direction_kind execution_direction = EXEC_FORWARD;
9033 static const char exec_forward[] = "forward";
9034 static const char exec_reverse[] = "reverse";
9035 static const char *exec_direction = exec_forward;
9036 static const char *const exec_direction_names[] = {
9043 set_exec_direction_func (const char *args, int from_tty,
9044 struct cmd_list_element *cmd)
9046 if (target_can_execute_reverse)
9048 if (!strcmp (exec_direction, exec_forward))
9049 execution_direction = EXEC_FORWARD;
9050 else if (!strcmp (exec_direction, exec_reverse))
9051 execution_direction = EXEC_REVERSE;
9055 exec_direction = exec_forward;
9056 error (_("Target does not support this operation."));
9061 show_exec_direction_func (struct ui_file *out, int from_tty,
9062 struct cmd_list_element *cmd, const char *value)
9064 switch (execution_direction) {
9066 fprintf_filtered (out, _("Forward.\n"));
9069 fprintf_filtered (out, _("Reverse.\n"));
9072 internal_error (__FILE__, __LINE__,
9073 _("bogus execution_direction value: %d"),
9074 (int) execution_direction);
9079 show_schedule_multiple (struct ui_file *file, int from_tty,
9080 struct cmd_list_element *c, const char *value)
9082 fprintf_filtered (file, _("Resuming the execution of threads "
9083 "of all processes is %s.\n"), value);
9086 /* Implementation of `siginfo' variable. */
9088 static const struct internalvar_funcs siginfo_funcs =
9095 /* Callback for infrun's target events source. This is marked when a
9096 thread has a pending status to process. */
9099 infrun_async_inferior_event_handler (gdb_client_data data)
9101 inferior_event_handler (INF_REG_EVENT, NULL);
9105 _initialize_infrun (void)
9109 struct cmd_list_element *c;
9111 /* Register extra event sources in the event loop. */
9112 infrun_async_inferior_event_token
9113 = create_async_event_handler (infrun_async_inferior_event_handler, NULL);
9115 add_info ("signals", info_signals_command, _("\
9116 What debugger does when program gets various signals.\n\
9117 Specify a signal as argument to print info on that signal only."));
9118 add_info_alias ("handle", "signals", 0);
9120 c = add_com ("handle", class_run, handle_command, _("\
9121 Specify how to handle signals.\n\
9122 Usage: handle SIGNAL [ACTIONS]\n\
9123 Args are signals and actions to apply to those signals.\n\
9124 If no actions are specified, the current settings for the specified signals\n\
9125 will be displayed instead.\n\
9127 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9128 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9129 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9130 The special arg \"all\" is recognized to mean all signals except those\n\
9131 used by the debugger, typically SIGTRAP and SIGINT.\n\
9133 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9134 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9135 Stop means reenter debugger if this signal happens (implies print).\n\
9136 Print means print a message if this signal happens.\n\
9137 Pass means let program see this signal; otherwise program doesn't know.\n\
9138 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9139 Pass and Stop may be combined.\n\
9141 Multiple signals may be specified. Signal numbers and signal names\n\
9142 may be interspersed with actions, with the actions being performed for\n\
9143 all signals cumulatively specified."));
9144 set_cmd_completer (c, handle_completer);
9147 stop_command = add_cmd ("stop", class_obscure,
9148 not_just_help_class_command, _("\
9149 There is no `stop' command, but you can set a hook on `stop'.\n\
9150 This allows you to set a list of commands to be run each time execution\n\
9151 of the program stops."), &cmdlist);
9153 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
9154 Set inferior debugging."), _("\
9155 Show inferior debugging."), _("\
9156 When non-zero, inferior specific debugging is enabled."),
9159 &setdebuglist, &showdebuglist);
9161 add_setshow_boolean_cmd ("displaced", class_maintenance,
9162 &debug_displaced, _("\
9163 Set displaced stepping debugging."), _("\
9164 Show displaced stepping debugging."), _("\
9165 When non-zero, displaced stepping specific debugging is enabled."),
9167 show_debug_displaced,
9168 &setdebuglist, &showdebuglist);
9170 add_setshow_boolean_cmd ("non-stop", no_class,
9172 Set whether gdb controls the inferior in non-stop mode."), _("\
9173 Show whether gdb controls the inferior in non-stop mode."), _("\
9174 When debugging a multi-threaded program and this setting is\n\
9175 off (the default, also called all-stop mode), when one thread stops\n\
9176 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9177 all other threads in the program while you interact with the thread of\n\
9178 interest. When you continue or step a thread, you can allow the other\n\
9179 threads to run, or have them remain stopped, but while you inspect any\n\
9180 thread's state, all threads stop.\n\
9182 In non-stop mode, when one thread stops, other threads can continue\n\
9183 to run freely. You'll be able to step each thread independently,\n\
9184 leave it stopped or free to run as needed."),
9190 numsigs = (int) GDB_SIGNAL_LAST;
9191 signal_stop = XNEWVEC (unsigned char, numsigs);
9192 signal_print = XNEWVEC (unsigned char, numsigs);
9193 signal_program = XNEWVEC (unsigned char, numsigs);
9194 signal_catch = XNEWVEC (unsigned char, numsigs);
9195 signal_pass = XNEWVEC (unsigned char, numsigs);
9196 for (i = 0; i < numsigs; i++)
9199 signal_print[i] = 1;
9200 signal_program[i] = 1;
9201 signal_catch[i] = 0;
9204 /* Signals caused by debugger's own actions should not be given to
9205 the program afterwards.
9207 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9208 explicitly specifies that it should be delivered to the target
9209 program. Typically, that would occur when a user is debugging a
9210 target monitor on a simulator: the target monitor sets a
9211 breakpoint; the simulator encounters this breakpoint and halts
9212 the simulation handing control to GDB; GDB, noting that the stop
9213 address doesn't map to any known breakpoint, returns control back
9214 to the simulator; the simulator then delivers the hardware
9215 equivalent of a GDB_SIGNAL_TRAP to the program being
9217 signal_program[GDB_SIGNAL_TRAP] = 0;
9218 signal_program[GDB_SIGNAL_INT] = 0;
9220 /* Signals that are not errors should not normally enter the debugger. */
9221 signal_stop[GDB_SIGNAL_ALRM] = 0;
9222 signal_print[GDB_SIGNAL_ALRM] = 0;
9223 signal_stop[GDB_SIGNAL_VTALRM] = 0;
9224 signal_print[GDB_SIGNAL_VTALRM] = 0;
9225 signal_stop[GDB_SIGNAL_PROF] = 0;
9226 signal_print[GDB_SIGNAL_PROF] = 0;
9227 signal_stop[GDB_SIGNAL_CHLD] = 0;
9228 signal_print[GDB_SIGNAL_CHLD] = 0;
9229 signal_stop[GDB_SIGNAL_IO] = 0;
9230 signal_print[GDB_SIGNAL_IO] = 0;
9231 signal_stop[GDB_SIGNAL_POLL] = 0;
9232 signal_print[GDB_SIGNAL_POLL] = 0;
9233 signal_stop[GDB_SIGNAL_URG] = 0;
9234 signal_print[GDB_SIGNAL_URG] = 0;
9235 signal_stop[GDB_SIGNAL_WINCH] = 0;
9236 signal_print[GDB_SIGNAL_WINCH] = 0;
9237 signal_stop[GDB_SIGNAL_PRIO] = 0;
9238 signal_print[GDB_SIGNAL_PRIO] = 0;
9240 /* These signals are used internally by user-level thread
9241 implementations. (See signal(5) on Solaris.) Like the above
9242 signals, a healthy program receives and handles them as part of
9243 its normal operation. */
9244 signal_stop[GDB_SIGNAL_LWP] = 0;
9245 signal_print[GDB_SIGNAL_LWP] = 0;
9246 signal_stop[GDB_SIGNAL_WAITING] = 0;
9247 signal_print[GDB_SIGNAL_WAITING] = 0;
9248 signal_stop[GDB_SIGNAL_CANCEL] = 0;
9249 signal_print[GDB_SIGNAL_CANCEL] = 0;
9250 signal_stop[GDB_SIGNAL_LIBRT] = 0;
9251 signal_print[GDB_SIGNAL_LIBRT] = 0;
9253 /* Update cached state. */
9254 signal_cache_update (-1);
9256 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
9257 &stop_on_solib_events, _("\
9258 Set stopping for shared library events."), _("\
9259 Show stopping for shared library events."), _("\
9260 If nonzero, gdb will give control to the user when the dynamic linker\n\
9261 notifies gdb of shared library events. The most common event of interest\n\
9262 to the user would be loading/unloading of a new library."),
9263 set_stop_on_solib_events,
9264 show_stop_on_solib_events,
9265 &setlist, &showlist);
9267 add_setshow_enum_cmd ("follow-fork-mode", class_run,
9268 follow_fork_mode_kind_names,
9269 &follow_fork_mode_string, _("\
9270 Set debugger response to a program call of fork or vfork."), _("\
9271 Show debugger response to a program call of fork or vfork."), _("\
9272 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9273 parent - the original process is debugged after a fork\n\
9274 child - the new process is debugged after a fork\n\
9275 The unfollowed process will continue to run.\n\
9276 By default, the debugger will follow the parent process."),
9278 show_follow_fork_mode_string,
9279 &setlist, &showlist);
9281 add_setshow_enum_cmd ("follow-exec-mode", class_run,
9282 follow_exec_mode_names,
9283 &follow_exec_mode_string, _("\
9284 Set debugger response to a program call of exec."), _("\
9285 Show debugger response to a program call of exec."), _("\
9286 An exec call replaces the program image of a process.\n\
9288 follow-exec-mode can be:\n\
9290 new - the debugger creates a new inferior and rebinds the process\n\
9291 to this new inferior. The program the process was running before\n\
9292 the exec call can be restarted afterwards by restarting the original\n\
9295 same - the debugger keeps the process bound to the same inferior.\n\
9296 The new executable image replaces the previous executable loaded in\n\
9297 the inferior. Restarting the inferior after the exec call restarts\n\
9298 the executable the process was running after the exec call.\n\
9300 By default, the debugger will use the same inferior."),
9302 show_follow_exec_mode_string,
9303 &setlist, &showlist);
9305 add_setshow_enum_cmd ("scheduler-locking", class_run,
9306 scheduler_enums, &scheduler_mode, _("\
9307 Set mode for locking scheduler during execution."), _("\
9308 Show mode for locking scheduler during execution."), _("\
9309 off == no locking (threads may preempt at any time)\n\
9310 on == full locking (no thread except the current thread may run)\n\
9311 This applies to both normal execution and replay mode.\n\
9312 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9313 In this mode, other threads may run during other commands.\n\
9314 This applies to both normal execution and replay mode.\n\
9315 replay == scheduler locked in replay mode and unlocked during normal execution."),
9316 set_schedlock_func, /* traps on target vector */
9317 show_scheduler_mode,
9318 &setlist, &showlist);
9320 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
9321 Set mode for resuming threads of all processes."), _("\
9322 Show mode for resuming threads of all processes."), _("\
9323 When on, execution commands (such as 'continue' or 'next') resume all\n\
9324 threads of all processes. When off (which is the default), execution\n\
9325 commands only resume the threads of the current process. The set of\n\
9326 threads that are resumed is further refined by the scheduler-locking\n\
9327 mode (see help set scheduler-locking)."),
9329 show_schedule_multiple,
9330 &setlist, &showlist);
9332 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
9333 Set mode of the step operation."), _("\
9334 Show mode of the step operation."), _("\
9335 When set, doing a step over a function without debug line information\n\
9336 will stop at the first instruction of that function. Otherwise, the\n\
9337 function is skipped and the step command stops at a different source line."),
9339 show_step_stop_if_no_debug,
9340 &setlist, &showlist);
9342 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
9343 &can_use_displaced_stepping, _("\
9344 Set debugger's willingness to use displaced stepping."), _("\
9345 Show debugger's willingness to use displaced stepping."), _("\
9346 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9347 supported by the target architecture. If off, gdb will not use displaced\n\
9348 stepping to step over breakpoints, even if such is supported by the target\n\
9349 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9350 if the target architecture supports it and non-stop mode is active, but will not\n\
9351 use it in all-stop mode (see help set non-stop)."),
9353 show_can_use_displaced_stepping,
9354 &setlist, &showlist);
9356 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
9357 &exec_direction, _("Set direction of execution.\n\
9358 Options are 'forward' or 'reverse'."),
9359 _("Show direction of execution (forward/reverse)."),
9360 _("Tells gdb whether to execute forward or backward."),
9361 set_exec_direction_func, show_exec_direction_func,
9362 &setlist, &showlist);
9364 /* Set/show detach-on-fork: user-settable mode. */
9366 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
9367 Set whether gdb will detach the child of a fork."), _("\
9368 Show whether gdb will detach the child of a fork."), _("\
9369 Tells gdb whether to detach the child of a fork."),
9370 NULL, NULL, &setlist, &showlist);
9372 /* Set/show disable address space randomization mode. */
9374 add_setshow_boolean_cmd ("disable-randomization", class_support,
9375 &disable_randomization, _("\
9376 Set disabling of debuggee's virtual address space randomization."), _("\
9377 Show disabling of debuggee's virtual address space randomization."), _("\
9378 When this mode is on (which is the default), randomization of the virtual\n\
9379 address space is disabled. Standalone programs run with the randomization\n\
9380 enabled by default on some platforms."),
9381 &set_disable_randomization,
9382 &show_disable_randomization,
9383 &setlist, &showlist);
9385 /* ptid initializations */
9386 inferior_ptid = null_ptid;
9387 target_last_wait_ptid = minus_one_ptid;
9389 gdb::observers::thread_ptid_changed.attach (infrun_thread_ptid_changed);
9390 gdb::observers::thread_stop_requested.attach (infrun_thread_stop_requested);
9391 gdb::observers::thread_exit.attach (infrun_thread_thread_exit);
9392 gdb::observers::inferior_exit.attach (infrun_inferior_exit);
9394 /* Explicitly create without lookup, since that tries to create a
9395 value with a void typed value, and when we get here, gdbarch
9396 isn't initialized yet. At this point, we're quite sure there
9397 isn't another convenience variable of the same name. */
9398 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
9400 add_setshow_boolean_cmd ("observer", no_class,
9401 &observer_mode_1, _("\
9402 Set whether gdb controls the inferior in observer mode."), _("\
9403 Show whether gdb controls the inferior in observer mode."), _("\
9404 In observer mode, GDB can get data from the inferior, but not\n\
9405 affect its execution. Registers and memory may not be changed,\n\
9406 breakpoints may not be set, and the program cannot be interrupted\n\