1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2023 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/>. */
22 #include "displaced-stepping.h"
28 #include "breakpoint.h"
32 #include "target-connection.h"
33 #include "gdbthread.h"
41 #include "observable.h"
46 #include "mi/mi-common.h"
47 #include "event-top.h"
49 #include "record-full.h"
50 #include "inline-frame.h"
52 #include "tracepoint.h"
56 #include "completer.h"
57 #include "target-descriptions.h"
58 #include "target-dcache.h"
61 #include "gdbsupport/event-loop.h"
62 #include "thread-fsm.h"
63 #include "gdbsupport/enum-flags.h"
64 #include "progspace-and-thread.h"
66 #include "arch-utils.h"
67 #include "gdbsupport/scope-exit.h"
68 #include "gdbsupport/forward-scope-exit.h"
69 #include "gdbsupport/gdb_select.h"
70 #include <unordered_map>
71 #include "async-event.h"
72 #include "gdbsupport/selftest.h"
73 #include "scoped-mock-context.h"
74 #include "test-target.h"
75 #include "gdbsupport/common-debug.h"
76 #include "gdbsupport/buildargv.h"
77 #include "extension.h"
81 /* Prototypes for local functions */
83 static void sig_print_info (enum gdb_signal
);
85 static void sig_print_header (void);
87 static void follow_inferior_reset_breakpoints (void);
89 static bool currently_stepping (struct thread_info
*tp
);
91 static void insert_hp_step_resume_breakpoint_at_frame (frame_info_ptr
);
93 static void insert_step_resume_breakpoint_at_caller (frame_info_ptr
);
95 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
97 static bool maybe_software_singlestep (struct gdbarch
*gdbarch
);
99 static void resume (gdb_signal sig
);
101 static void wait_for_inferior (inferior
*inf
);
103 static void restart_threads (struct thread_info
*event_thread
,
104 inferior
*inf
= nullptr);
106 static bool start_step_over (void);
108 static bool step_over_info_valid_p (void);
110 static bool schedlock_applies (struct thread_info
*tp
);
112 /* Asynchronous signal handler registered as event loop source for
113 when we have pending events ready to be passed to the core. */
114 static struct async_event_handler
*infrun_async_inferior_event_token
;
116 /* Stores whether infrun_async was previously enabled or disabled.
117 Starts off as -1, indicating "never enabled/disabled". */
118 static int infrun_is_async
= -1;
123 infrun_async (int enable
)
125 if (infrun_is_async
!= enable
)
127 infrun_is_async
= enable
;
129 infrun_debug_printf ("enable=%d", enable
);
132 mark_async_event_handler (infrun_async_inferior_event_token
);
134 clear_async_event_handler (infrun_async_inferior_event_token
);
141 mark_infrun_async_event_handler (void)
143 mark_async_event_handler (infrun_async_inferior_event_token
);
146 /* When set, stop the 'step' command if we enter a function which has
147 no line number information. The normal behavior is that we step
148 over such function. */
149 bool step_stop_if_no_debug
= false;
151 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
152 struct cmd_list_element
*c
, const char *value
)
154 gdb_printf (file
, _("Mode of the step operation is %s.\n"), value
);
157 /* proceed and normal_stop use this to notify the user when the
158 inferior stopped in a different thread than it had been running in.
159 It can also be used to find for which thread normal_stop last
161 static thread_info_ref previous_thread
;
166 update_previous_thread ()
168 if (inferior_ptid
== null_ptid
)
169 previous_thread
= nullptr;
171 previous_thread
= thread_info_ref::new_reference (inferior_thread ());
177 get_previous_thread ()
179 return previous_thread
.get ();
182 /* If set (default for legacy reasons), when following a fork, GDB
183 will detach from one of the fork branches, child or parent.
184 Exactly which branch is detached depends on 'set follow-fork-mode'
187 static bool detach_fork
= true;
189 bool debug_infrun
= false;
191 show_debug_infrun (struct ui_file
*file
, int from_tty
,
192 struct cmd_list_element
*c
, const char *value
)
194 gdb_printf (file
, _("Inferior debugging is %s.\n"), value
);
197 /* Support for disabling address space randomization. */
199 bool disable_randomization
= true;
202 show_disable_randomization (struct ui_file
*file
, int from_tty
,
203 struct cmd_list_element
*c
, const char *value
)
205 if (target_supports_disable_randomization ())
207 _("Disabling randomization of debuggee's "
208 "virtual address space is %s.\n"),
211 gdb_puts (_("Disabling randomization of debuggee's "
212 "virtual address space is unsupported on\n"
213 "this platform.\n"), file
);
217 set_disable_randomization (const char *args
, int from_tty
,
218 struct cmd_list_element
*c
)
220 if (!target_supports_disable_randomization ())
221 error (_("Disabling randomization of debuggee's "
222 "virtual address space is unsupported on\n"
226 /* User interface for non-stop mode. */
228 bool non_stop
= false;
229 static bool non_stop_1
= false;
232 set_non_stop (const char *args
, int from_tty
,
233 struct cmd_list_element
*c
)
235 if (target_has_execution ())
237 non_stop_1
= non_stop
;
238 error (_("Cannot change this setting while the inferior is running."));
241 non_stop
= non_stop_1
;
245 show_non_stop (struct ui_file
*file
, int from_tty
,
246 struct cmd_list_element
*c
, const char *value
)
249 _("Controlling the inferior in non-stop mode is %s.\n"),
253 /* "Observer mode" is somewhat like a more extreme version of
254 non-stop, in which all GDB operations that might affect the
255 target's execution have been disabled. */
257 static bool observer_mode
= false;
258 static bool observer_mode_1
= false;
261 set_observer_mode (const char *args
, int from_tty
,
262 struct cmd_list_element
*c
)
264 if (target_has_execution ())
266 observer_mode_1
= observer_mode
;
267 error (_("Cannot change this setting while the inferior is running."));
270 observer_mode
= observer_mode_1
;
272 may_write_registers
= !observer_mode
;
273 may_write_memory
= !observer_mode
;
274 may_insert_breakpoints
= !observer_mode
;
275 may_insert_tracepoints
= !observer_mode
;
276 /* We can insert fast tracepoints in or out of observer mode,
277 but enable them if we're going into this mode. */
279 may_insert_fast_tracepoints
= true;
280 may_stop
= !observer_mode
;
281 update_target_permissions ();
283 /* Going *into* observer mode we must force non-stop, then
284 going out we leave it that way. */
287 pagination_enabled
= false;
288 non_stop
= non_stop_1
= true;
292 gdb_printf (_("Observer mode is now %s.\n"),
293 (observer_mode
? "on" : "off"));
297 show_observer_mode (struct ui_file
*file
, int from_tty
,
298 struct cmd_list_element
*c
, const char *value
)
300 gdb_printf (file
, _("Observer mode is %s.\n"), value
);
303 /* This updates the value of observer mode based on changes in
304 permissions. Note that we are deliberately ignoring the values of
305 may-write-registers and may-write-memory, since the user may have
306 reason to enable these during a session, for instance to turn on a
307 debugging-related global. */
310 update_observer_mode (void)
312 bool newval
= (!may_insert_breakpoints
313 && !may_insert_tracepoints
314 && may_insert_fast_tracepoints
318 /* Let the user know if things change. */
319 if (newval
!= observer_mode
)
320 gdb_printf (_("Observer mode is now %s.\n"),
321 (newval
? "on" : "off"));
323 observer_mode
= observer_mode_1
= newval
;
326 /* Tables of how to react to signals; the user sets them. */
328 static unsigned char signal_stop
[GDB_SIGNAL_LAST
];
329 static unsigned char signal_print
[GDB_SIGNAL_LAST
];
330 static unsigned char signal_program
[GDB_SIGNAL_LAST
];
332 /* Table of signals that are registered with "catch signal". A
333 non-zero entry indicates that the signal is caught by some "catch
335 static unsigned char signal_catch
[GDB_SIGNAL_LAST
];
337 /* Table of signals that the target may silently handle.
338 This is automatically determined from the flags above,
339 and simply cached here. */
340 static unsigned char signal_pass
[GDB_SIGNAL_LAST
];
342 #define SET_SIGS(nsigs,sigs,flags) \
344 int signum = (nsigs); \
345 while (signum-- > 0) \
346 if ((sigs)[signum]) \
347 (flags)[signum] = 1; \
350 #define UNSET_SIGS(nsigs,sigs,flags) \
352 int signum = (nsigs); \
353 while (signum-- > 0) \
354 if ((sigs)[signum]) \
355 (flags)[signum] = 0; \
358 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
359 this function is to avoid exporting `signal_program'. */
362 update_signals_program_target (void)
364 target_program_signals (signal_program
);
367 /* Value to pass to target_resume() to cause all threads to resume. */
369 #define RESUME_ALL minus_one_ptid
371 /* Command list pointer for the "stop" placeholder. */
373 static struct cmd_list_element
*stop_command
;
375 /* Nonzero if we want to give control to the user when we're notified
376 of shared library events by the dynamic linker. */
377 int stop_on_solib_events
;
379 /* Enable or disable optional shared library event breakpoints
380 as appropriate when the above flag is changed. */
383 set_stop_on_solib_events (const char *args
,
384 int from_tty
, struct cmd_list_element
*c
)
386 update_solib_breakpoints ();
390 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
391 struct cmd_list_element
*c
, const char *value
)
393 gdb_printf (file
, _("Stopping for shared library events is %s.\n"),
397 /* True after stop if current stack frame should be printed. */
399 static bool stop_print_frame
;
401 /* This is a cached copy of the target/ptid/waitstatus of the last
402 event returned by target_wait().
403 This information is returned by get_last_target_status(). */
404 static process_stratum_target
*target_last_proc_target
;
405 static ptid_t target_last_wait_ptid
;
406 static struct target_waitstatus target_last_waitstatus
;
408 void init_thread_stepping_state (struct thread_info
*tss
);
410 static const char follow_fork_mode_child
[] = "child";
411 static const char follow_fork_mode_parent
[] = "parent";
413 static const char *const follow_fork_mode_kind_names
[] = {
414 follow_fork_mode_child
,
415 follow_fork_mode_parent
,
419 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
421 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
422 struct cmd_list_element
*c
, const char *value
)
425 _("Debugger response to a program "
426 "call of fork or vfork is \"%s\".\n"),
431 /* Handle changes to the inferior list based on the type of fork,
432 which process is being followed, and whether the other process
433 should be detached. On entry inferior_ptid must be the ptid of
434 the fork parent. At return inferior_ptid is the ptid of the
435 followed inferior. */
438 follow_fork_inferior (bool follow_child
, bool detach_fork
)
440 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
442 infrun_debug_printf ("follow_child = %d, detach_fork = %d",
443 follow_child
, detach_fork
);
445 target_waitkind fork_kind
= inferior_thread ()->pending_follow
.kind ();
446 gdb_assert (fork_kind
== TARGET_WAITKIND_FORKED
447 || fork_kind
== TARGET_WAITKIND_VFORKED
);
448 bool has_vforked
= fork_kind
== TARGET_WAITKIND_VFORKED
;
449 ptid_t parent_ptid
= inferior_ptid
;
450 ptid_t child_ptid
= inferior_thread ()->pending_follow
.child_ptid ();
453 && !non_stop
/* Non-stop always resumes both branches. */
454 && current_ui
->prompt_state
== PROMPT_BLOCKED
455 && !(follow_child
|| detach_fork
|| sched_multi
))
457 /* The parent stays blocked inside the vfork syscall until the
458 child execs or exits. If we don't let the child run, then
459 the parent stays blocked. If we're telling the parent to run
460 in the foreground, the user will not be able to ctrl-c to get
461 back the terminal, effectively hanging the debug session. */
462 gdb_printf (gdb_stderr
, _("\
463 Can not resume the parent process over vfork in the foreground while\n\
464 holding the child stopped. Try \"set detach-on-fork\" or \
465 \"set schedule-multiple\".\n"));
469 inferior
*parent_inf
= current_inferior ();
470 inferior
*child_inf
= nullptr;
472 gdb_assert (parent_inf
->thread_waiting_for_vfork_done
== nullptr);
476 /* Detach new forked process? */
479 /* Before detaching from the child, remove all breakpoints
480 from it. If we forked, then this has already been taken
481 care of by infrun.c. If we vforked however, any
482 breakpoint inserted in the parent is visible in the
483 child, even those added while stopped in a vfork
484 catchpoint. This will remove the breakpoints from the
485 parent also, but they'll be reinserted below. */
488 /* Keep breakpoints list in sync. */
489 remove_breakpoints_inf (current_inferior ());
492 if (print_inferior_events
)
494 /* Ensure that we have a process ptid. */
495 ptid_t process_ptid
= ptid_t (child_ptid
.pid ());
497 target_terminal::ours_for_output ();
498 gdb_printf (_("[Detaching after %s from child %s]\n"),
499 has_vforked
? "vfork" : "fork",
500 target_pid_to_str (process_ptid
).c_str ());
505 /* Add process to GDB's tables. */
506 child_inf
= add_inferior (child_ptid
.pid ());
508 child_inf
->attach_flag
= parent_inf
->attach_flag
;
509 copy_terminal_info (child_inf
, parent_inf
);
510 child_inf
->set_arch (parent_inf
->arch ());
511 child_inf
->tdesc_info
= parent_inf
->tdesc_info
;
513 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
515 /* If this is a vfork child, then the address-space is
516 shared with the parent. */
519 child_inf
->pspace
= parent_inf
->pspace
;
520 child_inf
->aspace
= parent_inf
->aspace
;
522 exec_on_vfork (child_inf
);
524 /* The parent will be frozen until the child is done
525 with the shared region. Keep track of the
527 child_inf
->vfork_parent
= parent_inf
;
528 child_inf
->pending_detach
= false;
529 parent_inf
->vfork_child
= child_inf
;
530 parent_inf
->pending_detach
= false;
534 child_inf
->pspace
= new program_space (new_address_space ());
535 child_inf
->aspace
= child_inf
->pspace
->aspace
;
536 child_inf
->removable
= true;
537 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
543 /* If we detached from the child, then we have to be careful
544 to not insert breakpoints in the parent until the child
545 is done with the shared memory region. However, if we're
546 staying attached to the child, then we can and should
547 insert breakpoints, so that we can debug it. A
548 subsequent child exec or exit is enough to know when does
549 the child stops using the parent's address space. */
550 parent_inf
->thread_waiting_for_vfork_done
551 = detach_fork
? inferior_thread () : nullptr;
552 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
555 ("parent_inf->thread_waiting_for_vfork_done == %s",
556 (parent_inf
->thread_waiting_for_vfork_done
== nullptr
558 : (parent_inf
->thread_waiting_for_vfork_done
559 ->ptid
.to_string ().c_str ())));
564 /* Follow the child. */
566 if (print_inferior_events
)
568 std::string parent_pid
= target_pid_to_str (parent_ptid
);
569 std::string child_pid
= target_pid_to_str (child_ptid
);
571 target_terminal::ours_for_output ();
572 gdb_printf (_("[Attaching after %s %s to child %s]\n"),
574 has_vforked
? "vfork" : "fork",
578 /* Add the new inferior first, so that the target_detach below
579 doesn't unpush the target. */
581 child_inf
= add_inferior (child_ptid
.pid ());
583 child_inf
->attach_flag
= parent_inf
->attach_flag
;
584 copy_terminal_info (child_inf
, parent_inf
);
585 child_inf
->set_arch (parent_inf
->arch ());
586 child_inf
->tdesc_info
= parent_inf
->tdesc_info
;
590 /* If this is a vfork child, then the address-space is shared
592 child_inf
->aspace
= parent_inf
->aspace
;
593 child_inf
->pspace
= parent_inf
->pspace
;
595 exec_on_vfork (child_inf
);
597 else if (detach_fork
)
599 /* We follow the child and detach from the parent: move the parent's
600 program space to the child. This simplifies some things, like
601 doing "next" over fork() and landing on the expected line in the
602 child (note, that is broken with "set detach-on-fork off").
604 Before assigning brand new spaces for the parent, remove
605 breakpoints from it: because the new pspace won't match
606 currently inserted locations, the normal detach procedure
607 wouldn't remove them, and we would leave them inserted when
609 remove_breakpoints_inf (parent_inf
);
611 child_inf
->aspace
= parent_inf
->aspace
;
612 child_inf
->pspace
= parent_inf
->pspace
;
613 parent_inf
->pspace
= new program_space (new_address_space ());
614 parent_inf
->aspace
= parent_inf
->pspace
->aspace
;
615 clone_program_space (parent_inf
->pspace
, child_inf
->pspace
);
617 /* The parent inferior is still the current one, so keep things
619 set_current_program_space (parent_inf
->pspace
);
623 child_inf
->pspace
= new program_space (new_address_space ());
624 child_inf
->aspace
= child_inf
->pspace
->aspace
;
625 child_inf
->removable
= true;
626 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
627 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
631 gdb_assert (current_inferior () == parent_inf
);
633 /* If we are setting up an inferior for the child, target_follow_fork is
634 responsible for pushing the appropriate targets on the new inferior's
635 target stack and adding the initial thread (with ptid CHILD_PTID).
637 If we are not setting up an inferior for the child (because following
638 the parent and detach_fork is true), it is responsible for detaching
640 target_follow_fork (child_inf
, child_ptid
, fork_kind
, follow_child
,
643 gdb::observers::inferior_forked
.notify (parent_inf
, child_inf
, fork_kind
);
645 /* target_follow_fork must leave the parent as the current inferior. If we
646 want to follow the child, we make it the current one below. */
647 gdb_assert (current_inferior () == parent_inf
);
649 /* If there is a child inferior, target_follow_fork must have created a thread
651 if (child_inf
!= nullptr)
652 gdb_assert (!child_inf
->thread_list
.empty ());
654 /* Clear the parent thread's pending follow field. Do this before calling
655 target_detach, so that the target can differentiate the two following
658 - We continue past a fork with "follow-fork-mode == child" &&
659 "detach-on-fork on", and therefore detach the parent. In that
660 case the target should not detach the fork child.
661 - We run to a fork catchpoint and the user types "detach". In that
662 case, the target should detach the fork child in addition to the
665 The former case will have pending_follow cleared, the later will have
666 pending_follow set. */
667 thread_info
*parent_thread
= parent_inf
->find_thread (parent_ptid
);
668 gdb_assert (parent_thread
!= nullptr);
669 parent_thread
->pending_follow
.set_spurious ();
671 /* Detach the parent if needed. */
674 /* If we're vforking, we want to hold on to the parent until
675 the child exits or execs. At child exec or exit time we
676 can remove the old breakpoints from the parent and detach
677 or resume debugging it. Otherwise, detach the parent now;
678 we'll want to reuse it's program/address spaces, but we
679 can't set them to the child before removing breakpoints
680 from the parent, otherwise, the breakpoints module could
681 decide to remove breakpoints from the wrong process (since
682 they'd be assigned to the same address space). */
686 gdb_assert (child_inf
->vfork_parent
== nullptr);
687 gdb_assert (parent_inf
->vfork_child
== nullptr);
688 child_inf
->vfork_parent
= parent_inf
;
689 child_inf
->pending_detach
= false;
690 parent_inf
->vfork_child
= child_inf
;
691 parent_inf
->pending_detach
= detach_fork
;
693 else if (detach_fork
)
695 if (print_inferior_events
)
697 /* Ensure that we have a process ptid. */
698 ptid_t process_ptid
= ptid_t (parent_ptid
.pid ());
700 target_terminal::ours_for_output ();
701 gdb_printf (_("[Detaching after fork from "
703 target_pid_to_str (process_ptid
).c_str ());
706 target_detach (parent_inf
, 0);
710 /* If we ended up creating a new inferior, call post_create_inferior to inform
711 the various subcomponents. */
712 if (child_inf
!= nullptr)
714 /* If FOLLOW_CHILD, we leave CHILD_INF as the current inferior
715 (do not restore the parent as the current inferior). */
716 std::optional
<scoped_restore_current_thread
> maybe_restore
;
718 if (!follow_child
&& !sched_multi
)
719 maybe_restore
.emplace ();
721 switch_to_thread (*child_inf
->threads ().begin ());
722 post_create_inferior (0);
728 /* Set the last target status as TP having stopped. */
731 set_last_target_status_stopped (thread_info
*tp
)
733 set_last_target_status (tp
->inf
->process_target (), tp
->ptid
,
734 target_waitstatus
{}.set_stopped (GDB_SIGNAL_0
));
737 /* Tell the target to follow the fork we're stopped at. Returns true
738 if the inferior should be resumed; false, if the target for some
739 reason decided it's best not to resume. */
744 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
746 bool follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
747 bool should_resume
= true;
749 /* Copy user stepping state to the new inferior thread. FIXME: the
750 followed fork child thread should have a copy of most of the
751 parent thread structure's run control related fields, not just these.
752 Initialized to avoid "may be used uninitialized" warnings from gcc. */
753 struct breakpoint
*step_resume_breakpoint
= nullptr;
754 struct breakpoint
*exception_resume_breakpoint
= nullptr;
755 CORE_ADDR step_range_start
= 0;
756 CORE_ADDR step_range_end
= 0;
757 int current_line
= 0;
758 symtab
*current_symtab
= nullptr;
759 struct frame_id step_frame_id
= { 0 };
763 thread_info
*cur_thr
= inferior_thread ();
766 = user_visible_resume_ptid (cur_thr
->control
.stepping_command
);
767 process_stratum_target
*resume_target
768 = user_visible_resume_target (resume_ptid
);
770 /* Check if there's a thread that we're about to resume, other
771 than the current, with an unfollowed fork/vfork. If so,
772 switch back to it, to tell the target to follow it (in either
773 direction). We'll afterwards refuse to resume, and inform
774 the user what happened. */
775 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
781 /* follow_fork_inferior clears tp->pending_follow, and below
782 we'll need the value after the follow_fork_inferior
784 target_waitkind kind
= tp
->pending_follow
.kind ();
786 if (kind
!= TARGET_WAITKIND_SPURIOUS
)
788 infrun_debug_printf ("need to follow-fork [%s] first",
789 tp
->ptid
.to_string ().c_str ());
791 switch_to_thread (tp
);
793 /* Set up inferior(s) as specified by the caller, and
794 tell the target to do whatever is necessary to follow
795 either parent or child. */
798 /* The thread that started the execution command
799 won't exist in the child. Abort the command and
800 immediately stop in this thread, in the child,
802 should_resume
= false;
806 /* Following the parent, so let the thread fork its
807 child freely, it won't influence the current
808 execution command. */
809 if (follow_fork_inferior (follow_child
, detach_fork
))
811 /* Target refused to follow, or there's some
812 other reason we shouldn't resume. */
813 switch_to_thread (cur_thr
);
814 set_last_target_status_stopped (cur_thr
);
818 /* If we're following a vfork, when we need to leave
819 the just-forked thread as selected, as we need to
820 solo-resume it to collect the VFORK_DONE event.
821 If we're following a fork, however, switch back
822 to the original thread that we continue stepping
824 if (kind
!= TARGET_WAITKIND_VFORKED
)
826 gdb_assert (kind
== TARGET_WAITKIND_FORKED
);
827 switch_to_thread (cur_thr
);
836 thread_info
*tp
= inferior_thread ();
838 /* If there were any forks/vforks that were caught and are now to be
839 followed, then do so now. */
840 switch (tp
->pending_follow
.kind ())
842 case TARGET_WAITKIND_FORKED
:
843 case TARGET_WAITKIND_VFORKED
:
845 ptid_t parent
, child
;
846 std::unique_ptr
<struct thread_fsm
> thread_fsm
;
848 /* If the user did a next/step, etc, over a fork call,
849 preserve the stepping state in the fork child. */
850 if (follow_child
&& should_resume
)
852 step_resume_breakpoint
= clone_momentary_breakpoint
853 (tp
->control
.step_resume_breakpoint
);
854 step_range_start
= tp
->control
.step_range_start
;
855 step_range_end
= tp
->control
.step_range_end
;
856 current_line
= tp
->current_line
;
857 current_symtab
= tp
->current_symtab
;
858 step_frame_id
= tp
->control
.step_frame_id
;
859 exception_resume_breakpoint
860 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
861 thread_fsm
= tp
->release_thread_fsm ();
863 /* For now, delete the parent's sr breakpoint, otherwise,
864 parent/child sr breakpoints are considered duplicates,
865 and the child version will not be installed. Remove
866 this when the breakpoints module becomes aware of
867 inferiors and address spaces. */
868 delete_step_resume_breakpoint (tp
);
869 tp
->control
.step_range_start
= 0;
870 tp
->control
.step_range_end
= 0;
871 tp
->control
.step_frame_id
= null_frame_id
;
872 delete_exception_resume_breakpoint (tp
);
875 parent
= inferior_ptid
;
876 child
= tp
->pending_follow
.child_ptid ();
878 /* If handling a vfork, stop all the inferior's threads, they will be
879 restarted when the vfork shared region is complete. */
880 if (tp
->pending_follow
.kind () == TARGET_WAITKIND_VFORKED
881 && target_is_non_stop_p ())
882 stop_all_threads ("handling vfork", tp
->inf
);
884 process_stratum_target
*parent_targ
= tp
->inf
->process_target ();
885 /* Set up inferior(s) as specified by the caller, and tell the
886 target to do whatever is necessary to follow either parent
888 if (follow_fork_inferior (follow_child
, detach_fork
))
890 /* Target refused to follow, or there's some other reason
891 we shouldn't resume. */
896 /* If we followed the child, switch to it... */
899 tp
= parent_targ
->find_thread (child
);
900 switch_to_thread (tp
);
902 /* ... and preserve the stepping state, in case the
903 user was stepping over the fork call. */
906 tp
->control
.step_resume_breakpoint
907 = step_resume_breakpoint
;
908 tp
->control
.step_range_start
= step_range_start
;
909 tp
->control
.step_range_end
= step_range_end
;
910 tp
->current_line
= current_line
;
911 tp
->current_symtab
= current_symtab
;
912 tp
->control
.step_frame_id
= step_frame_id
;
913 tp
->control
.exception_resume_breakpoint
914 = exception_resume_breakpoint
;
915 tp
->set_thread_fsm (std::move (thread_fsm
));
919 /* If we get here, it was because we're trying to
920 resume from a fork catchpoint, but, the user
921 has switched threads away from the thread that
922 forked. In that case, the resume command
923 issued is most likely not applicable to the
924 child, so just warn, and refuse to resume. */
925 warning (_("Not resuming: switched threads "
926 "before following fork child."));
929 /* Reset breakpoints in the child as appropriate. */
930 follow_inferior_reset_breakpoints ();
935 case TARGET_WAITKIND_SPURIOUS
:
936 /* Nothing to follow. */
939 internal_error ("Unexpected pending_follow.kind %d\n",
940 tp
->pending_follow
.kind ());
945 set_last_target_status_stopped (tp
);
946 return should_resume
;
950 follow_inferior_reset_breakpoints (void)
952 struct thread_info
*tp
= inferior_thread ();
954 /* Was there a step_resume breakpoint? (There was if the user
955 did a "next" at the fork() call.) If so, explicitly reset its
956 thread number. Cloned step_resume breakpoints are disabled on
957 creation, so enable it here now that it is associated with the
960 step_resumes are a form of bp that are made to be per-thread.
961 Since we created the step_resume bp when the parent process
962 was being debugged, and now are switching to the child process,
963 from the breakpoint package's viewpoint, that's a switch of
964 "threads". We must update the bp's notion of which thread
965 it is for, or it'll be ignored when it triggers. */
967 if (tp
->control
.step_resume_breakpoint
)
969 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
970 tp
->control
.step_resume_breakpoint
->first_loc ().enabled
= 1;
973 /* Treat exception_resume breakpoints like step_resume breakpoints. */
974 if (tp
->control
.exception_resume_breakpoint
)
976 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
977 tp
->control
.exception_resume_breakpoint
->first_loc ().enabled
= 1;
980 /* Reinsert all breakpoints in the child. The user may have set
981 breakpoints after catching the fork, in which case those
982 were never set in the child, but only in the parent. This makes
983 sure the inserted breakpoints match the breakpoint list. */
985 breakpoint_re_set ();
986 insert_breakpoints ();
989 /* The child has exited or execed: resume THREAD, a thread of the parent,
990 if it was meant to be executing. */
993 proceed_after_vfork_done (thread_info
*thread
)
995 if (thread
->state
== THREAD_RUNNING
996 && !thread
->executing ()
997 && !thread
->stop_requested
998 && thread
->stop_signal () == GDB_SIGNAL_0
)
1000 infrun_debug_printf ("resuming vfork parent thread %s",
1001 thread
->ptid
.to_string ().c_str ());
1003 switch_to_thread (thread
);
1004 clear_proceed_status (0);
1005 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1009 /* Called whenever we notice an exec or exit event, to handle
1010 detaching or resuming a vfork parent. */
1013 handle_vfork_child_exec_or_exit (int exec
)
1015 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
1017 struct inferior
*inf
= current_inferior ();
1019 if (inf
->vfork_parent
)
1021 inferior
*resume_parent
= nullptr;
1023 /* This exec or exit marks the end of the shared memory region
1024 between the parent and the child. Break the bonds. */
1025 inferior
*vfork_parent
= inf
->vfork_parent
;
1026 inf
->vfork_parent
->vfork_child
= nullptr;
1027 inf
->vfork_parent
= nullptr;
1029 /* If the user wanted to detach from the parent, now is the
1031 if (vfork_parent
->pending_detach
)
1033 struct program_space
*pspace
;
1035 /* follow-fork child, detach-on-fork on. */
1037 vfork_parent
->pending_detach
= false;
1039 scoped_restore_current_pspace_and_thread restore_thread
;
1041 /* We're letting loose of the parent. */
1042 thread_info
*tp
= any_live_thread_of_inferior (vfork_parent
);
1043 switch_to_thread (tp
);
1045 /* We're about to detach from the parent, which implicitly
1046 removes breakpoints from its address space. There's a
1047 catch here: we want to reuse the spaces for the child,
1048 but, parent/child are still sharing the pspace at this
1049 point, although the exec in reality makes the kernel give
1050 the child a fresh set of new pages. The problem here is
1051 that the breakpoints module being unaware of this, would
1052 likely chose the child process to write to the parent
1053 address space. Swapping the child temporarily away from
1054 the spaces has the desired effect. Yes, this is "sort
1057 pspace
= inf
->pspace
;
1058 inf
->pspace
= nullptr;
1059 address_space_ref_ptr aspace
= std::move (inf
->aspace
);
1061 if (print_inferior_events
)
1064 = target_pid_to_str (ptid_t (vfork_parent
->pid
));
1066 target_terminal::ours_for_output ();
1070 gdb_printf (_("[Detaching vfork parent %s "
1071 "after child exec]\n"), pidstr
.c_str ());
1075 gdb_printf (_("[Detaching vfork parent %s "
1076 "after child exit]\n"), pidstr
.c_str ());
1080 target_detach (vfork_parent
, 0);
1083 inf
->pspace
= pspace
;
1084 inf
->aspace
= aspace
;
1088 /* We're staying attached to the parent, so, really give the
1089 child a new address space. */
1090 inf
->pspace
= new program_space (maybe_new_address_space ());
1091 inf
->aspace
= inf
->pspace
->aspace
;
1092 inf
->removable
= true;
1093 set_current_program_space (inf
->pspace
);
1095 resume_parent
= vfork_parent
;
1099 /* If this is a vfork child exiting, then the pspace and
1100 aspaces were shared with the parent. Since we're
1101 reporting the process exit, we'll be mourning all that is
1102 found in the address space, and switching to null_ptid,
1103 preparing to start a new inferior. But, since we don't
1104 want to clobber the parent's address/program spaces, we
1105 go ahead and create a new one for this exiting
1108 /* Switch to no-thread while running clone_program_space, so
1109 that clone_program_space doesn't want to read the
1110 selected frame of a dead process. */
1111 scoped_restore_current_thread restore_thread
;
1112 switch_to_no_thread ();
1114 inf
->pspace
= new program_space (maybe_new_address_space ());
1115 inf
->aspace
= inf
->pspace
->aspace
;
1116 set_current_program_space (inf
->pspace
);
1117 inf
->removable
= true;
1118 inf
->symfile_flags
= SYMFILE_NO_READ
;
1119 clone_program_space (inf
->pspace
, vfork_parent
->pspace
);
1121 resume_parent
= vfork_parent
;
1124 gdb_assert (current_program_space
== inf
->pspace
);
1126 if (non_stop
&& resume_parent
!= nullptr)
1128 /* If the user wanted the parent to be running, let it go
1130 scoped_restore_current_thread restore_thread
;
1132 infrun_debug_printf ("resuming vfork parent process %d",
1133 resume_parent
->pid
);
1135 for (thread_info
*thread
: resume_parent
->threads ())
1136 proceed_after_vfork_done (thread
);
1141 /* Handle TARGET_WAITKIND_VFORK_DONE. */
1144 handle_vfork_done (thread_info
*event_thread
)
1146 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
1148 /* We only care about this event if inferior::thread_waiting_for_vfork_done is
1149 set, that is if we are waiting for a vfork child not under our control
1150 (because we detached it) to exec or exit.
1152 If an inferior has vforked and we are debugging the child, we don't use
1153 the vfork-done event to get notified about the end of the shared address
1154 space window. We rely instead on the child's exec or exit event, and the
1155 inferior::vfork_{parent,child} fields are used instead. See
1156 handle_vfork_child_exec_or_exit for that. */
1157 if (event_thread
->inf
->thread_waiting_for_vfork_done
== nullptr)
1159 infrun_debug_printf ("not waiting for a vfork-done event");
1163 /* We stopped all threads (other than the vforking thread) of the inferior in
1164 follow_fork and kept them stopped until now. It should therefore not be
1165 possible for another thread to have reported a vfork during that window.
1166 If THREAD_WAITING_FOR_VFORK_DONE is set, it has to be the same thread whose
1167 vfork-done we are handling right now. */
1168 gdb_assert (event_thread
->inf
->thread_waiting_for_vfork_done
== event_thread
);
1170 event_thread
->inf
->thread_waiting_for_vfork_done
= nullptr;
1171 event_thread
->inf
->pspace
->breakpoints_not_allowed
= 0;
1173 /* On non-stop targets, we stopped all the inferior's threads in follow_fork,
1174 resume them now. On all-stop targets, everything that needs to be resumed
1175 will be when we resume the event thread. */
1176 if (target_is_non_stop_p ())
1178 /* restart_threads and start_step_over may change the current thread, make
1179 sure we leave the event thread as the current thread. */
1180 scoped_restore_current_thread restore_thread
;
1182 insert_breakpoints ();
1185 if (!step_over_info_valid_p ())
1186 restart_threads (event_thread
, event_thread
->inf
);
1190 /* Enum strings for "set|show follow-exec-mode". */
1192 static const char follow_exec_mode_new
[] = "new";
1193 static const char follow_exec_mode_same
[] = "same";
1194 static const char *const follow_exec_mode_names
[] =
1196 follow_exec_mode_new
,
1197 follow_exec_mode_same
,
1201 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1203 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1204 struct cmd_list_element
*c
, const char *value
)
1206 gdb_printf (file
, _("Follow exec mode is \"%s\".\n"), value
);
1209 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1212 follow_exec (ptid_t ptid
, const char *exec_file_target
)
1214 int pid
= ptid
.pid ();
1215 ptid_t process_ptid
;
1217 /* Switch terminal for any messages produced e.g. by
1218 breakpoint_re_set. */
1219 target_terminal::ours_for_output ();
1221 /* This is an exec event that we actually wish to pay attention to.
1222 Refresh our symbol table to the newly exec'd program, remove any
1223 momentary bp's, etc.
1225 If there are breakpoints, they aren't really inserted now,
1226 since the exec() transformed our inferior into a fresh set
1229 We want to preserve symbolic breakpoints on the list, since
1230 we have hopes that they can be reset after the new a.out's
1231 symbol table is read.
1233 However, any "raw" breakpoints must be removed from the list
1234 (e.g., the solib bp's), since their address is probably invalid
1237 And, we DON'T want to call delete_breakpoints() here, since
1238 that may write the bp's "shadow contents" (the instruction
1239 value that was overwritten with a TRAP instruction). Since
1240 we now have a new a.out, those shadow contents aren't valid. */
1242 mark_breakpoints_out ();
1244 /* The target reports the exec event to the main thread, even if
1245 some other thread does the exec, and even if the main thread was
1246 stopped or already gone. We may still have non-leader threads of
1247 the process on our list. E.g., on targets that don't have thread
1248 exit events (like remote) and nothing forces an update of the
1249 thread list up to here. When debugging remotely, it's best to
1250 avoid extra traffic, when possible, so avoid syncing the thread
1251 list with the target, and instead go ahead and delete all threads
1252 of the process but the one that reported the event. Note this must
1253 be done before calling update_breakpoints_after_exec, as
1254 otherwise clearing the threads' resources would reference stale
1255 thread breakpoints -- it may have been one of these threads that
1256 stepped across the exec. We could just clear their stepping
1257 states, but as long as we're iterating, might as well delete
1258 them. Deleting them now rather than at the next user-visible
1259 stop provides a nicer sequence of events for user and MI
1261 for (thread_info
*th
: all_threads_safe ())
1262 if (th
->ptid
.pid () == pid
&& th
->ptid
!= ptid
)
1265 /* We also need to clear any left over stale state for the
1266 leader/event thread. E.g., if there was any step-resume
1267 breakpoint or similar, it's gone now. We cannot truly
1268 step-to-next statement through an exec(). */
1269 thread_info
*th
= inferior_thread ();
1270 th
->control
.step_resume_breakpoint
= nullptr;
1271 th
->control
.exception_resume_breakpoint
= nullptr;
1272 th
->control
.single_step_breakpoints
= nullptr;
1273 th
->control
.step_range_start
= 0;
1274 th
->control
.step_range_end
= 0;
1276 /* The user may have had the main thread held stopped in the
1277 previous image (e.g., schedlock on, or non-stop). Release
1279 th
->stop_requested
= 0;
1281 update_breakpoints_after_exec ();
1283 /* What is this a.out's name? */
1284 process_ptid
= ptid_t (pid
);
1285 gdb_printf (_("%s is executing new program: %s\n"),
1286 target_pid_to_str (process_ptid
).c_str (),
1289 /* We've followed the inferior through an exec. Therefore, the
1290 inferior has essentially been killed & reborn. */
1292 breakpoint_init_inferior (inf_execd
);
1294 gdb::unique_xmalloc_ptr
<char> exec_file_host
1295 = exec_file_find (exec_file_target
, nullptr);
1297 /* If we were unable to map the executable target pathname onto a host
1298 pathname, tell the user that. Otherwise GDB's subsequent behavior
1299 is confusing. Maybe it would even be better to stop at this point
1300 so that the user can specify a file manually before continuing. */
1301 if (exec_file_host
== nullptr)
1302 warning (_("Could not load symbols for executable %s.\n"
1303 "Do you need \"set sysroot\"?"),
1306 /* Reset the shared library package. This ensures that we get a
1307 shlib event when the child reaches "_start", at which point the
1308 dld will have had a chance to initialize the child. */
1309 /* Also, loading a symbol file below may trigger symbol lookups, and
1310 we don't want those to be satisfied by the libraries of the
1311 previous incarnation of this process. */
1312 no_shared_libraries (nullptr, 0);
1314 inferior
*execing_inferior
= current_inferior ();
1315 inferior
*following_inferior
;
1317 if (follow_exec_mode_string
== follow_exec_mode_new
)
1319 /* The user wants to keep the old inferior and program spaces
1320 around. Create a new fresh one, and switch to it. */
1322 /* Do exit processing for the original inferior before setting the new
1323 inferior's pid. Having two inferiors with the same pid would confuse
1324 find_inferior_p(t)id. Transfer the terminal state and info from the
1325 old to the new inferior. */
1326 following_inferior
= add_inferior_with_spaces ();
1328 swap_terminal_info (following_inferior
, execing_inferior
);
1329 exit_inferior (execing_inferior
);
1331 following_inferior
->pid
= pid
;
1335 /* follow-exec-mode is "same", we continue execution in the execing
1337 following_inferior
= execing_inferior
;
1339 /* The old description may no longer be fit for the new image.
1340 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1341 old description; we'll read a new one below. No need to do
1342 this on "follow-exec-mode new", as the old inferior stays
1343 around (its description is later cleared/refetched on
1345 target_clear_description ();
1348 target_follow_exec (following_inferior
, ptid
, exec_file_target
);
1350 gdb_assert (current_inferior () == following_inferior
);
1351 gdb_assert (current_program_space
== following_inferior
->pspace
);
1353 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1354 because the proper displacement for a PIE (Position Independent
1355 Executable) main symbol file will only be computed by
1356 solib_create_inferior_hook below. breakpoint_re_set would fail
1357 to insert the breakpoints with the zero displacement. */
1358 try_open_exec_file (exec_file_host
.get (), following_inferior
,
1359 SYMFILE_DEFER_BP_RESET
);
1361 /* If the target can specify a description, read it. Must do this
1362 after flipping to the new executable (because the target supplied
1363 description must be compatible with the executable's
1364 architecture, and the old executable may e.g., be 32-bit, while
1365 the new one 64-bit), and before anything involving memory or
1367 target_find_description ();
1369 gdb::observers::inferior_execd
.notify (execing_inferior
, following_inferior
);
1371 breakpoint_re_set ();
1373 /* Reinsert all breakpoints. (Those which were symbolic have
1374 been reset to the proper address in the new a.out, thanks
1375 to symbol_file_command...). */
1376 insert_breakpoints ();
1378 /* The next resume of this inferior should bring it to the shlib
1379 startup breakpoints. (If the user had also set bp's on
1380 "main" from the old (parent) process, then they'll auto-
1381 matically get reset there in the new process.). */
1384 /* The chain of threads that need to do a step-over operation to get
1385 past e.g., a breakpoint. What technique is used to step over the
1386 breakpoint/watchpoint does not matter -- all threads end up in the
1387 same queue, to maintain rough temporal order of execution, in order
1388 to avoid starvation, otherwise, we could e.g., find ourselves
1389 constantly stepping the same couple threads past their breakpoints
1390 over and over, if the single-step finish fast enough. */
1391 thread_step_over_list global_thread_step_over_list
;
1393 /* Bit flags indicating what the thread needs to step over. */
1395 enum step_over_what_flag
1397 /* Step over a breakpoint. */
1398 STEP_OVER_BREAKPOINT
= 1,
1400 /* Step past a non-continuable watchpoint, in order to let the
1401 instruction execute so we can evaluate the watchpoint
1403 STEP_OVER_WATCHPOINT
= 2
1405 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag
, step_over_what
);
1407 /* Info about an instruction that is being stepped over. */
1409 struct step_over_info
1411 /* If we're stepping past a breakpoint, this is the address space
1412 and address of the instruction the breakpoint is set at. We'll
1413 skip inserting all breakpoints here. Valid iff ASPACE is
1415 const address_space
*aspace
= nullptr;
1416 CORE_ADDR address
= 0;
1418 /* The instruction being stepped over triggers a nonsteppable
1419 watchpoint. If true, we'll skip inserting watchpoints. */
1420 int nonsteppable_watchpoint_p
= 0;
1422 /* The thread's global number. */
1426 /* The step-over info of the location that is being stepped over.
1428 Note that with async/breakpoint always-inserted mode, a user might
1429 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1430 being stepped over. As setting a new breakpoint inserts all
1431 breakpoints, we need to make sure the breakpoint being stepped over
1432 isn't inserted then. We do that by only clearing the step-over
1433 info when the step-over is actually finished (or aborted).
1435 Presently GDB can only step over one breakpoint at any given time.
1436 Given threads that can't run code in the same address space as the
1437 breakpoint's can't really miss the breakpoint, GDB could be taught
1438 to step-over at most one breakpoint per address space (so this info
1439 could move to the address space object if/when GDB is extended).
1440 The set of breakpoints being stepped over will normally be much
1441 smaller than the set of all breakpoints, so a flag in the
1442 breakpoint location structure would be wasteful. A separate list
1443 also saves complexity and run-time, as otherwise we'd have to go
1444 through all breakpoint locations clearing their flag whenever we
1445 start a new sequence. Similar considerations weigh against storing
1446 this info in the thread object. Plus, not all step overs actually
1447 have breakpoint locations -- e.g., stepping past a single-step
1448 breakpoint, or stepping to complete a non-continuable
1450 static struct step_over_info step_over_info
;
1452 /* Record the address of the breakpoint/instruction we're currently
1454 N.B. We record the aspace and address now, instead of say just the thread,
1455 because when we need the info later the thread may be running. */
1458 set_step_over_info (const address_space
*aspace
, CORE_ADDR address
,
1459 int nonsteppable_watchpoint_p
,
1462 step_over_info
.aspace
= aspace
;
1463 step_over_info
.address
= address
;
1464 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1465 step_over_info
.thread
= thread
;
1468 /* Called when we're not longer stepping over a breakpoint / an
1469 instruction, so all breakpoints are free to be (re)inserted. */
1472 clear_step_over_info (void)
1474 infrun_debug_printf ("clearing step over info");
1475 step_over_info
.aspace
= nullptr;
1476 step_over_info
.address
= 0;
1477 step_over_info
.nonsteppable_watchpoint_p
= 0;
1478 step_over_info
.thread
= -1;
1484 stepping_past_instruction_at (struct address_space
*aspace
,
1487 return (step_over_info
.aspace
!= nullptr
1488 && breakpoint_address_match (aspace
, address
,
1489 step_over_info
.aspace
,
1490 step_over_info
.address
));
1496 thread_is_stepping_over_breakpoint (int thread
)
1498 return (step_over_info
.thread
!= -1
1499 && thread
== step_over_info
.thread
);
1505 stepping_past_nonsteppable_watchpoint (void)
1507 return step_over_info
.nonsteppable_watchpoint_p
;
1510 /* Returns true if step-over info is valid. */
1513 step_over_info_valid_p (void)
1515 return (step_over_info
.aspace
!= nullptr
1516 || stepping_past_nonsteppable_watchpoint ());
1520 /* Displaced stepping. */
1522 /* In non-stop debugging mode, we must take special care to manage
1523 breakpoints properly; in particular, the traditional strategy for
1524 stepping a thread past a breakpoint it has hit is unsuitable.
1525 'Displaced stepping' is a tactic for stepping one thread past a
1526 breakpoint it has hit while ensuring that other threads running
1527 concurrently will hit the breakpoint as they should.
1529 The traditional way to step a thread T off a breakpoint in a
1530 multi-threaded program in all-stop mode is as follows:
1532 a0) Initially, all threads are stopped, and breakpoints are not
1534 a1) We single-step T, leaving breakpoints uninserted.
1535 a2) We insert breakpoints, and resume all threads.
1537 In non-stop debugging, however, this strategy is unsuitable: we
1538 don't want to have to stop all threads in the system in order to
1539 continue or step T past a breakpoint. Instead, we use displaced
1542 n0) Initially, T is stopped, other threads are running, and
1543 breakpoints are inserted.
1544 n1) We copy the instruction "under" the breakpoint to a separate
1545 location, outside the main code stream, making any adjustments
1546 to the instruction, register, and memory state as directed by
1548 n2) We single-step T over the instruction at its new location.
1549 n3) We adjust the resulting register and memory state as directed
1550 by T's architecture. This includes resetting T's PC to point
1551 back into the main instruction stream.
1554 This approach depends on the following gdbarch methods:
1556 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1557 indicate where to copy the instruction, and how much space must
1558 be reserved there. We use these in step n1.
1560 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1561 address, and makes any necessary adjustments to the instruction,
1562 register contents, and memory. We use this in step n1.
1564 - gdbarch_displaced_step_fixup adjusts registers and memory after
1565 we have successfully single-stepped the instruction, to yield the
1566 same effect the instruction would have had if we had executed it
1567 at its original address. We use this in step n3.
1569 The gdbarch_displaced_step_copy_insn and
1570 gdbarch_displaced_step_fixup functions must be written so that
1571 copying an instruction with gdbarch_displaced_step_copy_insn,
1572 single-stepping across the copied instruction, and then applying
1573 gdbarch_displaced_insn_fixup should have the same effects on the
1574 thread's memory and registers as stepping the instruction in place
1575 would have. Exactly which responsibilities fall to the copy and
1576 which fall to the fixup is up to the author of those functions.
1578 See the comments in gdbarch.sh for details.
1580 Note that displaced stepping and software single-step cannot
1581 currently be used in combination, although with some care I think
1582 they could be made to. Software single-step works by placing
1583 breakpoints on all possible subsequent instructions; if the
1584 displaced instruction is a PC-relative jump, those breakpoints
1585 could fall in very strange places --- on pages that aren't
1586 executable, or at addresses that are not proper instruction
1587 boundaries. (We do generally let other threads run while we wait
1588 to hit the software single-step breakpoint, and they might
1589 encounter such a corrupted instruction.) One way to work around
1590 this would be to have gdbarch_displaced_step_copy_insn fully
1591 simulate the effect of PC-relative instructions (and return NULL)
1592 on architectures that use software single-stepping.
1594 In non-stop mode, we can have independent and simultaneous step
1595 requests, so more than one thread may need to simultaneously step
1596 over a breakpoint. The current implementation assumes there is
1597 only one scratch space per process. In this case, we have to
1598 serialize access to the scratch space. If thread A wants to step
1599 over a breakpoint, but we are currently waiting for some other
1600 thread to complete a displaced step, we leave thread A stopped and
1601 place it in the displaced_step_request_queue. Whenever a displaced
1602 step finishes, we pick the next thread in the queue and start a new
1603 displaced step operation on it. See displaced_step_prepare and
1604 displaced_step_finish for details. */
1606 /* Return true if THREAD is doing a displaced step. */
1609 displaced_step_in_progress_thread (thread_info
*thread
)
1611 gdb_assert (thread
!= nullptr);
1613 return thread
->displaced_step_state
.in_progress ();
1616 /* Return true if INF has a thread doing a displaced step. */
1619 displaced_step_in_progress (inferior
*inf
)
1621 return inf
->displaced_step_state
.in_progress_count
> 0;
1624 /* Return true if any thread is doing a displaced step. */
1627 displaced_step_in_progress_any_thread ()
1629 for (inferior
*inf
: all_non_exited_inferiors ())
1631 if (displaced_step_in_progress (inf
))
1639 infrun_inferior_exit (struct inferior
*inf
)
1641 inf
->displaced_step_state
.reset ();
1642 inf
->thread_waiting_for_vfork_done
= nullptr;
1646 infrun_inferior_execd (inferior
*exec_inf
, inferior
*follow_inf
)
1648 /* If some threads where was doing a displaced step in this inferior at the
1649 moment of the exec, they no longer exist. Even if the exec'ing thread
1650 doing a displaced step, we don't want to to any fixup nor restore displaced
1651 stepping buffer bytes. */
1652 follow_inf
->displaced_step_state
.reset ();
1654 for (thread_info
*thread
: follow_inf
->threads ())
1655 thread
->displaced_step_state
.reset ();
1657 /* Since an in-line step is done with everything else stopped, if there was
1658 one in progress at the time of the exec, it must have been the exec'ing
1660 clear_step_over_info ();
1662 follow_inf
->thread_waiting_for_vfork_done
= nullptr;
1665 /* If ON, and the architecture supports it, GDB will use displaced
1666 stepping to step over breakpoints. If OFF, or if the architecture
1667 doesn't support it, GDB will instead use the traditional
1668 hold-and-step approach. If AUTO (which is the default), GDB will
1669 decide which technique to use to step over breakpoints depending on
1670 whether the target works in a non-stop way (see use_displaced_stepping). */
1672 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1675 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1676 struct cmd_list_element
*c
,
1679 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1681 _("Debugger's willingness to use displaced stepping "
1682 "to step over breakpoints is %s (currently %s).\n"),
1683 value
, target_is_non_stop_p () ? "on" : "off");
1686 _("Debugger's willingness to use displaced stepping "
1687 "to step over breakpoints is %s.\n"), value
);
1690 /* Return true if the gdbarch implements the required methods to use
1691 displaced stepping. */
1694 gdbarch_supports_displaced_stepping (gdbarch
*arch
)
1696 /* Only check for the presence of `prepare`. The gdbarch verification ensures
1697 that if `prepare` is provided, so is `finish`. */
1698 return gdbarch_displaced_step_prepare_p (arch
);
1701 /* Return non-zero if displaced stepping can/should be used to step
1702 over breakpoints of thread TP. */
1705 use_displaced_stepping (thread_info
*tp
)
1707 /* If the user disabled it explicitly, don't use displaced stepping. */
1708 if (can_use_displaced_stepping
== AUTO_BOOLEAN_FALSE
)
1711 /* If "auto", only use displaced stepping if the target operates in a non-stop
1713 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1714 && !target_is_non_stop_p ())
1717 gdbarch
*gdbarch
= get_thread_regcache (tp
)->arch ();
1719 /* If the architecture doesn't implement displaced stepping, don't use
1721 if (!gdbarch_supports_displaced_stepping (gdbarch
))
1724 /* If recording, don't use displaced stepping. */
1725 if (find_record_target () != nullptr)
1728 /* If displaced stepping failed before for this inferior, don't bother trying
1730 if (tp
->inf
->displaced_step_state
.failed_before
)
1736 /* Simple function wrapper around displaced_step_thread_state::reset. */
1739 displaced_step_reset (displaced_step_thread_state
*displaced
)
1741 displaced
->reset ();
1744 /* A cleanup that wraps displaced_step_reset. We use this instead of, say,
1745 SCOPE_EXIT, because it needs to be discardable with "cleanup.release ()". */
1747 using displaced_step_reset_cleanup
= FORWARD_SCOPE_EXIT (displaced_step_reset
);
1749 /* Prepare to single-step, using displaced stepping.
1751 Note that we cannot use displaced stepping when we have a signal to
1752 deliver. If we have a signal to deliver and an instruction to step
1753 over, then after the step, there will be no indication from the
1754 target whether the thread entered a signal handler or ignored the
1755 signal and stepped over the instruction successfully --- both cases
1756 result in a simple SIGTRAP. In the first case we mustn't do a
1757 fixup, and in the second case we must --- but we can't tell which.
1758 Comments in the code for 'random signals' in handle_inferior_event
1759 explain how we handle this case instead.
1761 Returns DISPLACED_STEP_PREPARE_STATUS_OK if preparing was successful -- this
1762 thread is going to be stepped now; DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
1763 if displaced stepping this thread got queued; or
1764 DISPLACED_STEP_PREPARE_STATUS_CANT if this instruction can't be displaced
1767 static displaced_step_prepare_status
1768 displaced_step_prepare_throw (thread_info
*tp
)
1770 regcache
*regcache
= get_thread_regcache (tp
);
1771 struct gdbarch
*gdbarch
= regcache
->arch ();
1772 displaced_step_thread_state
&disp_step_thread_state
1773 = tp
->displaced_step_state
;
1775 /* We should never reach this function if the architecture does not
1776 support displaced stepping. */
1777 gdb_assert (gdbarch_supports_displaced_stepping (gdbarch
));
1779 /* Nor if the thread isn't meant to step over a breakpoint. */
1780 gdb_assert (tp
->control
.trap_expected
);
1782 /* Disable range stepping while executing in the scratch pad. We
1783 want a single-step even if executing the displaced instruction in
1784 the scratch buffer lands within the stepping range (e.g., a
1786 tp
->control
.may_range_step
= 0;
1788 /* We are about to start a displaced step for this thread. If one is already
1789 in progress, something's wrong. */
1790 gdb_assert (!disp_step_thread_state
.in_progress ());
1792 if (tp
->inf
->displaced_step_state
.unavailable
)
1794 /* The gdbarch tells us it's not worth asking to try a prepare because
1795 it is likely that it will return unavailable, so don't bother asking. */
1797 displaced_debug_printf ("deferring step of %s",
1798 tp
->ptid
.to_string ().c_str ());
1800 global_thread_step_over_chain_enqueue (tp
);
1801 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1804 displaced_debug_printf ("displaced-stepping %s now",
1805 tp
->ptid
.to_string ().c_str ());
1807 scoped_restore_current_thread restore_thread
;
1809 switch_to_thread (tp
);
1811 CORE_ADDR original_pc
= regcache_read_pc (regcache
);
1812 CORE_ADDR displaced_pc
;
1814 /* Display the instruction we are going to displaced step. */
1815 if (debug_displaced
)
1817 string_file tmp_stream
;
1818 int dislen
= gdb_print_insn (gdbarch
, original_pc
, &tmp_stream
,
1823 gdb::byte_vector
insn_buf (dislen
);
1824 read_memory (original_pc
, insn_buf
.data (), insn_buf
.size ());
1826 std::string insn_bytes
= bytes_to_string (insn_buf
);
1828 displaced_debug_printf ("original insn %s: %s \t %s",
1829 paddress (gdbarch
, original_pc
),
1830 insn_bytes
.c_str (),
1831 tmp_stream
.string ().c_str ());
1834 displaced_debug_printf ("original insn %s: invalid length: %d",
1835 paddress (gdbarch
, original_pc
), dislen
);
1838 displaced_step_prepare_status status
1839 = gdbarch_displaced_step_prepare (gdbarch
, tp
, displaced_pc
);
1841 if (status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
1843 displaced_debug_printf ("failed to prepare (%s)",
1844 tp
->ptid
.to_string ().c_str ());
1846 return DISPLACED_STEP_PREPARE_STATUS_CANT
;
1848 else if (status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
1850 /* Not enough displaced stepping resources available, defer this
1851 request by placing it the queue. */
1853 displaced_debug_printf ("not enough resources available, "
1854 "deferring step of %s",
1855 tp
->ptid
.to_string ().c_str ());
1857 global_thread_step_over_chain_enqueue (tp
);
1859 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1862 gdb_assert (status
== DISPLACED_STEP_PREPARE_STATUS_OK
);
1864 /* Save the information we need to fix things up if the step
1866 disp_step_thread_state
.set (gdbarch
);
1868 tp
->inf
->displaced_step_state
.in_progress_count
++;
1870 displaced_debug_printf ("prepared successfully thread=%s, "
1871 "original_pc=%s, displaced_pc=%s",
1872 tp
->ptid
.to_string ().c_str (),
1873 paddress (gdbarch
, original_pc
),
1874 paddress (gdbarch
, displaced_pc
));
1876 /* Display the new displaced instruction(s). */
1877 if (debug_displaced
)
1879 string_file tmp_stream
;
1880 CORE_ADDR addr
= displaced_pc
;
1882 /* If displaced stepping is going to use h/w single step then we know
1883 that the replacement instruction can only be a single instruction,
1884 in that case set the end address at the next byte.
1886 Otherwise the displaced stepping copy instruction routine could
1887 have generated multiple instructions, and all we know is that they
1888 must fit within the LEN bytes of the buffer. */
1890 = addr
+ (gdbarch_displaced_step_hw_singlestep (gdbarch
)
1891 ? 1 : gdbarch_displaced_step_buffer_length (gdbarch
));
1895 int dislen
= gdb_print_insn (gdbarch
, addr
, &tmp_stream
, nullptr);
1898 displaced_debug_printf
1899 ("replacement insn %s: invalid length: %d",
1900 paddress (gdbarch
, addr
), dislen
);
1904 gdb::byte_vector
insn_buf (dislen
);
1905 read_memory (addr
, insn_buf
.data (), insn_buf
.size ());
1907 std::string insn_bytes
= bytes_to_string (insn_buf
);
1908 std::string insn_str
= tmp_stream
.release ();
1909 displaced_debug_printf ("replacement insn %s: %s \t %s",
1910 paddress (gdbarch
, addr
),
1911 insn_bytes
.c_str (),
1917 return DISPLACED_STEP_PREPARE_STATUS_OK
;
1920 /* Wrapper for displaced_step_prepare_throw that disabled further
1921 attempts at displaced stepping if we get a memory error. */
1923 static displaced_step_prepare_status
1924 displaced_step_prepare (thread_info
*thread
)
1926 displaced_step_prepare_status status
1927 = DISPLACED_STEP_PREPARE_STATUS_CANT
;
1931 status
= displaced_step_prepare_throw (thread
);
1933 catch (const gdb_exception_error
&ex
)
1935 if (ex
.error
!= MEMORY_ERROR
1936 && ex
.error
!= NOT_SUPPORTED_ERROR
)
1939 infrun_debug_printf ("caught exception, disabling displaced stepping: %s",
1942 /* Be verbose if "set displaced-stepping" is "on", silent if
1944 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1946 warning (_("disabling displaced stepping: %s"),
1950 /* Disable further displaced stepping attempts. */
1951 thread
->inf
->displaced_step_state
.failed_before
= 1;
1957 /* True if any thread of TARGET that matches RESUME_PTID requires
1958 target_thread_events enabled. This assumes TARGET does not support
1959 target thread options. */
1962 any_thread_needs_target_thread_events (process_stratum_target
*target
,
1965 for (thread_info
*tp
: all_non_exited_threads (target
, resume_ptid
))
1966 if (displaced_step_in_progress_thread (tp
)
1967 || schedlock_applies (tp
)
1968 || tp
->thread_fsm () != nullptr)
1973 /* Maybe disable thread-{cloned,created,exited} event reporting after
1974 a step-over (either in-line or displaced) finishes. */
1977 update_thread_events_after_step_over (thread_info
*event_thread
,
1978 const target_waitstatus
&event_status
)
1980 if (schedlock_applies (event_thread
))
1982 /* If scheduler-locking applies, continue reporting
1983 thread-created/thread-cloned events. */
1986 else if (target_supports_set_thread_options (0))
1988 /* We can control per-thread options. Disable events for the
1989 event thread, unless the thread is gone. */
1990 if (event_status
.kind () != TARGET_WAITKIND_THREAD_EXITED
)
1991 event_thread
->set_thread_options (0);
1995 /* We can only control the target-wide target_thread_events
1996 setting. Disable it, but only if other threads in the target
1997 don't need it enabled. */
1998 process_stratum_target
*target
= event_thread
->inf
->process_target ();
1999 if (!any_thread_needs_target_thread_events (target
, minus_one_ptid
))
2000 target_thread_events (false);
2004 /* If we displaced stepped an instruction successfully, adjust registers and
2005 memory to yield the same effect the instruction would have had if we had
2006 executed it at its original address, and return
2007 DISPLACED_STEP_FINISH_STATUS_OK. If the instruction didn't complete,
2008 relocate the PC and return DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED.
2010 If the thread wasn't displaced stepping, return
2011 DISPLACED_STEP_FINISH_STATUS_OK as well. */
2013 static displaced_step_finish_status
2014 displaced_step_finish (thread_info
*event_thread
,
2015 const target_waitstatus
&event_status
)
2017 /* Check whether the parent is displaced stepping. */
2018 struct regcache
*regcache
= get_thread_regcache (event_thread
);
2019 struct gdbarch
*gdbarch
= regcache
->arch ();
2020 inferior
*parent_inf
= event_thread
->inf
;
2022 /* If this was a fork/vfork/clone, this event indicates that the
2023 displaced stepping of the syscall instruction has been done, so
2024 we perform cleanup for parent here. Also note that this
2025 operation also cleans up the child for vfork, because their pages
2028 /* If this is a fork (child gets its own address space copy) and
2029 some displaced step buffers were in use at the time of the fork,
2030 restore the displaced step buffer bytes in the child process.
2032 Architectures which support displaced stepping and fork events
2033 must supply an implementation of
2034 gdbarch_displaced_step_restore_all_in_ptid. This is not enforced
2035 during gdbarch validation to support architectures which support
2036 displaced stepping but not forks. */
2037 if (event_status
.kind () == TARGET_WAITKIND_FORKED
2038 && gdbarch_supports_displaced_stepping (gdbarch
))
2039 gdbarch_displaced_step_restore_all_in_ptid
2040 (gdbarch
, parent_inf
, event_status
.child_ptid ());
2042 displaced_step_thread_state
*displaced
= &event_thread
->displaced_step_state
;
2044 /* Was this thread performing a displaced step? */
2045 if (!displaced
->in_progress ())
2046 return DISPLACED_STEP_FINISH_STATUS_OK
;
2048 update_thread_events_after_step_over (event_thread
, event_status
);
2050 gdb_assert (event_thread
->inf
->displaced_step_state
.in_progress_count
> 0);
2051 event_thread
->inf
->displaced_step_state
.in_progress_count
--;
2053 /* Fixup may need to read memory/registers. Switch to the thread
2054 that we're fixing up. Also, target_stopped_by_watchpoint checks
2055 the current thread, and displaced_step_restore performs ptid-dependent
2056 memory accesses using current_inferior(). */
2057 switch_to_thread (event_thread
);
2059 displaced_step_reset_cleanup
cleanup (displaced
);
2061 /* Do the fixup, and release the resources acquired to do the displaced
2063 displaced_step_finish_status status
2064 = gdbarch_displaced_step_finish (displaced
->get_original_gdbarch (),
2065 event_thread
, event_status
);
2067 if (event_status
.kind () == TARGET_WAITKIND_FORKED
2068 || event_status
.kind () == TARGET_WAITKIND_VFORKED
2069 || event_status
.kind () == TARGET_WAITKIND_THREAD_CLONED
)
2071 /* Since the vfork/fork/clone syscall instruction was executed
2072 in the scratchpad, the child's PC is also within the
2073 scratchpad. Set the child's PC to the parent's PC value,
2074 which has already been fixed up. Note: we use the parent's
2075 aspace here, although we're touching the child, because the
2076 child hasn't been added to the inferior list yet at this
2079 struct regcache
*child_regcache
2080 = get_thread_arch_regcache (parent_inf
, event_status
.child_ptid (),
2082 /* Read PC value of parent. */
2083 CORE_ADDR parent_pc
= regcache_read_pc (regcache
);
2085 displaced_debug_printf ("write child pc from %s to %s",
2087 regcache_read_pc (child_regcache
)),
2088 paddress (gdbarch
, parent_pc
));
2090 regcache_write_pc (child_regcache
, parent_pc
);
2096 /* Data to be passed around while handling an event. This data is
2097 discarded between events. */
2098 struct execution_control_state
2100 explicit execution_control_state (thread_info
*thr
= nullptr)
2101 : ptid (thr
== nullptr ? null_ptid
: thr
->ptid
),
2106 process_stratum_target
*target
= nullptr;
2108 /* The thread that got the event, if this was a thread event; NULL
2110 struct thread_info
*event_thread
;
2112 struct target_waitstatus ws
;
2113 int stop_func_filled_in
= 0;
2114 CORE_ADDR stop_func_alt_start
= 0;
2115 CORE_ADDR stop_func_start
= 0;
2116 CORE_ADDR stop_func_end
= 0;
2117 const char *stop_func_name
= nullptr;
2118 int wait_some_more
= 0;
2120 /* True if the event thread hit the single-step breakpoint of
2121 another thread. Thus the event doesn't cause a stop, the thread
2122 needs to be single-stepped past the single-step breakpoint before
2123 we can switch back to the original stepping thread. */
2124 int hit_singlestep_breakpoint
= 0;
2127 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
2128 static void prepare_to_wait (struct execution_control_state
*ecs
);
2129 static bool keep_going_stepped_thread (struct thread_info
*tp
);
2130 static step_over_what
thread_still_needs_step_over (struct thread_info
*tp
);
2132 /* Are there any pending step-over requests? If so, run all we can
2133 now and return true. Otherwise, return false. */
2136 start_step_over (void)
2138 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
2140 /* Don't start a new step-over if we already have an in-line
2141 step-over operation ongoing. */
2142 if (step_over_info_valid_p ())
2145 /* Steal the global thread step over chain. As we try to initiate displaced
2146 steps, threads will be enqueued in the global chain if no buffers are
2147 available. If we iterated on the global chain directly, we might iterate
2149 thread_step_over_list threads_to_step
2150 = std::move (global_thread_step_over_list
);
2152 infrun_debug_printf ("stealing global queue of threads to step, length = %d",
2153 thread_step_over_chain_length (threads_to_step
));
2155 bool started
= false;
2157 /* On scope exit (whatever the reason, return or exception), if there are
2158 threads left in the THREADS_TO_STEP chain, put back these threads in the
2162 if (threads_to_step
.empty ())
2163 infrun_debug_printf ("step-over queue now empty");
2166 infrun_debug_printf ("putting back %d threads to step in global queue",
2167 thread_step_over_chain_length (threads_to_step
));
2169 global_thread_step_over_chain_enqueue_chain
2170 (std::move (threads_to_step
));
2174 thread_step_over_list_safe_range range
2175 = make_thread_step_over_list_safe_range (threads_to_step
);
2177 for (thread_info
*tp
: range
)
2179 step_over_what step_what
;
2180 int must_be_in_line
;
2182 gdb_assert (!tp
->stop_requested
);
2184 if (tp
->inf
->displaced_step_state
.unavailable
)
2186 /* The arch told us to not even try preparing another displaced step
2187 for this inferior. Just leave the thread in THREADS_TO_STEP, it
2188 will get moved to the global chain on scope exit. */
2192 if (tp
->inf
->thread_waiting_for_vfork_done
!= nullptr)
2194 /* When we stop all threads, handling a vfork, any thread in the step
2195 over chain remains there. A user could also try to continue a
2196 thread stopped at a breakpoint while another thread is waiting for
2197 a vfork-done event. In any case, we don't want to start a step
2202 /* Remove thread from the THREADS_TO_STEP chain. If anything goes wrong
2203 while we try to prepare the displaced step, we don't add it back to
2204 the global step over chain. This is to avoid a thread staying in the
2205 step over chain indefinitely if something goes wrong when resuming it
2206 If the error is intermittent and it still needs a step over, it will
2207 get enqueued again when we try to resume it normally. */
2208 threads_to_step
.erase (threads_to_step
.iterator_to (*tp
));
2210 step_what
= thread_still_needs_step_over (tp
);
2211 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
2212 || ((step_what
& STEP_OVER_BREAKPOINT
)
2213 && !use_displaced_stepping (tp
)));
2215 /* We currently stop all threads of all processes to step-over
2216 in-line. If we need to start a new in-line step-over, let
2217 any pending displaced steps finish first. */
2218 if (must_be_in_line
&& displaced_step_in_progress_any_thread ())
2220 global_thread_step_over_chain_enqueue (tp
);
2224 if (tp
->control
.trap_expected
2226 || tp
->executing ())
2228 internal_error ("[%s] has inconsistent state: "
2229 "trap_expected=%d, resumed=%d, executing=%d\n",
2230 tp
->ptid
.to_string ().c_str (),
2231 tp
->control
.trap_expected
,
2236 infrun_debug_printf ("resuming [%s] for step-over",
2237 tp
->ptid
.to_string ().c_str ());
2239 /* keep_going_pass_signal skips the step-over if the breakpoint
2240 is no longer inserted. In all-stop, we want to keep looking
2241 for a thread that needs a step-over instead of resuming TP,
2242 because we wouldn't be able to resume anything else until the
2243 target stops again. In non-stop, the resume always resumes
2244 only TP, so it's OK to let the thread resume freely. */
2245 if (!target_is_non_stop_p () && !step_what
)
2248 switch_to_thread (tp
);
2249 execution_control_state
ecs (tp
);
2250 keep_going_pass_signal (&ecs
);
2252 if (!ecs
.wait_some_more
)
2253 error (_("Command aborted."));
2255 /* If the thread's step over could not be initiated because no buffers
2256 were available, it was re-added to the global step over chain. */
2259 infrun_debug_printf ("[%s] was resumed.",
2260 tp
->ptid
.to_string ().c_str ());
2261 gdb_assert (!thread_is_in_step_over_chain (tp
));
2265 infrun_debug_printf ("[%s] was NOT resumed.",
2266 tp
->ptid
.to_string ().c_str ());
2267 gdb_assert (thread_is_in_step_over_chain (tp
));
2270 /* If we started a new in-line step-over, we're done. */
2271 if (step_over_info_valid_p ())
2273 gdb_assert (tp
->control
.trap_expected
);
2278 if (!target_is_non_stop_p ())
2280 /* On all-stop, shouldn't have resumed unless we needed a
2282 gdb_assert (tp
->control
.trap_expected
2283 || tp
->step_after_step_resume_breakpoint
);
2285 /* With remote targets (at least), in all-stop, we can't
2286 issue any further remote commands until the program stops
2292 /* Either the thread no longer needed a step-over, or a new
2293 displaced stepping sequence started. Even in the latter
2294 case, continue looking. Maybe we can also start another
2295 displaced step on a thread of other process. */
2301 /* Update global variables holding ptids to hold NEW_PTID if they were
2302 holding OLD_PTID. */
2304 infrun_thread_ptid_changed (process_stratum_target
*target
,
2305 ptid_t old_ptid
, ptid_t new_ptid
)
2307 if (inferior_ptid
== old_ptid
2308 && current_inferior ()->process_target () == target
)
2309 inferior_ptid
= new_ptid
;
2314 static const char schedlock_off
[] = "off";
2315 static const char schedlock_on
[] = "on";
2316 static const char schedlock_step
[] = "step";
2317 static const char schedlock_replay
[] = "replay";
2318 static const char *const scheduler_enums
[] = {
2325 static const char *scheduler_mode
= schedlock_replay
;
2327 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2328 struct cmd_list_element
*c
, const char *value
)
2331 _("Mode for locking scheduler "
2332 "during execution is \"%s\".\n"),
2337 set_schedlock_func (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2339 if (!target_can_lock_scheduler ())
2341 scheduler_mode
= schedlock_off
;
2342 error (_("Target '%s' cannot support this command."),
2343 target_shortname ());
2347 /* True if execution commands resume all threads of all processes by
2348 default; otherwise, resume only threads of the current inferior
2350 bool sched_multi
= false;
2352 /* Try to setup for software single stepping. Return true if target_resume()
2353 should use hardware single step.
2355 GDBARCH the current gdbarch. */
2358 maybe_software_singlestep (struct gdbarch
*gdbarch
)
2360 bool hw_step
= true;
2362 if (execution_direction
== EXEC_FORWARD
2363 && gdbarch_software_single_step_p (gdbarch
))
2364 hw_step
= !insert_single_step_breakpoints (gdbarch
);
2372 user_visible_resume_ptid (int step
)
2378 /* With non-stop mode on, threads are always handled
2380 resume_ptid
= inferior_ptid
;
2382 else if ((scheduler_mode
== schedlock_on
)
2383 || (scheduler_mode
== schedlock_step
&& step
))
2385 /* User-settable 'scheduler' mode requires solo thread
2387 resume_ptid
= inferior_ptid
;
2389 else if ((scheduler_mode
== schedlock_replay
)
2390 && target_record_will_replay (minus_one_ptid
, execution_direction
))
2392 /* User-settable 'scheduler' mode requires solo thread resume in replay
2394 resume_ptid
= inferior_ptid
;
2396 else if (!sched_multi
&& target_supports_multi_process ())
2398 /* Resume all threads of the current process (and none of other
2400 resume_ptid
= ptid_t (inferior_ptid
.pid ());
2404 /* Resume all threads of all processes. */
2405 resume_ptid
= RESUME_ALL
;
2413 process_stratum_target
*
2414 user_visible_resume_target (ptid_t resume_ptid
)
2416 return (resume_ptid
== minus_one_ptid
&& sched_multi
2418 : current_inferior ()->process_target ());
2421 /* Find a thread from the inferiors that we'll resume that is waiting
2422 for a vfork-done event. */
2424 static thread_info
*
2425 find_thread_waiting_for_vfork_done ()
2427 gdb_assert (!target_is_non_stop_p ());
2431 for (inferior
*inf
: all_non_exited_inferiors ())
2432 if (inf
->thread_waiting_for_vfork_done
!= nullptr)
2433 return inf
->thread_waiting_for_vfork_done
;
2437 inferior
*cur_inf
= current_inferior ();
2438 if (cur_inf
->thread_waiting_for_vfork_done
!= nullptr)
2439 return cur_inf
->thread_waiting_for_vfork_done
;
2444 /* Return a ptid representing the set of threads that we will resume,
2445 in the perspective of the target, assuming run control handling
2446 does not require leaving some threads stopped (e.g., stepping past
2447 breakpoint). USER_STEP indicates whether we're about to start the
2448 target for a stepping command. */
2451 internal_resume_ptid (int user_step
)
2453 /* In non-stop, we always control threads individually. Note that
2454 the target may always work in non-stop mode even with "set
2455 non-stop off", in which case user_visible_resume_ptid could
2456 return a wildcard ptid. */
2457 if (target_is_non_stop_p ())
2458 return inferior_ptid
;
2460 /* The rest of the function assumes non-stop==off and
2461 target-non-stop==off.
2463 If a thread is waiting for a vfork-done event, it means breakpoints are out
2464 for this inferior (well, program space in fact). We don't want to resume
2465 any thread other than the one waiting for vfork done, otherwise these other
2466 threads could miss breakpoints. So if a thread in the resumption set is
2467 waiting for a vfork-done event, resume only that thread.
2469 The resumption set width depends on whether schedule-multiple is on or off.
2471 Note that if the target_resume interface was more flexible, we could be
2472 smarter here when schedule-multiple is on. For example, imagine 3
2473 inferiors with 2 threads each (1.1, 1.2, 2.1, 2.2, 3.1 and 3.2). Threads
2474 2.1 and 3.2 are both waiting for a vfork-done event. Then we could ask the
2475 target(s) to resume:
2477 - All threads of inferior 1
2481 Since we don't have that flexibility (we can only pass one ptid), just
2482 resume the first thread waiting for a vfork-done event we find (e.g. thread
2484 thread_info
*thr
= find_thread_waiting_for_vfork_done ();
2487 /* If we have a thread that is waiting for a vfork-done event,
2488 then we should have switched to it earlier. Calling
2489 target_resume with thread scope is only possible when the
2490 current thread matches the thread scope. */
2491 gdb_assert (thr
->ptid
== inferior_ptid
);
2492 gdb_assert (thr
->inf
->process_target ()
2493 == inferior_thread ()->inf
->process_target ());
2497 return user_visible_resume_ptid (user_step
);
2500 /* Wrapper for target_resume, that handles infrun-specific
2504 do_target_resume (ptid_t resume_ptid
, bool step
, enum gdb_signal sig
)
2506 struct thread_info
*tp
= inferior_thread ();
2508 gdb_assert (!tp
->stop_requested
);
2510 /* Install inferior's terminal modes. */
2511 target_terminal::inferior ();
2513 /* Avoid confusing the next resume, if the next stop/resume
2514 happens to apply to another thread. */
2515 tp
->set_stop_signal (GDB_SIGNAL_0
);
2517 /* Advise target which signals may be handled silently.
2519 If we have removed breakpoints because we are stepping over one
2520 in-line (in any thread), we need to receive all signals to avoid
2521 accidentally skipping a breakpoint during execution of a signal
2524 Likewise if we're displaced stepping, otherwise a trap for a
2525 breakpoint in a signal handler might be confused with the
2526 displaced step finishing. We don't make the displaced_step_finish
2527 step distinguish the cases instead, because:
2529 - a backtrace while stopped in the signal handler would show the
2530 scratch pad as frame older than the signal handler, instead of
2531 the real mainline code.
2533 - when the thread is later resumed, the signal handler would
2534 return to the scratch pad area, which would no longer be
2536 if (step_over_info_valid_p ()
2537 || displaced_step_in_progress (tp
->inf
))
2538 target_pass_signals ({});
2540 target_pass_signals (signal_pass
);
2542 /* Request that the target report thread-{created,cloned,exited}
2543 events in the following situations:
2545 - If we are performing an in-line step-over-breakpoint, then we
2546 will remove a breakpoint from the target and only run the
2547 current thread. We don't want any new thread (spawned by the
2548 step) to start running, as it might miss the breakpoint. We
2549 need to clear the step-over state if the stepped thread exits,
2550 so we also enable thread-exit events.
2552 - If we are stepping over a breakpoint out of line (displaced
2553 stepping) then we won't remove a breakpoint from the target,
2554 but, if the step spawns a new clone thread, then we will need
2555 to fixup the $pc address in the clone child too, so we need it
2556 to start stopped. We need to release the displaced stepping
2557 buffer if the stepped thread exits, so we also enable
2560 - If scheduler-locking applies, threads that the current thread
2561 spawns should remain halted. It's not strictly necessary to
2562 enable thread-exit events in this case, but it doesn't hurt.
2564 if (step_over_info_valid_p ()
2565 || displaced_step_in_progress_thread (tp
)
2566 || schedlock_applies (tp
))
2568 gdb_thread_options options
2569 = GDB_THREAD_OPTION_CLONE
| GDB_THREAD_OPTION_EXIT
;
2570 if (target_supports_set_thread_options (options
))
2571 tp
->set_thread_options (options
);
2573 target_thread_events (true);
2575 else if (tp
->thread_fsm () != nullptr)
2577 gdb_thread_options options
= GDB_THREAD_OPTION_EXIT
;
2578 if (target_supports_set_thread_options (options
))
2579 tp
->set_thread_options (options
);
2581 target_thread_events (true);
2585 if (target_supports_set_thread_options (0))
2586 tp
->set_thread_options (0);
2589 process_stratum_target
*resume_target
= tp
->inf
->process_target ();
2590 if (!any_thread_needs_target_thread_events (resume_target
,
2592 target_thread_events (false);
2596 /* If we're resuming more than one thread simultaneously, then any
2597 thread other than the leader is being set to run free. Clear any
2598 previous thread option for those threads. */
2599 if (resume_ptid
!= inferior_ptid
&& target_supports_set_thread_options (0))
2601 process_stratum_target
*resume_target
= tp
->inf
->process_target ();
2602 for (thread_info
*thr_iter
: all_non_exited_threads (resume_target
,
2605 thr_iter
->set_thread_options (0);
2608 infrun_debug_printf ("resume_ptid=%s, step=%d, sig=%s",
2609 resume_ptid
.to_string ().c_str (),
2610 step
, gdb_signal_to_symbol_string (sig
));
2612 target_resume (resume_ptid
, step
, sig
);
2615 /* Resume the inferior. SIG is the signal to give the inferior
2616 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2617 call 'resume', which handles exceptions. */
2620 resume_1 (enum gdb_signal sig
)
2622 struct thread_info
*tp
= inferior_thread ();
2623 regcache
*regcache
= get_thread_regcache (tp
);
2624 struct gdbarch
*gdbarch
= regcache
->arch ();
2626 /* This represents the user's step vs continue request. When
2627 deciding whether "set scheduler-locking step" applies, it's the
2628 user's intention that counts. */
2629 const int user_step
= tp
->control
.stepping_command
;
2630 /* This represents what we'll actually request the target to do.
2631 This can decay from a step to a continue, if e.g., we need to
2632 implement single-stepping with breakpoints (software
2636 gdb_assert (!tp
->stop_requested
);
2637 gdb_assert (!thread_is_in_step_over_chain (tp
));
2639 if (tp
->has_pending_waitstatus ())
2642 ("thread %s has pending wait "
2643 "status %s (currently_stepping=%d).",
2644 tp
->ptid
.to_string ().c_str (),
2645 tp
->pending_waitstatus ().to_string ().c_str (),
2646 currently_stepping (tp
));
2648 tp
->inf
->process_target ()->threads_executing
= true;
2649 tp
->set_resumed (true);
2651 /* FIXME: What should we do if we are supposed to resume this
2652 thread with a signal? Maybe we should maintain a queue of
2653 pending signals to deliver. */
2654 if (sig
!= GDB_SIGNAL_0
)
2656 warning (_("Couldn't deliver signal %s to %s."),
2657 gdb_signal_to_name (sig
),
2658 tp
->ptid
.to_string ().c_str ());
2661 tp
->set_stop_signal (GDB_SIGNAL_0
);
2663 if (target_can_async_p ())
2665 target_async (true);
2666 /* Tell the event loop we have an event to process. */
2667 mark_async_event_handler (infrun_async_inferior_event_token
);
2672 tp
->stepped_breakpoint
= 0;
2674 /* Depends on stepped_breakpoint. */
2675 step
= currently_stepping (tp
);
2677 if (current_inferior ()->thread_waiting_for_vfork_done
!= nullptr)
2679 /* Don't try to single-step a vfork parent that is waiting for
2680 the child to get out of the shared memory region (by exec'ing
2681 or exiting). This is particularly important on software
2682 single-step archs, as the child process would trip on the
2683 software single step breakpoint inserted for the parent
2684 process. Since the parent will not actually execute any
2685 instruction until the child is out of the shared region (such
2686 are vfork's semantics), it is safe to simply continue it.
2687 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2688 the parent, and tell it to `keep_going', which automatically
2689 re-sets it stepping. */
2690 infrun_debug_printf ("resume : clear step");
2694 CORE_ADDR pc
= regcache_read_pc (regcache
);
2696 infrun_debug_printf ("step=%d, signal=%s, trap_expected=%d, "
2697 "current thread [%s] at %s",
2698 step
, gdb_signal_to_symbol_string (sig
),
2699 tp
->control
.trap_expected
,
2700 inferior_ptid
.to_string ().c_str (),
2701 paddress (gdbarch
, pc
));
2703 const address_space
*aspace
= tp
->inf
->aspace
.get ();
2705 /* Normally, by the time we reach `resume', the breakpoints are either
2706 removed or inserted, as appropriate. The exception is if we're sitting
2707 at a permanent breakpoint; we need to step over it, but permanent
2708 breakpoints can't be removed. So we have to test for it here. */
2709 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2711 if (sig
!= GDB_SIGNAL_0
)
2713 /* We have a signal to pass to the inferior. The resume
2714 may, or may not take us to the signal handler. If this
2715 is a step, we'll need to stop in the signal handler, if
2716 there's one, (if the target supports stepping into
2717 handlers), or in the next mainline instruction, if
2718 there's no handler. If this is a continue, we need to be
2719 sure to run the handler with all breakpoints inserted.
2720 In all cases, set a breakpoint at the current address
2721 (where the handler returns to), and once that breakpoint
2722 is hit, resume skipping the permanent breakpoint. If
2723 that breakpoint isn't hit, then we've stepped into the
2724 signal handler (or hit some other event). We'll delete
2725 the step-resume breakpoint then. */
2727 infrun_debug_printf ("resume: skipping permanent breakpoint, "
2728 "deliver signal first");
2730 clear_step_over_info ();
2731 tp
->control
.trap_expected
= 0;
2733 if (tp
->control
.step_resume_breakpoint
== nullptr)
2735 /* Set a "high-priority" step-resume, as we don't want
2736 user breakpoints at PC to trigger (again) when this
2738 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2739 gdb_assert (tp
->control
.step_resume_breakpoint
->first_loc ()
2742 tp
->step_after_step_resume_breakpoint
= step
;
2745 insert_breakpoints ();
2749 /* There's no signal to pass, we can go ahead and skip the
2750 permanent breakpoint manually. */
2751 infrun_debug_printf ("skipping permanent breakpoint");
2752 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2753 /* Update pc to reflect the new address from which we will
2754 execute instructions. */
2755 pc
= regcache_read_pc (regcache
);
2759 /* We've already advanced the PC, so the stepping part
2760 is done. Now we need to arrange for a trap to be
2761 reported to handle_inferior_event. Set a breakpoint
2762 at the current PC, and run to it. Don't update
2763 prev_pc, because if we end in
2764 switch_back_to_stepped_thread, we want the "expected
2765 thread advanced also" branch to be taken. IOW, we
2766 don't want this thread to step further from PC
2768 gdb_assert (!step_over_info_valid_p ());
2769 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2770 insert_breakpoints ();
2772 resume_ptid
= internal_resume_ptid (user_step
);
2773 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
2774 tp
->set_resumed (true);
2780 /* If we have a breakpoint to step over, make sure to do a single
2781 step only. Same if we have software watchpoints. */
2782 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2783 tp
->control
.may_range_step
= 0;
2785 /* If displaced stepping is enabled, step over breakpoints by executing a
2786 copy of the instruction at a different address.
2788 We can't use displaced stepping when we have a signal to deliver;
2789 the comments for displaced_step_prepare explain why. The
2790 comments in the handle_inferior event for dealing with 'random
2791 signals' explain what we do instead.
2793 We can't use displaced stepping when we are waiting for vfork_done
2794 event, displaced stepping breaks the vfork child similarly as single
2795 step software breakpoint. */
2796 if (tp
->control
.trap_expected
2797 && use_displaced_stepping (tp
)
2798 && !step_over_info_valid_p ()
2799 && sig
== GDB_SIGNAL_0
2800 && current_inferior ()->thread_waiting_for_vfork_done
== nullptr)
2802 displaced_step_prepare_status prepare_status
2803 = displaced_step_prepare (tp
);
2805 if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
2807 infrun_debug_printf ("Got placed in step-over queue");
2809 tp
->control
.trap_expected
= 0;
2812 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
2814 /* Fallback to stepping over the breakpoint in-line. */
2816 if (target_is_non_stop_p ())
2817 stop_all_threads ("displaced stepping falling back on inline stepping");
2819 set_step_over_info (aspace
, regcache_read_pc (regcache
), 0,
2822 step
= maybe_software_singlestep (gdbarch
);
2824 insert_breakpoints ();
2826 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_OK
)
2828 /* Update pc to reflect the new address from which we will
2829 execute instructions due to displaced stepping. */
2830 pc
= regcache_read_pc (get_thread_regcache (tp
));
2832 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
);
2835 gdb_assert_not_reached ("Invalid displaced_step_prepare_status "
2839 /* Do we need to do it the hard way, w/temp breakpoints? */
2841 step
= maybe_software_singlestep (gdbarch
);
2843 /* Currently, our software single-step implementation leads to different
2844 results than hardware single-stepping in one situation: when stepping
2845 into delivering a signal which has an associated signal handler,
2846 hardware single-step will stop at the first instruction of the handler,
2847 while software single-step will simply skip execution of the handler.
2849 For now, this difference in behavior is accepted since there is no
2850 easy way to actually implement single-stepping into a signal handler
2851 without kernel support.
2853 However, there is one scenario where this difference leads to follow-on
2854 problems: if we're stepping off a breakpoint by removing all breakpoints
2855 and then single-stepping. In this case, the software single-step
2856 behavior means that even if there is a *breakpoint* in the signal
2857 handler, GDB still would not stop.
2859 Fortunately, we can at least fix this particular issue. We detect
2860 here the case where we are about to deliver a signal while software
2861 single-stepping with breakpoints removed. In this situation, we
2862 revert the decisions to remove all breakpoints and insert single-
2863 step breakpoints, and instead we install a step-resume breakpoint
2864 at the current address, deliver the signal without stepping, and
2865 once we arrive back at the step-resume breakpoint, actually step
2866 over the breakpoint we originally wanted to step over. */
2867 if (thread_has_single_step_breakpoints_set (tp
)
2868 && sig
!= GDB_SIGNAL_0
2869 && step_over_info_valid_p ())
2871 /* If we have nested signals or a pending signal is delivered
2872 immediately after a handler returns, might already have
2873 a step-resume breakpoint set on the earlier handler. We cannot
2874 set another step-resume breakpoint; just continue on until the
2875 original breakpoint is hit. */
2876 if (tp
->control
.step_resume_breakpoint
== nullptr)
2878 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2879 tp
->step_after_step_resume_breakpoint
= 1;
2882 delete_single_step_breakpoints (tp
);
2884 clear_step_over_info ();
2885 tp
->control
.trap_expected
= 0;
2887 insert_breakpoints ();
2890 /* If STEP is set, it's a request to use hardware stepping
2891 facilities. But in that case, we should never
2892 use singlestep breakpoint. */
2893 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2895 /* Decide the set of threads to ask the target to resume. */
2896 if (tp
->control
.trap_expected
)
2898 /* We're allowing a thread to run past a breakpoint it has
2899 hit, either by single-stepping the thread with the breakpoint
2900 removed, or by displaced stepping, with the breakpoint inserted.
2901 In the former case, we need to single-step only this thread,
2902 and keep others stopped, as they can miss this breakpoint if
2903 allowed to run. That's not really a problem for displaced
2904 stepping, but, we still keep other threads stopped, in case
2905 another thread is also stopped for a breakpoint waiting for
2906 its turn in the displaced stepping queue. */
2907 resume_ptid
= inferior_ptid
;
2910 resume_ptid
= internal_resume_ptid (user_step
);
2912 if (execution_direction
!= EXEC_REVERSE
2913 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2915 /* There are two cases where we currently need to step a
2916 breakpoint instruction when we have a signal to deliver:
2918 - See handle_signal_stop where we handle random signals that
2919 could take out us out of the stepping range. Normally, in
2920 that case we end up continuing (instead of stepping) over the
2921 signal handler with a breakpoint at PC, but there are cases
2922 where we should _always_ single-step, even if we have a
2923 step-resume breakpoint, like when a software watchpoint is
2924 set. Assuming single-stepping and delivering a signal at the
2925 same time would takes us to the signal handler, then we could
2926 have removed the breakpoint at PC to step over it. However,
2927 some hardware step targets (like e.g., Mac OS) can't step
2928 into signal handlers, and for those, we need to leave the
2929 breakpoint at PC inserted, as otherwise if the handler
2930 recurses and executes PC again, it'll miss the breakpoint.
2931 So we leave the breakpoint inserted anyway, but we need to
2932 record that we tried to step a breakpoint instruction, so
2933 that adjust_pc_after_break doesn't end up confused.
2935 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2936 in one thread after another thread that was stepping had been
2937 momentarily paused for a step-over. When we re-resume the
2938 stepping thread, it may be resumed from that address with a
2939 breakpoint that hasn't trapped yet. Seen with
2940 gdb.threads/non-stop-fair-events.exp, on targets that don't
2941 do displaced stepping. */
2943 infrun_debug_printf ("resume: [%s] stepped breakpoint",
2944 tp
->ptid
.to_string ().c_str ());
2946 tp
->stepped_breakpoint
= 1;
2948 /* Most targets can step a breakpoint instruction, thus
2949 executing it normally. But if this one cannot, just
2950 continue and we will hit it anyway. */
2951 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2955 if (tp
->control
.may_range_step
)
2957 /* If we're resuming a thread with the PC out of the step
2958 range, then we're doing some nested/finer run control
2959 operation, like stepping the thread out of the dynamic
2960 linker or the displaced stepping scratch pad. We
2961 shouldn't have allowed a range step then. */
2962 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2965 do_target_resume (resume_ptid
, step
, sig
);
2966 tp
->set_resumed (true);
2969 /* Resume the inferior. SIG is the signal to give the inferior
2970 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2971 rolls back state on error. */
2974 resume (gdb_signal sig
)
2980 catch (const gdb_exception
&ex
)
2982 /* If resuming is being aborted for any reason, delete any
2983 single-step breakpoint resume_1 may have created, to avoid
2984 confusing the following resumption, and to avoid leaving
2985 single-step breakpoints perturbing other threads, in case
2986 we're running in non-stop mode. */
2987 if (inferior_ptid
!= null_ptid
)
2988 delete_single_step_breakpoints (inferior_thread ());
2998 /* Counter that tracks number of user visible stops. This can be used
2999 to tell whether a command has proceeded the inferior past the
3000 current location. This allows e.g., inferior function calls in
3001 breakpoint commands to not interrupt the command list. When the
3002 call finishes successfully, the inferior is standing at the same
3003 breakpoint as if nothing happened (and so we don't call
3005 static ULONGEST current_stop_id
;
3012 return current_stop_id
;
3015 /* Called when we report a user visible stop. */
3023 /* Clear out all variables saying what to do when inferior is continued.
3024 First do this, then set the ones you want, then call `proceed'. */
3027 clear_proceed_status_thread (struct thread_info
*tp
)
3029 infrun_debug_printf ("%s", tp
->ptid
.to_string ().c_str ());
3031 /* If we're starting a new sequence, then the previous finished
3032 single-step is no longer relevant. */
3033 if (tp
->has_pending_waitstatus ())
3035 if (tp
->stop_reason () == TARGET_STOPPED_BY_SINGLE_STEP
)
3037 infrun_debug_printf ("pending event of %s was a finished step. "
3039 tp
->ptid
.to_string ().c_str ());
3041 tp
->clear_pending_waitstatus ();
3042 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
3047 ("thread %s has pending wait status %s (currently_stepping=%d).",
3048 tp
->ptid
.to_string ().c_str (),
3049 tp
->pending_waitstatus ().to_string ().c_str (),
3050 currently_stepping (tp
));
3054 /* If this signal should not be seen by program, give it zero.
3055 Used for debugging signals. */
3056 if (!signal_pass_state (tp
->stop_signal ()))
3057 tp
->set_stop_signal (GDB_SIGNAL_0
);
3059 tp
->release_thread_fsm ();
3061 tp
->control
.trap_expected
= 0;
3062 tp
->control
.step_range_start
= 0;
3063 tp
->control
.step_range_end
= 0;
3064 tp
->control
.may_range_step
= 0;
3065 tp
->control
.step_frame_id
= null_frame_id
;
3066 tp
->control
.step_stack_frame_id
= null_frame_id
;
3067 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
3068 tp
->control
.step_start_function
= nullptr;
3069 tp
->stop_requested
= 0;
3071 tp
->control
.stop_step
= 0;
3073 tp
->control
.proceed_to_finish
= 0;
3075 tp
->control
.stepping_command
= 0;
3077 /* Discard any remaining commands or status from previous stop. */
3078 bpstat_clear (&tp
->control
.stop_bpstat
);
3081 /* Notify the current interpreter and observers that the target is about to
3085 notify_about_to_proceed ()
3087 top_level_interpreter ()->on_about_to_proceed ();
3088 gdb::observers::about_to_proceed
.notify ();
3092 clear_proceed_status (int step
)
3094 /* With scheduler-locking replay, stop replaying other threads if we're
3095 not replaying the user-visible resume ptid.
3097 This is a convenience feature to not require the user to explicitly
3098 stop replaying the other threads. We're assuming that the user's
3099 intent is to resume tracing the recorded process. */
3100 if (!non_stop
&& scheduler_mode
== schedlock_replay
3101 && target_record_is_replaying (minus_one_ptid
)
3102 && !target_record_will_replay (user_visible_resume_ptid (step
),
3103 execution_direction
))
3104 target_record_stop_replaying ();
3106 if (!non_stop
&& inferior_ptid
!= null_ptid
)
3108 ptid_t resume_ptid
= user_visible_resume_ptid (step
);
3109 process_stratum_target
*resume_target
3110 = user_visible_resume_target (resume_ptid
);
3112 /* In all-stop mode, delete the per-thread status of all threads
3113 we're about to resume, implicitly and explicitly. */
3114 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
3115 clear_proceed_status_thread (tp
);
3118 if (inferior_ptid
!= null_ptid
)
3120 struct inferior
*inferior
;
3124 /* If in non-stop mode, only delete the per-thread status of
3125 the current thread. */
3126 clear_proceed_status_thread (inferior_thread ());
3129 inferior
= current_inferior ();
3130 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
3133 notify_about_to_proceed ();
3136 /* Returns true if TP is still stopped at a breakpoint that needs
3137 stepping-over in order to make progress. If the breakpoint is gone
3138 meanwhile, we can skip the whole step-over dance. */
3141 thread_still_needs_step_over_bp (struct thread_info
*tp
)
3143 if (tp
->stepping_over_breakpoint
)
3145 struct regcache
*regcache
= get_thread_regcache (tp
);
3147 if (breakpoint_here_p (tp
->inf
->aspace
.get (),
3148 regcache_read_pc (regcache
))
3149 == ordinary_breakpoint_here
)
3152 tp
->stepping_over_breakpoint
= 0;
3158 /* Check whether thread TP still needs to start a step-over in order
3159 to make progress when resumed. Returns an bitwise or of enum
3160 step_over_what bits, indicating what needs to be stepped over. */
3162 static step_over_what
3163 thread_still_needs_step_over (struct thread_info
*tp
)
3165 step_over_what what
= 0;
3167 if (thread_still_needs_step_over_bp (tp
))
3168 what
|= STEP_OVER_BREAKPOINT
;
3170 if (tp
->stepping_over_watchpoint
3171 && !target_have_steppable_watchpoint ())
3172 what
|= STEP_OVER_WATCHPOINT
;
3177 /* Returns true if scheduler locking applies. STEP indicates whether
3178 we're about to do a step/next-like command to a thread. */
3181 schedlock_applies (struct thread_info
*tp
)
3183 return (scheduler_mode
== schedlock_on
3184 || (scheduler_mode
== schedlock_step
3185 && tp
->control
.stepping_command
)
3186 || (scheduler_mode
== schedlock_replay
3187 && target_record_will_replay (minus_one_ptid
,
3188 execution_direction
)));
3191 /* Set process_stratum_target::COMMIT_RESUMED_STATE in all target
3192 stacks that have threads executing and don't have threads with
3196 maybe_set_commit_resumed_all_targets ()
3198 scoped_restore_current_thread restore_thread
;
3200 for (inferior
*inf
: all_non_exited_inferiors ())
3202 process_stratum_target
*proc_target
= inf
->process_target ();
3204 if (proc_target
->commit_resumed_state
)
3206 /* We already set this in a previous iteration, via another
3207 inferior sharing the process_stratum target. */
3211 /* If the target has no resumed threads, it would be useless to
3212 ask it to commit the resumed threads. */
3213 if (!proc_target
->threads_executing
)
3215 infrun_debug_printf ("not requesting commit-resumed for target "
3216 "%s, no resumed threads",
3217 proc_target
->shortname ());
3221 /* As an optimization, if a thread from this target has some
3222 status to report, handle it before requiring the target to
3223 commit its resumed threads: handling the status might lead to
3224 resuming more threads. */
3225 if (proc_target
->has_resumed_with_pending_wait_status ())
3227 infrun_debug_printf ("not requesting commit-resumed for target %s, a"
3228 " thread has a pending waitstatus",
3229 proc_target
->shortname ());
3233 switch_to_inferior_no_thread (inf
);
3235 if (target_has_pending_events ())
3237 infrun_debug_printf ("not requesting commit-resumed for target %s, "
3238 "target has pending events",
3239 proc_target
->shortname ());
3243 infrun_debug_printf ("enabling commit-resumed for target %s",
3244 proc_target
->shortname ());
3246 proc_target
->commit_resumed_state
= true;
3253 maybe_call_commit_resumed_all_targets ()
3255 scoped_restore_current_thread restore_thread
;
3257 for (inferior
*inf
: all_non_exited_inferiors ())
3259 process_stratum_target
*proc_target
= inf
->process_target ();
3261 if (!proc_target
->commit_resumed_state
)
3264 switch_to_inferior_no_thread (inf
);
3266 infrun_debug_printf ("calling commit_resumed for target %s",
3267 proc_target
->shortname());
3269 target_commit_resumed ();
3273 /* To track nesting of scoped_disable_commit_resumed objects, ensuring
3274 that only the outermost one attempts to re-enable
3276 static bool enable_commit_resumed
= true;
3280 scoped_disable_commit_resumed::scoped_disable_commit_resumed
3281 (const char *reason
)
3282 : m_reason (reason
),
3283 m_prev_enable_commit_resumed (enable_commit_resumed
)
3285 infrun_debug_printf ("reason=%s", m_reason
);
3287 enable_commit_resumed
= false;
3289 for (inferior
*inf
: all_non_exited_inferiors ())
3291 process_stratum_target
*proc_target
= inf
->process_target ();
3293 if (m_prev_enable_commit_resumed
)
3295 /* This is the outermost instance: force all
3296 COMMIT_RESUMED_STATE to false. */
3297 proc_target
->commit_resumed_state
= false;
3301 /* This is not the outermost instance, we expect
3302 COMMIT_RESUMED_STATE to have been cleared by the
3303 outermost instance. */
3304 gdb_assert (!proc_target
->commit_resumed_state
);
3312 scoped_disable_commit_resumed::reset ()
3318 infrun_debug_printf ("reason=%s", m_reason
);
3320 gdb_assert (!enable_commit_resumed
);
3322 enable_commit_resumed
= m_prev_enable_commit_resumed
;
3324 if (m_prev_enable_commit_resumed
)
3326 /* This is the outermost instance, re-enable
3327 COMMIT_RESUMED_STATE on the targets where it's possible. */
3328 maybe_set_commit_resumed_all_targets ();
3332 /* This is not the outermost instance, we expect
3333 COMMIT_RESUMED_STATE to still be false. */
3334 for (inferior
*inf
: all_non_exited_inferiors ())
3336 process_stratum_target
*proc_target
= inf
->process_target ();
3337 gdb_assert (!proc_target
->commit_resumed_state
);
3344 scoped_disable_commit_resumed::~scoped_disable_commit_resumed ()
3352 scoped_disable_commit_resumed::reset_and_commit ()
3355 maybe_call_commit_resumed_all_targets ();
3360 scoped_enable_commit_resumed::scoped_enable_commit_resumed
3361 (const char *reason
)
3362 : m_reason (reason
),
3363 m_prev_enable_commit_resumed (enable_commit_resumed
)
3365 infrun_debug_printf ("reason=%s", m_reason
);
3367 if (!enable_commit_resumed
)
3369 enable_commit_resumed
= true;
3371 /* Re-enable COMMIT_RESUMED_STATE on the targets where it's
3373 maybe_set_commit_resumed_all_targets ();
3375 maybe_call_commit_resumed_all_targets ();
3381 scoped_enable_commit_resumed::~scoped_enable_commit_resumed ()
3383 infrun_debug_printf ("reason=%s", m_reason
);
3385 gdb_assert (enable_commit_resumed
);
3387 enable_commit_resumed
= m_prev_enable_commit_resumed
;
3389 if (!enable_commit_resumed
)
3391 /* Force all COMMIT_RESUMED_STATE back to false. */
3392 for (inferior
*inf
: all_non_exited_inferiors ())
3394 process_stratum_target
*proc_target
= inf
->process_target ();
3395 proc_target
->commit_resumed_state
= false;
3400 /* Check that all the targets we're about to resume are in non-stop
3401 mode. Ideally, we'd only care whether all targets support
3402 target-async, but we're not there yet. E.g., stop_all_threads
3403 doesn't know how to handle all-stop targets. Also, the remote
3404 protocol in all-stop mode is synchronous, irrespective of
3405 target-async, which means that things like a breakpoint re-set
3406 triggered by one target would try to read memory from all targets
3410 check_multi_target_resumption (process_stratum_target
*resume_target
)
3412 if (!non_stop
&& resume_target
== nullptr)
3414 scoped_restore_current_thread restore_thread
;
3416 /* This is used to track whether we're resuming more than one
3418 process_stratum_target
*first_connection
= nullptr;
3420 /* The first inferior we see with a target that does not work in
3421 always-non-stop mode. */
3422 inferior
*first_not_non_stop
= nullptr;
3424 for (inferior
*inf
: all_non_exited_inferiors ())
3426 switch_to_inferior_no_thread (inf
);
3428 if (!target_has_execution ())
3431 process_stratum_target
*proc_target
3432 = current_inferior ()->process_target();
3434 if (!target_is_non_stop_p ())
3435 first_not_non_stop
= inf
;
3437 if (first_connection
== nullptr)
3438 first_connection
= proc_target
;
3439 else if (first_connection
!= proc_target
3440 && first_not_non_stop
!= nullptr)
3442 switch_to_inferior_no_thread (first_not_non_stop
);
3444 proc_target
= current_inferior ()->process_target();
3446 error (_("Connection %d (%s) does not support "
3447 "multi-target resumption."),
3448 proc_target
->connection_number
,
3449 make_target_connection_string (proc_target
).c_str ());
3455 /* Helper function for `proceed`. Check if thread TP is suitable for
3456 resuming, and, if it is, switch to the thread and call
3457 `keep_going_pass_signal`. If TP is not suitable for resuming then this
3458 function will just return without switching threads. */
3461 proceed_resume_thread_checked (thread_info
*tp
)
3463 if (!tp
->inf
->has_execution ())
3465 infrun_debug_printf ("[%s] target has no execution",
3466 tp
->ptid
.to_string ().c_str ());
3472 infrun_debug_printf ("[%s] resumed",
3473 tp
->ptid
.to_string ().c_str ());
3474 gdb_assert (tp
->executing () || tp
->has_pending_waitstatus ());
3478 if (thread_is_in_step_over_chain (tp
))
3480 infrun_debug_printf ("[%s] needs step-over",
3481 tp
->ptid
.to_string ().c_str ());
3485 /* When handling a vfork GDB removes all breakpoints from the program
3486 space in which the vfork is being handled. If we are following the
3487 parent then GDB will set the thread_waiting_for_vfork_done member of
3488 the parent inferior. In this case we should take care to only resume
3489 the vfork parent thread, the kernel will hold this thread suspended
3490 until the vfork child has exited or execd, at which point the parent
3491 will be resumed and a VFORK_DONE event sent to GDB. */
3492 if (tp
->inf
->thread_waiting_for_vfork_done
!= nullptr)
3494 if (target_is_non_stop_p ())
3496 /* For non-stop targets, regardless of whether GDB is using
3497 all-stop or non-stop mode, threads are controlled
3500 When a thread is handling a vfork, breakpoints are removed
3501 from the inferior (well, program space in fact), so it is
3502 critical that we don't try to resume any thread other than the
3504 if (tp
!= tp
->inf
->thread_waiting_for_vfork_done
)
3506 infrun_debug_printf ("[%s] thread %s of this inferior is "
3507 "waiting for vfork-done",
3508 tp
->ptid
.to_string ().c_str (),
3509 tp
->inf
->thread_waiting_for_vfork_done
3510 ->ptid
.to_string ().c_str ());
3516 /* For all-stop targets, when we attempt to resume the inferior,
3517 we will only resume the vfork parent thread, this is handled
3518 in internal_resume_ptid.
3520 Additionally, we will always be called with the vfork parent
3521 thread as the current thread (TP) thanks to follow_fork, as
3522 such the following assertion should hold.
3524 Beyond this there is nothing more that needs to be done
3526 gdb_assert (tp
== tp
->inf
->thread_waiting_for_vfork_done
);
3530 /* When handling a vfork GDB removes all breakpoints from the program
3531 space in which the vfork is being handled. If we are following the
3532 child then GDB will set vfork_child member of the vfork parent
3533 inferior. Once the child has either exited or execd then GDB will
3534 detach from the parent process. Until that point GDB should not
3535 resume any thread in the parent process. */
3536 if (tp
->inf
->vfork_child
!= nullptr)
3538 infrun_debug_printf ("[%s] thread is part of a vfork parent, child is %d",
3539 tp
->ptid
.to_string ().c_str (),
3540 tp
->inf
->vfork_child
->pid
);
3544 infrun_debug_printf ("resuming %s",
3545 tp
->ptid
.to_string ().c_str ());
3547 execution_control_state
ecs (tp
);
3548 switch_to_thread (tp
);
3549 keep_going_pass_signal (&ecs
);
3550 if (!ecs
.wait_some_more
)
3551 error (_("Command aborted."));
3554 /* Basic routine for continuing the program in various fashions.
3556 ADDR is the address to resume at, or -1 for resume where stopped.
3557 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
3558 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
3560 You should call clear_proceed_status before calling proceed. */
3563 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
3565 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
3567 struct gdbarch
*gdbarch
;
3570 /* If we're stopped at a fork/vfork, switch to either the parent or child
3571 thread as defined by the "set follow-fork-mode" command, or, if both
3572 the parent and child are controlled by GDB, and schedule-multiple is
3573 on, follow the child. If none of the above apply then we just proceed
3574 resuming the current thread. */
3575 if (!follow_fork ())
3577 /* The target for some reason decided not to resume. */
3579 if (target_can_async_p ())
3580 inferior_event_handler (INF_EXEC_COMPLETE
);
3584 /* We'll update this if & when we switch to a new thread. */
3585 update_previous_thread ();
3587 thread_info
*cur_thr
= inferior_thread ();
3588 infrun_debug_printf ("cur_thr = %s", cur_thr
->ptid
.to_string ().c_str ());
3590 regcache
*regcache
= get_thread_regcache (cur_thr
);
3591 gdbarch
= regcache
->arch ();
3592 pc
= regcache_read_pc_protected (regcache
);
3594 /* Fill in with reasonable starting values. */
3595 init_thread_stepping_state (cur_thr
);
3597 gdb_assert (!thread_is_in_step_over_chain (cur_thr
));
3600 = user_visible_resume_ptid (cur_thr
->control
.stepping_command
);
3601 process_stratum_target
*resume_target
3602 = user_visible_resume_target (resume_ptid
);
3604 check_multi_target_resumption (resume_target
);
3606 if (addr
== (CORE_ADDR
) -1)
3608 const address_space
*aspace
= cur_thr
->inf
->aspace
.get ();
3610 if (cur_thr
->stop_pc_p ()
3611 && pc
== cur_thr
->stop_pc ()
3612 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
3613 && execution_direction
!= EXEC_REVERSE
)
3614 /* There is a breakpoint at the address we will resume at,
3615 step one instruction before inserting breakpoints so that
3616 we do not stop right away (and report a second hit at this
3619 Note, we don't do this in reverse, because we won't
3620 actually be executing the breakpoint insn anyway.
3621 We'll be (un-)executing the previous instruction. */
3622 cur_thr
->stepping_over_breakpoint
= 1;
3623 else if (gdbarch_single_step_through_delay_p (gdbarch
)
3624 && gdbarch_single_step_through_delay (gdbarch
,
3625 get_current_frame ()))
3626 /* We stepped onto an instruction that needs to be stepped
3627 again before re-inserting the breakpoint, do so. */
3628 cur_thr
->stepping_over_breakpoint
= 1;
3632 regcache_write_pc (regcache
, addr
);
3635 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
3636 cur_thr
->set_stop_signal (siggnal
);
3638 /* If an exception is thrown from this point on, make sure to
3639 propagate GDB's knowledge of the executing state to the
3640 frontend/user running state. */
3641 scoped_finish_thread_state
finish_state (resume_target
, resume_ptid
);
3643 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3644 threads (e.g., we might need to set threads stepping over
3645 breakpoints first), from the user/frontend's point of view, all
3646 threads in RESUME_PTID are now running. Unless we're calling an
3647 inferior function, as in that case we pretend the inferior
3648 doesn't run at all. */
3649 if (!cur_thr
->control
.in_infcall
)
3650 set_running (resume_target
, resume_ptid
, true);
3652 infrun_debug_printf ("addr=%s, signal=%s, resume_ptid=%s",
3653 paddress (gdbarch
, addr
),
3654 gdb_signal_to_symbol_string (siggnal
),
3655 resume_ptid
.to_string ().c_str ());
3657 annotate_starting ();
3659 /* Make sure that output from GDB appears before output from the
3661 gdb_flush (gdb_stdout
);
3663 /* Since we've marked the inferior running, give it the terminal. A
3664 QUIT/Ctrl-C from here on is forwarded to the target (which can
3665 still detect attempts to unblock a stuck connection with repeated
3666 Ctrl-C from within target_pass_ctrlc). */
3667 target_terminal::inferior ();
3669 /* In a multi-threaded task we may select another thread and
3670 then continue or step.
3672 But if a thread that we're resuming had stopped at a breakpoint,
3673 it will immediately cause another breakpoint stop without any
3674 execution (i.e. it will report a breakpoint hit incorrectly). So
3675 we must step over it first.
3677 Look for threads other than the current (TP) that reported a
3678 breakpoint hit and haven't been resumed yet since. */
3680 /* If scheduler locking applies, we can avoid iterating over all
3682 if (!non_stop
&& !schedlock_applies (cur_thr
))
3684 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3687 switch_to_thread_no_regs (tp
);
3689 /* Ignore the current thread here. It's handled
3694 if (!thread_still_needs_step_over (tp
))
3697 gdb_assert (!thread_is_in_step_over_chain (tp
));
3699 infrun_debug_printf ("need to step-over [%s] first",
3700 tp
->ptid
.to_string ().c_str ());
3702 global_thread_step_over_chain_enqueue (tp
);
3705 switch_to_thread (cur_thr
);
3708 /* Enqueue the current thread last, so that we move all other
3709 threads over their breakpoints first. */
3710 if (cur_thr
->stepping_over_breakpoint
)
3711 global_thread_step_over_chain_enqueue (cur_thr
);
3713 /* If the thread isn't started, we'll still need to set its prev_pc,
3714 so that switch_back_to_stepped_thread knows the thread hasn't
3715 advanced. Must do this before resuming any thread, as in
3716 all-stop/remote, once we resume we can't send any other packet
3717 until the target stops again. */
3718 cur_thr
->prev_pc
= regcache_read_pc_protected (regcache
);
3721 scoped_disable_commit_resumed
disable_commit_resumed ("proceeding");
3722 bool step_over_started
= start_step_over ();
3724 if (step_over_info_valid_p ())
3726 /* Either this thread started a new in-line step over, or some
3727 other thread was already doing one. In either case, don't
3728 resume anything else until the step-over is finished. */
3730 else if (step_over_started
&& !target_is_non_stop_p ())
3732 /* A new displaced stepping sequence was started. In all-stop,
3733 we can't talk to the target anymore until it next stops. */
3735 else if (!non_stop
&& target_is_non_stop_p ())
3737 INFRUN_SCOPED_DEBUG_START_END
3738 ("resuming threads, all-stop-on-top-of-non-stop");
3740 /* In all-stop, but the target is always in non-stop mode.
3741 Start all other threads that are implicitly resumed too. */
3742 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3745 switch_to_thread_no_regs (tp
);
3746 proceed_resume_thread_checked (tp
);
3750 proceed_resume_thread_checked (cur_thr
);
3752 disable_commit_resumed
.reset_and_commit ();
3755 finish_state
.release ();
3757 /* If we've switched threads above, switch back to the previously
3758 current thread. We don't want the user to see a different
3760 switch_to_thread (cur_thr
);
3762 /* Tell the event loop to wait for it to stop. If the target
3763 supports asynchronous execution, it'll do this from within
3765 if (!target_can_async_p ())
3766 mark_async_event_handler (infrun_async_inferior_event_token
);
3770 /* Start remote-debugging of a machine over a serial link. */
3773 start_remote (int from_tty
)
3775 inferior
*inf
= current_inferior ();
3776 inf
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3778 /* Always go on waiting for the target, regardless of the mode. */
3779 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3780 indicate to wait_for_inferior that a target should timeout if
3781 nothing is returned (instead of just blocking). Because of this,
3782 targets expecting an immediate response need to, internally, set
3783 things up so that the target_wait() is forced to eventually
3785 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3786 differentiate to its caller what the state of the target is after
3787 the initial open has been performed. Here we're assuming that
3788 the target has stopped. It should be possible to eventually have
3789 target_open() return to the caller an indication that the target
3790 is currently running and GDB state should be set to the same as
3791 for an async run. */
3792 wait_for_inferior (inf
);
3794 /* Now that the inferior has stopped, do any bookkeeping like
3795 loading shared libraries. We want to do this before normal_stop,
3796 so that the displayed frame is up to date. */
3797 post_create_inferior (from_tty
);
3802 /* Initialize static vars when a new inferior begins. */
3805 init_wait_for_inferior (void)
3807 /* These are meaningless until the first time through wait_for_inferior. */
3809 breakpoint_init_inferior (inf_starting
);
3811 clear_proceed_status (0);
3813 nullify_last_target_wait_ptid ();
3815 update_previous_thread ();
3820 static void handle_inferior_event (struct execution_control_state
*ecs
);
3822 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3823 struct execution_control_state
*ecs
);
3824 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3825 struct execution_control_state
*ecs
);
3826 static void handle_signal_stop (struct execution_control_state
*ecs
);
3827 static void check_exception_resume (struct execution_control_state
*,
3830 static void end_stepping_range (struct execution_control_state
*ecs
);
3831 static void stop_waiting (struct execution_control_state
*ecs
);
3832 static void keep_going (struct execution_control_state
*ecs
);
3833 static void process_event_stop_test (struct execution_control_state
*ecs
);
3834 static bool switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3836 /* This function is attached as a "thread_stop_requested" observer.
3837 Cleanup local state that assumed the PTID was to be resumed, and
3838 report the stop to the frontend. */
3841 infrun_thread_stop_requested (ptid_t ptid
)
3843 process_stratum_target
*curr_target
= current_inferior ()->process_target ();
3845 /* PTID was requested to stop. If the thread was already stopped,
3846 but the user/frontend doesn't know about that yet (e.g., the
3847 thread had been temporarily paused for some step-over), set up
3848 for reporting the stop now. */
3849 for (thread_info
*tp
: all_threads (curr_target
, ptid
))
3851 if (tp
->state
!= THREAD_RUNNING
)
3853 if (tp
->executing ())
3856 /* Remove matching threads from the step-over queue, so
3857 start_step_over doesn't try to resume them
3859 if (thread_is_in_step_over_chain (tp
))
3860 global_thread_step_over_chain_remove (tp
);
3862 /* If the thread is stopped, but the user/frontend doesn't
3863 know about that yet, queue a pending event, as if the
3864 thread had just stopped now. Unless the thread already had
3866 if (!tp
->has_pending_waitstatus ())
3868 target_waitstatus ws
;
3869 ws
.set_stopped (GDB_SIGNAL_0
);
3870 tp
->set_pending_waitstatus (ws
);
3873 /* Clear the inline-frame state, since we're re-processing the
3875 clear_inline_frame_state (tp
);
3877 /* If this thread was paused because some other thread was
3878 doing an inline-step over, let that finish first. Once
3879 that happens, we'll restart all threads and consume pending
3880 stop events then. */
3881 if (step_over_info_valid_p ())
3884 /* Otherwise we can process the (new) pending event now. Set
3885 it so this pending event is considered by
3887 tp
->set_resumed (true);
3891 /* Delete the step resume, single-step and longjmp/exception resume
3892 breakpoints of TP. */
3895 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3897 delete_step_resume_breakpoint (tp
);
3898 delete_exception_resume_breakpoint (tp
);
3899 delete_single_step_breakpoints (tp
);
3902 /* If the target still has execution, call FUNC for each thread that
3903 just stopped. In all-stop, that's all the non-exited threads; in
3904 non-stop, that's the current thread, only. */
3906 typedef void (*for_each_just_stopped_thread_callback_func
)
3907 (struct thread_info
*tp
);
3910 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3912 if (!target_has_execution () || inferior_ptid
== null_ptid
)
3915 if (target_is_non_stop_p ())
3917 /* If in non-stop mode, only the current thread stopped. */
3918 func (inferior_thread ());
3922 /* In all-stop mode, all threads have stopped. */
3923 for (thread_info
*tp
: all_non_exited_threads ())
3928 /* Delete the step resume and longjmp/exception resume breakpoints of
3929 the threads that just stopped. */
3932 delete_just_stopped_threads_infrun_breakpoints (void)
3934 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3937 /* Delete the single-step breakpoints of the threads that just
3941 delete_just_stopped_threads_single_step_breakpoints (void)
3943 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3949 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3950 const struct target_waitstatus
&ws
)
3952 infrun_debug_printf ("target_wait (%s [%s], status) =",
3953 waiton_ptid
.to_string ().c_str (),
3954 target_pid_to_str (waiton_ptid
).c_str ());
3955 infrun_debug_printf (" %s [%s],",
3956 result_ptid
.to_string ().c_str (),
3957 target_pid_to_str (result_ptid
).c_str ());
3958 infrun_debug_printf (" %s", ws
.to_string ().c_str ());
3961 /* Select a thread at random, out of those which are resumed and have
3964 static struct thread_info
*
3965 random_pending_event_thread (inferior
*inf
, ptid_t waiton_ptid
)
3967 process_stratum_target
*proc_target
= inf
->process_target ();
3969 = proc_target
->random_resumed_with_pending_wait_status (inf
, waiton_ptid
);
3971 if (thread
== nullptr)
3973 infrun_debug_printf ("None found.");
3977 infrun_debug_printf ("Found %s.", thread
->ptid
.to_string ().c_str ());
3978 gdb_assert (thread
->resumed ());
3979 gdb_assert (thread
->has_pending_waitstatus ());
3984 /* Wrapper for target_wait that first checks whether threads have
3985 pending statuses to report before actually asking the target for
3986 more events. INF is the inferior we're using to call target_wait
3990 do_target_wait_1 (inferior
*inf
, ptid_t ptid
,
3991 target_waitstatus
*status
, target_wait_flags options
)
3993 struct thread_info
*tp
;
3995 /* We know that we are looking for an event in the target of inferior
3996 INF, but we don't know which thread the event might come from. As
3997 such we want to make sure that INFERIOR_PTID is reset so that none of
3998 the wait code relies on it - doing so is always a mistake. */
3999 switch_to_inferior_no_thread (inf
);
4001 /* First check if there is a resumed thread with a wait status
4003 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
4005 tp
= random_pending_event_thread (inf
, ptid
);
4009 infrun_debug_printf ("Waiting for specific thread %s.",
4010 ptid
.to_string ().c_str ());
4012 /* We have a specific thread to check. */
4013 tp
= inf
->find_thread (ptid
);
4014 gdb_assert (tp
!= nullptr);
4015 if (!tp
->has_pending_waitstatus ())
4020 && (tp
->stop_reason () == TARGET_STOPPED_BY_SW_BREAKPOINT
4021 || tp
->stop_reason () == TARGET_STOPPED_BY_HW_BREAKPOINT
))
4023 struct regcache
*regcache
= get_thread_regcache (tp
);
4024 struct gdbarch
*gdbarch
= regcache
->arch ();
4028 pc
= regcache_read_pc (regcache
);
4030 if (pc
!= tp
->stop_pc ())
4032 infrun_debug_printf ("PC of %s changed. was=%s, now=%s",
4033 tp
->ptid
.to_string ().c_str (),
4034 paddress (gdbarch
, tp
->stop_pc ()),
4035 paddress (gdbarch
, pc
));
4038 else if (!breakpoint_inserted_here_p (tp
->inf
->aspace
.get (), pc
))
4040 infrun_debug_printf ("previous breakpoint of %s, at %s gone",
4041 tp
->ptid
.to_string ().c_str (),
4042 paddress (gdbarch
, pc
));
4049 infrun_debug_printf ("pending event of %s cancelled.",
4050 tp
->ptid
.to_string ().c_str ());
4052 tp
->clear_pending_waitstatus ();
4053 target_waitstatus ws
;
4055 tp
->set_pending_waitstatus (ws
);
4056 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
4062 infrun_debug_printf ("Using pending wait status %s for %s.",
4063 tp
->pending_waitstatus ().to_string ().c_str (),
4064 tp
->ptid
.to_string ().c_str ());
4066 /* Now that we've selected our final event LWP, un-adjust its PC
4067 if it was a software breakpoint (and the target doesn't
4068 always adjust the PC itself). */
4069 if (tp
->stop_reason () == TARGET_STOPPED_BY_SW_BREAKPOINT
4070 && !target_supports_stopped_by_sw_breakpoint ())
4072 struct regcache
*regcache
;
4073 struct gdbarch
*gdbarch
;
4076 regcache
= get_thread_regcache (tp
);
4077 gdbarch
= regcache
->arch ();
4079 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4084 pc
= regcache_read_pc (regcache
);
4085 regcache_write_pc (regcache
, pc
+ decr_pc
);
4089 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
4090 *status
= tp
->pending_waitstatus ();
4091 tp
->clear_pending_waitstatus ();
4093 /* Wake up the event loop again, until all pending events are
4095 if (target_is_async_p ())
4096 mark_async_event_handler (infrun_async_inferior_event_token
);
4100 /* But if we don't find one, we'll have to wait. */
4102 /* We can't ask a non-async target to do a non-blocking wait, so this will be
4104 if (!target_can_async_p ())
4105 options
&= ~TARGET_WNOHANG
;
4107 return target_wait (ptid
, status
, options
);
4110 /* Wrapper for target_wait that first checks whether threads have
4111 pending statuses to report before actually asking the target for
4112 more events. Polls for events from all inferiors/targets. */
4115 do_target_wait (execution_control_state
*ecs
, target_wait_flags options
)
4117 int num_inferiors
= 0;
4118 int random_selector
;
4120 /* For fairness, we pick the first inferior/target to poll at random
4121 out of all inferiors that may report events, and then continue
4122 polling the rest of the inferior list starting from that one in a
4123 circular fashion until the whole list is polled once. */
4125 auto inferior_matches
= [] (inferior
*inf
)
4127 return inf
->process_target () != nullptr;
4130 /* First see how many matching inferiors we have. */
4131 for (inferior
*inf
: all_inferiors ())
4132 if (inferior_matches (inf
))
4135 if (num_inferiors
== 0)
4137 ecs
->ws
.set_ignore ();
4141 /* Now randomly pick an inferior out of those that matched. */
4142 random_selector
= (int)
4143 ((num_inferiors
* (double) rand ()) / (RAND_MAX
+ 1.0));
4145 if (num_inferiors
> 1)
4146 infrun_debug_printf ("Found %d inferiors, starting at #%d",
4147 num_inferiors
, random_selector
);
4149 /* Select the Nth inferior that matched. */
4151 inferior
*selected
= nullptr;
4153 for (inferior
*inf
: all_inferiors ())
4154 if (inferior_matches (inf
))
4155 if (random_selector
-- == 0)
4161 /* Now poll for events out of each of the matching inferior's
4162 targets, starting from the selected one. */
4164 auto do_wait
= [&] (inferior
*inf
)
4166 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, options
);
4167 ecs
->target
= inf
->process_target ();
4168 return (ecs
->ws
.kind () != TARGET_WAITKIND_IGNORE
);
4171 /* Needed in 'all-stop + target-non-stop' mode, because we end up
4172 here spuriously after the target is all stopped and we've already
4173 reported the stop to the user, polling for events. */
4174 scoped_restore_current_thread restore_thread
;
4176 intrusive_list_iterator
<inferior
> start
4177 = inferior_list
.iterator_to (*selected
);
4179 for (intrusive_list_iterator
<inferior
> it
= start
;
4180 it
!= inferior_list
.end ();
4183 inferior
*inf
= &*it
;
4185 if (inferior_matches (inf
) && do_wait (inf
))
4189 for (intrusive_list_iterator
<inferior
> it
= inferior_list
.begin ();
4193 inferior
*inf
= &*it
;
4195 if (inferior_matches (inf
) && do_wait (inf
))
4199 ecs
->ws
.set_ignore ();
4203 /* An event reported by wait_one. */
4205 struct wait_one_event
4207 /* The target the event came out of. */
4208 process_stratum_target
*target
;
4210 /* The PTID the event was for. */
4213 /* The waitstatus. */
4214 target_waitstatus ws
;
4217 static bool handle_one (const wait_one_event
&event
);
4218 static int finish_step_over (struct execution_control_state
*ecs
);
4220 /* Prepare and stabilize the inferior for detaching it. E.g.,
4221 detaching while a thread is displaced stepping is a recipe for
4222 crashing it, as nothing would readjust the PC out of the scratch
4226 prepare_for_detach (void)
4228 struct inferior
*inf
= current_inferior ();
4229 ptid_t pid_ptid
= ptid_t (inf
->pid
);
4230 scoped_restore_current_thread restore_thread
;
4232 scoped_restore restore_detaching
= make_scoped_restore (&inf
->detaching
, true);
4234 /* Remove all threads of INF from the global step-over chain. We
4235 want to stop any ongoing step-over, not start any new one. */
4236 thread_step_over_list_safe_range range
4237 = make_thread_step_over_list_safe_range (global_thread_step_over_list
);
4239 for (thread_info
*tp
: range
)
4242 infrun_debug_printf ("removing thread %s from global step over chain",
4243 tp
->ptid
.to_string ().c_str ());
4244 global_thread_step_over_chain_remove (tp
);
4247 /* If we were already in the middle of an inline step-over, and the
4248 thread stepping belongs to the inferior we're detaching, we need
4249 to restart the threads of other inferiors. */
4250 if (step_over_info
.thread
!= -1)
4252 infrun_debug_printf ("inline step-over in-process while detaching");
4254 thread_info
*thr
= find_thread_global_id (step_over_info
.thread
);
4255 if (thr
->inf
== inf
)
4257 /* Since we removed threads of INF from the step-over chain,
4258 we know this won't start a step-over for INF. */
4259 clear_step_over_info ();
4261 if (target_is_non_stop_p ())
4263 /* Start a new step-over in another thread if there's
4264 one that needs it. */
4267 /* Restart all other threads (except the
4268 previously-stepping thread, since that one is still
4270 if (!step_over_info_valid_p ())
4271 restart_threads (thr
);
4276 if (displaced_step_in_progress (inf
))
4278 infrun_debug_printf ("displaced-stepping in-process while detaching");
4280 /* Stop threads currently displaced stepping, aborting it. */
4282 for (thread_info
*thr
: inf
->non_exited_threads ())
4284 if (thr
->displaced_step_state
.in_progress ())
4286 if (thr
->executing ())
4288 if (!thr
->stop_requested
)
4290 target_stop (thr
->ptid
);
4291 thr
->stop_requested
= true;
4295 thr
->set_resumed (false);
4299 while (displaced_step_in_progress (inf
))
4301 wait_one_event event
;
4303 event
.target
= inf
->process_target ();
4304 event
.ptid
= do_target_wait_1 (inf
, pid_ptid
, &event
.ws
, 0);
4307 print_target_wait_results (pid_ptid
, event
.ptid
, event
.ws
);
4312 /* It's OK to leave some of the threads of INF stopped, since
4313 they'll be detached shortly. */
4317 /* If all-stop, but there exists a non-stop target, stop all threads
4318 now that we're presenting the stop to the user. */
4321 stop_all_threads_if_all_stop_mode ()
4323 if (!non_stop
&& exists_non_stop_target ())
4324 stop_all_threads ("presenting stop to user in all-stop");
4327 /* Wait for control to return from inferior to debugger.
4329 If inferior gets a signal, we may decide to start it up again
4330 instead of returning. That is why there is a loop in this function.
4331 When this function actually returns it means the inferior
4332 should be left stopped and GDB should read more commands. */
4335 wait_for_inferior (inferior
*inf
)
4337 infrun_debug_printf ("wait_for_inferior ()");
4339 SCOPE_EXIT
{ delete_just_stopped_threads_infrun_breakpoints (); };
4341 /* If an error happens while handling the event, propagate GDB's
4342 knowledge of the executing state to the frontend/user running
4344 scoped_finish_thread_state finish_state
4345 (inf
->process_target (), minus_one_ptid
);
4349 execution_control_state ecs
;
4351 overlay_cache_invalid
= 1;
4353 /* Flush target cache before starting to handle each event.
4354 Target was running and cache could be stale. This is just a
4355 heuristic. Running threads may modify target memory, but we
4356 don't get any event. */
4357 target_dcache_invalidate (current_program_space
->aspace
);
4359 ecs
.ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
.ws
, 0);
4360 ecs
.target
= inf
->process_target ();
4363 print_target_wait_results (minus_one_ptid
, ecs
.ptid
, ecs
.ws
);
4365 /* Now figure out what to do with the result of the result. */
4366 handle_inferior_event (&ecs
);
4368 if (!ecs
.wait_some_more
)
4372 stop_all_threads_if_all_stop_mode ();
4374 /* No error, don't finish the state yet. */
4375 finish_state
.release ();
4378 /* Cleanup that reinstalls the readline callback handler, if the
4379 target is running in the background. If while handling the target
4380 event something triggered a secondary prompt, like e.g., a
4381 pagination prompt, we'll have removed the callback handler (see
4382 gdb_readline_wrapper_line). Need to do this as we go back to the
4383 event loop, ready to process further input. Note this has no
4384 effect if the handler hasn't actually been removed, because calling
4385 rl_callback_handler_install resets the line buffer, thus losing
4389 reinstall_readline_callback_handler_cleanup ()
4391 struct ui
*ui
= current_ui
;
4395 /* We're not going back to the top level event loop yet. Don't
4396 install the readline callback, as it'd prep the terminal,
4397 readline-style (raw, noecho) (e.g., --batch). We'll install
4398 it the next time the prompt is displayed, when we're ready
4403 if (ui
->command_editing
&& ui
->prompt_state
!= PROMPT_BLOCKED
)
4404 gdb_rl_callback_handler_reinstall ();
4407 /* Clean up the FSMs of threads that are now stopped. In non-stop,
4408 that's just the event thread. In all-stop, that's all threads. In
4409 all-stop, threads that had a pending exit no longer have a reason
4410 to be around, as their FSMs/commands are canceled, so we delete
4411 them. This avoids "info threads" listing such threads as if they
4412 were alive (and failing to read their registers), the user being
4413 able to select and resume them (and that failing), etc. */
4416 clean_up_just_stopped_threads_fsms (struct execution_control_state
*ecs
)
4418 /* The first clean_up call below assumes the event thread is the current
4420 if (ecs
->event_thread
!= nullptr)
4421 gdb_assert (ecs
->event_thread
== inferior_thread ());
4423 if (ecs
->event_thread
!= nullptr
4424 && ecs
->event_thread
->thread_fsm () != nullptr)
4425 ecs
->event_thread
->thread_fsm ()->clean_up (ecs
->event_thread
);
4429 scoped_restore_current_thread restore_thread
;
4431 for (thread_info
*thr
: all_threads_safe ())
4433 if (thr
->state
== THREAD_EXITED
)
4436 if (thr
== ecs
->event_thread
)
4439 if (thr
->thread_fsm () != nullptr)
4441 switch_to_thread (thr
);
4442 thr
->thread_fsm ()->clean_up (thr
);
4445 /* As we are cancelling the command/FSM of this thread,
4446 whatever was the reason we needed to report a thread
4447 exited event to the user, that reason is gone. Delete
4448 the thread, so that the user doesn't see it in the thread
4449 list, the next proceed doesn't try to resume it, etc. */
4450 if (thr
->has_pending_waitstatus ()
4451 && (thr
->pending_waitstatus ().kind ()
4452 == TARGET_WAITKIND_THREAD_EXITED
))
4453 delete_thread (thr
);
4458 /* Helper for all_uis_check_sync_execution_done that works on the
4462 check_curr_ui_sync_execution_done (void)
4464 struct ui
*ui
= current_ui
;
4466 if (ui
->prompt_state
== PROMPT_NEEDED
4468 && !gdb_in_secondary_prompt_p (ui
))
4470 target_terminal::ours ();
4471 top_level_interpreter ()->on_sync_execution_done ();
4472 ui
->register_file_handler ();
4479 all_uis_check_sync_execution_done (void)
4481 SWITCH_THRU_ALL_UIS ()
4483 check_curr_ui_sync_execution_done ();
4490 all_uis_on_sync_execution_starting (void)
4492 SWITCH_THRU_ALL_UIS ()
4494 if (current_ui
->prompt_state
== PROMPT_NEEDED
)
4495 async_disable_stdin ();
4499 /* A quit_handler callback installed while we're handling inferior
4503 infrun_quit_handler ()
4505 if (target_terminal::is_ours ())
4509 default_quit_handler would throw a quit in this case, but if
4510 we're handling an event while we have the terminal, it means
4511 the target is running a background execution command, and
4512 thus when users press Ctrl-C, they're wanting to interrupt
4513 whatever command they were executing in the command line.
4517 (gdb) foo bar whatever<ctrl-c>
4519 That Ctrl-C should clear the input line, not interrupt event
4520 handling if it happens that the user types Ctrl-C at just the
4523 It's as-if background event handling was handled by a
4524 separate background thread.
4526 To be clear, the Ctrl-C is not lost -- it will be processed
4527 by the next QUIT call once we're out of fetch_inferior_event
4532 if (check_quit_flag ())
4533 target_pass_ctrlc ();
4537 /* Asynchronous version of wait_for_inferior. It is called by the
4538 event loop whenever a change of state is detected on the file
4539 descriptor corresponding to the target. It can be called more than
4540 once to complete a single execution command. In such cases we need
4541 to keep the state in a global variable ECSS. If it is the last time
4542 that this function is called for a single execution command, then
4543 report to the user that the inferior has stopped, and do the
4544 necessary cleanups. */
4547 fetch_inferior_event ()
4549 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
4551 execution_control_state ecs
;
4554 /* Events are always processed with the main UI as current UI. This
4555 way, warnings, debug output, etc. are always consistently sent to
4556 the main console. */
4557 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, main_ui
);
4559 /* Temporarily disable pagination. Otherwise, the user would be
4560 given an option to press 'q' to quit, which would cause an early
4561 exit and could leave GDB in a half-baked state. */
4562 scoped_restore save_pagination
4563 = make_scoped_restore (&pagination_enabled
, false);
4565 /* Install a quit handler that does nothing if we have the terminal
4566 (meaning the target is running a background execution command),
4567 so that Ctrl-C never interrupts GDB before the event is fully
4569 scoped_restore restore_quit_handler
4570 = make_scoped_restore (&quit_handler
, infrun_quit_handler
);
4572 /* Make sure a SIGINT does not interrupt an extension language while
4573 we're handling an event. That could interrupt a Python unwinder
4574 or a Python observer or some such. A Ctrl-C should either be
4575 forwarded to the inferior if the inferior has the terminal, or,
4576 if GDB has the terminal, should interrupt the command the user is
4577 typing in the CLI. */
4578 scoped_disable_cooperative_sigint_handling restore_coop_sigint
;
4580 /* End up with readline processing input, if necessary. */
4582 SCOPE_EXIT
{ reinstall_readline_callback_handler_cleanup (); };
4584 /* We're handling a live event, so make sure we're doing live
4585 debugging. If we're looking at traceframes while the target is
4586 running, we're going to need to get back to that mode after
4587 handling the event. */
4588 std::optional
<scoped_restore_current_traceframe
> maybe_restore_traceframe
;
4591 maybe_restore_traceframe
.emplace ();
4592 set_current_traceframe (-1);
4595 /* The user/frontend should not notice a thread switch due to
4596 internal events. Make sure we revert to the user selected
4597 thread and frame after handling the event and running any
4598 breakpoint commands. */
4599 scoped_restore_current_thread restore_thread
;
4601 overlay_cache_invalid
= 1;
4602 /* Flush target cache before starting to handle each event. Target
4603 was running and cache could be stale. This is just a heuristic.
4604 Running threads may modify target memory, but we don't get any
4606 target_dcache_invalidate (current_program_space
->aspace
);
4608 scoped_restore save_exec_dir
4609 = make_scoped_restore (&execution_direction
,
4610 target_execution_direction ());
4612 /* Allow targets to pause their resumed threads while we handle
4614 scoped_disable_commit_resumed
disable_commit_resumed ("handling event");
4616 if (!do_target_wait (&ecs
, TARGET_WNOHANG
))
4618 infrun_debug_printf ("do_target_wait returned no event");
4619 disable_commit_resumed
.reset_and_commit ();
4623 gdb_assert (ecs
.ws
.kind () != TARGET_WAITKIND_IGNORE
);
4625 /* Switch to the inferior that generated the event, so we can do
4626 target calls. If the event was not associated to a ptid, */
4627 if (ecs
.ptid
!= null_ptid
4628 && ecs
.ptid
!= minus_one_ptid
)
4629 switch_to_inferior_no_thread (find_inferior_ptid (ecs
.target
, ecs
.ptid
));
4631 switch_to_target_no_thread (ecs
.target
);
4634 print_target_wait_results (minus_one_ptid
, ecs
.ptid
, ecs
.ws
);
4636 /* If an error happens while handling the event, propagate GDB's
4637 knowledge of the executing state to the frontend/user running
4639 ptid_t finish_ptid
= !target_is_non_stop_p () ? minus_one_ptid
: ecs
.ptid
;
4640 scoped_finish_thread_state
finish_state (ecs
.target
, finish_ptid
);
4642 /* Get executed before scoped_restore_current_thread above to apply
4643 still for the thread which has thrown the exception. */
4644 auto defer_bpstat_clear
4645 = make_scope_exit (bpstat_clear_actions
);
4646 auto defer_delete_threads
4647 = make_scope_exit (delete_just_stopped_threads_infrun_breakpoints
);
4649 int stop_id
= get_stop_id ();
4651 /* Now figure out what to do with the result of the result. */
4652 handle_inferior_event (&ecs
);
4654 if (!ecs
.wait_some_more
)
4656 struct inferior
*inf
= find_inferior_ptid (ecs
.target
, ecs
.ptid
);
4657 bool should_stop
= true;
4658 struct thread_info
*thr
= ecs
.event_thread
;
4660 delete_just_stopped_threads_infrun_breakpoints ();
4662 if (thr
!= nullptr && thr
->thread_fsm () != nullptr)
4663 should_stop
= thr
->thread_fsm ()->should_stop (thr
);
4671 bool should_notify_stop
= true;
4672 bool proceeded
= false;
4674 stop_all_threads_if_all_stop_mode ();
4676 clean_up_just_stopped_threads_fsms (&ecs
);
4678 if (stop_id
!= get_stop_id ())
4680 /* If the stop-id has changed then a stop has already been
4681 presented to the user in handle_inferior_event, this is
4682 likely a failed inferior call. As the stop has already
4683 been announced then we should not notify again.
4685 Also, if the prompt state is not PROMPT_NEEDED then GDB
4686 will not be ready for user input after this function. */
4687 should_notify_stop
= false;
4688 gdb_assert (current_ui
->prompt_state
== PROMPT_NEEDED
);
4690 else if (thr
!= nullptr && thr
->thread_fsm () != nullptr)
4692 = thr
->thread_fsm ()->should_notify_stop ();
4694 if (should_notify_stop
)
4696 /* We may not find an inferior if this was a process exit. */
4697 if (inf
== nullptr || inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
4698 proceeded
= normal_stop ();
4703 inferior_event_handler (INF_EXEC_COMPLETE
);
4707 /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
4708 previously selected thread is gone. We have two
4709 choices - switch to no thread selected, or restore the
4710 previously selected thread (now exited). We chose the
4711 later, just because that's what GDB used to do. After
4712 this, "info threads" says "The current thread <Thread
4713 ID 2> has terminated." instead of "No thread
4717 && ecs
.ws
.kind () != TARGET_WAITKIND_NO_RESUMED
)
4718 restore_thread
.dont_restore ();
4722 defer_delete_threads
.release ();
4723 defer_bpstat_clear
.release ();
4725 /* No error, don't finish the thread states yet. */
4726 finish_state
.release ();
4728 disable_commit_resumed
.reset_and_commit ();
4730 /* This scope is used to ensure that readline callbacks are
4731 reinstalled here. */
4734 /* Handling this event might have caused some inferiors to become prunable.
4735 For example, the exit of an inferior that was automatically added. Try
4736 to get rid of them. Keeping those around slows down things linearly.
4738 Note that this never removes the current inferior. Therefore, call this
4739 after RESTORE_THREAD went out of scope, in case the event inferior (which was
4740 temporarily made the current inferior) is meant to be deleted.
4742 Call this before all_uis_check_sync_execution_done, so that notifications about
4743 removed inferiors appear before the prompt. */
4746 /* If a UI was in sync execution mode, and now isn't, restore its
4747 prompt (a synchronous execution command has finished, and we're
4748 ready for input). */
4749 all_uis_check_sync_execution_done ();
4752 && exec_done_display_p
4753 && (inferior_ptid
== null_ptid
4754 || inferior_thread ()->state
!= THREAD_RUNNING
))
4755 gdb_printf (_("completed.\n"));
4761 set_step_info (thread_info
*tp
, frame_info_ptr frame
,
4762 struct symtab_and_line sal
)
4764 /* This can be removed once this function no longer implicitly relies on the
4765 inferior_ptid value. */
4766 gdb_assert (inferior_ptid
== tp
->ptid
);
4768 tp
->control
.step_frame_id
= get_frame_id (frame
);
4769 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
4771 tp
->current_symtab
= sal
.symtab
;
4772 tp
->current_line
= sal
.line
;
4775 ("symtab = %s, line = %d, step_frame_id = %s, step_stack_frame_id = %s",
4776 tp
->current_symtab
!= nullptr ? tp
->current_symtab
->filename
: "<null>",
4778 tp
->control
.step_frame_id
.to_string ().c_str (),
4779 tp
->control
.step_stack_frame_id
.to_string ().c_str ());
4782 /* Clear context switchable stepping state. */
4785 init_thread_stepping_state (struct thread_info
*tss
)
4787 tss
->stepped_breakpoint
= 0;
4788 tss
->stepping_over_breakpoint
= 0;
4789 tss
->stepping_over_watchpoint
= 0;
4790 tss
->step_after_step_resume_breakpoint
= 0;
4796 set_last_target_status (process_stratum_target
*target
, ptid_t ptid
,
4797 const target_waitstatus
&status
)
4799 target_last_proc_target
= target
;
4800 target_last_wait_ptid
= ptid
;
4801 target_last_waitstatus
= status
;
4807 get_last_target_status (process_stratum_target
**target
, ptid_t
*ptid
,
4808 target_waitstatus
*status
)
4810 if (target
!= nullptr)
4811 *target
= target_last_proc_target
;
4812 if (ptid
!= nullptr)
4813 *ptid
= target_last_wait_ptid
;
4814 if (status
!= nullptr)
4815 *status
= target_last_waitstatus
;
4821 nullify_last_target_wait_ptid (void)
4823 target_last_proc_target
= nullptr;
4824 target_last_wait_ptid
= minus_one_ptid
;
4825 target_last_waitstatus
= {};
4828 /* Switch thread contexts. */
4831 context_switch (execution_control_state
*ecs
)
4833 if (ecs
->ptid
!= inferior_ptid
4834 && (inferior_ptid
== null_ptid
4835 || ecs
->event_thread
!= inferior_thread ()))
4837 infrun_debug_printf ("Switching context from %s to %s",
4838 inferior_ptid
.to_string ().c_str (),
4839 ecs
->ptid
.to_string ().c_str ());
4842 switch_to_thread (ecs
->event_thread
);
4845 /* If the target can't tell whether we've hit breakpoints
4846 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4847 check whether that could have been caused by a breakpoint. If so,
4848 adjust the PC, per gdbarch_decr_pc_after_break. */
4851 adjust_pc_after_break (struct thread_info
*thread
,
4852 const target_waitstatus
&ws
)
4854 struct regcache
*regcache
;
4855 struct gdbarch
*gdbarch
;
4856 CORE_ADDR breakpoint_pc
, decr_pc
;
4858 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4859 we aren't, just return.
4861 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4862 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4863 implemented by software breakpoints should be handled through the normal
4866 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4867 different signals (SIGILL or SIGEMT for instance), but it is less
4868 clear where the PC is pointing afterwards. It may not match
4869 gdbarch_decr_pc_after_break. I don't know any specific target that
4870 generates these signals at breakpoints (the code has been in GDB since at
4871 least 1992) so I can not guess how to handle them here.
4873 In earlier versions of GDB, a target with
4874 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4875 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4876 target with both of these set in GDB history, and it seems unlikely to be
4877 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4879 if (ws
.kind () != TARGET_WAITKIND_STOPPED
)
4882 if (ws
.sig () != GDB_SIGNAL_TRAP
)
4885 /* In reverse execution, when a breakpoint is hit, the instruction
4886 under it has already been de-executed. The reported PC always
4887 points at the breakpoint address, so adjusting it further would
4888 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4891 B1 0x08000000 : INSN1
4892 B2 0x08000001 : INSN2
4894 PC -> 0x08000003 : INSN4
4896 Say you're stopped at 0x08000003 as above. Reverse continuing
4897 from that point should hit B2 as below. Reading the PC when the
4898 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4899 been de-executed already.
4901 B1 0x08000000 : INSN1
4902 B2 PC -> 0x08000001 : INSN2
4906 We can't apply the same logic as for forward execution, because
4907 we would wrongly adjust the PC to 0x08000000, since there's a
4908 breakpoint at PC - 1. We'd then report a hit on B1, although
4909 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4911 if (execution_direction
== EXEC_REVERSE
)
4914 /* If the target can tell whether the thread hit a SW breakpoint,
4915 trust it. Targets that can tell also adjust the PC
4917 if (target_supports_stopped_by_sw_breakpoint ())
4920 /* Note that relying on whether a breakpoint is planted in memory to
4921 determine this can fail. E.g,. the breakpoint could have been
4922 removed since. Or the thread could have been told to step an
4923 instruction the size of a breakpoint instruction, and only
4924 _after_ was a breakpoint inserted at its address. */
4926 /* If this target does not decrement the PC after breakpoints, then
4927 we have nothing to do. */
4928 regcache
= get_thread_regcache (thread
);
4929 gdbarch
= regcache
->arch ();
4931 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4935 const address_space
*aspace
= thread
->inf
->aspace
.get ();
4937 /* Find the location where (if we've hit a breakpoint) the
4938 breakpoint would be. */
4939 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4941 /* If the target can't tell whether a software breakpoint triggered,
4942 fallback to figuring it out based on breakpoints we think were
4943 inserted in the target, and on whether the thread was stepped or
4946 /* Check whether there actually is a software breakpoint inserted at
4949 If in non-stop mode, a race condition is possible where we've
4950 removed a breakpoint, but stop events for that breakpoint were
4951 already queued and arrive later. To suppress those spurious
4952 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4953 and retire them after a number of stop events are reported. Note
4954 this is an heuristic and can thus get confused. The real fix is
4955 to get the "stopped by SW BP and needs adjustment" info out of
4956 the target/kernel (and thus never reach here; see above). */
4957 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4958 || (target_is_non_stop_p ()
4959 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4961 std::optional
<scoped_restore_tmpl
<int>> restore_operation_disable
;
4963 if (record_full_is_used ())
4964 restore_operation_disable
.emplace
4965 (record_full_gdb_operation_disable_set ());
4967 /* When using hardware single-step, a SIGTRAP is reported for both
4968 a completed single-step and a software breakpoint. Need to
4969 differentiate between the two, as the latter needs adjusting
4970 but the former does not.
4972 The SIGTRAP can be due to a completed hardware single-step only if
4973 - we didn't insert software single-step breakpoints
4974 - this thread is currently being stepped
4976 If any of these events did not occur, we must have stopped due
4977 to hitting a software breakpoint, and have to back up to the
4980 As a special case, we could have hardware single-stepped a
4981 software breakpoint. In this case (prev_pc == breakpoint_pc),
4982 we also need to back up to the breakpoint address. */
4984 if (thread_has_single_step_breakpoints_set (thread
)
4985 || !currently_stepping (thread
)
4986 || (thread
->stepped_breakpoint
4987 && thread
->prev_pc
== breakpoint_pc
))
4988 regcache_write_pc (regcache
, breakpoint_pc
);
4993 stepped_in_from (frame_info_ptr frame
, struct frame_id step_frame_id
)
4995 for (frame
= get_prev_frame (frame
);
4997 frame
= get_prev_frame (frame
))
4999 if (get_frame_id (frame
) == step_frame_id
)
5002 if (get_frame_type (frame
) != INLINE_FRAME
)
5009 /* Look for an inline frame that is marked for skip.
5010 If PREV_FRAME is TRUE start at the previous frame,
5011 otherwise start at the current frame. Stop at the
5012 first non-inline frame, or at the frame where the
5016 inline_frame_is_marked_for_skip (bool prev_frame
, struct thread_info
*tp
)
5018 frame_info_ptr frame
= get_current_frame ();
5021 frame
= get_prev_frame (frame
);
5023 for (; frame
!= nullptr; frame
= get_prev_frame (frame
))
5025 const char *fn
= nullptr;
5026 symtab_and_line sal
;
5029 if (get_frame_id (frame
) == tp
->control
.step_frame_id
)
5031 if (get_frame_type (frame
) != INLINE_FRAME
)
5034 sal
= find_frame_sal (frame
);
5035 sym
= get_frame_function (frame
);
5038 fn
= sym
->print_name ();
5041 && function_name_is_marked_for_skip (fn
, sal
))
5048 /* If the event thread has the stop requested flag set, pretend it
5049 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
5053 handle_stop_requested (struct execution_control_state
*ecs
)
5055 if (ecs
->event_thread
->stop_requested
)
5057 ecs
->ws
.set_stopped (GDB_SIGNAL_0
);
5058 handle_signal_stop (ecs
);
5064 /* Auxiliary function that handles syscall entry/return events.
5065 It returns true if the inferior should keep going (and GDB
5066 should ignore the event), or false if the event deserves to be
5070 handle_syscall_event (struct execution_control_state
*ecs
)
5072 struct regcache
*regcache
;
5075 context_switch (ecs
);
5077 regcache
= get_thread_regcache (ecs
->event_thread
);
5078 syscall_number
= ecs
->ws
.syscall_number ();
5079 ecs
->event_thread
->set_stop_pc (regcache_read_pc (regcache
));
5081 if (catch_syscall_enabled ()
5082 && catching_syscall_number (syscall_number
))
5084 infrun_debug_printf ("syscall number=%d", syscall_number
);
5086 ecs
->event_thread
->control
.stop_bpstat
5087 = bpstat_stop_status_nowatch (ecs
->event_thread
->inf
->aspace
.get (),
5088 ecs
->event_thread
->stop_pc (),
5089 ecs
->event_thread
, ecs
->ws
);
5091 if (handle_stop_requested (ecs
))
5094 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5096 /* Catchpoint hit. */
5101 if (handle_stop_requested (ecs
))
5104 /* If no catchpoint triggered for this, then keep going. */
5110 /* Lazily fill in the execution_control_state's stop_func_* fields. */
5113 fill_in_stop_func (struct gdbarch
*gdbarch
,
5114 struct execution_control_state
*ecs
)
5116 if (!ecs
->stop_func_filled_in
)
5119 const general_symbol_info
*gsi
;
5121 /* Don't care about return value; stop_func_start and stop_func_name
5122 will both be 0 if it doesn't work. */
5123 find_pc_partial_function_sym (ecs
->event_thread
->stop_pc (),
5125 &ecs
->stop_func_start
,
5126 &ecs
->stop_func_end
,
5128 ecs
->stop_func_name
= gsi
== nullptr ? nullptr : gsi
->print_name ();
5130 /* The call to find_pc_partial_function, above, will set
5131 stop_func_start and stop_func_end to the start and end
5132 of the range containing the stop pc. If this range
5133 contains the entry pc for the block (which is always the
5134 case for contiguous blocks), advance stop_func_start past
5135 the function's start offset and entrypoint. Note that
5136 stop_func_start is NOT advanced when in a range of a
5137 non-contiguous block that does not contain the entry pc. */
5138 if (block
!= nullptr
5139 && ecs
->stop_func_start
<= block
->entry_pc ()
5140 && block
->entry_pc () < ecs
->stop_func_end
)
5142 ecs
->stop_func_start
5143 += gdbarch_deprecated_function_start_offset (gdbarch
);
5145 /* PowerPC functions have a Local Entry Point (LEP) and a Global
5146 Entry Point (GEP). There is only one Entry Point (GEP = LEP) for
5147 other architectures. */
5148 ecs
->stop_func_alt_start
= ecs
->stop_func_start
;
5150 if (gdbarch_skip_entrypoint_p (gdbarch
))
5151 ecs
->stop_func_start
5152 = gdbarch_skip_entrypoint (gdbarch
, ecs
->stop_func_start
);
5155 ecs
->stop_func_filled_in
= 1;
5160 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
5162 static enum stop_kind
5163 get_inferior_stop_soon (execution_control_state
*ecs
)
5165 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5167 gdb_assert (inf
!= nullptr);
5168 return inf
->control
.stop_soon
;
5171 /* Poll for one event out of the current target. Store the resulting
5172 waitstatus in WS, and return the event ptid. Does not block. */
5175 poll_one_curr_target (struct target_waitstatus
*ws
)
5179 overlay_cache_invalid
= 1;
5181 /* Flush target cache before starting to handle each event.
5182 Target was running and cache could be stale. This is just a
5183 heuristic. Running threads may modify target memory, but we
5184 don't get any event. */
5185 target_dcache_invalidate (current_program_space
->aspace
);
5187 event_ptid
= target_wait (minus_one_ptid
, ws
, TARGET_WNOHANG
);
5190 print_target_wait_results (minus_one_ptid
, event_ptid
, *ws
);
5195 /* Wait for one event out of any target. */
5197 static wait_one_event
5202 for (inferior
*inf
: all_inferiors ())
5204 process_stratum_target
*target
= inf
->process_target ();
5205 if (target
== nullptr
5206 || !target
->is_async_p ()
5207 || !target
->threads_executing
)
5210 switch_to_inferior_no_thread (inf
);
5212 wait_one_event event
;
5213 event
.target
= target
;
5214 event
.ptid
= poll_one_curr_target (&event
.ws
);
5216 if (event
.ws
.kind () == TARGET_WAITKIND_NO_RESUMED
)
5218 /* If nothing is resumed, remove the target from the
5220 target_async (false);
5222 else if (event
.ws
.kind () != TARGET_WAITKIND_IGNORE
)
5226 /* Block waiting for some event. */
5233 for (inferior
*inf
: all_inferiors ())
5235 process_stratum_target
*target
= inf
->process_target ();
5236 if (target
== nullptr
5237 || !target
->is_async_p ()
5238 || !target
->threads_executing
)
5241 int fd
= target
->async_wait_fd ();
5242 FD_SET (fd
, &readfds
);
5249 /* No waitable targets left. All must be stopped. */
5250 infrun_debug_printf ("no waitable targets left");
5252 target_waitstatus ws
;
5253 ws
.set_no_resumed ();
5254 return {nullptr, minus_one_ptid
, std::move (ws
)};
5259 int numfds
= interruptible_select (nfds
, &readfds
, 0, nullptr, 0);
5265 perror_with_name ("interruptible_select");
5270 /* Save the thread's event and stop reason to process it later. */
5273 save_waitstatus (struct thread_info
*tp
, const target_waitstatus
&ws
)
5275 infrun_debug_printf ("saving status %s for %s",
5276 ws
.to_string ().c_str (),
5277 tp
->ptid
.to_string ().c_str ());
5279 /* Record for later. */
5280 tp
->set_pending_waitstatus (ws
);
5282 if (ws
.kind () == TARGET_WAITKIND_STOPPED
5283 && ws
.sig () == GDB_SIGNAL_TRAP
)
5285 struct regcache
*regcache
= get_thread_regcache (tp
);
5286 const address_space
*aspace
= tp
->inf
->aspace
.get ();
5287 CORE_ADDR pc
= regcache_read_pc (regcache
);
5289 adjust_pc_after_break (tp
, tp
->pending_waitstatus ());
5291 scoped_restore_current_thread restore_thread
;
5292 switch_to_thread (tp
);
5294 if (target_stopped_by_watchpoint ())
5295 tp
->set_stop_reason (TARGET_STOPPED_BY_WATCHPOINT
);
5296 else if (target_supports_stopped_by_sw_breakpoint ()
5297 && target_stopped_by_sw_breakpoint ())
5298 tp
->set_stop_reason (TARGET_STOPPED_BY_SW_BREAKPOINT
);
5299 else if (target_supports_stopped_by_hw_breakpoint ()
5300 && target_stopped_by_hw_breakpoint ())
5301 tp
->set_stop_reason (TARGET_STOPPED_BY_HW_BREAKPOINT
);
5302 else if (!target_supports_stopped_by_hw_breakpoint ()
5303 && hardware_breakpoint_inserted_here_p (aspace
, pc
))
5304 tp
->set_stop_reason (TARGET_STOPPED_BY_HW_BREAKPOINT
);
5305 else if (!target_supports_stopped_by_sw_breakpoint ()
5306 && software_breakpoint_inserted_here_p (aspace
, pc
))
5307 tp
->set_stop_reason (TARGET_STOPPED_BY_SW_BREAKPOINT
);
5308 else if (!thread_has_single_step_breakpoints_set (tp
)
5309 && currently_stepping (tp
))
5310 tp
->set_stop_reason (TARGET_STOPPED_BY_SINGLE_STEP
);
5314 /* Mark the non-executing threads accordingly. In all-stop, all
5315 threads of all processes are stopped when we get any event
5316 reported. In non-stop mode, only the event thread stops. */
5319 mark_non_executing_threads (process_stratum_target
*target
,
5321 const target_waitstatus
&ws
)
5325 if (!target_is_non_stop_p ())
5326 mark_ptid
= minus_one_ptid
;
5327 else if (ws
.kind () == TARGET_WAITKIND_SIGNALLED
5328 || ws
.kind () == TARGET_WAITKIND_EXITED
)
5330 /* If we're handling a process exit in non-stop mode, even
5331 though threads haven't been deleted yet, one would think
5332 that there is nothing to do, as threads of the dead process
5333 will be soon deleted, and threads of any other process were
5334 left running. However, on some targets, threads survive a
5335 process exit event. E.g., for the "checkpoint" command,
5336 when the current checkpoint/fork exits, linux-fork.c
5337 automatically switches to another fork from within
5338 target_mourn_inferior, by associating the same
5339 inferior/thread to another fork. We haven't mourned yet at
5340 this point, but we must mark any threads left in the
5341 process as not-executing so that finish_thread_state marks
5342 them stopped (in the user's perspective) if/when we present
5343 the stop to the user. */
5344 mark_ptid
= ptid_t (event_ptid
.pid ());
5347 mark_ptid
= event_ptid
;
5349 set_executing (target
, mark_ptid
, false);
5351 /* Likewise the resumed flag. */
5352 set_resumed (target
, mark_ptid
, false);
5355 /* Handle one event after stopping threads. If the eventing thread
5356 reports back any interesting event, we leave it pending. If the
5357 eventing thread was in the middle of a displaced step, we
5358 cancel/finish it, and unless the thread's inferior is being
5359 detached, put the thread back in the step-over chain. Returns true
5360 if there are no resumed threads left in the target (thus there's no
5361 point in waiting further), false otherwise. */
5364 handle_one (const wait_one_event
&event
)
5367 ("%s %s", event
.ws
.to_string ().c_str (),
5368 event
.ptid
.to_string ().c_str ());
5370 if (event
.ws
.kind () == TARGET_WAITKIND_NO_RESUMED
)
5372 /* All resumed threads exited. */
5375 else if (event
.ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
5376 || event
.ws
.kind () == TARGET_WAITKIND_EXITED
5377 || event
.ws
.kind () == TARGET_WAITKIND_SIGNALLED
)
5379 /* One thread/process exited/signalled. */
5381 thread_info
*t
= nullptr;
5383 /* The target may have reported just a pid. If so, try
5384 the first non-exited thread. */
5385 if (event
.ptid
.is_pid ())
5387 int pid
= event
.ptid
.pid ();
5388 inferior
*inf
= find_inferior_pid (event
.target
, pid
);
5389 for (thread_info
*tp
: inf
->non_exited_threads ())
5395 /* If there is no available thread, the event would
5396 have to be appended to a per-inferior event list,
5397 which does not exist (and if it did, we'd have
5398 to adjust run control command to be able to
5399 resume such an inferior). We assert here instead
5400 of going into an infinite loop. */
5401 gdb_assert (t
!= nullptr);
5404 ("using %s", t
->ptid
.to_string ().c_str ());
5408 t
= event
.target
->find_thread (event
.ptid
);
5409 /* Check if this is the first time we see this thread.
5410 Don't bother adding if it individually exited. */
5412 && event
.ws
.kind () != TARGET_WAITKIND_THREAD_EXITED
)
5413 t
= add_thread (event
.target
, event
.ptid
);
5418 /* Set the threads as non-executing to avoid
5419 another stop attempt on them. */
5420 switch_to_thread_no_regs (t
);
5421 mark_non_executing_threads (event
.target
, event
.ptid
,
5423 save_waitstatus (t
, event
.ws
);
5424 t
->stop_requested
= false;
5426 if (event
.ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
5428 if (displaced_step_finish (t
, event
.ws
)
5429 != DISPLACED_STEP_FINISH_STATUS_OK
)
5431 gdb_assert_not_reached ("displaced_step_finish on "
5432 "exited thread failed");
5439 thread_info
*t
= event
.target
->find_thread (event
.ptid
);
5441 t
= add_thread (event
.target
, event
.ptid
);
5443 t
->stop_requested
= 0;
5444 t
->set_executing (false);
5445 t
->set_resumed (false);
5446 t
->control
.may_range_step
= 0;
5448 /* This may be the first time we see the inferior report
5450 if (t
->inf
->needs_setup
)
5452 switch_to_thread_no_regs (t
);
5456 if (event
.ws
.kind () == TARGET_WAITKIND_STOPPED
5457 && event
.ws
.sig () == GDB_SIGNAL_0
)
5459 /* We caught the event that we intended to catch, so
5460 there's no event to save as pending. */
5462 if (displaced_step_finish (t
, event
.ws
)
5463 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
5465 /* Add it back to the step-over queue. */
5467 ("displaced-step of %s canceled",
5468 t
->ptid
.to_string ().c_str ());
5470 t
->control
.trap_expected
= 0;
5471 if (!t
->inf
->detaching
)
5472 global_thread_step_over_chain_enqueue (t
);
5477 struct regcache
*regcache
;
5480 ("target_wait %s, saving status for %s",
5481 event
.ws
.to_string ().c_str (),
5482 t
->ptid
.to_string ().c_str ());
5484 /* Record for later. */
5485 save_waitstatus (t
, event
.ws
);
5487 if (displaced_step_finish (t
, event
.ws
)
5488 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
5490 /* Add it back to the step-over queue. */
5491 t
->control
.trap_expected
= 0;
5492 if (!t
->inf
->detaching
)
5493 global_thread_step_over_chain_enqueue (t
);
5496 regcache
= get_thread_regcache (t
);
5497 t
->set_stop_pc (regcache_read_pc (regcache
));
5499 infrun_debug_printf ("saved stop_pc=%s for %s "
5500 "(currently_stepping=%d)",
5501 paddress (current_inferior ()->arch (),
5503 t
->ptid
.to_string ().c_str (),
5504 currently_stepping (t
));
5511 /* Helper for stop_all_threads. wait_one waits for events until it
5512 sees a TARGET_WAITKIND_NO_RESUMED event. When it sees one, it
5513 disables target_async for the target to stop waiting for events
5514 from it. TARGET_WAITKIND_NO_RESUMED can be delayed though,
5515 consider, debugging against gdbserver:
5517 #1 - Threads 1-5 are running, and thread 1 hits a breakpoint.
5519 #2 - gdb processes the breakpoint hit for thread 1, stops all
5520 threads, and steps thread 1 over the breakpoint. while
5521 stopping threads, some other threads reported interesting
5522 events, which were left pending in the thread's objects
5525 #2 - Thread 1 exits (it stepped an exit syscall), and gdbserver
5526 reports the thread exit for thread 1. The event ends up in
5527 remote's stop reply queue.
5529 #3 - That was the last resumed thread, so gdbserver reports
5530 no-resumed, and that event also ends up in remote's stop
5531 reply queue, queued after the thread exit from #2.
5533 #4 - gdb processes the thread exit event, which finishes the
5534 step-over, and so gdb restarts all threads (threads with
5535 pending events are left marked resumed, but aren't set
5536 executing). The no-resumed event is still left pending in
5537 the remote stop reply queue.
5539 #5 - Since there are now resumed threads with pending breakpoint
5540 hits, gdb picks one at random to process next.
5542 #5 - gdb picks the breakpoint hit for thread 2 this time, and that
5543 breakpoint also needs to be stepped over, so gdb stops all
5546 #6 - stop_all_threads counts number of expected stops and calls
5547 wait_one once for each.
5549 #7 - The first wait_one call collects the no-resumed event from #3
5552 #9 - Seeing the no-resumed event, wait_one disables target async
5553 for the remote target, to stop waiting for events from it.
5554 wait_one from here on always return no-resumed directly
5555 without reaching the target.
5557 #10 - stop_all_threads still hasn't seen all the stops it expects,
5558 so it does another pass.
5560 #11 - Since the remote target is not async (disabled in #9),
5561 wait_one doesn't wait on it, so it won't see the expected
5562 stops, and instead returns no-resumed directly.
5564 #12 - stop_all_threads still haven't seen all the stops, so it
5565 does another pass. goto #11, looping forever.
5567 To handle this, we explicitly (re-)enable target async on all
5568 targets that can async every time stop_all_threads goes wait for
5569 the expected stops. */
5572 reenable_target_async ()
5574 for (inferior
*inf
: all_inferiors ())
5576 process_stratum_target
*target
= inf
->process_target ();
5577 if (target
!= nullptr
5578 && target
->threads_executing
5579 && target
->can_async_p ()
5580 && !target
->is_async_p ())
5582 switch_to_inferior_no_thread (inf
);
5591 stop_all_threads (const char *reason
, inferior
*inf
)
5593 /* We may need multiple passes to discover all threads. */
5597 gdb_assert (exists_non_stop_target ());
5599 INFRUN_SCOPED_DEBUG_START_END ("reason=%s, inf=%d", reason
,
5600 inf
!= nullptr ? inf
->num
: -1);
5602 infrun_debug_show_threads ("non-exited threads",
5603 all_non_exited_threads ());
5605 scoped_restore_current_thread restore_thread
;
5607 /* Enable thread events on relevant targets. */
5608 for (auto *target
: all_non_exited_process_targets ())
5610 if (inf
!= nullptr && inf
->process_target () != target
)
5613 switch_to_target_no_thread (target
);
5614 target_thread_events (true);
5619 /* Disable thread events on relevant targets. */
5620 for (auto *target
: all_non_exited_process_targets ())
5622 if (inf
!= nullptr && inf
->process_target () != target
)
5625 switch_to_target_no_thread (target
);
5626 target_thread_events (false);
5629 /* Use debug_prefixed_printf directly to get a meaningful function
5632 debug_prefixed_printf ("infrun", "stop_all_threads", "done");
5635 /* Request threads to stop, and then wait for the stops. Because
5636 threads we already know about can spawn more threads while we're
5637 trying to stop them, and we only learn about new threads when we
5638 update the thread list, do this in a loop, and keep iterating
5639 until two passes find no threads that need to be stopped. */
5640 for (pass
= 0; pass
< 2; pass
++, iterations
++)
5642 infrun_debug_printf ("pass=%d, iterations=%d", pass
, iterations
);
5645 int waits_needed
= 0;
5647 for (auto *target
: all_non_exited_process_targets ())
5649 if (inf
!= nullptr && inf
->process_target () != target
)
5652 switch_to_target_no_thread (target
);
5653 update_thread_list ();
5656 /* Go through all threads looking for threads that we need
5657 to tell the target to stop. */
5658 for (thread_info
*t
: all_non_exited_threads ())
5660 if (inf
!= nullptr && t
->inf
!= inf
)
5663 /* For a single-target setting with an all-stop target,
5664 we would not even arrive here. For a multi-target
5665 setting, until GDB is able to handle a mixture of
5666 all-stop and non-stop targets, simply skip all-stop
5667 targets' threads. This should be fine due to the
5668 protection of 'check_multi_target_resumption'. */
5670 switch_to_thread_no_regs (t
);
5671 if (!target_is_non_stop_p ())
5674 if (t
->executing ())
5676 /* If already stopping, don't request a stop again.
5677 We just haven't seen the notification yet. */
5678 if (!t
->stop_requested
)
5680 infrun_debug_printf (" %s executing, need stop",
5681 t
->ptid
.to_string ().c_str ());
5682 target_stop (t
->ptid
);
5683 t
->stop_requested
= 1;
5687 infrun_debug_printf (" %s executing, already stopping",
5688 t
->ptid
.to_string ().c_str ());
5691 if (t
->stop_requested
)
5696 infrun_debug_printf (" %s not executing",
5697 t
->ptid
.to_string ().c_str ());
5699 /* The thread may be not executing, but still be
5700 resumed with a pending status to process. */
5701 t
->set_resumed (false);
5705 if (waits_needed
== 0)
5708 /* If we find new threads on the second iteration, restart
5709 over. We want to see two iterations in a row with all
5714 reenable_target_async ();
5716 for (int i
= 0; i
< waits_needed
; i
++)
5718 wait_one_event event
= wait_one ();
5719 if (handle_one (event
))
5726 /* Handle a TARGET_WAITKIND_NO_RESUMED event. Return true if we
5727 handled the event and should continue waiting. Return false if we
5728 should stop and report the event to the user. */
5731 handle_no_resumed (struct execution_control_state
*ecs
)
5733 if (target_can_async_p ())
5735 bool any_sync
= false;
5737 for (ui
*ui
: all_uis ())
5739 if (ui
->prompt_state
== PROMPT_BLOCKED
)
5747 /* There were no unwaited-for children left in the target, but,
5748 we're not synchronously waiting for events either. Just
5751 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED (ignoring: bg)");
5752 prepare_to_wait (ecs
);
5757 /* Otherwise, if we were running a synchronous execution command, we
5758 may need to cancel it and give the user back the terminal.
5760 In non-stop mode, the target can't tell whether we've already
5761 consumed previous stop events, so it can end up sending us a
5762 no-resumed event like so:
5764 #0 - thread 1 is left stopped
5766 #1 - thread 2 is resumed and hits breakpoint
5767 -> TARGET_WAITKIND_STOPPED
5769 #2 - thread 3 is resumed and exits
5770 this is the last resumed thread, so
5771 -> TARGET_WAITKIND_NO_RESUMED
5773 #3 - gdb processes stop for thread 2 and decides to re-resume
5776 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
5777 thread 2 is now resumed, so the event should be ignored.
5779 IOW, if the stop for thread 2 doesn't end a foreground command,
5780 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
5781 event. But it could be that the event meant that thread 2 itself
5782 (or whatever other thread was the last resumed thread) exited.
5784 To address this we refresh the thread list and check whether we
5785 have resumed threads _now_. In the example above, this removes
5786 thread 3 from the thread list. If thread 2 was re-resumed, we
5787 ignore this event. If we find no thread resumed, then we cancel
5788 the synchronous command and show "no unwaited-for " to the
5791 inferior
*curr_inf
= current_inferior ();
5793 scoped_restore_current_thread restore_thread
;
5794 update_thread_list ();
5798 - the current target has no thread executing, and
5799 - the current inferior is native, and
5800 - the current inferior is the one which has the terminal, and
5803 then a Ctrl-C from this point on would remain stuck in the
5804 kernel, until a thread resumes and dequeues it. That would
5805 result in the GDB CLI not reacting to Ctrl-C, not able to
5806 interrupt the program. To address this, if the current inferior
5807 no longer has any thread executing, we give the terminal to some
5808 other inferior that has at least one thread executing. */
5809 bool swap_terminal
= true;
5811 /* Whether to ignore this TARGET_WAITKIND_NO_RESUMED event, or
5812 whether to report it to the user. */
5813 bool ignore_event
= false;
5815 for (thread_info
*thread
: all_non_exited_threads ())
5817 if (swap_terminal
&& thread
->executing ())
5819 if (thread
->inf
!= curr_inf
)
5821 target_terminal::ours ();
5823 switch_to_thread (thread
);
5824 target_terminal::inferior ();
5826 swap_terminal
= false;
5829 if (!ignore_event
&& thread
->resumed ())
5831 /* Either there were no unwaited-for children left in the
5832 target at some point, but there are now, or some target
5833 other than the eventing one has unwaited-for children
5834 left. Just ignore. */
5835 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED "
5836 "(ignoring: found resumed)");
5838 ignore_event
= true;
5841 if (ignore_event
&& !swap_terminal
)
5847 switch_to_inferior_no_thread (curr_inf
);
5848 prepare_to_wait (ecs
);
5852 /* Go ahead and report the event. */
5856 /* Handle a TARGET_WAITKIND_THREAD_EXITED event. Return true if we
5857 handled the event and should continue waiting. Return false if we
5858 should stop and report the event to the user. */
5861 handle_thread_exited (execution_control_state
*ecs
)
5863 context_switch (ecs
);
5865 /* Clear these so we don't re-start the thread stepping over a
5866 breakpoint/watchpoint. */
5867 ecs
->event_thread
->stepping_over_breakpoint
= 0;
5868 ecs
->event_thread
->stepping_over_watchpoint
= 0;
5870 /* If the thread had an FSM, then abort the command. But only after
5871 finishing the step over, as in non-stop mode, aborting this
5872 thread's command should not interfere with other threads. We
5873 must check this before finish_step over, however, which may
5874 update the thread list and delete the event thread. */
5875 bool abort_cmd
= (ecs
->event_thread
->thread_fsm () != nullptr);
5877 /* Maybe the thread was doing a step-over, if so release
5878 resources and start any further pending step-overs.
5880 If we are on a non-stop target and the thread was doing an
5881 in-line step, this also restarts the other threads. */
5882 int ret
= finish_step_over (ecs
);
5884 /* finish_step_over returns true if it moves ecs' wait status
5885 back into the thread, so that we go handle another pending
5886 event before this one. But we know it never does that if
5887 the event thread has exited. */
5888 gdb_assert (ret
== 0);
5892 delete_thread (ecs
->event_thread
);
5893 ecs
->event_thread
= nullptr;
5897 /* If finish_step_over started a new in-line step-over, don't
5898 try to restart anything else. */
5899 if (step_over_info_valid_p ())
5901 delete_thread (ecs
->event_thread
);
5905 /* Maybe we are on an all-stop target and we got this event
5906 while doing a step-like command on another thread. If so,
5907 go back to doing that. If this thread was stepping,
5908 switch_back_to_stepped_thread will consider that the thread
5909 was interrupted mid-step and will try keep stepping it. We
5910 don't want that, the thread is gone. So clear the proceed
5911 status so it doesn't do that. */
5912 clear_proceed_status_thread (ecs
->event_thread
);
5913 if (switch_back_to_stepped_thread (ecs
))
5915 delete_thread (ecs
->event_thread
);
5919 inferior
*inf
= ecs
->event_thread
->inf
;
5920 bool slock_applies
= schedlock_applies (ecs
->event_thread
);
5922 delete_thread (ecs
->event_thread
);
5923 ecs
->event_thread
= nullptr;
5925 /* Continue handling the event as if we had gotten a
5926 TARGET_WAITKIND_NO_RESUMED. */
5927 auto handle_as_no_resumed
= [ecs
] ()
5929 /* handle_no_resumed doesn't really look at the event kind, but
5930 normal_stop does. */
5931 ecs
->ws
.set_no_resumed ();
5932 ecs
->event_thread
= nullptr;
5933 ecs
->ptid
= minus_one_ptid
;
5935 /* Re-record the last target status. */
5936 set_last_target_status (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5938 return handle_no_resumed (ecs
);
5941 /* If we are on an all-stop target, the target has stopped all
5942 threads to report the event. We don't actually want to
5943 stop, so restart the threads. */
5944 if (!target_is_non_stop_p ())
5948 /* Since the target is !non-stop, then everything is stopped
5949 at this point, and we can't assume we'll get further
5950 events until we resume the target again. Handle this
5951 event like if it were a TARGET_WAITKIND_NO_RESUMED. Note
5952 this refreshes the thread list and checks whether there
5953 are other resumed threads before deciding whether to
5954 print "no-unwaited-for left". This is important because
5955 the user could have done:
5957 (gdb) set scheduler-locking on
5963 ... and only one of the threads exited. */
5964 return handle_as_no_resumed ();
5968 /* Switch to the first non-exited thread we can find, and
5970 auto range
= inf
->non_exited_threads ();
5971 if (range
.begin () == range
.end ())
5973 /* Looks like the target reported a
5974 TARGET_WAITKIND_THREAD_EXITED for its last known
5976 return handle_as_no_resumed ();
5978 thread_info
*non_exited_thread
= *range
.begin ();
5979 switch_to_thread (non_exited_thread
);
5980 insert_breakpoints ();
5981 resume (GDB_SIGNAL_0
);
5985 prepare_to_wait (ecs
);
5989 /* Given an execution control state that has been freshly filled in by
5990 an event from the inferior, figure out what it means and take
5993 The alternatives are:
5995 1) stop_waiting and return; to really stop and return to the
5998 2) keep_going and return; to wait for the next event (set
5999 ecs->event_thread->stepping_over_breakpoint to 1 to single step
6003 handle_inferior_event (struct execution_control_state
*ecs
)
6005 /* Make sure that all temporary struct value objects that were
6006 created during the handling of the event get deleted at the
6008 scoped_value_mark free_values
;
6010 infrun_debug_printf ("%s", ecs
->ws
.to_string ().c_str ());
6012 if (ecs
->ws
.kind () == TARGET_WAITKIND_IGNORE
)
6014 /* We had an event in the inferior, but we are not interested in
6015 handling it at this level. The lower layers have already
6016 done what needs to be done, if anything.
6018 One of the possible circumstances for this is when the
6019 inferior produces output for the console. The inferior has
6020 not stopped, and we are ignoring the event. Another possible
6021 circumstance is any event which the lower level knows will be
6022 reported multiple times without an intervening resume. */
6023 prepare_to_wait (ecs
);
6027 if (ecs
->ws
.kind () == TARGET_WAITKIND_NO_RESUMED
6028 && handle_no_resumed (ecs
))
6031 /* Cache the last target/ptid/waitstatus. */
6032 set_last_target_status (ecs
->target
, ecs
->ptid
, ecs
->ws
);
6034 /* Always clear state belonging to the previous time we stopped. */
6035 stop_stack_dummy
= STOP_NONE
;
6037 if (ecs
->ws
.kind () == TARGET_WAITKIND_NO_RESUMED
)
6039 /* No unwaited-for children left. IOW, all resumed children
6045 if (ecs
->ws
.kind () != TARGET_WAITKIND_EXITED
6046 && ecs
->ws
.kind () != TARGET_WAITKIND_SIGNALLED
)
6048 ecs
->event_thread
= ecs
->target
->find_thread (ecs
->ptid
);
6049 /* If it's a new thread, add it to the thread database. */
6050 if (ecs
->event_thread
== nullptr)
6051 ecs
->event_thread
= add_thread (ecs
->target
, ecs
->ptid
);
6053 /* Disable range stepping. If the next step request could use a
6054 range, this will be end up re-enabled then. */
6055 ecs
->event_thread
->control
.may_range_step
= 0;
6058 /* Dependent on valid ECS->EVENT_THREAD. */
6059 adjust_pc_after_break (ecs
->event_thread
, ecs
->ws
);
6061 /* Dependent on the current PC value modified by adjust_pc_after_break. */
6062 reinit_frame_cache ();
6064 breakpoint_retire_moribund ();
6066 /* First, distinguish signals caused by the debugger from signals
6067 that have to do with the program's own actions. Note that
6068 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
6069 on the operating system version. Here we detect when a SIGILL or
6070 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
6071 something similar for SIGSEGV, since a SIGSEGV will be generated
6072 when we're trying to execute a breakpoint instruction on a
6073 non-executable stack. This happens for call dummy breakpoints
6074 for architectures like SPARC that place call dummies on the
6076 if (ecs
->ws
.kind () == TARGET_WAITKIND_STOPPED
6077 && (ecs
->ws
.sig () == GDB_SIGNAL_ILL
6078 || ecs
->ws
.sig () == GDB_SIGNAL_SEGV
6079 || ecs
->ws
.sig () == GDB_SIGNAL_EMT
))
6081 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
6083 if (breakpoint_inserted_here_p (ecs
->event_thread
->inf
->aspace
.get (),
6084 regcache_read_pc (regcache
)))
6086 infrun_debug_printf ("Treating signal as SIGTRAP");
6087 ecs
->ws
.set_stopped (GDB_SIGNAL_TRAP
);
6091 mark_non_executing_threads (ecs
->target
, ecs
->ptid
, ecs
->ws
);
6093 switch (ecs
->ws
.kind ())
6095 case TARGET_WAITKIND_LOADED
:
6097 context_switch (ecs
);
6098 /* Ignore gracefully during startup of the inferior, as it might
6099 be the shell which has just loaded some objects, otherwise
6100 add the symbols for the newly loaded objects. Also ignore at
6101 the beginning of an attach or remote session; we will query
6102 the full list of libraries once the connection is
6105 stop_kind stop_soon
= get_inferior_stop_soon (ecs
);
6106 if (stop_soon
== NO_STOP_QUIETLY
)
6108 struct regcache
*regcache
;
6110 regcache
= get_thread_regcache (ecs
->event_thread
);
6112 handle_solib_event ();
6114 ecs
->event_thread
->set_stop_pc (regcache_read_pc (regcache
));
6115 address_space
*aspace
= ecs
->event_thread
->inf
->aspace
.get ();
6116 ecs
->event_thread
->control
.stop_bpstat
6117 = bpstat_stop_status_nowatch (aspace
,
6118 ecs
->event_thread
->stop_pc (),
6119 ecs
->event_thread
, ecs
->ws
);
6121 if (handle_stop_requested (ecs
))
6124 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
6126 /* A catchpoint triggered. */
6127 process_event_stop_test (ecs
);
6131 /* If requested, stop when the dynamic linker notifies
6132 gdb of events. This allows the user to get control
6133 and place breakpoints in initializer routines for
6134 dynamically loaded objects (among other things). */
6135 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6136 if (stop_on_solib_events
)
6138 /* Make sure we print "Stopped due to solib-event" in
6140 stop_print_frame
= true;
6147 /* If we are skipping through a shell, or through shared library
6148 loading that we aren't interested in, resume the program. If
6149 we're running the program normally, also resume. */
6150 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
6152 /* Loading of shared libraries might have changed breakpoint
6153 addresses. Make sure new breakpoints are inserted. */
6154 if (stop_soon
== NO_STOP_QUIETLY
)
6155 insert_breakpoints ();
6156 resume (GDB_SIGNAL_0
);
6157 prepare_to_wait (ecs
);
6161 /* But stop if we're attaching or setting up a remote
6163 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
6164 || stop_soon
== STOP_QUIETLY_REMOTE
)
6166 infrun_debug_printf ("quietly stopped");
6171 internal_error (_("unhandled stop_soon: %d"), (int) stop_soon
);
6174 case TARGET_WAITKIND_SPURIOUS
:
6175 if (handle_stop_requested (ecs
))
6177 context_switch (ecs
);
6178 resume (GDB_SIGNAL_0
);
6179 prepare_to_wait (ecs
);
6182 case TARGET_WAITKIND_THREAD_CREATED
:
6183 if (handle_stop_requested (ecs
))
6185 context_switch (ecs
);
6186 if (!switch_back_to_stepped_thread (ecs
))
6190 case TARGET_WAITKIND_THREAD_EXITED
:
6191 if (handle_thread_exited (ecs
))
6196 case TARGET_WAITKIND_EXITED
:
6197 case TARGET_WAITKIND_SIGNALLED
:
6199 /* Depending on the system, ecs->ptid may point to a thread or
6200 to a process. On some targets, target_mourn_inferior may
6201 need to have access to the just-exited thread. That is the
6202 case of GNU/Linux's "checkpoint" support, for example.
6203 Call the switch_to_xxx routine as appropriate. */
6204 thread_info
*thr
= ecs
->target
->find_thread (ecs
->ptid
);
6206 switch_to_thread (thr
);
6209 inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
6210 switch_to_inferior_no_thread (inf
);
6213 handle_vfork_child_exec_or_exit (0);
6214 target_terminal::ours (); /* Must do this before mourn anyway. */
6216 /* Clearing any previous state of convenience variables. */
6217 clear_exit_convenience_vars ();
6219 if (ecs
->ws
.kind () == TARGET_WAITKIND_EXITED
)
6221 /* Record the exit code in the convenience variable $_exitcode, so
6222 that the user can inspect this again later. */
6223 set_internalvar_integer (lookup_internalvar ("_exitcode"),
6224 (LONGEST
) ecs
->ws
.exit_status ());
6226 /* Also record this in the inferior itself. */
6227 current_inferior ()->has_exit_code
= true;
6228 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.exit_status ();
6230 /* Support the --return-child-result option. */
6231 return_child_result_value
= ecs
->ws
.exit_status ();
6233 interps_notify_exited (ecs
->ws
.exit_status ());
6237 struct gdbarch
*gdbarch
= current_inferior ()->arch ();
6239 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
6241 /* Set the value of the internal variable $_exitsignal,
6242 which holds the signal uncaught by the inferior. */
6243 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
6244 gdbarch_gdb_signal_to_target (gdbarch
,
6249 /* We don't have access to the target's method used for
6250 converting between signal numbers (GDB's internal
6251 representation <-> target's representation).
6252 Therefore, we cannot do a good job at displaying this
6253 information to the user. It's better to just warn
6254 her about it (if infrun debugging is enabled), and
6256 infrun_debug_printf ("Cannot fill $_exitsignal with the correct "
6260 interps_notify_signal_exited (ecs
->ws
.sig ());
6263 gdb_flush (gdb_stdout
);
6264 target_mourn_inferior (inferior_ptid
);
6265 stop_print_frame
= false;
6269 case TARGET_WAITKIND_FORKED
:
6270 case TARGET_WAITKIND_VFORKED
:
6271 case TARGET_WAITKIND_THREAD_CLONED
:
6273 displaced_step_finish (ecs
->event_thread
, ecs
->ws
);
6275 /* Start a new step-over in another thread if there's one that
6279 context_switch (ecs
);
6281 /* Immediately detach breakpoints from the child before there's
6282 any chance of letting the user delete breakpoints from the
6283 breakpoint lists. If we don't do this early, it's easy to
6284 leave left over traps in the child, vis: "break foo; catch
6285 fork; c; <fork>; del; c; <child calls foo>". We only follow
6286 the fork on the last `continue', and by that time the
6287 breakpoint at "foo" is long gone from the breakpoint table.
6288 If we vforked, then we don't need to unpatch here, since both
6289 parent and child are sharing the same memory pages; we'll
6290 need to unpatch at follow/detach time instead to be certain
6291 that new breakpoints added between catchpoint hit time and
6292 vfork follow are detached. */
6293 if (ecs
->ws
.kind () == TARGET_WAITKIND_FORKED
)
6295 /* This won't actually modify the breakpoint list, but will
6296 physically remove the breakpoints from the child. */
6297 detach_breakpoints (ecs
->ws
.child_ptid ());
6300 delete_just_stopped_threads_single_step_breakpoints ();
6302 /* In case the event is caught by a catchpoint, remember that
6303 the event is to be followed at the next resume of the thread,
6304 and not immediately. */
6305 ecs
->event_thread
->pending_follow
= ecs
->ws
;
6307 ecs
->event_thread
->set_stop_pc
6308 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
6310 ecs
->event_thread
->control
.stop_bpstat
6311 = bpstat_stop_status_nowatch (ecs
->event_thread
->inf
->aspace
.get (),
6312 ecs
->event_thread
->stop_pc (),
6313 ecs
->event_thread
, ecs
->ws
);
6315 if (handle_stop_requested (ecs
))
6318 /* If no catchpoint triggered for this, then keep going. Note
6319 that we're interested in knowing the bpstat actually causes a
6320 stop, not just if it may explain the signal. Software
6321 watchpoints, for example, always appear in the bpstat. */
6322 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
6325 = (ecs
->ws
.kind () != TARGET_WAITKIND_THREAD_CLONED
6326 && follow_fork_mode_string
== follow_fork_mode_child
);
6328 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6330 process_stratum_target
*targ
6331 = ecs
->event_thread
->inf
->process_target ();
6334 if (ecs
->ws
.kind () != TARGET_WAITKIND_THREAD_CLONED
)
6335 should_resume
= follow_fork ();
6338 should_resume
= true;
6339 inferior
*inf
= ecs
->event_thread
->inf
;
6340 inf
->top_target ()->follow_clone (ecs
->ws
.child_ptid ());
6341 ecs
->event_thread
->pending_follow
.set_spurious ();
6344 /* Note that one of these may be an invalid pointer,
6345 depending on detach_fork. */
6346 thread_info
*parent
= ecs
->event_thread
;
6347 thread_info
*child
= targ
->find_thread (ecs
->ws
.child_ptid ());
6349 /* At this point, the parent is marked running, and the
6350 child is marked stopped. */
6352 /* If not resuming the parent, mark it stopped. */
6353 if (ecs
->ws
.kind () != TARGET_WAITKIND_THREAD_CLONED
6354 && follow_child
&& !detach_fork
&& !non_stop
&& !sched_multi
)
6355 parent
->set_running (false);
6357 /* If resuming the child, mark it running. */
6358 if ((ecs
->ws
.kind () == TARGET_WAITKIND_THREAD_CLONED
6359 && !schedlock_applies (ecs
->event_thread
))
6360 || (ecs
->ws
.kind () != TARGET_WAITKIND_THREAD_CLONED
6362 || (!detach_fork
&& (non_stop
|| sched_multi
)))))
6363 child
->set_running (true);
6365 /* In non-stop mode, also resume the other branch. */
6366 if ((ecs
->ws
.kind () == TARGET_WAITKIND_THREAD_CLONED
6367 && target_is_non_stop_p ()
6368 && !schedlock_applies (ecs
->event_thread
))
6369 || (ecs
->ws
.kind () != TARGET_WAITKIND_THREAD_CLONED
6370 && (!detach_fork
&& (non_stop
6372 && target_is_non_stop_p ())))))
6375 switch_to_thread (parent
);
6377 switch_to_thread (child
);
6379 ecs
->event_thread
= inferior_thread ();
6380 ecs
->ptid
= inferior_ptid
;
6385 switch_to_thread (child
);
6387 switch_to_thread (parent
);
6389 ecs
->event_thread
= inferior_thread ();
6390 ecs
->ptid
= inferior_ptid
;
6394 /* Never call switch_back_to_stepped_thread if we are waiting for
6395 vfork-done (waiting for an external vfork child to exec or
6396 exit). We will resume only the vforking thread for the purpose
6397 of collecting the vfork-done event, and we will restart any
6398 step once the critical shared address space window is done. */
6401 && parent
->inf
->thread_waiting_for_vfork_done
!= nullptr)
6402 || !switch_back_to_stepped_thread (ecs
))
6409 process_event_stop_test (ecs
);
6412 case TARGET_WAITKIND_VFORK_DONE
:
6413 /* Done with the shared memory region. Re-insert breakpoints in
6414 the parent, and keep going. */
6416 context_switch (ecs
);
6418 handle_vfork_done (ecs
->event_thread
);
6419 gdb_assert (inferior_thread () == ecs
->event_thread
);
6421 if (handle_stop_requested (ecs
))
6424 if (!switch_back_to_stepped_thread (ecs
))
6426 gdb_assert (inferior_thread () == ecs
->event_thread
);
6427 /* This also takes care of reinserting breakpoints in the
6428 previously locked inferior. */
6433 case TARGET_WAITKIND_EXECD
:
6435 /* Note we can't read registers yet (the stop_pc), because we
6436 don't yet know the inferior's post-exec architecture.
6437 'stop_pc' is explicitly read below instead. */
6438 switch_to_thread_no_regs (ecs
->event_thread
);
6440 /* Do whatever is necessary to the parent branch of the vfork. */
6441 handle_vfork_child_exec_or_exit (1);
6443 /* This causes the eventpoints and symbol table to be reset.
6444 Must do this now, before trying to determine whether to
6446 follow_exec (inferior_ptid
, ecs
->ws
.execd_pathname ());
6448 /* In follow_exec we may have deleted the original thread and
6449 created a new one. Make sure that the event thread is the
6450 execd thread for that case (this is a nop otherwise). */
6451 ecs
->event_thread
= inferior_thread ();
6453 ecs
->event_thread
->set_stop_pc
6454 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
6456 ecs
->event_thread
->control
.stop_bpstat
6457 = bpstat_stop_status_nowatch (ecs
->event_thread
->inf
->aspace
.get (),
6458 ecs
->event_thread
->stop_pc (),
6459 ecs
->event_thread
, ecs
->ws
);
6461 if (handle_stop_requested (ecs
))
6464 /* If no catchpoint triggered for this, then keep going. */
6465 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
6467 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6471 process_event_stop_test (ecs
);
6474 /* Be careful not to try to gather much state about a thread
6475 that's in a syscall. It's frequently a losing proposition. */
6476 case TARGET_WAITKIND_SYSCALL_ENTRY
:
6477 /* Getting the current syscall number. */
6478 if (handle_syscall_event (ecs
) == 0)
6479 process_event_stop_test (ecs
);
6482 /* Before examining the threads further, step this thread to
6483 get it entirely out of the syscall. (We get notice of the
6484 event when the thread is just on the verge of exiting a
6485 syscall. Stepping one instruction seems to get it back
6487 case TARGET_WAITKIND_SYSCALL_RETURN
:
6488 if (handle_syscall_event (ecs
) == 0)
6489 process_event_stop_test (ecs
);
6492 case TARGET_WAITKIND_STOPPED
:
6493 handle_signal_stop (ecs
);
6496 case TARGET_WAITKIND_NO_HISTORY
:
6497 /* Reverse execution: target ran out of history info. */
6499 /* Switch to the stopped thread. */
6500 context_switch (ecs
);
6501 infrun_debug_printf ("stopped");
6503 delete_just_stopped_threads_single_step_breakpoints ();
6504 ecs
->event_thread
->set_stop_pc
6505 (regcache_read_pc (get_thread_regcache (inferior_thread ())));
6507 if (handle_stop_requested (ecs
))
6510 interps_notify_no_history ();
6516 /* Restart threads back to what they were trying to do back when we
6517 paused them (because of an in-line step-over or vfork, for example).
6518 The EVENT_THREAD thread is ignored (not restarted).
6520 If INF is non-nullptr, only resume threads from INF. */
6523 restart_threads (struct thread_info
*event_thread
, inferior
*inf
)
6525 INFRUN_SCOPED_DEBUG_START_END ("event_thread=%s, inf=%d",
6526 event_thread
->ptid
.to_string ().c_str (),
6527 inf
!= nullptr ? inf
->num
: -1);
6529 gdb_assert (!step_over_info_valid_p ());
6531 /* In case the instruction just stepped spawned a new thread. */
6532 update_thread_list ();
6534 for (thread_info
*tp
: all_non_exited_threads ())
6536 if (inf
!= nullptr && tp
->inf
!= inf
)
6539 if (tp
->inf
->detaching
)
6541 infrun_debug_printf ("restart threads: [%s] inferior detaching",
6542 tp
->ptid
.to_string ().c_str ());
6546 switch_to_thread_no_regs (tp
);
6548 if (tp
== event_thread
)
6550 infrun_debug_printf ("restart threads: [%s] is event thread",
6551 tp
->ptid
.to_string ().c_str ());
6555 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
6557 infrun_debug_printf ("restart threads: [%s] not meant to be running",
6558 tp
->ptid
.to_string ().c_str ());
6564 infrun_debug_printf ("restart threads: [%s] resumed",
6565 tp
->ptid
.to_string ().c_str ());
6566 gdb_assert (tp
->executing () || tp
->has_pending_waitstatus ());
6570 if (thread_is_in_step_over_chain (tp
))
6572 infrun_debug_printf ("restart threads: [%s] needs step-over",
6573 tp
->ptid
.to_string ().c_str ());
6574 gdb_assert (!tp
->resumed ());
6579 if (tp
->has_pending_waitstatus ())
6581 infrun_debug_printf ("restart threads: [%s] has pending status",
6582 tp
->ptid
.to_string ().c_str ());
6583 tp
->set_resumed (true);
6587 gdb_assert (!tp
->stop_requested
);
6589 /* If some thread needs to start a step-over at this point, it
6590 should still be in the step-over queue, and thus skipped
6592 if (thread_still_needs_step_over (tp
))
6594 internal_error ("thread [%s] needs a step-over, but not in "
6595 "step-over queue\n",
6596 tp
->ptid
.to_string ().c_str ());
6599 if (currently_stepping (tp
))
6601 infrun_debug_printf ("restart threads: [%s] was stepping",
6602 tp
->ptid
.to_string ().c_str ());
6603 keep_going_stepped_thread (tp
);
6607 infrun_debug_printf ("restart threads: [%s] continuing",
6608 tp
->ptid
.to_string ().c_str ());
6609 execution_control_state
ecs (tp
);
6610 switch_to_thread (tp
);
6611 keep_going_pass_signal (&ecs
);
6616 /* Callback for iterate_over_threads. Find a resumed thread that has
6617 a pending waitstatus. */
6620 resumed_thread_with_pending_status (struct thread_info
*tp
,
6623 return tp
->resumed () && tp
->has_pending_waitstatus ();
6626 /* Called when we get an event that may finish an in-line or
6627 out-of-line (displaced stepping) step-over started previously.
6628 Return true if the event is processed and we should go back to the
6629 event loop; false if the caller should continue processing the
6633 finish_step_over (struct execution_control_state
*ecs
)
6635 displaced_step_finish (ecs
->event_thread
, ecs
->ws
);
6637 bool had_step_over_info
= step_over_info_valid_p ();
6639 if (had_step_over_info
)
6641 /* If we're stepping over a breakpoint with all threads locked,
6642 then only the thread that was stepped should be reporting
6644 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
6646 update_thread_events_after_step_over (ecs
->event_thread
, ecs
->ws
);
6648 clear_step_over_info ();
6651 if (!target_is_non_stop_p ())
6654 /* Start a new step-over in another thread if there's one that
6658 /* If we were stepping over a breakpoint before, and haven't started
6659 a new in-line step-over sequence, then restart all other threads
6660 (except the event thread). We can't do this in all-stop, as then
6661 e.g., we wouldn't be able to issue any other remote packet until
6662 these other threads stop. */
6663 if (had_step_over_info
&& !step_over_info_valid_p ())
6665 struct thread_info
*pending
;
6667 /* If we only have threads with pending statuses, the restart
6668 below won't restart any thread and so nothing re-inserts the
6669 breakpoint we just stepped over. But we need it inserted
6670 when we later process the pending events, otherwise if
6671 another thread has a pending event for this breakpoint too,
6672 we'd discard its event (because the breakpoint that
6673 originally caused the event was no longer inserted). */
6674 context_switch (ecs
);
6675 insert_breakpoints ();
6677 restart_threads (ecs
->event_thread
);
6679 /* If we have events pending, go through handle_inferior_event
6680 again, picking up a pending event at random. This avoids
6681 thread starvation. */
6683 /* But not if we just stepped over a watchpoint in order to let
6684 the instruction execute so we can evaluate its expression.
6685 The set of watchpoints that triggered is recorded in the
6686 breakpoint objects themselves (see bp->watchpoint_triggered).
6687 If we processed another event first, that other event could
6688 clobber this info. */
6689 if (ecs
->event_thread
->stepping_over_watchpoint
)
6692 /* The code below is meant to avoid one thread hogging the event
6693 loop by doing constant in-line step overs. If the stepping
6694 thread exited, there's no risk for this to happen, so we can
6695 safely let our caller process the event immediately. */
6696 if (ecs
->ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
6699 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
6701 if (pending
!= nullptr)
6703 struct thread_info
*tp
= ecs
->event_thread
;
6704 struct regcache
*regcache
;
6706 infrun_debug_printf ("found resumed threads with "
6707 "pending events, saving status");
6709 gdb_assert (pending
!= tp
);
6711 /* Record the event thread's event for later. */
6712 save_waitstatus (tp
, ecs
->ws
);
6713 /* This was cleared early, by handle_inferior_event. Set it
6714 so this pending event is considered by
6716 tp
->set_resumed (true);
6718 gdb_assert (!tp
->executing ());
6720 regcache
= get_thread_regcache (tp
);
6721 tp
->set_stop_pc (regcache_read_pc (regcache
));
6723 infrun_debug_printf ("saved stop_pc=%s for %s "
6724 "(currently_stepping=%d)",
6725 paddress (current_inferior ()->arch (),
6727 tp
->ptid
.to_string ().c_str (),
6728 currently_stepping (tp
));
6730 /* This in-line step-over finished; clear this so we won't
6731 start a new one. This is what handle_signal_stop would
6732 do, if we returned false. */
6733 tp
->stepping_over_breakpoint
= 0;
6735 /* Wake up the event loop again. */
6736 mark_async_event_handler (infrun_async_inferior_event_token
);
6738 prepare_to_wait (ecs
);
6749 notify_signal_received (gdb_signal sig
)
6751 interps_notify_signal_received (sig
);
6752 gdb::observers::signal_received
.notify (sig
);
6758 notify_normal_stop (bpstat
*bs
, int print_frame
)
6760 interps_notify_normal_stop (bs
, print_frame
);
6761 gdb::observers::normal_stop
.notify (bs
, print_frame
);
6766 void notify_user_selected_context_changed (user_selected_what selection
)
6768 interps_notify_user_selected_context_changed (selection
);
6769 gdb::observers::user_selected_context_changed
.notify (selection
);
6772 /* Come here when the program has stopped with a signal. */
6775 handle_signal_stop (struct execution_control_state
*ecs
)
6777 frame_info_ptr frame
;
6778 struct gdbarch
*gdbarch
;
6779 int stopped_by_watchpoint
;
6780 enum stop_kind stop_soon
;
6783 gdb_assert (ecs
->ws
.kind () == TARGET_WAITKIND_STOPPED
);
6785 ecs
->event_thread
->set_stop_signal (ecs
->ws
.sig ());
6787 /* Do we need to clean up the state of a thread that has
6788 completed a displaced single-step? (Doing so usually affects
6789 the PC, so do it here, before we set stop_pc.) */
6790 if (finish_step_over (ecs
))
6793 /* If we either finished a single-step or hit a breakpoint, but
6794 the user wanted this thread to be stopped, pretend we got a
6795 SIG0 (generic unsignaled stop). */
6796 if (ecs
->event_thread
->stop_requested
6797 && ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
6798 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6800 ecs
->event_thread
->set_stop_pc
6801 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
6803 context_switch (ecs
);
6805 if (deprecated_context_hook
)
6806 deprecated_context_hook (ecs
->event_thread
->global_num
);
6810 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
6811 struct gdbarch
*reg_gdbarch
= regcache
->arch ();
6814 ("stop_pc=%s", paddress (reg_gdbarch
, ecs
->event_thread
->stop_pc ()));
6815 if (target_stopped_by_watchpoint ())
6819 infrun_debug_printf ("stopped by watchpoint");
6821 if (target_stopped_data_address (current_inferior ()->top_target (),
6823 infrun_debug_printf ("stopped data address=%s",
6824 paddress (reg_gdbarch
, addr
));
6826 infrun_debug_printf ("(no data address available)");
6830 /* This is originated from start_remote(), start_inferior() and
6831 shared libraries hook functions. */
6832 stop_soon
= get_inferior_stop_soon (ecs
);
6833 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
6835 infrun_debug_printf ("quietly stopped");
6836 stop_print_frame
= true;
6841 /* This originates from attach_command(). We need to overwrite
6842 the stop_signal here, because some kernels don't ignore a
6843 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
6844 See more comments in inferior.h. On the other hand, if we
6845 get a non-SIGSTOP, report it to the user - assume the backend
6846 will handle the SIGSTOP if it should show up later.
6848 Also consider that the attach is complete when we see a
6849 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
6850 target extended-remote report it instead of a SIGSTOP
6851 (e.g. gdbserver). We already rely on SIGTRAP being our
6852 signal, so this is no exception.
6854 Also consider that the attach is complete when we see a
6855 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
6856 the target to stop all threads of the inferior, in case the
6857 low level attach operation doesn't stop them implicitly. If
6858 they weren't stopped implicitly, then the stub will report a
6859 GDB_SIGNAL_0, meaning: stopped for no particular reason
6860 other than GDB's request. */
6861 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
6862 && (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_STOP
6863 || ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6864 || ecs
->event_thread
->stop_signal () == GDB_SIGNAL_0
))
6866 stop_print_frame
= true;
6868 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6872 /* At this point, get hold of the now-current thread's frame. */
6873 frame
= get_current_frame ();
6874 gdbarch
= get_frame_arch (frame
);
6876 /* Pull the single step breakpoints out of the target. */
6877 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
6879 struct regcache
*regcache
;
6882 regcache
= get_thread_regcache (ecs
->event_thread
);
6883 const address_space
*aspace
= ecs
->event_thread
->inf
->aspace
.get ();
6885 pc
= regcache_read_pc (regcache
);
6887 /* However, before doing so, if this single-step breakpoint was
6888 actually for another thread, set this thread up for moving
6890 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
6893 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
6895 infrun_debug_printf ("[%s] hit another thread's single-step "
6897 ecs
->ptid
.to_string ().c_str ());
6898 ecs
->hit_singlestep_breakpoint
= 1;
6903 infrun_debug_printf ("[%s] hit its single-step breakpoint",
6904 ecs
->ptid
.to_string ().c_str ());
6907 delete_just_stopped_threads_single_step_breakpoints ();
6909 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6910 && ecs
->event_thread
->control
.trap_expected
6911 && ecs
->event_thread
->stepping_over_watchpoint
)
6912 stopped_by_watchpoint
= 0;
6914 stopped_by_watchpoint
= watchpoints_triggered (ecs
->ws
);
6916 /* If necessary, step over this watchpoint. We'll be back to display
6918 if (stopped_by_watchpoint
6919 && (target_have_steppable_watchpoint ()
6920 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
6922 /* At this point, we are stopped at an instruction which has
6923 attempted to write to a piece of memory under control of
6924 a watchpoint. The instruction hasn't actually executed
6925 yet. If we were to evaluate the watchpoint expression
6926 now, we would get the old value, and therefore no change
6927 would seem to have occurred.
6929 In order to make watchpoints work `right', we really need
6930 to complete the memory write, and then evaluate the
6931 watchpoint expression. We do this by single-stepping the
6934 It may not be necessary to disable the watchpoint to step over
6935 it. For example, the PA can (with some kernel cooperation)
6936 single step over a watchpoint without disabling the watchpoint.
6938 It is far more common to need to disable a watchpoint to step
6939 the inferior over it. If we have non-steppable watchpoints,
6940 we must disable the current watchpoint; it's simplest to
6941 disable all watchpoints.
6943 Any breakpoint at PC must also be stepped over -- if there's
6944 one, it will have already triggered before the watchpoint
6945 triggered, and we either already reported it to the user, or
6946 it didn't cause a stop and we called keep_going. In either
6947 case, if there was a breakpoint at PC, we must be trying to
6949 ecs
->event_thread
->stepping_over_watchpoint
= 1;
6954 ecs
->event_thread
->stepping_over_breakpoint
= 0;
6955 ecs
->event_thread
->stepping_over_watchpoint
= 0;
6956 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
6957 ecs
->event_thread
->control
.stop_step
= 0;
6958 stop_print_frame
= true;
6959 stopped_by_random_signal
= 0;
6960 bpstat
*stop_chain
= nullptr;
6962 /* Hide inlined functions starting here, unless we just performed stepi or
6963 nexti. After stepi and nexti, always show the innermost frame (not any
6964 inline function call sites). */
6965 if (ecs
->event_thread
->control
.step_range_end
!= 1)
6967 const address_space
*aspace
= ecs
->event_thread
->inf
->aspace
.get ();
6969 /* skip_inline_frames is expensive, so we avoid it if we can
6970 determine that the address is one where functions cannot have
6971 been inlined. This improves performance with inferiors that
6972 load a lot of shared libraries, because the solib event
6973 breakpoint is defined as the address of a function (i.e. not
6974 inline). Note that we have to check the previous PC as well
6975 as the current one to catch cases when we have just
6976 single-stepped off a breakpoint prior to reinstating it.
6977 Note that we're assuming that the code we single-step to is
6978 not inline, but that's not definitive: there's nothing
6979 preventing the event breakpoint function from containing
6980 inlined code, and the single-step ending up there. If the
6981 user had set a breakpoint on that inlined code, the missing
6982 skip_inline_frames call would break things. Fortunately
6983 that's an extremely unlikely scenario. */
6984 if (!pc_at_non_inline_function (aspace
,
6985 ecs
->event_thread
->stop_pc (),
6987 && !(ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6988 && ecs
->event_thread
->control
.trap_expected
6989 && pc_at_non_inline_function (aspace
,
6990 ecs
->event_thread
->prev_pc
,
6993 stop_chain
= build_bpstat_chain (aspace
,
6994 ecs
->event_thread
->stop_pc (),
6996 skip_inline_frames (ecs
->event_thread
, stop_chain
);
6998 /* Re-fetch current thread's frame in case that invalidated
7000 frame
= get_current_frame ();
7001 gdbarch
= get_frame_arch (frame
);
7005 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
7006 && ecs
->event_thread
->control
.trap_expected
7007 && gdbarch_single_step_through_delay_p (gdbarch
)
7008 && currently_stepping (ecs
->event_thread
))
7010 /* We're trying to step off a breakpoint. Turns out that we're
7011 also on an instruction that needs to be stepped multiple
7012 times before it's been fully executing. E.g., architectures
7013 with a delay slot. It needs to be stepped twice, once for
7014 the instruction and once for the delay slot. */
7015 int step_through_delay
7016 = gdbarch_single_step_through_delay (gdbarch
, frame
);
7018 if (step_through_delay
)
7019 infrun_debug_printf ("step through delay");
7021 if (ecs
->event_thread
->control
.step_range_end
== 0
7022 && step_through_delay
)
7024 /* The user issued a continue when stopped at a breakpoint.
7025 Set up for another trap and get out of here. */
7026 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7030 else if (step_through_delay
)
7032 /* The user issued a step when stopped at a breakpoint.
7033 Maybe we should stop, maybe we should not - the delay
7034 slot *might* correspond to a line of source. In any
7035 case, don't decide that here, just set
7036 ecs->stepping_over_breakpoint, making sure we
7037 single-step again before breakpoints are re-inserted. */
7038 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7042 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
7043 handles this event. */
7044 ecs
->event_thread
->control
.stop_bpstat
7045 = bpstat_stop_status (ecs
->event_thread
->inf
->aspace
.get (),
7046 ecs
->event_thread
->stop_pc (),
7047 ecs
->event_thread
, ecs
->ws
, stop_chain
);
7049 /* Following in case break condition called a
7051 stop_print_frame
= true;
7053 /* This is where we handle "moribund" watchpoints. Unlike
7054 software breakpoints traps, hardware watchpoint traps are
7055 always distinguishable from random traps. If no high-level
7056 watchpoint is associated with the reported stop data address
7057 anymore, then the bpstat does not explain the signal ---
7058 simply make sure to ignore it if `stopped_by_watchpoint' is
7061 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
7062 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
7064 && stopped_by_watchpoint
)
7066 infrun_debug_printf ("no user watchpoint explains watchpoint SIGTRAP, "
7070 /* NOTE: cagney/2003-03-29: These checks for a random signal
7071 at one stage in the past included checks for an inferior
7072 function call's call dummy's return breakpoint. The original
7073 comment, that went with the test, read:
7075 ``End of a stack dummy. Some systems (e.g. Sony news) give
7076 another signal besides SIGTRAP, so check here as well as
7079 If someone ever tries to get call dummys on a
7080 non-executable stack to work (where the target would stop
7081 with something like a SIGSEGV), then those tests might need
7082 to be re-instated. Given, however, that the tests were only
7083 enabled when momentary breakpoints were not being used, I
7084 suspect that it won't be the case.
7086 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
7087 be necessary for call dummies on a non-executable stack on
7090 /* See if the breakpoints module can explain the signal. */
7092 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
7093 ecs
->event_thread
->stop_signal ());
7095 /* Maybe this was a trap for a software breakpoint that has since
7097 if (random_signal
&& target_stopped_by_sw_breakpoint ())
7099 if (gdbarch_program_breakpoint_here_p (gdbarch
,
7100 ecs
->event_thread
->stop_pc ()))
7102 struct regcache
*regcache
;
7105 /* Re-adjust PC to what the program would see if GDB was not
7107 regcache
= get_thread_regcache (ecs
->event_thread
);
7108 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
7111 std::optional
<scoped_restore_tmpl
<int>>
7112 restore_operation_disable
;
7114 if (record_full_is_used ())
7115 restore_operation_disable
.emplace
7116 (record_full_gdb_operation_disable_set ());
7118 regcache_write_pc (regcache
,
7119 ecs
->event_thread
->stop_pc () + decr_pc
);
7124 /* A delayed software breakpoint event. Ignore the trap. */
7125 infrun_debug_printf ("delayed software breakpoint trap, ignoring");
7130 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
7131 has since been removed. */
7132 if (random_signal
&& target_stopped_by_hw_breakpoint ())
7134 /* A delayed hardware breakpoint event. Ignore the trap. */
7135 infrun_debug_printf ("delayed hardware breakpoint/watchpoint "
7140 /* If not, perhaps stepping/nexting can. */
7142 random_signal
= !(ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
7143 && currently_stepping (ecs
->event_thread
));
7145 /* Perhaps the thread hit a single-step breakpoint of _another_
7146 thread. Single-step breakpoints are transparent to the
7147 breakpoints module. */
7149 random_signal
= !ecs
->hit_singlestep_breakpoint
;
7151 /* No? Perhaps we got a moribund watchpoint. */
7153 random_signal
= !stopped_by_watchpoint
;
7155 /* Always stop if the user explicitly requested this thread to
7157 if (ecs
->event_thread
->stop_requested
)
7160 infrun_debug_printf ("user-requested stop");
7163 /* For the program's own signals, act according to
7164 the signal handling tables. */
7168 /* Signal not for debugging purposes. */
7169 enum gdb_signal stop_signal
= ecs
->event_thread
->stop_signal ();
7171 infrun_debug_printf ("random signal (%s)",
7172 gdb_signal_to_symbol_string (stop_signal
));
7174 stopped_by_random_signal
= 1;
7176 /* Always stop on signals if we're either just gaining control
7177 of the program, or the user explicitly requested this thread
7178 to remain stopped. */
7179 if (stop_soon
!= NO_STOP_QUIETLY
7180 || ecs
->event_thread
->stop_requested
7181 || signal_stop_state (ecs
->event_thread
->stop_signal ()))
7187 /* Notify observers the signal has "handle print" set. Note we
7188 returned early above if stopping; normal_stop handles the
7189 printing in that case. */
7190 if (signal_print
[ecs
->event_thread
->stop_signal ()])
7192 /* The signal table tells us to print about this signal. */
7193 target_terminal::ours_for_output ();
7194 notify_signal_received (ecs
->event_thread
->stop_signal ());
7195 target_terminal::inferior ();
7198 /* Clear the signal if it should not be passed. */
7199 if (signal_program
[ecs
->event_thread
->stop_signal ()] == 0)
7200 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
7202 if (ecs
->event_thread
->prev_pc
== ecs
->event_thread
->stop_pc ()
7203 && ecs
->event_thread
->control
.trap_expected
7204 && ecs
->event_thread
->control
.step_resume_breakpoint
== nullptr)
7206 /* We were just starting a new sequence, attempting to
7207 single-step off of a breakpoint and expecting a SIGTRAP.
7208 Instead this signal arrives. This signal will take us out
7209 of the stepping range so GDB needs to remember to, when
7210 the signal handler returns, resume stepping off that
7212 /* To simplify things, "continue" is forced to use the same
7213 code paths as single-step - set a breakpoint at the
7214 signal return address and then, once hit, step off that
7216 infrun_debug_printf ("signal arrived while stepping over breakpoint");
7218 insert_hp_step_resume_breakpoint_at_frame (frame
);
7219 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
7220 /* Reset trap_expected to ensure breakpoints are re-inserted. */
7221 ecs
->event_thread
->control
.trap_expected
= 0;
7223 /* If we were nexting/stepping some other thread, switch to
7224 it, so that we don't continue it, losing control. */
7225 if (!switch_back_to_stepped_thread (ecs
))
7230 if (ecs
->event_thread
->stop_signal () != GDB_SIGNAL_0
7231 && (pc_in_thread_step_range (ecs
->event_thread
->stop_pc (),
7233 || ecs
->event_thread
->control
.step_range_end
== 1)
7234 && (get_stack_frame_id (frame
)
7235 == ecs
->event_thread
->control
.step_stack_frame_id
)
7236 && ecs
->event_thread
->control
.step_resume_breakpoint
== nullptr)
7238 /* The inferior is about to take a signal that will take it
7239 out of the single step range. Set a breakpoint at the
7240 current PC (which is presumably where the signal handler
7241 will eventually return) and then allow the inferior to
7244 Note that this is only needed for a signal delivered
7245 while in the single-step range. Nested signals aren't a
7246 problem as they eventually all return. */
7247 infrun_debug_printf ("signal may take us out of single-step range");
7249 clear_step_over_info ();
7250 insert_hp_step_resume_breakpoint_at_frame (frame
);
7251 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
7252 /* Reset trap_expected to ensure breakpoints are re-inserted. */
7253 ecs
->event_thread
->control
.trap_expected
= 0;
7258 /* Note: step_resume_breakpoint may be non-NULL. This occurs
7259 when either there's a nested signal, or when there's a
7260 pending signal enabled just as the signal handler returns
7261 (leaving the inferior at the step-resume-breakpoint without
7262 actually executing it). Either way continue until the
7263 breakpoint is really hit. */
7265 if (!switch_back_to_stepped_thread (ecs
))
7267 infrun_debug_printf ("random signal, keep going");
7274 process_event_stop_test (ecs
);
7277 /* Come here when we've got some debug event / signal we can explain
7278 (IOW, not a random signal), and test whether it should cause a
7279 stop, or whether we should resume the inferior (transparently).
7280 E.g., could be a breakpoint whose condition evaluates false; we
7281 could be still stepping within the line; etc. */
7284 process_event_stop_test (struct execution_control_state
*ecs
)
7286 struct symtab_and_line stop_pc_sal
;
7287 frame_info_ptr frame
;
7288 struct gdbarch
*gdbarch
;
7289 CORE_ADDR jmp_buf_pc
;
7290 struct bpstat_what what
;
7292 /* Handle cases caused by hitting a breakpoint. */
7294 frame
= get_current_frame ();
7295 gdbarch
= get_frame_arch (frame
);
7297 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
7299 if (what
.call_dummy
)
7301 stop_stack_dummy
= what
.call_dummy
;
7304 /* A few breakpoint types have callbacks associated (e.g.,
7305 bp_jit_event). Run them now. */
7306 bpstat_run_callbacks (ecs
->event_thread
->control
.stop_bpstat
);
7308 /* If we hit an internal event that triggers symbol changes, the
7309 current frame will be invalidated within bpstat_what (e.g., if we
7310 hit an internal solib event). Re-fetch it. */
7311 frame
= get_current_frame ();
7312 gdbarch
= get_frame_arch (frame
);
7314 /* Shorthand to make if statements smaller. */
7315 struct frame_id original_frame_id
7316 = ecs
->event_thread
->control
.step_frame_id
;
7317 struct frame_id curr_frame_id
= get_frame_id (get_current_frame ());
7319 switch (what
.main_action
)
7321 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
7322 /* If we hit the breakpoint at longjmp while stepping, we
7323 install a momentary breakpoint at the target of the
7326 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME");
7328 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7330 if (what
.is_longjmp
)
7332 struct value
*arg_value
;
7334 /* If we set the longjmp breakpoint via a SystemTap probe,
7335 then use it to extract the arguments. The destination PC
7336 is the third argument to the probe. */
7337 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
7340 jmp_buf_pc
= value_as_address (arg_value
);
7341 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
7343 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
7344 || !gdbarch_get_longjmp_target (gdbarch
,
7345 frame
, &jmp_buf_pc
))
7347 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME "
7348 "(!gdbarch_get_longjmp_target)");
7353 /* Insert a breakpoint at resume address. */
7354 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
7357 check_exception_resume (ecs
, frame
);
7361 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
7363 frame_info_ptr init_frame
;
7365 /* There are several cases to consider.
7367 1. The initiating frame no longer exists. In this case we
7368 must stop, because the exception or longjmp has gone too
7371 2. The initiating frame exists, and is the same as the
7372 current frame. We stop, because the exception or longjmp
7375 3. The initiating frame exists and is different from the
7376 current frame. This means the exception or longjmp has
7377 been caught beneath the initiating frame, so keep going.
7379 4. longjmp breakpoint has been placed just to protect
7380 against stale dummy frames and user is not interested in
7381 stopping around longjmps. */
7383 infrun_debug_printf ("BPSTAT_WHAT_CLEAR_LONGJMP_RESUME");
7385 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
7387 delete_exception_resume_breakpoint (ecs
->event_thread
);
7389 if (what
.is_longjmp
)
7391 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
7393 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
7401 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
7405 if (curr_frame_id
== ecs
->event_thread
->initiating_frame
)
7407 /* Case 2. Fall through. */
7417 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
7419 delete_step_resume_breakpoint (ecs
->event_thread
);
7421 end_stepping_range (ecs
);
7425 case BPSTAT_WHAT_SINGLE
:
7426 infrun_debug_printf ("BPSTAT_WHAT_SINGLE");
7427 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7428 /* Still need to check other stuff, at least the case where we
7429 are stepping and step out of the right range. */
7432 case BPSTAT_WHAT_STEP_RESUME
:
7433 infrun_debug_printf ("BPSTAT_WHAT_STEP_RESUME");
7435 delete_step_resume_breakpoint (ecs
->event_thread
);
7436 if (ecs
->event_thread
->control
.proceed_to_finish
7437 && execution_direction
== EXEC_REVERSE
)
7439 struct thread_info
*tp
= ecs
->event_thread
;
7441 /* We are finishing a function in reverse, and just hit the
7442 step-resume breakpoint at the start address of the
7443 function, and we're almost there -- just need to back up
7444 by one more single-step, which should take us back to the
7446 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
7450 fill_in_stop_func (gdbarch
, ecs
);
7451 if (ecs
->event_thread
->stop_pc () == ecs
->stop_func_start
7452 && execution_direction
== EXEC_REVERSE
)
7454 /* We are stepping over a function call in reverse, and just
7455 hit the step-resume breakpoint at the start address of
7456 the function. Go back to single-stepping, which should
7457 take us back to the function call. */
7458 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7464 case BPSTAT_WHAT_STOP_NOISY
:
7465 infrun_debug_printf ("BPSTAT_WHAT_STOP_NOISY");
7466 stop_print_frame
= true;
7468 /* Assume the thread stopped for a breakpoint. We'll still check
7469 whether a/the breakpoint is there when the thread is next
7471 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7476 case BPSTAT_WHAT_STOP_SILENT
:
7477 infrun_debug_printf ("BPSTAT_WHAT_STOP_SILENT");
7478 stop_print_frame
= false;
7480 /* Assume the thread stopped for a breakpoint. We'll still check
7481 whether a/the breakpoint is there when the thread is next
7483 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7487 case BPSTAT_WHAT_HP_STEP_RESUME
:
7488 infrun_debug_printf ("BPSTAT_WHAT_HP_STEP_RESUME");
7490 delete_step_resume_breakpoint (ecs
->event_thread
);
7491 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
7493 /* Back when the step-resume breakpoint was inserted, we
7494 were trying to single-step off a breakpoint. Go back to
7496 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
7497 ecs
->event_thread
->stepping_over_breakpoint
= 1;
7503 case BPSTAT_WHAT_KEEP_CHECKING
:
7507 /* If we stepped a permanent breakpoint and we had a high priority
7508 step-resume breakpoint for the address we stepped, but we didn't
7509 hit it, then we must have stepped into the signal handler. The
7510 step-resume was only necessary to catch the case of _not_
7511 stepping into the handler, so delete it, and fall through to
7512 checking whether the step finished. */
7513 if (ecs
->event_thread
->stepped_breakpoint
)
7515 struct breakpoint
*sr_bp
7516 = ecs
->event_thread
->control
.step_resume_breakpoint
;
7518 if (sr_bp
!= nullptr
7519 && sr_bp
->first_loc ().permanent
7520 && sr_bp
->type
== bp_hp_step_resume
7521 && sr_bp
->first_loc ().address
== ecs
->event_thread
->prev_pc
)
7523 infrun_debug_printf ("stepped permanent breakpoint, stopped in handler");
7524 delete_step_resume_breakpoint (ecs
->event_thread
);
7525 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
7529 /* We come here if we hit a breakpoint but should not stop for it.
7530 Possibly we also were stepping and should stop for that. So fall
7531 through and test for stepping. But, if not stepping, do not
7534 /* In all-stop mode, if we're currently stepping but have stopped in
7535 some other thread, we need to switch back to the stepped thread. */
7536 if (switch_back_to_stepped_thread (ecs
))
7539 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
7541 infrun_debug_printf ("step-resume breakpoint is inserted");
7543 /* Having a step-resume breakpoint overrides anything
7544 else having to do with stepping commands until
7545 that breakpoint is reached. */
7550 if (ecs
->event_thread
->control
.step_range_end
== 0)
7552 infrun_debug_printf ("no stepping, continue");
7553 /* Likewise if we aren't even stepping. */
7558 /* Re-fetch current thread's frame in case the code above caused
7559 the frame cache to be re-initialized, making our FRAME variable
7560 a dangling pointer. */
7561 frame
= get_current_frame ();
7562 gdbarch
= get_frame_arch (frame
);
7563 fill_in_stop_func (gdbarch
, ecs
);
7565 /* If stepping through a line, keep going if still within it.
7567 Note that step_range_end is the address of the first instruction
7568 beyond the step range, and NOT the address of the last instruction
7571 Note also that during reverse execution, we may be stepping
7572 through a function epilogue and therefore must detect when
7573 the current-frame changes in the middle of a line. */
7575 if (pc_in_thread_step_range (ecs
->event_thread
->stop_pc (),
7577 && (execution_direction
!= EXEC_REVERSE
7578 || curr_frame_id
== original_frame_id
))
7581 ("stepping inside range [%s-%s]",
7582 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
7583 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
7585 /* Tentatively re-enable range stepping; `resume' disables it if
7586 necessary (e.g., if we're stepping over a breakpoint or we
7587 have software watchpoints). */
7588 ecs
->event_thread
->control
.may_range_step
= 1;
7590 /* When stepping backward, stop at beginning of line range
7591 (unless it's the function entry point, in which case
7592 keep going back to the call point). */
7593 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
7594 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
7595 && stop_pc
!= ecs
->stop_func_start
7596 && execution_direction
== EXEC_REVERSE
)
7597 end_stepping_range (ecs
);
7604 /* We stepped out of the stepping range. */
7606 /* If we are stepping at the source level and entered the runtime
7607 loader dynamic symbol resolution code...
7609 EXEC_FORWARD: we keep on single stepping until we exit the run
7610 time loader code and reach the callee's address.
7612 EXEC_REVERSE: we've already executed the callee (backward), and
7613 the runtime loader code is handled just like any other
7614 undebuggable function call. Now we need only keep stepping
7615 backward through the trampoline code, and that's handled further
7616 down, so there is nothing for us to do here. */
7618 if (execution_direction
!= EXEC_REVERSE
7619 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7620 && in_solib_dynsym_resolve_code (ecs
->event_thread
->stop_pc ())
7621 && (ecs
->event_thread
->control
.step_start_function
== nullptr
7622 || !in_solib_dynsym_resolve_code (
7623 ecs
->event_thread
->control
.step_start_function
->value_block ()
7626 CORE_ADDR pc_after_resolver
=
7627 gdbarch_skip_solib_resolver (gdbarch
, ecs
->event_thread
->stop_pc ());
7629 infrun_debug_printf ("stepped into dynsym resolve code");
7631 if (pc_after_resolver
)
7633 /* Set up a step-resume breakpoint at the address
7634 indicated by SKIP_SOLIB_RESOLVER. */
7635 symtab_and_line sr_sal
;
7636 sr_sal
.pc
= pc_after_resolver
;
7637 sr_sal
.pspace
= get_frame_program_space (frame
);
7639 insert_step_resume_breakpoint_at_sal (gdbarch
,
7640 sr_sal
, null_frame_id
);
7647 /* Step through an indirect branch thunk. */
7648 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
7649 && gdbarch_in_indirect_branch_thunk (gdbarch
,
7650 ecs
->event_thread
->stop_pc ()))
7652 infrun_debug_printf ("stepped into indirect branch thunk");
7657 if (ecs
->event_thread
->control
.step_range_end
!= 1
7658 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7659 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
7660 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
7662 infrun_debug_printf ("stepped into signal trampoline");
7663 /* The inferior, while doing a "step" or "next", has ended up in
7664 a signal trampoline (either by a signal being delivered or by
7665 the signal handler returning). Just single-step until the
7666 inferior leaves the trampoline (either by calling the handler
7672 /* If we're in the return path from a shared library trampoline,
7673 we want to proceed through the trampoline when stepping. */
7674 /* macro/2012-04-25: This needs to come before the subroutine
7675 call check below as on some targets return trampolines look
7676 like subroutine calls (MIPS16 return thunks). */
7677 if (gdbarch_in_solib_return_trampoline (gdbarch
,
7678 ecs
->event_thread
->stop_pc (),
7679 ecs
->stop_func_name
)
7680 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
7682 /* Determine where this trampoline returns. */
7683 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
7684 CORE_ADDR real_stop_pc
7685 = gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
7687 infrun_debug_printf ("stepped into solib return tramp");
7689 /* Only proceed through if we know where it's going. */
7692 /* And put the step-breakpoint there and go until there. */
7693 symtab_and_line sr_sal
;
7694 sr_sal
.pc
= real_stop_pc
;
7695 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7696 sr_sal
.pspace
= get_frame_program_space (frame
);
7698 /* Do not specify what the fp should be when we stop since
7699 on some machines the prologue is where the new fp value
7701 insert_step_resume_breakpoint_at_sal (gdbarch
,
7702 sr_sal
, null_frame_id
);
7704 /* Restart without fiddling with the step ranges or
7711 /* Check for subroutine calls. The check for the current frame
7712 equalling the step ID is not necessary - the check of the
7713 previous frame's ID is sufficient - but it is a common case and
7714 cheaper than checking the previous frame's ID.
7716 NOTE: frame_id::operator== will never report two invalid frame IDs as
7717 being equal, so to get into this block, both the current and
7718 previous frame must have valid frame IDs. */
7719 /* The outer_frame_id check is a heuristic to detect stepping
7720 through startup code. If we step over an instruction which
7721 sets the stack pointer from an invalid value to a valid value,
7722 we may detect that as a subroutine call from the mythical
7723 "outermost" function. This could be fixed by marking
7724 outermost frames as !stack_p,code_p,special_p. Then the
7725 initial outermost frame, before sp was valid, would
7726 have code_addr == &_start. See the comment in frame_id::operator==
7729 /* We want "nexti" to step into, not over, signal handlers invoked
7730 by the kernel, therefore this subroutine check should not trigger
7731 for a signal handler invocation. On most platforms, this is already
7732 not the case, as the kernel puts a signal trampoline frame onto the
7733 stack to handle proper return after the handler, and therefore at this
7734 point, the current frame is a grandchild of the step frame, not a
7735 child. However, on some platforms, the kernel actually uses a
7736 trampoline to handle *invocation* of the handler. In that case,
7737 when executing the first instruction of the trampoline, this check
7738 would erroneously detect the trampoline invocation as a subroutine
7739 call. Fix this by checking for SIGTRAMP_FRAME. */
7740 if ((get_stack_frame_id (frame
)
7741 != ecs
->event_thread
->control
.step_stack_frame_id
)
7742 && get_frame_type (frame
) != SIGTRAMP_FRAME
7743 && ((frame_unwind_caller_id (get_current_frame ())
7744 == ecs
->event_thread
->control
.step_stack_frame_id
)
7745 && ((ecs
->event_thread
->control
.step_stack_frame_id
7747 || (ecs
->event_thread
->control
.step_start_function
7748 != find_pc_function (ecs
->event_thread
->stop_pc ())))))
7750 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
7751 CORE_ADDR real_stop_pc
;
7753 infrun_debug_printf ("stepped into subroutine");
7755 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
7757 /* I presume that step_over_calls is only 0 when we're
7758 supposed to be stepping at the assembly language level
7759 ("stepi"). Just stop. */
7760 /* And this works the same backward as frontward. MVS */
7761 end_stepping_range (ecs
);
7765 /* Reverse stepping through solib trampolines. */
7767 if (execution_direction
== EXEC_REVERSE
7768 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
7769 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
7770 || (ecs
->stop_func_start
== 0
7771 && in_solib_dynsym_resolve_code (stop_pc
))))
7773 /* Any solib trampoline code can be handled in reverse
7774 by simply continuing to single-step. We have already
7775 executed the solib function (backwards), and a few
7776 steps will take us back through the trampoline to the
7782 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
7784 /* We're doing a "next".
7786 Normal (forward) execution: set a breakpoint at the
7787 callee's return address (the address at which the caller
7790 Reverse (backward) execution. set the step-resume
7791 breakpoint at the start of the function that we just
7792 stepped into (backwards), and continue to there. When we
7793 get there, we'll need to single-step back to the caller. */
7795 if (execution_direction
== EXEC_REVERSE
)
7797 /* If we're already at the start of the function, we've either
7798 just stepped backward into a single instruction function,
7799 or stepped back out of a signal handler to the first instruction
7800 of the function. Just keep going, which will single-step back
7802 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
7804 /* Normal function call return (static or dynamic). */
7805 symtab_and_line sr_sal
;
7806 sr_sal
.pc
= ecs
->stop_func_start
;
7807 sr_sal
.pspace
= get_frame_program_space (frame
);
7808 insert_step_resume_breakpoint_at_sal (gdbarch
,
7809 sr_sal
, get_stack_frame_id (frame
));
7813 insert_step_resume_breakpoint_at_caller (frame
);
7819 /* If we are in a function call trampoline (a stub between the
7820 calling routine and the real function), locate the real
7821 function. That's what tells us (a) whether we want to step
7822 into it at all, and (b) what prologue we want to run to the
7823 end of, if we do step into it. */
7824 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
7825 if (real_stop_pc
== 0)
7826 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
7827 if (real_stop_pc
!= 0)
7828 ecs
->stop_func_start
= real_stop_pc
;
7830 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
7832 symtab_and_line sr_sal
;
7833 sr_sal
.pc
= ecs
->stop_func_start
;
7834 sr_sal
.pspace
= get_frame_program_space (frame
);
7836 insert_step_resume_breakpoint_at_sal (gdbarch
,
7837 sr_sal
, null_frame_id
);
7842 /* If we have line number information for the function we are
7843 thinking of stepping into and the function isn't on the skip
7846 If there are several symtabs at that PC (e.g. with include
7847 files), just want to know whether *any* of them have line
7848 numbers. find_pc_line handles this. */
7850 struct symtab_and_line tmp_sal
;
7852 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
7853 if (tmp_sal
.line
!= 0
7854 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
7856 && !inline_frame_is_marked_for_skip (true, ecs
->event_thread
))
7858 if (execution_direction
== EXEC_REVERSE
)
7859 handle_step_into_function_backward (gdbarch
, ecs
);
7861 handle_step_into_function (gdbarch
, ecs
);
7866 /* If we have no line number and the step-stop-if-no-debug is
7867 set, we stop the step so that the user has a chance to switch
7868 in assembly mode. */
7869 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7870 && step_stop_if_no_debug
)
7872 end_stepping_range (ecs
);
7876 if (execution_direction
== EXEC_REVERSE
)
7878 /* If we're already at the start of the function, we've either just
7879 stepped backward into a single instruction function without line
7880 number info, or stepped back out of a signal handler to the first
7881 instruction of the function without line number info. Just keep
7882 going, which will single-step back to the caller. */
7883 if (ecs
->stop_func_start
!= stop_pc
)
7885 /* Set a breakpoint at callee's start address.
7886 From there we can step once and be back in the caller. */
7887 symtab_and_line sr_sal
;
7888 sr_sal
.pc
= ecs
->stop_func_start
;
7889 sr_sal
.pspace
= get_frame_program_space (frame
);
7890 insert_step_resume_breakpoint_at_sal (gdbarch
,
7891 sr_sal
, null_frame_id
);
7895 /* Set a breakpoint at callee's return address (the address
7896 at which the caller will resume). */
7897 insert_step_resume_breakpoint_at_caller (frame
);
7903 /* Reverse stepping through solib trampolines. */
7905 if (execution_direction
== EXEC_REVERSE
7906 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
7908 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
7910 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
7911 || (ecs
->stop_func_start
== 0
7912 && in_solib_dynsym_resolve_code (stop_pc
)))
7914 /* Any solib trampoline code can be handled in reverse
7915 by simply continuing to single-step. We have already
7916 executed the solib function (backwards), and a few
7917 steps will take us back through the trampoline to the
7922 else if (in_solib_dynsym_resolve_code (stop_pc
))
7924 /* Stepped backward into the solib dynsym resolver.
7925 Set a breakpoint at its start and continue, then
7926 one more step will take us out. */
7927 symtab_and_line sr_sal
;
7928 sr_sal
.pc
= ecs
->stop_func_start
;
7929 sr_sal
.pspace
= get_frame_program_space (frame
);
7930 insert_step_resume_breakpoint_at_sal (gdbarch
,
7931 sr_sal
, null_frame_id
);
7937 /* This always returns the sal for the inner-most frame when we are in a
7938 stack of inlined frames, even if GDB actually believes that it is in a
7939 more outer frame. This is checked for below by calls to
7940 inline_skipped_frames. */
7941 stop_pc_sal
= find_pc_line (ecs
->event_thread
->stop_pc (), 0);
7943 /* NOTE: tausq/2004-05-24: This if block used to be done before all
7944 the trampoline processing logic, however, there are some trampolines
7945 that have no names, so we should do trampoline handling first. */
7946 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7947 && ecs
->stop_func_name
== nullptr
7948 && stop_pc_sal
.line
== 0)
7950 infrun_debug_printf ("stepped into undebuggable function");
7952 /* The inferior just stepped into, or returned to, an
7953 undebuggable function (where there is no debugging information
7954 and no line number corresponding to the address where the
7955 inferior stopped). Since we want to skip this kind of code,
7956 we keep going until the inferior returns from this
7957 function - unless the user has asked us not to (via
7958 set step-mode) or we no longer know how to get back
7959 to the call site. */
7960 if (step_stop_if_no_debug
7961 || !frame_id_p (frame_unwind_caller_id (frame
)))
7963 /* If we have no line number and the step-stop-if-no-debug
7964 is set, we stop the step so that the user has a chance to
7965 switch in assembly mode. */
7966 end_stepping_range (ecs
);
7971 /* Set a breakpoint at callee's return address (the address
7972 at which the caller will resume). */
7973 insert_step_resume_breakpoint_at_caller (frame
);
7979 if (execution_direction
== EXEC_REVERSE
7980 && ecs
->event_thread
->control
.proceed_to_finish
7981 && ecs
->event_thread
->stop_pc () >= ecs
->stop_func_alt_start
7982 && ecs
->event_thread
->stop_pc () < ecs
->stop_func_start
)
7984 /* We are executing the reverse-finish command.
7985 If the system supports multiple entry points and we are finishing a
7986 function in reverse. If we are between the entry points single-step
7987 back to the alternate entry point. If we are at the alternate entry
7988 point -- just need to back up by one more single-step, which
7989 should take us back to the function call. */
7990 ecs
->event_thread
->control
.step_range_start
7991 = ecs
->event_thread
->control
.step_range_end
= 1;
7997 if (ecs
->event_thread
->control
.step_range_end
== 1)
7999 /* It is stepi or nexti. We always want to stop stepping after
8001 infrun_debug_printf ("stepi/nexti");
8002 end_stepping_range (ecs
);
8006 if (stop_pc_sal
.line
== 0)
8008 /* We have no line number information. That means to stop
8009 stepping (does this always happen right after one instruction,
8010 when we do "s" in a function with no line numbers,
8011 or can this happen as a result of a return or longjmp?). */
8012 infrun_debug_printf ("line number info");
8013 end_stepping_range (ecs
);
8017 /* Look for "calls" to inlined functions, part one. If the inline
8018 frame machinery detected some skipped call sites, we have entered
8019 a new inline function. */
8021 if ((curr_frame_id
== original_frame_id
)
8022 && inline_skipped_frames (ecs
->event_thread
))
8024 infrun_debug_printf ("stepped into inlined function");
8026 symtab_and_line call_sal
= find_frame_sal (get_current_frame ());
8028 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
8030 /* For "step", we're going to stop. But if the call site
8031 for this inlined function is on the same source line as
8032 we were previously stepping, go down into the function
8033 first. Otherwise stop at the call site. */
8035 if (call_sal
.line
== ecs
->event_thread
->current_line
8036 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
8038 step_into_inline_frame (ecs
->event_thread
);
8039 if (inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
8046 end_stepping_range (ecs
);
8051 /* For "next", we should stop at the call site if it is on a
8052 different source line. Otherwise continue through the
8053 inlined function. */
8054 if (call_sal
.line
== ecs
->event_thread
->current_line
8055 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
8058 end_stepping_range (ecs
);
8063 /* Look for "calls" to inlined functions, part two. If we are still
8064 in the same real function we were stepping through, but we have
8065 to go further up to find the exact frame ID, we are stepping
8066 through a more inlined call beyond its call site. */
8068 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
8069 && (curr_frame_id
!= original_frame_id
)
8070 && stepped_in_from (get_current_frame (), original_frame_id
))
8072 infrun_debug_printf ("stepping through inlined function");
8074 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
8075 || inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
8078 end_stepping_range (ecs
);
8082 bool refresh_step_info
= true;
8083 if ((ecs
->event_thread
->stop_pc () == stop_pc_sal
.pc
)
8084 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
8085 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
8087 /* We are at a different line. */
8089 if (stop_pc_sal
.is_stmt
)
8091 /* We are at the start of a statement.
8093 So stop. Note that we don't stop if we step into the middle of a
8094 statement. That is said to make things like for (;;) statements
8096 infrun_debug_printf ("stepped to a different line");
8097 end_stepping_range (ecs
);
8100 else if (curr_frame_id
== original_frame_id
)
8102 /* We are not at the start of a statement, and we have not changed
8105 We ignore this line table entry, and continue stepping forward,
8106 looking for a better place to stop. */
8107 refresh_step_info
= false;
8108 infrun_debug_printf ("stepped to a different line, but "
8109 "it's not the start of a statement");
8113 /* We are not the start of a statement, and we have changed frame.
8115 We ignore this line table entry, and continue stepping forward,
8116 looking for a better place to stop. Keep refresh_step_info at
8117 true to note that the frame has changed, but ignore the line
8118 number to make sure we don't ignore a subsequent entry with the
8119 same line number. */
8120 stop_pc_sal
.line
= 0;
8121 infrun_debug_printf ("stepped to a different frame, but "
8122 "it's not the start of a statement");
8125 else if (execution_direction
== EXEC_REVERSE
8126 && curr_frame_id
!= original_frame_id
8127 && original_frame_id
.code_addr_p
&& curr_frame_id
.code_addr_p
8128 && original_frame_id
.code_addr
== curr_frame_id
.code_addr
)
8130 /* If we enter here, we're leaving a recursive function call. In this
8131 situation, we shouldn't refresh the step information, because if we
8132 do, we'll lose the frame_id of when we started stepping, and this
8133 will make GDB not know we need to print frame information. */
8134 refresh_step_info
= false;
8135 infrun_debug_printf ("reverse stepping, left a recursive call, don't "
8136 "update step info so we remember we left a frame");
8139 /* We aren't done stepping.
8141 Optimize by setting the stepping range to the line.
8142 (We might not be in the original line, but if we entered a
8143 new line in mid-statement, we continue stepping. This makes
8144 things like for(;;) statements work better.)
8146 If we entered a SAL that indicates a non-statement line table entry,
8147 then we update the stepping range, but we don't update the step info,
8148 which includes things like the line number we are stepping away from.
8149 This means we will stop when we find a line table entry that is marked
8150 as is-statement, even if it matches the non-statement one we just
8153 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
8154 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
8155 ecs
->event_thread
->control
.may_range_step
= 1;
8157 ("updated step range, start = %s, end = %s, may_range_step = %d",
8158 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
8159 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
),
8160 ecs
->event_thread
->control
.may_range_step
);
8161 if (refresh_step_info
)
8162 set_step_info (ecs
->event_thread
, frame
, stop_pc_sal
);
8164 infrun_debug_printf ("keep going");
8168 static bool restart_stepped_thread (process_stratum_target
*resume_target
,
8169 ptid_t resume_ptid
);
8171 /* In all-stop mode, if we're currently stepping but have stopped in
8172 some other thread, we may need to switch back to the stepped
8173 thread. Returns true we set the inferior running, false if we left
8174 it stopped (and the event needs further processing). */
8177 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
8179 if (!target_is_non_stop_p ())
8181 /* If any thread is blocked on some internal breakpoint, and we
8182 simply need to step over that breakpoint to get it going
8183 again, do that first. */
8185 /* However, if we see an event for the stepping thread, then we
8186 know all other threads have been moved past their breakpoints
8187 already. Let the caller check whether the step is finished,
8188 etc., before deciding to move it past a breakpoint. */
8189 if (ecs
->event_thread
->control
.step_range_end
!= 0)
8192 /* Check if the current thread is blocked on an incomplete
8193 step-over, interrupted by a random signal. */
8194 if (ecs
->event_thread
->control
.trap_expected
8195 && ecs
->event_thread
->stop_signal () != GDB_SIGNAL_TRAP
)
8198 ("need to finish step-over of [%s]",
8199 ecs
->event_thread
->ptid
.to_string ().c_str ());
8204 /* Check if the current thread is blocked by a single-step
8205 breakpoint of another thread. */
8206 if (ecs
->hit_singlestep_breakpoint
)
8208 infrun_debug_printf ("need to step [%s] over single-step breakpoint",
8209 ecs
->ptid
.to_string ().c_str ());
8214 /* If this thread needs yet another step-over (e.g., stepping
8215 through a delay slot), do it first before moving on to
8217 if (thread_still_needs_step_over (ecs
->event_thread
))
8220 ("thread [%s] still needs step-over",
8221 ecs
->event_thread
->ptid
.to_string ().c_str ());
8226 /* If scheduler locking applies even if not stepping, there's no
8227 need to walk over threads. Above we've checked whether the
8228 current thread is stepping. If some other thread not the
8229 event thread is stepping, then it must be that scheduler
8230 locking is not in effect. */
8231 if (schedlock_applies (ecs
->event_thread
))
8234 /* Otherwise, we no longer expect a trap in the current thread.
8235 Clear the trap_expected flag before switching back -- this is
8236 what keep_going does as well, if we call it. */
8237 ecs
->event_thread
->control
.trap_expected
= 0;
8239 /* Likewise, clear the signal if it should not be passed. */
8240 if (!signal_program
[ecs
->event_thread
->stop_signal ()])
8241 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
8243 if (restart_stepped_thread (ecs
->target
, ecs
->ptid
))
8245 prepare_to_wait (ecs
);
8249 switch_to_thread (ecs
->event_thread
);
8255 /* Look for the thread that was stepping, and resume it.
8256 RESUME_TARGET / RESUME_PTID indicate the set of threads the caller
8257 is resuming. Return true if a thread was started, false
8261 restart_stepped_thread (process_stratum_target
*resume_target
,
8264 /* Do all pending step-overs before actually proceeding with
8266 if (start_step_over ())
8269 for (thread_info
*tp
: all_threads_safe ())
8271 if (tp
->state
== THREAD_EXITED
)
8274 if (tp
->has_pending_waitstatus ())
8277 /* Ignore threads of processes the caller is not
8280 && (tp
->inf
->process_target () != resume_target
8281 || tp
->inf
->pid
!= resume_ptid
.pid ()))
8284 if (tp
->control
.trap_expected
)
8286 infrun_debug_printf ("switching back to stepped thread (step-over)");
8288 if (keep_going_stepped_thread (tp
))
8293 for (thread_info
*tp
: all_threads_safe ())
8295 if (tp
->state
== THREAD_EXITED
)
8298 if (tp
->has_pending_waitstatus ())
8301 /* Ignore threads of processes the caller is not
8304 && (tp
->inf
->process_target () != resume_target
8305 || tp
->inf
->pid
!= resume_ptid
.pid ()))
8308 /* Did we find the stepping thread? */
8309 if (tp
->control
.step_range_end
)
8311 infrun_debug_printf ("switching back to stepped thread (stepping)");
8313 if (keep_going_stepped_thread (tp
))
8324 restart_after_all_stop_detach (process_stratum_target
*proc_target
)
8326 /* Note we don't check target_is_non_stop_p() here, because the
8327 current inferior may no longer have a process_stratum target
8328 pushed, as we just detached. */
8330 /* See if we have a THREAD_RUNNING thread that need to be
8331 re-resumed. If we have any thread that is already executing,
8332 then we don't need to resume the target -- it is already been
8333 resumed. With the remote target (in all-stop), it's even
8334 impossible to issue another resumption if the target is already
8335 resumed, until the target reports a stop. */
8336 for (thread_info
*thr
: all_threads (proc_target
))
8338 if (thr
->state
!= THREAD_RUNNING
)
8341 /* If we have any thread that is already executing, then we
8342 don't need to resume the target -- it is already been
8344 if (thr
->executing ())
8347 /* If we have a pending event to process, skip resuming the
8348 target and go straight to processing it. */
8349 if (thr
->resumed () && thr
->has_pending_waitstatus ())
8353 /* Alright, we need to re-resume the target. If a thread was
8354 stepping, we need to restart it stepping. */
8355 if (restart_stepped_thread (proc_target
, minus_one_ptid
))
8358 /* Otherwise, find the first THREAD_RUNNING thread and resume
8360 for (thread_info
*thr
: all_threads (proc_target
))
8362 if (thr
->state
!= THREAD_RUNNING
)
8365 execution_control_state
ecs (thr
);
8366 switch_to_thread (thr
);
8372 /* Set a previously stepped thread back to stepping. Returns true on
8373 success, false if the resume is not possible (e.g., the thread
8377 keep_going_stepped_thread (struct thread_info
*tp
)
8379 frame_info_ptr frame
;
8381 /* If the stepping thread exited, then don't try to switch back and
8382 resume it, which could fail in several different ways depending
8383 on the target. Instead, just keep going.
8385 We can find a stepping dead thread in the thread list in two
8388 - The target supports thread exit events, and when the target
8389 tries to delete the thread from the thread list, inferior_ptid
8390 pointed at the exiting thread. In such case, calling
8391 delete_thread does not really remove the thread from the list;
8392 instead, the thread is left listed, with 'exited' state.
8394 - The target's debug interface does not support thread exit
8395 events, and so we have no idea whatsoever if the previously
8396 stepping thread is still alive. For that reason, we need to
8397 synchronously query the target now. */
8399 if (tp
->state
== THREAD_EXITED
|| !target_thread_alive (tp
->ptid
))
8401 infrun_debug_printf ("not resuming previously stepped thread, it has "
8408 infrun_debug_printf ("resuming previously stepped thread");
8410 execution_control_state
ecs (tp
);
8411 switch_to_thread (tp
);
8413 tp
->set_stop_pc (regcache_read_pc (get_thread_regcache (tp
)));
8414 frame
= get_current_frame ();
8416 /* If the PC of the thread we were trying to single-step has
8417 changed, then that thread has trapped or been signaled, but the
8418 event has not been reported to GDB yet. Re-poll the target
8419 looking for this particular thread's event (i.e. temporarily
8420 enable schedlock) by:
8422 - setting a break at the current PC
8423 - resuming that particular thread, only (by setting trap
8426 This prevents us continuously moving the single-step breakpoint
8427 forward, one instruction at a time, overstepping. */
8429 if (tp
->stop_pc () != tp
->prev_pc
)
8433 infrun_debug_printf ("expected thread advanced also (%s -> %s)",
8434 paddress (current_inferior ()->arch (), tp
->prev_pc
),
8435 paddress (current_inferior ()->arch (),
8438 /* Clear the info of the previous step-over, as it's no longer
8439 valid (if the thread was trying to step over a breakpoint, it
8440 has already succeeded). It's what keep_going would do too,
8441 if we called it. Do this before trying to insert the sss
8442 breakpoint, otherwise if we were previously trying to step
8443 over this exact address in another thread, the breakpoint is
8445 clear_step_over_info ();
8446 tp
->control
.trap_expected
= 0;
8448 insert_single_step_breakpoint (get_frame_arch (frame
),
8449 get_frame_address_space (frame
),
8452 tp
->set_resumed (true);
8453 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
8454 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
8458 infrun_debug_printf ("expected thread still hasn't advanced");
8460 keep_going_pass_signal (&ecs
);
8466 /* Is thread TP in the middle of (software or hardware)
8467 single-stepping? (Note the result of this function must never be
8468 passed directly as target_resume's STEP parameter.) */
8471 currently_stepping (struct thread_info
*tp
)
8473 return ((tp
->control
.step_range_end
8474 && tp
->control
.step_resume_breakpoint
== nullptr)
8475 || tp
->control
.trap_expected
8476 || tp
->stepped_breakpoint
8477 || bpstat_should_step ());
8480 /* Inferior has stepped into a subroutine call with source code that
8481 we should not step over. Do step to the first line of code in
8485 handle_step_into_function (struct gdbarch
*gdbarch
,
8486 struct execution_control_state
*ecs
)
8488 fill_in_stop_func (gdbarch
, ecs
);
8490 compunit_symtab
*cust
8491 = find_pc_compunit_symtab (ecs
->event_thread
->stop_pc ());
8492 if (cust
!= nullptr && cust
->language () != language_asm
)
8493 ecs
->stop_func_start
8494 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
8496 symtab_and_line stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
8497 /* Use the step_resume_break to step until the end of the prologue,
8498 even if that involves jumps (as it seems to on the vax under
8500 /* If the prologue ends in the middle of a source line, continue to
8501 the end of that source line (if it is still within the function).
8502 Otherwise, just go to end of prologue. */
8503 if (stop_func_sal
.end
8504 && stop_func_sal
.pc
!= ecs
->stop_func_start
8505 && stop_func_sal
.end
< ecs
->stop_func_end
)
8506 ecs
->stop_func_start
= stop_func_sal
.end
;
8508 /* Architectures which require breakpoint adjustment might not be able
8509 to place a breakpoint at the computed address. If so, the test
8510 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
8511 ecs->stop_func_start to an address at which a breakpoint may be
8512 legitimately placed.
8514 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
8515 made, GDB will enter an infinite loop when stepping through
8516 optimized code consisting of VLIW instructions which contain
8517 subinstructions corresponding to different source lines. On
8518 FR-V, it's not permitted to place a breakpoint on any but the
8519 first subinstruction of a VLIW instruction. When a breakpoint is
8520 set, GDB will adjust the breakpoint address to the beginning of
8521 the VLIW instruction. Thus, we need to make the corresponding
8522 adjustment here when computing the stop address. */
8524 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
8526 ecs
->stop_func_start
8527 = gdbarch_adjust_breakpoint_address (gdbarch
,
8528 ecs
->stop_func_start
);
8531 if (ecs
->stop_func_start
== ecs
->event_thread
->stop_pc ())
8533 /* We are already there: stop now. */
8534 end_stepping_range (ecs
);
8539 /* Put the step-breakpoint there and go until there. */
8540 symtab_and_line sr_sal
;
8541 sr_sal
.pc
= ecs
->stop_func_start
;
8542 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
8543 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
8545 /* Do not specify what the fp should be when we stop since on
8546 some machines the prologue is where the new fp value is
8548 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
8550 /* And make sure stepping stops right away then. */
8551 ecs
->event_thread
->control
.step_range_end
8552 = ecs
->event_thread
->control
.step_range_start
;
8557 /* Inferior has stepped backward into a subroutine call with source
8558 code that we should not step over. Do step to the beginning of the
8559 last line of code in it. */
8562 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
8563 struct execution_control_state
*ecs
)
8565 struct compunit_symtab
*cust
;
8566 struct symtab_and_line stop_func_sal
;
8568 fill_in_stop_func (gdbarch
, ecs
);
8570 cust
= find_pc_compunit_symtab (ecs
->event_thread
->stop_pc ());
8571 if (cust
!= nullptr && cust
->language () != language_asm
)
8572 ecs
->stop_func_start
8573 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
8575 stop_func_sal
= find_pc_line (ecs
->event_thread
->stop_pc (), 0);
8577 /* OK, we're just going to keep stepping here. */
8578 if (stop_func_sal
.pc
== ecs
->event_thread
->stop_pc ())
8580 /* We're there already. Just stop stepping now. */
8581 end_stepping_range (ecs
);
8585 /* Else just reset the step range and keep going.
8586 No step-resume breakpoint, they don't work for
8587 epilogues, which can have multiple entry paths. */
8588 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
8589 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
8595 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
8596 This is used to both functions and to skip over code. */
8599 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
8600 struct symtab_and_line sr_sal
,
8601 struct frame_id sr_id
,
8602 enum bptype sr_type
)
8604 /* There should never be more than one step-resume or longjmp-resume
8605 breakpoint per thread, so we should never be setting a new
8606 step_resume_breakpoint when one is already active. */
8607 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== nullptr);
8608 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
8610 infrun_debug_printf ("inserting step-resume breakpoint at %s",
8611 paddress (gdbarch
, sr_sal
.pc
));
8613 inferior_thread ()->control
.step_resume_breakpoint
8614 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
).release ();
8618 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
8619 struct symtab_and_line sr_sal
,
8620 struct frame_id sr_id
)
8622 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
8627 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
8628 This is used to skip a potential signal handler.
8630 This is called with the interrupted function's frame. The signal
8631 handler, when it returns, will resume the interrupted function at
8635 insert_hp_step_resume_breakpoint_at_frame (frame_info_ptr return_frame
)
8637 gdb_assert (return_frame
!= nullptr);
8639 struct gdbarch
*gdbarch
= get_frame_arch (return_frame
);
8641 symtab_and_line sr_sal
;
8642 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
8643 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
8644 sr_sal
.pspace
= get_frame_program_space (return_frame
);
8646 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
8647 get_stack_frame_id (return_frame
),
8651 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
8652 is used to skip a function after stepping into it (for "next" or if
8653 the called function has no debugging information).
8655 The current function has almost always been reached by single
8656 stepping a call or return instruction. NEXT_FRAME belongs to the
8657 current function, and the breakpoint will be set at the caller's
8660 This is a separate function rather than reusing
8661 insert_hp_step_resume_breakpoint_at_frame in order to avoid
8662 get_prev_frame, which may stop prematurely (see the implementation
8663 of frame_unwind_caller_id for an example). */
8666 insert_step_resume_breakpoint_at_caller (frame_info_ptr next_frame
)
8668 /* We shouldn't have gotten here if we don't know where the call site
8670 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
8672 struct gdbarch
*gdbarch
= frame_unwind_caller_arch (next_frame
);
8674 symtab_and_line sr_sal
;
8675 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
8676 frame_unwind_caller_pc (next_frame
));
8677 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
8678 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
8680 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
8681 frame_unwind_caller_id (next_frame
));
8684 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
8685 new breakpoint at the target of a jmp_buf. The handling of
8686 longjmp-resume uses the same mechanisms used for handling
8687 "step-resume" breakpoints. */
8690 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
8692 /* There should never be more than one longjmp-resume breakpoint per
8693 thread, so we should never be setting a new
8694 longjmp_resume_breakpoint when one is already active. */
8695 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== nullptr);
8697 infrun_debug_printf ("inserting longjmp-resume breakpoint at %s",
8698 paddress (gdbarch
, pc
));
8700 inferior_thread ()->control
.exception_resume_breakpoint
=
8701 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
).release ();
8704 /* Insert an exception resume breakpoint. TP is the thread throwing
8705 the exception. The block B is the block of the unwinder debug hook
8706 function. FRAME is the frame corresponding to the call to this
8707 function. SYM is the symbol of the function argument holding the
8708 target PC of the exception. */
8711 insert_exception_resume_breakpoint (struct thread_info
*tp
,
8712 const struct block
*b
,
8713 frame_info_ptr frame
,
8718 struct block_symbol vsym
;
8719 struct value
*value
;
8721 struct breakpoint
*bp
;
8723 vsym
= lookup_symbol_search_name (sym
->search_name (),
8725 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
8726 /* If the value was optimized out, revert to the old behavior. */
8727 if (! value
->optimized_out ())
8729 handler
= value_as_address (value
);
8731 infrun_debug_printf ("exception resume at %lx",
8732 (unsigned long) handler
);
8734 /* set_momentary_breakpoint_at_pc creates a thread-specific
8735 breakpoint for the current inferior thread. */
8736 gdb_assert (tp
== inferior_thread ());
8737 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
8739 bp_exception_resume
).release ();
8741 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
8744 tp
->control
.exception_resume_breakpoint
= bp
;
8747 catch (const gdb_exception_error
&e
)
8749 /* We want to ignore errors here. */
8753 /* A helper for check_exception_resume that sets an
8754 exception-breakpoint based on a SystemTap probe. */
8757 insert_exception_resume_from_probe (struct thread_info
*tp
,
8758 const struct bound_probe
*probe
,
8759 frame_info_ptr frame
)
8761 struct value
*arg_value
;
8763 struct breakpoint
*bp
;
8765 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
8769 handler
= value_as_address (arg_value
);
8771 infrun_debug_printf ("exception resume at %s",
8772 paddress (probe
->objfile
->arch (), handler
));
8774 /* set_momentary_breakpoint_at_pc creates a thread-specific breakpoint
8775 for the current inferior thread. */
8776 gdb_assert (tp
== inferior_thread ());
8777 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
8778 handler
, bp_exception_resume
).release ();
8779 tp
->control
.exception_resume_breakpoint
= bp
;
8782 /* This is called when an exception has been intercepted. Check to
8783 see whether the exception's destination is of interest, and if so,
8784 set an exception resume breakpoint there. */
8787 check_exception_resume (struct execution_control_state
*ecs
,
8788 frame_info_ptr frame
)
8790 struct bound_probe probe
;
8791 struct symbol
*func
;
8793 /* First see if this exception unwinding breakpoint was set via a
8794 SystemTap probe point. If so, the probe has two arguments: the
8795 CFA and the HANDLER. We ignore the CFA, extract the handler, and
8796 set a breakpoint there. */
8797 probe
= find_probe_by_pc (get_frame_pc (frame
));
8800 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
8804 func
= get_frame_function (frame
);
8810 const struct block
*b
;
8813 /* The exception breakpoint is a thread-specific breakpoint on
8814 the unwinder's debug hook, declared as:
8816 void _Unwind_DebugHook (void *cfa, void *handler);
8818 The CFA argument indicates the frame to which control is
8819 about to be transferred. HANDLER is the destination PC.
8821 We ignore the CFA and set a temporary breakpoint at HANDLER.
8822 This is not extremely efficient but it avoids issues in gdb
8823 with computing the DWARF CFA, and it also works even in weird
8824 cases such as throwing an exception from inside a signal
8827 b
= func
->value_block ();
8828 for (struct symbol
*sym
: block_iterator_range (b
))
8830 if (!sym
->is_argument ())
8837 insert_exception_resume_breakpoint (ecs
->event_thread
,
8843 catch (const gdb_exception_error
&e
)
8849 stop_waiting (struct execution_control_state
*ecs
)
8851 infrun_debug_printf ("stop_waiting");
8853 /* Let callers know we don't want to wait for the inferior anymore. */
8854 ecs
->wait_some_more
= 0;
8857 /* Like keep_going, but passes the signal to the inferior, even if the
8858 signal is set to nopass. */
8861 keep_going_pass_signal (struct execution_control_state
*ecs
)
8863 gdb_assert (ecs
->event_thread
->ptid
== inferior_ptid
);
8864 gdb_assert (!ecs
->event_thread
->resumed ());
8866 /* Save the pc before execution, to compare with pc after stop. */
8867 ecs
->event_thread
->prev_pc
8868 = regcache_read_pc_protected (get_thread_regcache (ecs
->event_thread
));
8870 if (ecs
->event_thread
->control
.trap_expected
)
8872 struct thread_info
*tp
= ecs
->event_thread
;
8874 infrun_debug_printf ("%s has trap_expected set, "
8875 "resuming to collect trap",
8876 tp
->ptid
.to_string ().c_str ());
8878 /* We haven't yet gotten our trap, and either: intercepted a
8879 non-signal event (e.g., a fork); or took a signal which we
8880 are supposed to pass through to the inferior. Simply
8882 resume (ecs
->event_thread
->stop_signal ());
8884 else if (step_over_info_valid_p ())
8886 /* Another thread is stepping over a breakpoint in-line. If
8887 this thread needs a step-over too, queue the request. In
8888 either case, this resume must be deferred for later. */
8889 struct thread_info
*tp
= ecs
->event_thread
;
8891 if (ecs
->hit_singlestep_breakpoint
8892 || thread_still_needs_step_over (tp
))
8894 infrun_debug_printf ("step-over already in progress: "
8895 "step-over for %s deferred",
8896 tp
->ptid
.to_string ().c_str ());
8897 global_thread_step_over_chain_enqueue (tp
);
8900 infrun_debug_printf ("step-over in progress: resume of %s deferred",
8901 tp
->ptid
.to_string ().c_str ());
8905 regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
8908 step_over_what step_what
;
8910 /* Either the trap was not expected, but we are continuing
8911 anyway (if we got a signal, the user asked it be passed to
8914 We got our expected trap, but decided we should resume from
8917 We're going to run this baby now!
8919 Note that insert_breakpoints won't try to re-insert
8920 already inserted breakpoints. Therefore, we don't
8921 care if breakpoints were already inserted, or not. */
8923 /* If we need to step over a breakpoint, and we're not using
8924 displaced stepping to do so, insert all breakpoints
8925 (watchpoints, etc.) but the one we're stepping over, step one
8926 instruction, and then re-insert the breakpoint when that step
8929 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
8931 remove_bp
= (ecs
->hit_singlestep_breakpoint
8932 || (step_what
& STEP_OVER_BREAKPOINT
));
8933 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
8935 /* We can't use displaced stepping if we need to step past a
8936 watchpoint. The instruction copied to the scratch pad would
8937 still trigger the watchpoint. */
8939 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
8941 set_step_over_info (ecs
->event_thread
->inf
->aspace
.get (),
8942 regcache_read_pc (regcache
), remove_wps
,
8943 ecs
->event_thread
->global_num
);
8945 else if (remove_wps
)
8946 set_step_over_info (nullptr, 0, remove_wps
, -1);
8948 /* If we now need to do an in-line step-over, we need to stop
8949 all other threads. Note this must be done before
8950 insert_breakpoints below, because that removes the breakpoint
8951 we're about to step over, otherwise other threads could miss
8953 if (step_over_info_valid_p () && target_is_non_stop_p ())
8954 stop_all_threads ("starting in-line step-over");
8956 /* Stop stepping if inserting breakpoints fails. */
8959 insert_breakpoints ();
8961 catch (const gdb_exception_error
&e
)
8963 exception_print (gdb_stderr
, e
);
8965 clear_step_over_info ();
8969 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
8971 resume (ecs
->event_thread
->stop_signal ());
8974 prepare_to_wait (ecs
);
8977 /* Called when we should continue running the inferior, because the
8978 current event doesn't cause a user visible stop. This does the
8979 resuming part; waiting for the next event is done elsewhere. */
8982 keep_going (struct execution_control_state
*ecs
)
8984 if (ecs
->event_thread
->control
.trap_expected
8985 && ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
8986 ecs
->event_thread
->control
.trap_expected
= 0;
8988 if (!signal_program
[ecs
->event_thread
->stop_signal ()])
8989 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
8990 keep_going_pass_signal (ecs
);
8993 /* This function normally comes after a resume, before
8994 handle_inferior_event exits. It takes care of any last bits of
8995 housekeeping, and sets the all-important wait_some_more flag. */
8998 prepare_to_wait (struct execution_control_state
*ecs
)
9000 infrun_debug_printf ("prepare_to_wait");
9002 ecs
->wait_some_more
= 1;
9004 /* If the target can't async, emulate it by marking the infrun event
9005 handler such that as soon as we get back to the event-loop, we
9006 immediately end up in fetch_inferior_event again calling
9008 if (!target_can_async_p ())
9009 mark_infrun_async_event_handler ();
9012 /* We are done with the step range of a step/next/si/ni command.
9013 Called once for each n of a "step n" operation. */
9016 end_stepping_range (struct execution_control_state
*ecs
)
9018 ecs
->event_thread
->control
.stop_step
= 1;
9022 /* Several print_*_reason functions to print why the inferior has stopped.
9023 We always print something when the inferior exits, or receives a signal.
9024 The rest of the cases are dealt with later on in normal_stop and
9025 print_it_typical. Ideally there should be a call to one of these
9026 print_*_reason functions functions from handle_inferior_event each time
9027 stop_waiting is called.
9029 Note that we don't call these directly, instead we delegate that to
9030 the interpreters, through observers. Interpreters then call these
9031 with whatever uiout is right. */
9034 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
9036 annotate_signalled ();
9037 if (uiout
->is_mi_like_p ())
9039 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
9040 uiout
->text ("\nProgram terminated with signal ");
9041 annotate_signal_name ();
9042 uiout
->field_string ("signal-name",
9043 gdb_signal_to_name (siggnal
));
9044 annotate_signal_name_end ();
9046 annotate_signal_string ();
9047 uiout
->field_string ("signal-meaning",
9048 gdb_signal_to_string (siggnal
));
9049 annotate_signal_string_end ();
9050 uiout
->text (".\n");
9051 uiout
->text ("The program no longer exists.\n");
9055 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
9057 struct inferior
*inf
= current_inferior ();
9058 std::string pidstr
= target_pid_to_str (ptid_t (inf
->pid
));
9060 annotate_exited (exitstatus
);
9063 if (uiout
->is_mi_like_p ())
9064 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED
));
9065 std::string exit_code_str
9066 = string_printf ("0%o", (unsigned int) exitstatus
);
9067 uiout
->message ("[Inferior %s (%s) exited with code %pF]\n",
9068 plongest (inf
->num
), pidstr
.c_str (),
9069 string_field ("exit-code", exit_code_str
.c_str ()));
9073 if (uiout
->is_mi_like_p ())
9075 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
9076 uiout
->message ("[Inferior %s (%s) exited normally]\n",
9077 plongest (inf
->num
), pidstr
.c_str ());
9082 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
9084 struct thread_info
*thr
= inferior_thread ();
9086 infrun_debug_printf ("signal = %s", gdb_signal_to_string (siggnal
));
9090 if (uiout
->is_mi_like_p ())
9092 else if (show_thread_that_caused_stop ())
9094 uiout
->text ("\nThread ");
9095 uiout
->field_string ("thread-id", print_thread_id (thr
));
9097 const char *name
= thread_name (thr
);
9098 if (name
!= nullptr)
9100 uiout
->text (" \"");
9101 uiout
->field_string ("name", name
);
9106 uiout
->text ("\nProgram");
9108 if (siggnal
== GDB_SIGNAL_0
&& !uiout
->is_mi_like_p ())
9109 uiout
->text (" stopped");
9112 uiout
->text (" received signal ");
9113 annotate_signal_name ();
9114 if (uiout
->is_mi_like_p ())
9116 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
9117 uiout
->field_string ("signal-name", gdb_signal_to_name (siggnal
));
9118 annotate_signal_name_end ();
9120 annotate_signal_string ();
9121 uiout
->field_string ("signal-meaning", gdb_signal_to_string (siggnal
));
9123 regcache
*regcache
= get_thread_regcache (thr
);
9124 struct gdbarch
*gdbarch
= regcache
->arch ();
9125 if (gdbarch_report_signal_info_p (gdbarch
))
9126 gdbarch_report_signal_info (gdbarch
, uiout
, siggnal
);
9128 annotate_signal_string_end ();
9130 uiout
->text (".\n");
9134 print_no_history_reason (struct ui_out
*uiout
)
9136 if (uiout
->is_mi_like_p ())
9137 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_NO_HISTORY
));
9139 uiout
->text ("\nNo more reverse-execution history.\n");
9142 /* Print current location without a level number, if we have changed
9143 functions or hit a breakpoint. Print source line if we have one.
9144 bpstat_print contains the logic deciding in detail what to print,
9145 based on the event(s) that just occurred. */
9148 print_stop_location (const target_waitstatus
&ws
)
9151 enum print_what source_flag
;
9152 int do_frame_printing
= 1;
9153 struct thread_info
*tp
= inferior_thread ();
9155 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
.kind ());
9159 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
9160 should) carry around the function and does (or should) use
9161 that when doing a frame comparison. */
9162 if (tp
->control
.stop_step
9163 && (tp
->control
.step_frame_id
9164 == get_frame_id (get_current_frame ()))
9165 && (tp
->control
.step_start_function
9166 == find_pc_function (tp
->stop_pc ())))
9168 /* Finished step, just print source line. */
9169 source_flag
= SRC_LINE
;
9173 /* Print location and source line. */
9174 source_flag
= SRC_AND_LOC
;
9177 case PRINT_SRC_AND_LOC
:
9178 /* Print location and source line. */
9179 source_flag
= SRC_AND_LOC
;
9181 case PRINT_SRC_ONLY
:
9182 source_flag
= SRC_LINE
;
9185 /* Something bogus. */
9186 source_flag
= SRC_LINE
;
9187 do_frame_printing
= 0;
9190 internal_error (_("Unknown value."));
9193 /* The behavior of this routine with respect to the source
9195 SRC_LINE: Print only source line
9196 LOCATION: Print only location
9197 SRC_AND_LOC: Print location and source line. */
9198 if (do_frame_printing
)
9199 print_stack_frame (get_selected_frame (nullptr), 0, source_flag
, 1);
9205 print_stop_event (struct ui_out
*uiout
, bool displays
)
9207 struct target_waitstatus last
;
9208 struct thread_info
*tp
;
9210 get_last_target_status (nullptr, nullptr, &last
);
9213 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
9215 print_stop_location (last
);
9217 /* Display the auto-display expressions. */
9222 tp
= inferior_thread ();
9223 if (tp
->thread_fsm () != nullptr
9224 && tp
->thread_fsm ()->finished_p ())
9226 struct return_value_info
*rv
;
9228 rv
= tp
->thread_fsm ()->return_value ();
9230 print_return_value (uiout
, rv
);
9237 maybe_remove_breakpoints (void)
9239 if (!breakpoints_should_be_inserted_now () && target_has_execution ())
9241 if (remove_breakpoints ())
9243 target_terminal::ours_for_output ();
9244 gdb_printf (_("Cannot remove breakpoints because "
9245 "program is no longer writable.\nFurther "
9246 "execution is probably impossible.\n"));
9251 /* The execution context that just caused a normal stop. */
9257 DISABLE_COPY_AND_ASSIGN (stop_context
);
9259 bool changed () const;
9264 /* The event PTID. */
9268 /* If stopp for a thread event, this is the thread that caused the
9270 thread_info_ref thread
;
9272 /* The inferior that caused the stop. */
9276 /* Initializes a new stop context. If stopped for a thread event, this
9277 takes a strong reference to the thread. */
9279 stop_context::stop_context ()
9281 stop_id
= get_stop_id ();
9282 ptid
= inferior_ptid
;
9283 inf_num
= current_inferior ()->num
;
9285 if (inferior_ptid
!= null_ptid
)
9287 /* Take a strong reference so that the thread can't be deleted
9289 thread
= thread_info_ref::new_reference (inferior_thread ());
9293 /* Return true if the current context no longer matches the saved stop
9297 stop_context::changed () const
9299 if (ptid
!= inferior_ptid
)
9301 if (inf_num
!= current_inferior ()->num
)
9303 if (thread
!= nullptr && thread
->state
!= THREAD_STOPPED
)
9305 if (get_stop_id () != stop_id
)
9315 struct target_waitstatus last
;
9317 get_last_target_status (nullptr, nullptr, &last
);
9321 /* If an exception is thrown from this point on, make sure to
9322 propagate GDB's knowledge of the executing state to the
9323 frontend/user running state. A QUIT is an easy exception to see
9324 here, so do this before any filtered output. */
9326 ptid_t finish_ptid
= null_ptid
;
9329 finish_ptid
= minus_one_ptid
;
9330 else if (last
.kind () == TARGET_WAITKIND_SIGNALLED
9331 || last
.kind () == TARGET_WAITKIND_EXITED
)
9333 /* On some targets, we may still have live threads in the
9334 inferior when we get a process exit event. E.g., for
9335 "checkpoint", when the current checkpoint/fork exits,
9336 linux-fork.c automatically switches to another fork from
9337 within target_mourn_inferior. */
9338 if (inferior_ptid
!= null_ptid
)
9339 finish_ptid
= ptid_t (inferior_ptid
.pid ());
9341 else if (last
.kind () != TARGET_WAITKIND_NO_RESUMED
9342 && last
.kind () != TARGET_WAITKIND_THREAD_EXITED
)
9343 finish_ptid
= inferior_ptid
;
9345 std::optional
<scoped_finish_thread_state
> maybe_finish_thread_state
;
9346 if (finish_ptid
!= null_ptid
)
9348 maybe_finish_thread_state
.emplace
9349 (user_visible_resume_target (finish_ptid
), finish_ptid
);
9352 /* As we're presenting a stop, and potentially removing breakpoints,
9353 update the thread list so we can tell whether there are threads
9354 running on the target. With target remote, for example, we can
9355 only learn about new threads when we explicitly update the thread
9356 list. Do this before notifying the interpreters about signal
9357 stops, end of stepping ranges, etc., so that the "new thread"
9358 output is emitted before e.g., "Program received signal FOO",
9359 instead of after. */
9360 update_thread_list ();
9362 if (last
.kind () == TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
9363 notify_signal_received (inferior_thread ()->stop_signal ());
9365 /* As with the notification of thread events, we want to delay
9366 notifying the user that we've switched thread context until
9367 the inferior actually stops.
9369 There's no point in saying anything if the inferior has exited.
9370 Note that SIGNALLED here means "exited with a signal", not
9371 "received a signal".
9373 Also skip saying anything in non-stop mode. In that mode, as we
9374 don't want GDB to switch threads behind the user's back, to avoid
9375 races where the user is typing a command to apply to thread x,
9376 but GDB switches to thread y before the user finishes entering
9377 the command, fetch_inferior_event installs a cleanup to restore
9378 the current thread back to the thread the user had selected right
9379 after this event is handled, so we're not really switching, only
9380 informing of a stop. */
9383 if ((last
.kind () != TARGET_WAITKIND_SIGNALLED
9384 && last
.kind () != TARGET_WAITKIND_EXITED
9385 && last
.kind () != TARGET_WAITKIND_NO_RESUMED
9386 && last
.kind () != TARGET_WAITKIND_THREAD_EXITED
)
9387 && target_has_execution ()
9388 && previous_thread
!= inferior_thread ())
9390 SWITCH_THRU_ALL_UIS ()
9392 target_terminal::ours_for_output ();
9393 gdb_printf (_("[Switching to %s]\n"),
9394 target_pid_to_str (inferior_ptid
).c_str ());
9395 annotate_thread_changed ();
9399 update_previous_thread ();
9402 if (last
.kind () == TARGET_WAITKIND_NO_RESUMED
9403 || last
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
9405 stop_print_frame
= false;
9407 SWITCH_THRU_ALL_UIS ()
9408 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
9410 target_terminal::ours_for_output ();
9411 if (last
.kind () == TARGET_WAITKIND_NO_RESUMED
)
9412 gdb_printf (_("No unwaited-for children left.\n"));
9413 else if (last
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
9414 gdb_printf (_("Command aborted, thread exited.\n"));
9416 gdb_assert_not_reached ("unhandled");
9420 /* Note: this depends on the update_thread_list call above. */
9421 maybe_remove_breakpoints ();
9423 /* If an auto-display called a function and that got a signal,
9424 delete that auto-display to avoid an infinite recursion. */
9426 if (stopped_by_random_signal
)
9427 disable_current_display ();
9429 SWITCH_THRU_ALL_UIS ()
9431 async_enable_stdin ();
9434 /* Let the user/frontend see the threads as stopped. */
9435 maybe_finish_thread_state
.reset ();
9437 /* Select innermost stack frame - i.e., current frame is frame 0,
9438 and current location is based on that. Handle the case where the
9439 dummy call is returning after being stopped. E.g. the dummy call
9440 previously hit a breakpoint. (If the dummy call returns
9441 normally, we won't reach here.) Do this before the stop hook is
9442 run, so that it doesn't get to see the temporary dummy frame,
9443 which is not where we'll present the stop. */
9444 if (has_stack_frames ())
9446 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
9448 /* Pop the empty frame that contains the stack dummy. This
9449 also restores inferior state prior to the call (struct
9450 infcall_suspend_state). */
9451 frame_info_ptr frame
= get_current_frame ();
9453 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
9455 /* frame_pop calls reinit_frame_cache as the last thing it
9456 does which means there's now no selected frame. */
9459 select_frame (get_current_frame ());
9461 /* Set the current source location. */
9462 set_current_sal_from_frame (get_current_frame ());
9465 /* Look up the hook_stop and run it (CLI internally handles problem
9466 of stop_command's pre-hook not existing). */
9467 stop_context saved_context
;
9471 execute_cmd_pre_hook (stop_command
);
9473 catch (const gdb_exception_error
&ex
)
9475 exception_fprintf (gdb_stderr
, ex
,
9476 "Error while running hook_stop:\n");
9479 /* If the stop hook resumes the target, then there's no point in
9480 trying to notify about the previous stop; its context is
9481 gone. Likewise if the command switches thread or inferior --
9482 the observers would print a stop for the wrong
9484 if (saved_context
.changed ())
9487 /* Notify observers about the stop. This is where the interpreters
9488 print the stop event. */
9489 notify_normal_stop ((inferior_ptid
!= null_ptid
9490 ? inferior_thread ()->control
.stop_bpstat
9493 annotate_stopped ();
9495 if (target_has_execution ())
9497 if (last
.kind () != TARGET_WAITKIND_SIGNALLED
9498 && last
.kind () != TARGET_WAITKIND_EXITED
9499 && last
.kind () != TARGET_WAITKIND_NO_RESUMED
9500 && last
.kind () != TARGET_WAITKIND_THREAD_EXITED
)
9501 /* Delete the breakpoint we stopped at, if it wants to be deleted.
9502 Delete any breakpoint that is to be deleted at the next stop. */
9503 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
9510 signal_stop_state (int signo
)
9512 return signal_stop
[signo
];
9516 signal_print_state (int signo
)
9518 return signal_print
[signo
];
9522 signal_pass_state (int signo
)
9524 return signal_program
[signo
];
9528 signal_cache_update (int signo
)
9532 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
9533 signal_cache_update (signo
);
9538 signal_pass
[signo
] = (signal_stop
[signo
] == 0
9539 && signal_print
[signo
] == 0
9540 && signal_program
[signo
] == 1
9541 && signal_catch
[signo
] == 0);
9545 signal_stop_update (int signo
, int state
)
9547 int ret
= signal_stop
[signo
];
9549 signal_stop
[signo
] = state
;
9550 signal_cache_update (signo
);
9555 signal_print_update (int signo
, int state
)
9557 int ret
= signal_print
[signo
];
9559 signal_print
[signo
] = state
;
9560 signal_cache_update (signo
);
9565 signal_pass_update (int signo
, int state
)
9567 int ret
= signal_program
[signo
];
9569 signal_program
[signo
] = state
;
9570 signal_cache_update (signo
);
9574 /* Update the global 'signal_catch' from INFO and notify the
9578 signal_catch_update (const unsigned int *info
)
9582 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
9583 signal_catch
[i
] = info
[i
] > 0;
9584 signal_cache_update (-1);
9585 target_pass_signals (signal_pass
);
9589 sig_print_header (void)
9591 gdb_printf (_("Signal Stop\tPrint\tPass "
9592 "to program\tDescription\n"));
9596 sig_print_info (enum gdb_signal oursig
)
9598 const char *name
= gdb_signal_to_name (oursig
);
9599 int name_padding
= 13 - strlen (name
);
9601 if (name_padding
<= 0)
9604 gdb_printf ("%s", name
);
9605 gdb_printf ("%*.*s ", name_padding
, name_padding
, " ");
9606 gdb_printf ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
9607 gdb_printf ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
9608 gdb_printf ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
9609 gdb_printf ("%s\n", gdb_signal_to_string (oursig
));
9612 /* Specify how various signals in the inferior should be handled. */
9615 handle_command (const char *args
, int from_tty
)
9617 int digits
, wordlen
;
9618 int sigfirst
, siglast
;
9619 enum gdb_signal oursig
;
9622 if (args
== nullptr)
9624 error_no_arg (_("signal to handle"));
9627 /* Allocate and zero an array of flags for which signals to handle. */
9629 const size_t nsigs
= GDB_SIGNAL_LAST
;
9630 unsigned char sigs
[nsigs
] {};
9632 /* Break the command line up into args. */
9634 gdb_argv
built_argv (args
);
9636 /* Walk through the args, looking for signal oursigs, signal names, and
9637 actions. Signal numbers and signal names may be interspersed with
9638 actions, with the actions being performed for all signals cumulatively
9639 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
9641 for (char *arg
: built_argv
)
9643 wordlen
= strlen (arg
);
9644 for (digits
= 0; isdigit (arg
[digits
]); digits
++)
9648 sigfirst
= siglast
= -1;
9650 if (wordlen
>= 1 && !strncmp (arg
, "all", wordlen
))
9652 /* Apply action to all signals except those used by the
9653 debugger. Silently skip those. */
9656 siglast
= nsigs
- 1;
9658 else if (wordlen
>= 1 && !strncmp (arg
, "stop", wordlen
))
9660 SET_SIGS (nsigs
, sigs
, signal_stop
);
9661 SET_SIGS (nsigs
, sigs
, signal_print
);
9663 else if (wordlen
>= 1 && !strncmp (arg
, "ignore", wordlen
))
9665 UNSET_SIGS (nsigs
, sigs
, signal_program
);
9667 else if (wordlen
>= 2 && !strncmp (arg
, "print", wordlen
))
9669 SET_SIGS (nsigs
, sigs
, signal_print
);
9671 else if (wordlen
>= 2 && !strncmp (arg
, "pass", wordlen
))
9673 SET_SIGS (nsigs
, sigs
, signal_program
);
9675 else if (wordlen
>= 3 && !strncmp (arg
, "nostop", wordlen
))
9677 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
9679 else if (wordlen
>= 3 && !strncmp (arg
, "noignore", wordlen
))
9681 SET_SIGS (nsigs
, sigs
, signal_program
);
9683 else if (wordlen
>= 4 && !strncmp (arg
, "noprint", wordlen
))
9685 UNSET_SIGS (nsigs
, sigs
, signal_print
);
9686 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
9688 else if (wordlen
>= 4 && !strncmp (arg
, "nopass", wordlen
))
9690 UNSET_SIGS (nsigs
, sigs
, signal_program
);
9692 else if (digits
> 0)
9694 /* It is numeric. The numeric signal refers to our own
9695 internal signal numbering from target.h, not to host/target
9696 signal number. This is a feature; users really should be
9697 using symbolic names anyway, and the common ones like
9698 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
9700 sigfirst
= siglast
= (int)
9701 gdb_signal_from_command (atoi (arg
));
9702 if (arg
[digits
] == '-')
9705 gdb_signal_from_command (atoi (arg
+ digits
+ 1));
9707 if (sigfirst
> siglast
)
9709 /* Bet he didn't figure we'd think of this case... */
9710 std::swap (sigfirst
, siglast
);
9715 oursig
= gdb_signal_from_name (arg
);
9716 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
9718 sigfirst
= siglast
= (int) oursig
;
9722 /* Not a number and not a recognized flag word => complain. */
9723 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg
);
9727 /* If any signal numbers or symbol names were found, set flags for
9728 which signals to apply actions to. */
9730 for (int signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
9732 switch ((enum gdb_signal
) signum
)
9734 case GDB_SIGNAL_TRAP
:
9735 case GDB_SIGNAL_INT
:
9736 if (!allsigs
&& !sigs
[signum
])
9738 if (query (_("%s is used by the debugger.\n\
9739 Are you sure you want to change it? "),
9740 gdb_signal_to_name ((enum gdb_signal
) signum
)))
9745 gdb_printf (_("Not confirmed, unchanged.\n"));
9749 case GDB_SIGNAL_DEFAULT
:
9750 case GDB_SIGNAL_UNKNOWN
:
9751 /* Make sure that "all" doesn't print these. */
9760 for (int signum
= 0; signum
< nsigs
; signum
++)
9763 signal_cache_update (-1);
9764 target_pass_signals (signal_pass
);
9765 target_program_signals (signal_program
);
9769 /* Show the results. */
9770 sig_print_header ();
9771 for (; signum
< nsigs
; signum
++)
9773 sig_print_info ((enum gdb_signal
) signum
);
9780 /* Complete the "handle" command. */
9783 handle_completer (struct cmd_list_element
*ignore
,
9784 completion_tracker
&tracker
,
9785 const char *text
, const char *word
)
9787 static const char * const keywords
[] =
9801 signal_completer (ignore
, tracker
, text
, word
);
9802 complete_on_enum (tracker
, keywords
, word
, word
);
9806 gdb_signal_from_command (int num
)
9808 if (num
>= 1 && num
<= 15)
9809 return (enum gdb_signal
) num
;
9810 error (_("Only signals 1-15 are valid as numeric signals.\n\
9811 Use \"info signals\" for a list of symbolic signals."));
9814 /* Print current contents of the tables set by the handle command.
9815 It is possible we should just be printing signals actually used
9816 by the current target (but for things to work right when switching
9817 targets, all signals should be in the signal tables). */
9820 info_signals_command (const char *signum_exp
, int from_tty
)
9822 enum gdb_signal oursig
;
9824 sig_print_header ();
9828 /* First see if this is a symbol name. */
9829 oursig
= gdb_signal_from_name (signum_exp
);
9830 if (oursig
== GDB_SIGNAL_UNKNOWN
)
9832 /* No, try numeric. */
9834 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
9836 sig_print_info (oursig
);
9841 /* These ugly casts brought to you by the native VAX compiler. */
9842 for (oursig
= GDB_SIGNAL_FIRST
;
9843 (int) oursig
< (int) GDB_SIGNAL_LAST
;
9844 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
9848 if (oursig
!= GDB_SIGNAL_UNKNOWN
9849 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
9850 sig_print_info (oursig
);
9853 gdb_printf (_("\nUse the \"handle\" command "
9854 "to change these tables.\n"));
9857 /* The $_siginfo convenience variable is a bit special. We don't know
9858 for sure the type of the value until we actually have a chance to
9859 fetch the data. The type can change depending on gdbarch, so it is
9860 also dependent on which thread you have selected.
9862 1. making $_siginfo be an internalvar that creates a new value on
9865 2. making the value of $_siginfo be an lval_computed value. */
9867 /* This function implements the lval_computed support for reading a
9871 siginfo_value_read (struct value
*v
)
9873 LONGEST transferred
;
9875 /* If we can access registers, so can we access $_siginfo. Likewise
9877 validate_registers_access ();
9880 target_read (current_inferior ()->top_target (),
9881 TARGET_OBJECT_SIGNAL_INFO
,
9883 v
->contents_all_raw ().data (),
9885 v
->type ()->length ());
9887 if (transferred
!= v
->type ()->length ())
9888 error (_("Unable to read siginfo"));
9891 /* This function implements the lval_computed support for writing a
9895 siginfo_value_write (struct value
*v
, struct value
*fromval
)
9897 LONGEST transferred
;
9899 /* If we can access registers, so can we access $_siginfo. Likewise
9901 validate_registers_access ();
9903 transferred
= target_write (current_inferior ()->top_target (),
9904 TARGET_OBJECT_SIGNAL_INFO
,
9906 fromval
->contents_all_raw ().data (),
9908 fromval
->type ()->length ());
9910 if (transferred
!= fromval
->type ()->length ())
9911 error (_("Unable to write siginfo"));
9914 static const struct lval_funcs siginfo_value_funcs
=
9920 /* Return a new value with the correct type for the siginfo object of
9921 the current thread using architecture GDBARCH. Return a void value
9922 if there's no object available. */
9924 static struct value
*
9925 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
9928 if (target_has_stack ()
9929 && inferior_ptid
!= null_ptid
9930 && gdbarch_get_siginfo_type_p (gdbarch
))
9932 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9934 return value::allocate_computed (type
, &siginfo_value_funcs
, nullptr);
9937 return value::allocate (builtin_type (gdbarch
)->builtin_void
);
9941 /* infcall_suspend_state contains state about the program itself like its
9942 registers and any signal it received when it last stopped.
9943 This state must be restored regardless of how the inferior function call
9944 ends (either successfully, or after it hits a breakpoint or signal)
9945 if the program is to properly continue where it left off. */
9947 class infcall_suspend_state
9950 /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
9951 once the inferior function call has finished. */
9952 infcall_suspend_state (struct gdbarch
*gdbarch
,
9953 const struct thread_info
*tp
,
9954 struct regcache
*regcache
)
9955 : m_registers (new readonly_detached_regcache (*regcache
))
9957 tp
->save_suspend_to (m_thread_suspend
);
9959 gdb::unique_xmalloc_ptr
<gdb_byte
> siginfo_data
;
9961 if (gdbarch_get_siginfo_type_p (gdbarch
))
9963 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9964 size_t len
= type
->length ();
9966 siginfo_data
.reset ((gdb_byte
*) xmalloc (len
));
9968 if (target_read (current_inferior ()->top_target (),
9969 TARGET_OBJECT_SIGNAL_INFO
, nullptr,
9970 siginfo_data
.get (), 0, len
) != len
)
9972 /* Errors ignored. */
9973 siginfo_data
.reset (nullptr);
9979 m_siginfo_gdbarch
= gdbarch
;
9980 m_siginfo_data
= std::move (siginfo_data
);
9984 /* Return a pointer to the stored register state. */
9986 readonly_detached_regcache
*registers () const
9988 return m_registers
.get ();
9991 /* Restores the stored state into GDBARCH, TP, and REGCACHE. */
9993 void restore (struct gdbarch
*gdbarch
,
9994 struct thread_info
*tp
,
9995 struct regcache
*regcache
) const
9997 tp
->restore_suspend_from (m_thread_suspend
);
9999 if (m_siginfo_gdbarch
== gdbarch
)
10001 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
10003 /* Errors ignored. */
10004 target_write (current_inferior ()->top_target (),
10005 TARGET_OBJECT_SIGNAL_INFO
, nullptr,
10006 m_siginfo_data
.get (), 0, type
->length ());
10009 /* The inferior can be gone if the user types "print exit(0)"
10010 (and perhaps other times). */
10011 if (target_has_execution ())
10012 /* NB: The register write goes through to the target. */
10013 regcache
->restore (registers ());
10017 /* How the current thread stopped before the inferior function call was
10019 struct thread_suspend_state m_thread_suspend
;
10021 /* The registers before the inferior function call was executed. */
10022 std::unique_ptr
<readonly_detached_regcache
> m_registers
;
10024 /* Format of SIGINFO_DATA or NULL if it is not present. */
10025 struct gdbarch
*m_siginfo_gdbarch
= nullptr;
10027 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
10028 gdbarch_get_siginfo_type ()->length (). For different gdbarch the
10029 content would be invalid. */
10030 gdb::unique_xmalloc_ptr
<gdb_byte
> m_siginfo_data
;
10033 infcall_suspend_state_up
10034 save_infcall_suspend_state ()
10036 struct thread_info
*tp
= inferior_thread ();
10037 regcache
*regcache
= get_thread_regcache (tp
);
10038 struct gdbarch
*gdbarch
= regcache
->arch ();
10040 infcall_suspend_state_up inf_state
10041 (new struct infcall_suspend_state (gdbarch
, tp
, regcache
));
10043 /* Having saved the current state, adjust the thread state, discarding
10044 any stop signal information. The stop signal is not useful when
10045 starting an inferior function call, and run_inferior_call will not use
10046 the signal due to its `proceed' call with GDB_SIGNAL_0. */
10047 tp
->set_stop_signal (GDB_SIGNAL_0
);
10052 /* Restore inferior session state to INF_STATE. */
10055 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
10057 struct thread_info
*tp
= inferior_thread ();
10058 regcache
*regcache
= get_thread_regcache (inferior_thread ());
10059 struct gdbarch
*gdbarch
= regcache
->arch ();
10061 inf_state
->restore (gdbarch
, tp
, regcache
);
10062 discard_infcall_suspend_state (inf_state
);
10066 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
10071 readonly_detached_regcache
*
10072 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
10074 return inf_state
->registers ();
10077 /* infcall_control_state contains state regarding gdb's control of the
10078 inferior itself like stepping control. It also contains session state like
10079 the user's currently selected frame. */
10081 struct infcall_control_state
10083 struct thread_control_state thread_control
;
10084 struct inferior_control_state inferior_control
;
10086 /* Other fields: */
10087 enum stop_stack_kind stop_stack_dummy
= STOP_NONE
;
10088 int stopped_by_random_signal
= 0;
10090 /* ID and level of the selected frame when the inferior function
10092 struct frame_id selected_frame_id
{};
10093 int selected_frame_level
= -1;
10096 /* Save all of the information associated with the inferior<==>gdb
10099 infcall_control_state_up
10100 save_infcall_control_state ()
10102 infcall_control_state_up
inf_status (new struct infcall_control_state
);
10103 struct thread_info
*tp
= inferior_thread ();
10104 struct inferior
*inf
= current_inferior ();
10106 inf_status
->thread_control
= tp
->control
;
10107 inf_status
->inferior_control
= inf
->control
;
10109 tp
->control
.step_resume_breakpoint
= nullptr;
10110 tp
->control
.exception_resume_breakpoint
= nullptr;
10112 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
10113 chain. If caller's caller is walking the chain, they'll be happier if we
10114 hand them back the original chain when restore_infcall_control_state is
10116 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
10118 /* Other fields: */
10119 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
10120 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
10122 save_selected_frame (&inf_status
->selected_frame_id
,
10123 &inf_status
->selected_frame_level
);
10128 /* Restore inferior session state to INF_STATUS. */
10131 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
10133 struct thread_info
*tp
= inferior_thread ();
10134 struct inferior
*inf
= current_inferior ();
10136 if (tp
->control
.step_resume_breakpoint
)
10137 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
10139 if (tp
->control
.exception_resume_breakpoint
)
10140 tp
->control
.exception_resume_breakpoint
->disposition
10141 = disp_del_at_next_stop
;
10143 /* Handle the bpstat_copy of the chain. */
10144 bpstat_clear (&tp
->control
.stop_bpstat
);
10146 tp
->control
= inf_status
->thread_control
;
10147 inf
->control
= inf_status
->inferior_control
;
10149 /* Other fields: */
10150 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
10151 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
10153 if (target_has_stack ())
10155 restore_selected_frame (inf_status
->selected_frame_id
,
10156 inf_status
->selected_frame_level
);
10163 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
10165 if (inf_status
->thread_control
.step_resume_breakpoint
)
10166 inf_status
->thread_control
.step_resume_breakpoint
->disposition
10167 = disp_del_at_next_stop
;
10169 if (inf_status
->thread_control
.exception_resume_breakpoint
)
10170 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
10171 = disp_del_at_next_stop
;
10173 /* See save_infcall_control_state for info on stop_bpstat. */
10174 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
10179 /* See infrun.h. */
10182 clear_exit_convenience_vars (void)
10184 clear_internalvar (lookup_internalvar ("_exitsignal"));
10185 clear_internalvar (lookup_internalvar ("_exitcode"));
10189 /* User interface for reverse debugging:
10190 Set exec-direction / show exec-direction commands
10191 (returns error unless target implements to_set_exec_direction method). */
10193 enum exec_direction_kind execution_direction
= EXEC_FORWARD
;
10194 static const char exec_forward
[] = "forward";
10195 static const char exec_reverse
[] = "reverse";
10196 static const char *exec_direction
= exec_forward
;
10197 static const char *const exec_direction_names
[] = {
10204 set_exec_direction_func (const char *args
, int from_tty
,
10205 struct cmd_list_element
*cmd
)
10207 if (target_can_execute_reverse ())
10209 if (!strcmp (exec_direction
, exec_forward
))
10210 execution_direction
= EXEC_FORWARD
;
10211 else if (!strcmp (exec_direction
, exec_reverse
))
10212 execution_direction
= EXEC_REVERSE
;
10216 exec_direction
= exec_forward
;
10217 error (_("Target does not support this operation."));
10222 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
10223 struct cmd_list_element
*cmd
, const char *value
)
10225 switch (execution_direction
) {
10227 gdb_printf (out
, _("Forward.\n"));
10230 gdb_printf (out
, _("Reverse.\n"));
10233 internal_error (_("bogus execution_direction value: %d"),
10234 (int) execution_direction
);
10239 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
10240 struct cmd_list_element
*c
, const char *value
)
10242 gdb_printf (file
, _("Resuming the execution of threads "
10243 "of all processes is %s.\n"), value
);
10246 /* Implementation of `siginfo' variable. */
10248 static const struct internalvar_funcs siginfo_funcs
=
10250 siginfo_make_value
,
10254 /* Callback for infrun's target events source. This is marked when a
10255 thread has a pending status to process. */
10258 infrun_async_inferior_event_handler (gdb_client_data data
)
10260 clear_async_event_handler (infrun_async_inferior_event_token
);
10261 inferior_event_handler (INF_REG_EVENT
);
10265 namespace selftests
10268 /* Verify that when two threads with the same ptid exist (from two different
10269 targets) and one of them changes ptid, we only update inferior_ptid if
10270 it is appropriate. */
10273 infrun_thread_ptid_changed ()
10275 gdbarch
*arch
= current_inferior ()->arch ();
10277 /* The thread which inferior_ptid represents changes ptid. */
10279 scoped_restore_current_pspace_and_thread restore
;
10281 scoped_mock_context
<test_target_ops
> target1 (arch
);
10282 scoped_mock_context
<test_target_ops
> target2 (arch
);
10284 ptid_t
old_ptid (111, 222);
10285 ptid_t
new_ptid (111, 333);
10287 target1
.mock_inferior
.pid
= old_ptid
.pid ();
10288 target1
.mock_thread
.ptid
= old_ptid
;
10289 target1
.mock_inferior
.ptid_thread_map
.clear ();
10290 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
10292 target2
.mock_inferior
.pid
= old_ptid
.pid ();
10293 target2
.mock_thread
.ptid
= old_ptid
;
10294 target2
.mock_inferior
.ptid_thread_map
.clear ();
10295 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
10297 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
10298 set_current_inferior (&target1
.mock_inferior
);
10300 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
10302 gdb_assert (inferior_ptid
== new_ptid
);
10305 /* A thread with the same ptid as inferior_ptid, but from another target,
10308 scoped_restore_current_pspace_and_thread restore
;
10310 scoped_mock_context
<test_target_ops
> target1 (arch
);
10311 scoped_mock_context
<test_target_ops
> target2 (arch
);
10313 ptid_t
old_ptid (111, 222);
10314 ptid_t
new_ptid (111, 333);
10316 target1
.mock_inferior
.pid
= old_ptid
.pid ();
10317 target1
.mock_thread
.ptid
= old_ptid
;
10318 target1
.mock_inferior
.ptid_thread_map
.clear ();
10319 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
10321 target2
.mock_inferior
.pid
= old_ptid
.pid ();
10322 target2
.mock_thread
.ptid
= old_ptid
;
10323 target2
.mock_inferior
.ptid_thread_map
.clear ();
10324 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
10326 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
10327 set_current_inferior (&target2
.mock_inferior
);
10329 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
10331 gdb_assert (inferior_ptid
== old_ptid
);
10335 } /* namespace selftests */
10337 #endif /* GDB_SELF_TEST */
10339 void _initialize_infrun ();
10341 _initialize_infrun ()
10343 struct cmd_list_element
*c
;
10345 /* Register extra event sources in the event loop. */
10346 infrun_async_inferior_event_token
10347 = create_async_event_handler (infrun_async_inferior_event_handler
, nullptr,
10350 cmd_list_element
*info_signals_cmd
10351 = add_info ("signals", info_signals_command
, _("\
10352 What debugger does when program gets various signals.\n\
10353 Specify a signal as argument to print info on that signal only."));
10354 add_info_alias ("handle", info_signals_cmd
, 0);
10356 c
= add_com ("handle", class_run
, handle_command
, _("\
10357 Specify how to handle signals.\n\
10358 Usage: handle SIGNAL [ACTIONS]\n\
10359 Args are signals and actions to apply to those signals.\n\
10360 If no actions are specified, the current settings for the specified signals\n\
10361 will be displayed instead.\n\
10363 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
10364 from 1-15 are allowed for compatibility with old versions of GDB.\n\
10365 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
10366 The special arg \"all\" is recognized to mean all signals except those\n\
10367 used by the debugger, typically SIGTRAP and SIGINT.\n\
10369 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
10370 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
10371 Stop means reenter debugger if this signal happens (implies print).\n\
10372 Print means print a message if this signal happens.\n\
10373 Pass means let program see this signal; otherwise program doesn't know.\n\
10374 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
10375 Pass and Stop may be combined.\n\
10377 Multiple signals may be specified. Signal numbers and signal names\n\
10378 may be interspersed with actions, with the actions being performed for\n\
10379 all signals cumulatively specified."));
10380 set_cmd_completer (c
, handle_completer
);
10382 stop_command
= add_cmd ("stop", class_obscure
,
10383 not_just_help_class_command
, _("\
10384 There is no `stop' command, but you can set a hook on `stop'.\n\
10385 This allows you to set a list of commands to be run each time execution\n\
10386 of the program stops."), &cmdlist
);
10388 add_setshow_boolean_cmd
10389 ("infrun", class_maintenance
, &debug_infrun
,
10390 _("Set inferior debugging."),
10391 _("Show inferior debugging."),
10392 _("When non-zero, inferior specific debugging is enabled."),
10393 nullptr, show_debug_infrun
, &setdebuglist
, &showdebuglist
);
10395 add_setshow_boolean_cmd ("non-stop", no_class
,
10397 Set whether gdb controls the inferior in non-stop mode."), _("\
10398 Show whether gdb controls the inferior in non-stop mode."), _("\
10399 When debugging a multi-threaded program and this setting is\n\
10400 off (the default, also called all-stop mode), when one thread stops\n\
10401 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
10402 all other threads in the program while you interact with the thread of\n\
10403 interest. When you continue or step a thread, you can allow the other\n\
10404 threads to run, or have them remain stopped, but while you inspect any\n\
10405 thread's state, all threads stop.\n\
10407 In non-stop mode, when one thread stops, other threads can continue\n\
10408 to run freely. You'll be able to step each thread independently,\n\
10409 leave it stopped or free to run as needed."),
10415 for (size_t i
= 0; i
< GDB_SIGNAL_LAST
; i
++)
10417 signal_stop
[i
] = 1;
10418 signal_print
[i
] = 1;
10419 signal_program
[i
] = 1;
10420 signal_catch
[i
] = 0;
10423 /* Signals caused by debugger's own actions should not be given to
10424 the program afterwards.
10426 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
10427 explicitly specifies that it should be delivered to the target
10428 program. Typically, that would occur when a user is debugging a
10429 target monitor on a simulator: the target monitor sets a
10430 breakpoint; the simulator encounters this breakpoint and halts
10431 the simulation handing control to GDB; GDB, noting that the stop
10432 address doesn't map to any known breakpoint, returns control back
10433 to the simulator; the simulator then delivers the hardware
10434 equivalent of a GDB_SIGNAL_TRAP to the program being
10436 signal_program
[GDB_SIGNAL_TRAP
] = 0;
10437 signal_program
[GDB_SIGNAL_INT
] = 0;
10439 /* Signals that are not errors should not normally enter the debugger. */
10440 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
10441 signal_print
[GDB_SIGNAL_ALRM
] = 0;
10442 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
10443 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
10444 signal_stop
[GDB_SIGNAL_PROF
] = 0;
10445 signal_print
[GDB_SIGNAL_PROF
] = 0;
10446 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
10447 signal_print
[GDB_SIGNAL_CHLD
] = 0;
10448 signal_stop
[GDB_SIGNAL_IO
] = 0;
10449 signal_print
[GDB_SIGNAL_IO
] = 0;
10450 signal_stop
[GDB_SIGNAL_POLL
] = 0;
10451 signal_print
[GDB_SIGNAL_POLL
] = 0;
10452 signal_stop
[GDB_SIGNAL_URG
] = 0;
10453 signal_print
[GDB_SIGNAL_URG
] = 0;
10454 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
10455 signal_print
[GDB_SIGNAL_WINCH
] = 0;
10456 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
10457 signal_print
[GDB_SIGNAL_PRIO
] = 0;
10459 /* These signals are used internally by user-level thread
10460 implementations. (See signal(5) on Solaris.) Like the above
10461 signals, a healthy program receives and handles them as part of
10462 its normal operation. */
10463 signal_stop
[GDB_SIGNAL_LWP
] = 0;
10464 signal_print
[GDB_SIGNAL_LWP
] = 0;
10465 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
10466 signal_print
[GDB_SIGNAL_WAITING
] = 0;
10467 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
10468 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
10469 signal_stop
[GDB_SIGNAL_LIBRT
] = 0;
10470 signal_print
[GDB_SIGNAL_LIBRT
] = 0;
10472 /* Update cached state. */
10473 signal_cache_update (-1);
10475 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
10476 &stop_on_solib_events
, _("\
10477 Set stopping for shared library events."), _("\
10478 Show stopping for shared library events."), _("\
10479 If nonzero, gdb will give control to the user when the dynamic linker\n\
10480 notifies gdb of shared library events. The most common event of interest\n\
10481 to the user would be loading/unloading of a new library."),
10482 set_stop_on_solib_events
,
10483 show_stop_on_solib_events
,
10484 &setlist
, &showlist
);
10486 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
10487 follow_fork_mode_kind_names
,
10488 &follow_fork_mode_string
, _("\
10489 Set debugger response to a program call of fork or vfork."), _("\
10490 Show debugger response to a program call of fork or vfork."), _("\
10491 A fork or vfork creates a new process. follow-fork-mode can be:\n\
10492 parent - the original process is debugged after a fork\n\
10493 child - the new process is debugged after a fork\n\
10494 The unfollowed process will continue to run.\n\
10495 By default, the debugger will follow the parent process."),
10497 show_follow_fork_mode_string
,
10498 &setlist
, &showlist
);
10500 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
10501 follow_exec_mode_names
,
10502 &follow_exec_mode_string
, _("\
10503 Set debugger response to a program call of exec."), _("\
10504 Show debugger response to a program call of exec."), _("\
10505 An exec call replaces the program image of a process.\n\
10507 follow-exec-mode can be:\n\
10509 new - the debugger creates a new inferior and rebinds the process\n\
10510 to this new inferior. The program the process was running before\n\
10511 the exec call can be restarted afterwards by restarting the original\n\
10514 same - the debugger keeps the process bound to the same inferior.\n\
10515 The new executable image replaces the previous executable loaded in\n\
10516 the inferior. Restarting the inferior after the exec call restarts\n\
10517 the executable the process was running after the exec call.\n\
10519 By default, the debugger will use the same inferior."),
10521 show_follow_exec_mode_string
,
10522 &setlist
, &showlist
);
10524 add_setshow_enum_cmd ("scheduler-locking", class_run
,
10525 scheduler_enums
, &scheduler_mode
, _("\
10526 Set mode for locking scheduler during execution."), _("\
10527 Show mode for locking scheduler during execution."), _("\
10528 off == no locking (threads may preempt at any time)\n\
10529 on == full locking (no thread except the current thread may run)\n\
10530 This applies to both normal execution and replay mode.\n\
10531 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
10532 In this mode, other threads may run during other commands.\n\
10533 This applies to both normal execution and replay mode.\n\
10534 replay == scheduler locked in replay mode and unlocked during normal execution."),
10535 set_schedlock_func
, /* traps on target vector */
10536 show_scheduler_mode
,
10537 &setlist
, &showlist
);
10539 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
10540 Set mode for resuming threads of all processes."), _("\
10541 Show mode for resuming threads of all processes."), _("\
10542 When on, execution commands (such as 'continue' or 'next') resume all\n\
10543 threads of all processes. When off (which is the default), execution\n\
10544 commands only resume the threads of the current process. The set of\n\
10545 threads that are resumed is further refined by the scheduler-locking\n\
10546 mode (see help set scheduler-locking)."),
10548 show_schedule_multiple
,
10549 &setlist
, &showlist
);
10551 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
10552 Set mode of the step operation."), _("\
10553 Show mode of the step operation."), _("\
10554 When set, doing a step over a function without debug line information\n\
10555 will stop at the first instruction of that function. Otherwise, the\n\
10556 function is skipped and the step command stops at a different source line."),
10558 show_step_stop_if_no_debug
,
10559 &setlist
, &showlist
);
10561 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
10562 &can_use_displaced_stepping
, _("\
10563 Set debugger's willingness to use displaced stepping."), _("\
10564 Show debugger's willingness to use displaced stepping."), _("\
10565 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
10566 supported by the target architecture. If off, gdb will not use displaced\n\
10567 stepping to step over breakpoints, even if such is supported by the target\n\
10568 architecture. If auto (which is the default), gdb will use displaced stepping\n\
10569 if the target architecture supports it and non-stop mode is active, but will not\n\
10570 use it in all-stop mode (see help set non-stop)."),
10572 show_can_use_displaced_stepping
,
10573 &setlist
, &showlist
);
10575 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
10576 &exec_direction
, _("Set direction of execution.\n\
10577 Options are 'forward' or 'reverse'."),
10578 _("Show direction of execution (forward/reverse)."),
10579 _("Tells gdb whether to execute forward or backward."),
10580 set_exec_direction_func
, show_exec_direction_func
,
10581 &setlist
, &showlist
);
10583 /* Set/show detach-on-fork: user-settable mode. */
10585 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
10586 Set whether gdb will detach the child of a fork."), _("\
10587 Show whether gdb will detach the child of a fork."), _("\
10588 Tells gdb whether to detach the child of a fork."),
10589 nullptr, nullptr, &setlist
, &showlist
);
10591 /* Set/show disable address space randomization mode. */
10593 add_setshow_boolean_cmd ("disable-randomization", class_support
,
10594 &disable_randomization
, _("\
10595 Set disabling of debuggee's virtual address space randomization."), _("\
10596 Show disabling of debuggee's virtual address space randomization."), _("\
10597 When this mode is on (which is the default), randomization of the virtual\n\
10598 address space is disabled. Standalone programs run with the randomization\n\
10599 enabled by default on some platforms."),
10600 &set_disable_randomization
,
10601 &show_disable_randomization
,
10602 &setlist
, &showlist
);
10604 /* ptid initializations */
10605 inferior_ptid
= null_ptid
;
10606 target_last_wait_ptid
= minus_one_ptid
;
10608 gdb::observers::thread_ptid_changed
.attach (infrun_thread_ptid_changed
,
10610 gdb::observers::thread_stop_requested
.attach (infrun_thread_stop_requested
,
10612 gdb::observers::inferior_exit
.attach (infrun_inferior_exit
, "infrun");
10613 gdb::observers::inferior_execd
.attach (infrun_inferior_execd
, "infrun");
10615 /* Explicitly create without lookup, since that tries to create a
10616 value with a void typed value, and when we get here, gdbarch
10617 isn't initialized yet. At this point, we're quite sure there
10618 isn't another convenience variable of the same name. */
10619 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, nullptr);
10621 add_setshow_boolean_cmd ("observer", no_class
,
10622 &observer_mode_1
, _("\
10623 Set whether gdb controls the inferior in observer mode."), _("\
10624 Show whether gdb controls the inferior in observer mode."), _("\
10625 In observer mode, GDB can get data from the inferior, but not\n\
10626 affect its execution. Registers and memory may not be changed,\n\
10627 breakpoints may not be set, and the program cannot be interrupted\n\
10630 show_observer_mode
,
10635 selftests::register_test ("infrun_thread_ptid_changed",
10636 selftests::infrun_thread_ptid_changed
);