1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2021 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"
40 #include "observable.h"
45 #include "mi/mi-common.h"
46 #include "event-top.h"
48 #include "record-full.h"
49 #include "inline-frame.h"
51 #include "tracepoint.h"
55 #include "completer.h"
56 #include "target-descriptions.h"
57 #include "target-dcache.h"
60 #include "gdbsupport/event-loop.h"
61 #include "thread-fsm.h"
62 #include "gdbsupport/enum-flags.h"
63 #include "progspace-and-thread.h"
64 #include "gdbsupport/gdb_optional.h"
65 #include "arch-utils.h"
66 #include "gdbsupport/scope-exit.h"
67 #include "gdbsupport/forward-scope-exit.h"
68 #include "gdbsupport/gdb_select.h"
69 #include <unordered_map>
70 #include "async-event.h"
71 #include "gdbsupport/selftest.h"
72 #include "scoped-mock-context.h"
73 #include "test-target.h"
74 #include "gdbsupport/common-debug.h"
76 /* Prototypes for local functions */
78 static void sig_print_info (enum gdb_signal
);
80 static void sig_print_header (void);
82 static void follow_inferior_reset_breakpoints (void);
84 static bool currently_stepping (struct thread_info
*tp
);
86 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
88 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
90 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
92 static bool maybe_software_singlestep (struct gdbarch
*gdbarch
);
94 static void resume (gdb_signal sig
);
96 static void wait_for_inferior (inferior
*inf
);
98 /* Asynchronous signal handler registered as event loop source for
99 when we have pending events ready to be passed to the core. */
100 static struct async_event_handler
*infrun_async_inferior_event_token
;
102 /* Stores whether infrun_async was previously enabled or disabled.
103 Starts off as -1, indicating "never enabled/disabled". */
104 static int infrun_is_async
= -1;
109 infrun_async (int enable
)
111 if (infrun_is_async
!= enable
)
113 infrun_is_async
= enable
;
115 infrun_debug_printf ("enable=%d", enable
);
118 mark_async_event_handler (infrun_async_inferior_event_token
);
120 clear_async_event_handler (infrun_async_inferior_event_token
);
127 mark_infrun_async_event_handler (void)
129 mark_async_event_handler (infrun_async_inferior_event_token
);
132 /* When set, stop the 'step' command if we enter a function which has
133 no line number information. The normal behavior is that we step
134 over such function. */
135 bool step_stop_if_no_debug
= false;
137 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
138 struct cmd_list_element
*c
, const char *value
)
140 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
143 /* proceed and normal_stop use this to notify the user when the
144 inferior stopped in a different thread than it had been running
147 static ptid_t previous_inferior_ptid
;
149 /* If set (default for legacy reasons), when following a fork, GDB
150 will detach from one of the fork branches, child or parent.
151 Exactly which branch is detached depends on 'set follow-fork-mode'
154 static bool detach_fork
= true;
156 bool debug_infrun
= false;
158 show_debug_infrun (struct ui_file
*file
, int from_tty
,
159 struct cmd_list_element
*c
, const char *value
)
161 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
164 /* Support for disabling address space randomization. */
166 bool disable_randomization
= true;
169 show_disable_randomization (struct ui_file
*file
, int from_tty
,
170 struct cmd_list_element
*c
, const char *value
)
172 if (target_supports_disable_randomization ())
173 fprintf_filtered (file
,
174 _("Disabling randomization of debuggee's "
175 "virtual address space is %s.\n"),
178 fputs_filtered (_("Disabling randomization of debuggee's "
179 "virtual address space is unsupported on\n"
180 "this platform.\n"), file
);
184 set_disable_randomization (const char *args
, int from_tty
,
185 struct cmd_list_element
*c
)
187 if (!target_supports_disable_randomization ())
188 error (_("Disabling randomization of debuggee's "
189 "virtual address space is unsupported on\n"
193 /* User interface for non-stop mode. */
195 bool non_stop
= false;
196 static bool non_stop_1
= false;
199 set_non_stop (const char *args
, int from_tty
,
200 struct cmd_list_element
*c
)
202 if (target_has_execution ())
204 non_stop_1
= non_stop
;
205 error (_("Cannot change this setting while the inferior is running."));
208 non_stop
= non_stop_1
;
212 show_non_stop (struct ui_file
*file
, int from_tty
,
213 struct cmd_list_element
*c
, const char *value
)
215 fprintf_filtered (file
,
216 _("Controlling the inferior in non-stop mode is %s.\n"),
220 /* "Observer mode" is somewhat like a more extreme version of
221 non-stop, in which all GDB operations that might affect the
222 target's execution have been disabled. */
224 static bool observer_mode
= false;
225 static bool observer_mode_1
= false;
228 set_observer_mode (const char *args
, int from_tty
,
229 struct cmd_list_element
*c
)
231 if (target_has_execution ())
233 observer_mode_1
= observer_mode
;
234 error (_("Cannot change this setting while the inferior is running."));
237 observer_mode
= observer_mode_1
;
239 may_write_registers
= !observer_mode
;
240 may_write_memory
= !observer_mode
;
241 may_insert_breakpoints
= !observer_mode
;
242 may_insert_tracepoints
= !observer_mode
;
243 /* We can insert fast tracepoints in or out of observer mode,
244 but enable them if we're going into this mode. */
246 may_insert_fast_tracepoints
= true;
247 may_stop
= !observer_mode
;
248 update_target_permissions ();
250 /* Going *into* observer mode we must force non-stop, then
251 going out we leave it that way. */
254 pagination_enabled
= 0;
255 non_stop
= non_stop_1
= true;
259 printf_filtered (_("Observer mode is now %s.\n"),
260 (observer_mode
? "on" : "off"));
264 show_observer_mode (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
, const char *value
)
267 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
270 /* This updates the value of observer mode based on changes in
271 permissions. Note that we are deliberately ignoring the values of
272 may-write-registers and may-write-memory, since the user may have
273 reason to enable these during a session, for instance to turn on a
274 debugging-related global. */
277 update_observer_mode (void)
279 bool newval
= (!may_insert_breakpoints
280 && !may_insert_tracepoints
281 && may_insert_fast_tracepoints
285 /* Let the user know if things change. */
286 if (newval
!= observer_mode
)
287 printf_filtered (_("Observer mode is now %s.\n"),
288 (newval
? "on" : "off"));
290 observer_mode
= observer_mode_1
= newval
;
293 /* Tables of how to react to signals; the user sets them. */
295 static unsigned char signal_stop
[GDB_SIGNAL_LAST
];
296 static unsigned char signal_print
[GDB_SIGNAL_LAST
];
297 static unsigned char signal_program
[GDB_SIGNAL_LAST
];
299 /* Table of signals that are registered with "catch signal". A
300 non-zero entry indicates that the signal is caught by some "catch
302 static unsigned char signal_catch
[GDB_SIGNAL_LAST
];
304 /* Table of signals that the target may silently handle.
305 This is automatically determined from the flags above,
306 and simply cached here. */
307 static unsigned char signal_pass
[GDB_SIGNAL_LAST
];
309 #define SET_SIGS(nsigs,sigs,flags) \
311 int signum = (nsigs); \
312 while (signum-- > 0) \
313 if ((sigs)[signum]) \
314 (flags)[signum] = 1; \
317 #define UNSET_SIGS(nsigs,sigs,flags) \
319 int signum = (nsigs); \
320 while (signum-- > 0) \
321 if ((sigs)[signum]) \
322 (flags)[signum] = 0; \
325 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
326 this function is to avoid exporting `signal_program'. */
329 update_signals_program_target (void)
331 target_program_signals (signal_program
);
334 /* Value to pass to target_resume() to cause all threads to resume. */
336 #define RESUME_ALL minus_one_ptid
338 /* Command list pointer for the "stop" placeholder. */
340 static struct cmd_list_element
*stop_command
;
342 /* Nonzero if we want to give control to the user when we're notified
343 of shared library events by the dynamic linker. */
344 int stop_on_solib_events
;
346 /* Enable or disable optional shared library event breakpoints
347 as appropriate when the above flag is changed. */
350 set_stop_on_solib_events (const char *args
,
351 int from_tty
, struct cmd_list_element
*c
)
353 update_solib_breakpoints ();
357 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
358 struct cmd_list_element
*c
, const char *value
)
360 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
364 /* True after stop if current stack frame should be printed. */
366 static bool stop_print_frame
;
368 /* This is a cached copy of the target/ptid/waitstatus of the last
369 event returned by target_wait()/deprecated_target_wait_hook().
370 This information is returned by get_last_target_status(). */
371 static process_stratum_target
*target_last_proc_target
;
372 static ptid_t target_last_wait_ptid
;
373 static struct target_waitstatus target_last_waitstatus
;
375 void init_thread_stepping_state (struct thread_info
*tss
);
377 static const char follow_fork_mode_child
[] = "child";
378 static const char follow_fork_mode_parent
[] = "parent";
380 static const char *const follow_fork_mode_kind_names
[] = {
381 follow_fork_mode_child
,
382 follow_fork_mode_parent
,
386 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
388 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
389 struct cmd_list_element
*c
, const char *value
)
391 fprintf_filtered (file
,
392 _("Debugger response to a program "
393 "call of fork or vfork is \"%s\".\n"),
398 /* Handle changes to the inferior list based on the type of fork,
399 which process is being followed, and whether the other process
400 should be detached. On entry inferior_ptid must be the ptid of
401 the fork parent. At return inferior_ptid is the ptid of the
402 followed inferior. */
405 follow_fork_inferior (bool follow_child
, bool detach_fork
)
407 target_waitkind fork_kind
= inferior_thread ()->pending_follow
.kind ();
408 gdb_assert (fork_kind
== TARGET_WAITKIND_FORKED
409 || fork_kind
== TARGET_WAITKIND_VFORKED
);
410 bool has_vforked
= fork_kind
== TARGET_WAITKIND_VFORKED
;
411 ptid_t parent_ptid
= inferior_ptid
;
412 ptid_t child_ptid
= inferior_thread ()->pending_follow
.child_ptid ();
415 && !non_stop
/* Non-stop always resumes both branches. */
416 && current_ui
->prompt_state
== PROMPT_BLOCKED
417 && !(follow_child
|| detach_fork
|| sched_multi
))
419 /* The parent stays blocked inside the vfork syscall until the
420 child execs or exits. If we don't let the child run, then
421 the parent stays blocked. If we're telling the parent to run
422 in the foreground, the user will not be able to ctrl-c to get
423 back the terminal, effectively hanging the debug session. */
424 fprintf_filtered (gdb_stderr
, _("\
425 Can not resume the parent process over vfork in the foreground while\n\
426 holding the child stopped. Try \"set detach-on-fork\" or \
427 \"set schedule-multiple\".\n"));
431 inferior
*parent_inf
= current_inferior ();
432 inferior
*child_inf
= nullptr;
436 /* Detach new forked process? */
439 /* Before detaching from the child, remove all breakpoints
440 from it. If we forked, then this has already been taken
441 care of by infrun.c. If we vforked however, any
442 breakpoint inserted in the parent is visible in the
443 child, even those added while stopped in a vfork
444 catchpoint. This will remove the breakpoints from the
445 parent also, but they'll be reinserted below. */
448 /* Keep breakpoints list in sync. */
449 remove_breakpoints_inf (current_inferior ());
452 if (print_inferior_events
)
454 /* Ensure that we have a process ptid. */
455 ptid_t process_ptid
= ptid_t (child_ptid
.pid ());
457 target_terminal::ours_for_output ();
458 printf_filtered (_("[Detaching after %s from child %s]\n"),
459 has_vforked
? "vfork" : "fork",
460 target_pid_to_str (process_ptid
).c_str ());
465 /* Add process to GDB's tables. */
466 child_inf
= add_inferior (child_ptid
.pid ());
468 child_inf
->attach_flag
= parent_inf
->attach_flag
;
469 copy_terminal_info (child_inf
, parent_inf
);
470 child_inf
->gdbarch
= parent_inf
->gdbarch
;
471 copy_inferior_target_desc_info (child_inf
, parent_inf
);
473 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
475 /* If this is a vfork child, then the address-space is
476 shared with the parent. */
479 child_inf
->pspace
= parent_inf
->pspace
;
480 child_inf
->aspace
= parent_inf
->aspace
;
482 exec_on_vfork (child_inf
);
484 /* The parent will be frozen until the child is done
485 with the shared region. Keep track of the
487 child_inf
->vfork_parent
= parent_inf
;
488 child_inf
->pending_detach
= 0;
489 parent_inf
->vfork_child
= child_inf
;
490 parent_inf
->pending_detach
= 0;
494 child_inf
->aspace
= new_address_space ();
495 child_inf
->pspace
= new program_space (child_inf
->aspace
);
496 child_inf
->removable
= 1;
497 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
503 /* If we detached from the child, then we have to be careful
504 to not insert breakpoints in the parent until the child
505 is done with the shared memory region. However, if we're
506 staying attached to the child, then we can and should
507 insert breakpoints, so that we can debug it. A
508 subsequent child exec or exit is enough to know when does
509 the child stops using the parent's address space. */
510 parent_inf
->waiting_for_vfork_done
= detach_fork
;
511 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
516 /* Follow the child. */
518 if (print_inferior_events
)
520 std::string parent_pid
= target_pid_to_str (parent_ptid
);
521 std::string child_pid
= target_pid_to_str (child_ptid
);
523 target_terminal::ours_for_output ();
524 printf_filtered (_("[Attaching after %s %s to child %s]\n"),
526 has_vforked
? "vfork" : "fork",
530 /* Add the new inferior first, so that the target_detach below
531 doesn't unpush the target. */
533 child_inf
= add_inferior (child_ptid
.pid ());
535 child_inf
->attach_flag
= parent_inf
->attach_flag
;
536 copy_terminal_info (child_inf
, parent_inf
);
537 child_inf
->gdbarch
= parent_inf
->gdbarch
;
538 copy_inferior_target_desc_info (child_inf
, parent_inf
);
542 /* If this is a vfork child, then the address-space is shared
544 child_inf
->aspace
= parent_inf
->aspace
;
545 child_inf
->pspace
= parent_inf
->pspace
;
547 exec_on_vfork (child_inf
);
549 else if (detach_fork
)
551 /* We follow the child and detach from the parent: move the parent's
552 program space to the child. This simplifies some things, like
553 doing "next" over fork() and landing on the expected line in the
554 child (note, that is broken with "set detach-on-fork off").
556 Before assigning brand new spaces for the parent, remove
557 breakpoints from it: because the new pspace won't match
558 currently inserted locations, the normal detach procedure
559 wouldn't remove them, and we would leave them inserted when
561 remove_breakpoints_inf (parent_inf
);
563 child_inf
->aspace
= parent_inf
->aspace
;
564 child_inf
->pspace
= parent_inf
->pspace
;
565 parent_inf
->aspace
= new_address_space ();
566 parent_inf
->pspace
= new program_space (parent_inf
->aspace
);
567 clone_program_space (parent_inf
->pspace
, child_inf
->pspace
);
569 /* The parent inferior is still the current one, so keep things
571 set_current_program_space (parent_inf
->pspace
);
575 child_inf
->aspace
= new_address_space ();
576 child_inf
->pspace
= new program_space (child_inf
->aspace
);
577 child_inf
->removable
= 1;
578 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
579 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
583 gdb_assert (current_inferior () == parent_inf
);
585 /* If we are setting up an inferior for the child, target_follow_fork is
586 responsible for pushing the appropriate targets on the new inferior's
587 target stack and adding the initial thread (with ptid CHILD_PTID).
589 If we are not setting up an inferior for the child (because following
590 the parent and detach_fork is true), it is responsible for detaching
592 target_follow_fork (child_inf
, child_ptid
, fork_kind
, follow_child
,
595 /* target_follow_fork must leave the parent as the current inferior. If we
596 want to follow the child, we make it the current one below. */
597 gdb_assert (current_inferior () == parent_inf
);
599 /* If there is a child inferior, target_follow_fork must have created a thread
601 if (child_inf
!= nullptr)
602 gdb_assert (!child_inf
->thread_list
.empty ());
604 /* Clear the parent thread's pending follow field. Do this before calling
605 target_detach, so that the target can differentiate the two following
608 - We continue past a fork with "follow-fork-mode == child" &&
609 "detach-on-fork on", and therefore detach the parent. In that
610 case the target should not detach the fork child.
611 - We run to a fork catchpoint and the user types "detach". In that
612 case, the target should detach the fork child in addition to the
615 The former case will have pending_follow cleared, the later will have
616 pending_follow set. */
617 thread_info
*parent_thread
= find_thread_ptid (parent_inf
, parent_ptid
);
618 gdb_assert (parent_thread
!= nullptr);
619 parent_thread
->pending_follow
.set_spurious ();
621 /* Detach the parent if needed. */
624 /* If we're vforking, we want to hold on to the parent until
625 the child exits or execs. At child exec or exit time we
626 can remove the old breakpoints from the parent and detach
627 or resume debugging it. Otherwise, detach the parent now;
628 we'll want to reuse it's program/address spaces, but we
629 can't set them to the child before removing breakpoints
630 from the parent, otherwise, the breakpoints module could
631 decide to remove breakpoints from the wrong process (since
632 they'd be assigned to the same address space). */
636 gdb_assert (child_inf
->vfork_parent
== NULL
);
637 gdb_assert (parent_inf
->vfork_child
== NULL
);
638 child_inf
->vfork_parent
= parent_inf
;
639 child_inf
->pending_detach
= 0;
640 parent_inf
->vfork_child
= child_inf
;
641 parent_inf
->pending_detach
= detach_fork
;
642 parent_inf
->waiting_for_vfork_done
= 0;
644 else if (detach_fork
)
646 if (print_inferior_events
)
648 /* Ensure that we have a process ptid. */
649 ptid_t process_ptid
= ptid_t (parent_ptid
.pid ());
651 target_terminal::ours_for_output ();
652 printf_filtered (_("[Detaching after fork from "
654 target_pid_to_str (process_ptid
).c_str ());
657 target_detach (parent_inf
, 0);
661 /* If we ended up creating a new inferior, call post_create_inferior to inform
662 the various subcomponents. */
663 if (child_inf
!= nullptr)
665 /* If FOLLOW_CHILD, we leave CHILD_INF as the current inferior
666 (do not restore the parent as the current inferior). */
667 gdb::optional
<scoped_restore_current_thread
> maybe_restore
;
670 maybe_restore
.emplace ();
672 switch_to_thread (*child_inf
->threads ().begin ());
673 post_create_inferior (0);
679 /* Tell the target to follow the fork we're stopped at. Returns true
680 if the inferior should be resumed; false, if the target for some
681 reason decided it's best not to resume. */
686 bool follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
687 bool should_resume
= true;
689 /* Copy user stepping state to the new inferior thread. FIXME: the
690 followed fork child thread should have a copy of most of the
691 parent thread structure's run control related fields, not just these.
692 Initialized to avoid "may be used uninitialized" warnings from gcc. */
693 struct breakpoint
*step_resume_breakpoint
= NULL
;
694 struct breakpoint
*exception_resume_breakpoint
= NULL
;
695 CORE_ADDR step_range_start
= 0;
696 CORE_ADDR step_range_end
= 0;
697 int current_line
= 0;
698 symtab
*current_symtab
= NULL
;
699 struct frame_id step_frame_id
= { 0 };
700 struct thread_fsm
*thread_fsm
= NULL
;
704 process_stratum_target
*wait_target
;
706 struct target_waitstatus wait_status
;
708 /* Get the last target status returned by target_wait(). */
709 get_last_target_status (&wait_target
, &wait_ptid
, &wait_status
);
711 /* If not stopped at a fork event, then there's nothing else to
713 if (wait_status
.kind () != TARGET_WAITKIND_FORKED
714 && wait_status
.kind () != TARGET_WAITKIND_VFORKED
)
717 /* Check if we switched over from WAIT_PTID, since the event was
719 if (wait_ptid
!= minus_one_ptid
720 && (current_inferior ()->process_target () != wait_target
721 || inferior_ptid
!= wait_ptid
))
723 /* We did. Switch back to WAIT_PTID thread, to tell the
724 target to follow it (in either direction). We'll
725 afterwards refuse to resume, and inform the user what
727 thread_info
*wait_thread
= find_thread_ptid (wait_target
, wait_ptid
);
728 switch_to_thread (wait_thread
);
729 should_resume
= false;
733 thread_info
*tp
= inferior_thread ();
735 /* If there were any forks/vforks that were caught and are now to be
736 followed, then do so now. */
737 switch (tp
->pending_follow
.kind ())
739 case TARGET_WAITKIND_FORKED
:
740 case TARGET_WAITKIND_VFORKED
:
742 ptid_t parent
, child
;
744 /* If the user did a next/step, etc, over a fork call,
745 preserve the stepping state in the fork child. */
746 if (follow_child
&& should_resume
)
748 step_resume_breakpoint
= clone_momentary_breakpoint
749 (tp
->control
.step_resume_breakpoint
);
750 step_range_start
= tp
->control
.step_range_start
;
751 step_range_end
= tp
->control
.step_range_end
;
752 current_line
= tp
->current_line
;
753 current_symtab
= tp
->current_symtab
;
754 step_frame_id
= tp
->control
.step_frame_id
;
755 exception_resume_breakpoint
756 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
757 thread_fsm
= tp
->thread_fsm
;
759 /* For now, delete the parent's sr breakpoint, otherwise,
760 parent/child sr breakpoints are considered duplicates,
761 and the child version will not be installed. Remove
762 this when the breakpoints module becomes aware of
763 inferiors and address spaces. */
764 delete_step_resume_breakpoint (tp
);
765 tp
->control
.step_range_start
= 0;
766 tp
->control
.step_range_end
= 0;
767 tp
->control
.step_frame_id
= null_frame_id
;
768 delete_exception_resume_breakpoint (tp
);
769 tp
->thread_fsm
= NULL
;
772 parent
= inferior_ptid
;
773 child
= tp
->pending_follow
.child_ptid ();
775 process_stratum_target
*parent_targ
= tp
->inf
->process_target ();
776 /* Set up inferior(s) as specified by the caller, and tell the
777 target to do whatever is necessary to follow either parent
779 if (follow_fork_inferior (follow_child
, detach_fork
))
781 /* Target refused to follow, or there's some other reason
782 we shouldn't resume. */
787 /* This makes sure we don't try to apply the "Switched
788 over from WAIT_PID" logic above. */
789 nullify_last_target_wait_ptid ();
791 /* If we followed the child, switch to it... */
794 thread_info
*child_thr
= find_thread_ptid (parent_targ
, child
);
795 switch_to_thread (child_thr
);
797 /* ... and preserve the stepping state, in case the
798 user was stepping over the fork call. */
801 tp
= inferior_thread ();
802 tp
->control
.step_resume_breakpoint
803 = step_resume_breakpoint
;
804 tp
->control
.step_range_start
= step_range_start
;
805 tp
->control
.step_range_end
= step_range_end
;
806 tp
->current_line
= current_line
;
807 tp
->current_symtab
= current_symtab
;
808 tp
->control
.step_frame_id
= step_frame_id
;
809 tp
->control
.exception_resume_breakpoint
810 = exception_resume_breakpoint
;
811 tp
->thread_fsm
= thread_fsm
;
815 /* If we get here, it was because we're trying to
816 resume from a fork catchpoint, but, the user
817 has switched threads away from the thread that
818 forked. In that case, the resume command
819 issued is most likely not applicable to the
820 child, so just warn, and refuse to resume. */
821 warning (_("Not resuming: switched threads "
822 "before following fork child."));
825 /* Reset breakpoints in the child as appropriate. */
826 follow_inferior_reset_breakpoints ();
831 case TARGET_WAITKIND_SPURIOUS
:
832 /* Nothing to follow. */
835 internal_error (__FILE__
, __LINE__
,
836 "Unexpected pending_follow.kind %d\n",
837 tp
->pending_follow
.kind ());
841 return should_resume
;
845 follow_inferior_reset_breakpoints (void)
847 struct thread_info
*tp
= inferior_thread ();
849 /* Was there a step_resume breakpoint? (There was if the user
850 did a "next" at the fork() call.) If so, explicitly reset its
851 thread number. Cloned step_resume breakpoints are disabled on
852 creation, so enable it here now that it is associated with the
855 step_resumes are a form of bp that are made to be per-thread.
856 Since we created the step_resume bp when the parent process
857 was being debugged, and now are switching to the child process,
858 from the breakpoint package's viewpoint, that's a switch of
859 "threads". We must update the bp's notion of which thread
860 it is for, or it'll be ignored when it triggers. */
862 if (tp
->control
.step_resume_breakpoint
)
864 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
865 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
868 /* Treat exception_resume breakpoints like step_resume breakpoints. */
869 if (tp
->control
.exception_resume_breakpoint
)
871 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
872 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
875 /* Reinsert all breakpoints in the child. The user may have set
876 breakpoints after catching the fork, in which case those
877 were never set in the child, but only in the parent. This makes
878 sure the inserted breakpoints match the breakpoint list. */
880 breakpoint_re_set ();
881 insert_breakpoints ();
884 /* The child has exited or execed: resume THREAD, a thread of the parent,
885 if it was meant to be executing. */
888 proceed_after_vfork_done (thread_info
*thread
)
890 if (thread
->state
== THREAD_RUNNING
891 && !thread
->executing ()
892 && !thread
->stop_requested
893 && thread
->stop_signal () == GDB_SIGNAL_0
)
895 infrun_debug_printf ("resuming vfork parent thread %s",
896 thread
->ptid
.to_string ().c_str ());
898 switch_to_thread (thread
);
899 clear_proceed_status (0);
900 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
904 /* Called whenever we notice an exec or exit event, to handle
905 detaching or resuming a vfork parent. */
908 handle_vfork_child_exec_or_exit (int exec
)
910 struct inferior
*inf
= current_inferior ();
912 if (inf
->vfork_parent
)
914 inferior
*resume_parent
= nullptr;
916 /* This exec or exit marks the end of the shared memory region
917 between the parent and the child. Break the bonds. */
918 inferior
*vfork_parent
= inf
->vfork_parent
;
919 inf
->vfork_parent
->vfork_child
= NULL
;
920 inf
->vfork_parent
= NULL
;
922 /* If the user wanted to detach from the parent, now is the
924 if (vfork_parent
->pending_detach
)
926 struct program_space
*pspace
;
927 struct address_space
*aspace
;
929 /* follow-fork child, detach-on-fork on. */
931 vfork_parent
->pending_detach
= 0;
933 scoped_restore_current_pspace_and_thread restore_thread
;
935 /* We're letting loose of the parent. */
936 thread_info
*tp
= any_live_thread_of_inferior (vfork_parent
);
937 switch_to_thread (tp
);
939 /* We're about to detach from the parent, which implicitly
940 removes breakpoints from its address space. There's a
941 catch here: we want to reuse the spaces for the child,
942 but, parent/child are still sharing the pspace at this
943 point, although the exec in reality makes the kernel give
944 the child a fresh set of new pages. The problem here is
945 that the breakpoints module being unaware of this, would
946 likely chose the child process to write to the parent
947 address space. Swapping the child temporarily away from
948 the spaces has the desired effect. Yes, this is "sort
951 pspace
= inf
->pspace
;
952 aspace
= inf
->aspace
;
956 if (print_inferior_events
)
959 = target_pid_to_str (ptid_t (vfork_parent
->pid
));
961 target_terminal::ours_for_output ();
965 printf_filtered (_("[Detaching vfork parent %s "
966 "after child exec]\n"), pidstr
.c_str ());
970 printf_filtered (_("[Detaching vfork parent %s "
971 "after child exit]\n"), pidstr
.c_str ());
975 target_detach (vfork_parent
, 0);
978 inf
->pspace
= pspace
;
979 inf
->aspace
= aspace
;
983 /* We're staying attached to the parent, so, really give the
984 child a new address space. */
985 inf
->pspace
= new program_space (maybe_new_address_space ());
986 inf
->aspace
= inf
->pspace
->aspace
;
988 set_current_program_space (inf
->pspace
);
990 resume_parent
= vfork_parent
;
994 /* If this is a vfork child exiting, then the pspace and
995 aspaces were shared with the parent. Since we're
996 reporting the process exit, we'll be mourning all that is
997 found in the address space, and switching to null_ptid,
998 preparing to start a new inferior. But, since we don't
999 want to clobber the parent's address/program spaces, we
1000 go ahead and create a new one for this exiting
1003 /* Switch to no-thread while running clone_program_space, so
1004 that clone_program_space doesn't want to read the
1005 selected frame of a dead process. */
1006 scoped_restore_current_thread restore_thread
;
1007 switch_to_no_thread ();
1009 inf
->pspace
= new program_space (maybe_new_address_space ());
1010 inf
->aspace
= inf
->pspace
->aspace
;
1011 set_current_program_space (inf
->pspace
);
1013 inf
->symfile_flags
= SYMFILE_NO_READ
;
1014 clone_program_space (inf
->pspace
, vfork_parent
->pspace
);
1016 resume_parent
= vfork_parent
;
1019 gdb_assert (current_program_space
== inf
->pspace
);
1021 if (non_stop
&& resume_parent
!= nullptr)
1023 /* If the user wanted the parent to be running, let it go
1025 scoped_restore_current_thread restore_thread
;
1027 infrun_debug_printf ("resuming vfork parent process %d",
1028 resume_parent
->pid
);
1030 for (thread_info
*thread
: resume_parent
->threads ())
1031 proceed_after_vfork_done (thread
);
1036 /* Enum strings for "set|show follow-exec-mode". */
1038 static const char follow_exec_mode_new
[] = "new";
1039 static const char follow_exec_mode_same
[] = "same";
1040 static const char *const follow_exec_mode_names
[] =
1042 follow_exec_mode_new
,
1043 follow_exec_mode_same
,
1047 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1049 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1050 struct cmd_list_element
*c
, const char *value
)
1052 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1055 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1058 follow_exec (ptid_t ptid
, const char *exec_file_target
)
1060 int pid
= ptid
.pid ();
1061 ptid_t process_ptid
;
1063 /* Switch terminal for any messages produced e.g. by
1064 breakpoint_re_set. */
1065 target_terminal::ours_for_output ();
1067 /* This is an exec event that we actually wish to pay attention to.
1068 Refresh our symbol table to the newly exec'd program, remove any
1069 momentary bp's, etc.
1071 If there are breakpoints, they aren't really inserted now,
1072 since the exec() transformed our inferior into a fresh set
1075 We want to preserve symbolic breakpoints on the list, since
1076 we have hopes that they can be reset after the new a.out's
1077 symbol table is read.
1079 However, any "raw" breakpoints must be removed from the list
1080 (e.g., the solib bp's), since their address is probably invalid
1083 And, we DON'T want to call delete_breakpoints() here, since
1084 that may write the bp's "shadow contents" (the instruction
1085 value that was overwritten with a TRAP instruction). Since
1086 we now have a new a.out, those shadow contents aren't valid. */
1088 mark_breakpoints_out ();
1090 /* The target reports the exec event to the main thread, even if
1091 some other thread does the exec, and even if the main thread was
1092 stopped or already gone. We may still have non-leader threads of
1093 the process on our list. E.g., on targets that don't have thread
1094 exit events (like remote); or on native Linux in non-stop mode if
1095 there were only two threads in the inferior and the non-leader
1096 one is the one that execs (and nothing forces an update of the
1097 thread list up to here). When debugging remotely, it's best to
1098 avoid extra traffic, when possible, so avoid syncing the thread
1099 list with the target, and instead go ahead and delete all threads
1100 of the process but one that reported the event. Note this must
1101 be done before calling update_breakpoints_after_exec, as
1102 otherwise clearing the threads' resources would reference stale
1103 thread breakpoints -- it may have been one of these threads that
1104 stepped across the exec. We could just clear their stepping
1105 states, but as long as we're iterating, might as well delete
1106 them. Deleting them now rather than at the next user-visible
1107 stop provides a nicer sequence of events for user and MI
1109 for (thread_info
*th
: all_threads_safe ())
1110 if (th
->ptid
.pid () == pid
&& th
->ptid
!= ptid
)
1113 /* We also need to clear any left over stale state for the
1114 leader/event thread. E.g., if there was any step-resume
1115 breakpoint or similar, it's gone now. We cannot truly
1116 step-to-next statement through an exec(). */
1117 thread_info
*th
= inferior_thread ();
1118 th
->control
.step_resume_breakpoint
= NULL
;
1119 th
->control
.exception_resume_breakpoint
= NULL
;
1120 th
->control
.single_step_breakpoints
= NULL
;
1121 th
->control
.step_range_start
= 0;
1122 th
->control
.step_range_end
= 0;
1124 /* The user may have had the main thread held stopped in the
1125 previous image (e.g., schedlock on, or non-stop). Release
1127 th
->stop_requested
= 0;
1129 update_breakpoints_after_exec ();
1131 /* What is this a.out's name? */
1132 process_ptid
= ptid_t (pid
);
1133 printf_unfiltered (_("%s is executing new program: %s\n"),
1134 target_pid_to_str (process_ptid
).c_str (),
1137 /* We've followed the inferior through an exec. Therefore, the
1138 inferior has essentially been killed & reborn. */
1140 breakpoint_init_inferior (inf_execd
);
1142 gdb::unique_xmalloc_ptr
<char> exec_file_host
1143 = exec_file_find (exec_file_target
, NULL
);
1145 /* If we were unable to map the executable target pathname onto a host
1146 pathname, tell the user that. Otherwise GDB's subsequent behavior
1147 is confusing. Maybe it would even be better to stop at this point
1148 so that the user can specify a file manually before continuing. */
1149 if (exec_file_host
== NULL
)
1150 warning (_("Could not load symbols for executable %s.\n"
1151 "Do you need \"set sysroot\"?"),
1154 /* Reset the shared library package. This ensures that we get a
1155 shlib event when the child reaches "_start", at which point the
1156 dld will have had a chance to initialize the child. */
1157 /* Also, loading a symbol file below may trigger symbol lookups, and
1158 we don't want those to be satisfied by the libraries of the
1159 previous incarnation of this process. */
1160 no_shared_libraries (NULL
, 0);
1162 struct inferior
*inf
= current_inferior ();
1164 if (follow_exec_mode_string
== follow_exec_mode_new
)
1166 /* The user wants to keep the old inferior and program spaces
1167 around. Create a new fresh one, and switch to it. */
1169 /* Do exit processing for the original inferior before setting the new
1170 inferior's pid. Having two inferiors with the same pid would confuse
1171 find_inferior_p(t)id. Transfer the terminal state and info from the
1172 old to the new inferior. */
1173 inferior
*new_inferior
= add_inferior_with_spaces ();
1175 swap_terminal_info (new_inferior
, inf
);
1176 exit_inferior_silent (inf
);
1178 new_inferior
->pid
= pid
;
1179 target_follow_exec (new_inferior
, ptid
, exec_file_target
);
1181 /* We continue with the new inferior. */
1186 /* The old description may no longer be fit for the new image.
1187 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1188 old description; we'll read a new one below. No need to do
1189 this on "follow-exec-mode new", as the old inferior stays
1190 around (its description is later cleared/refetched on
1192 target_clear_description ();
1193 target_follow_exec (inf
, ptid
, exec_file_target
);
1196 gdb_assert (current_inferior () == inf
);
1197 gdb_assert (current_program_space
== inf
->pspace
);
1199 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1200 because the proper displacement for a PIE (Position Independent
1201 Executable) main symbol file will only be computed by
1202 solib_create_inferior_hook below. breakpoint_re_set would fail
1203 to insert the breakpoints with the zero displacement. */
1204 try_open_exec_file (exec_file_host
.get (), inf
, SYMFILE_DEFER_BP_RESET
);
1206 /* If the target can specify a description, read it. Must do this
1207 after flipping to the new executable (because the target supplied
1208 description must be compatible with the executable's
1209 architecture, and the old executable may e.g., be 32-bit, while
1210 the new one 64-bit), and before anything involving memory or
1212 target_find_description ();
1214 gdb::observers::inferior_execd
.notify (inf
);
1216 breakpoint_re_set ();
1218 /* Reinsert all breakpoints. (Those which were symbolic have
1219 been reset to the proper address in the new a.out, thanks
1220 to symbol_file_command...). */
1221 insert_breakpoints ();
1223 /* The next resume of this inferior should bring it to the shlib
1224 startup breakpoints. (If the user had also set bp's on
1225 "main" from the old (parent) process, then they'll auto-
1226 matically get reset there in the new process.). */
1229 /* The chain of threads that need to do a step-over operation to get
1230 past e.g., a breakpoint. What technique is used to step over the
1231 breakpoint/watchpoint does not matter -- all threads end up in the
1232 same queue, to maintain rough temporal order of execution, in order
1233 to avoid starvation, otherwise, we could e.g., find ourselves
1234 constantly stepping the same couple threads past their breakpoints
1235 over and over, if the single-step finish fast enough. */
1236 thread_step_over_list global_thread_step_over_list
;
1238 /* Bit flags indicating what the thread needs to step over. */
1240 enum step_over_what_flag
1242 /* Step over a breakpoint. */
1243 STEP_OVER_BREAKPOINT
= 1,
1245 /* Step past a non-continuable watchpoint, in order to let the
1246 instruction execute so we can evaluate the watchpoint
1248 STEP_OVER_WATCHPOINT
= 2
1250 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag
, step_over_what
);
1252 /* Info about an instruction that is being stepped over. */
1254 struct step_over_info
1256 /* If we're stepping past a breakpoint, this is the address space
1257 and address of the instruction the breakpoint is set at. We'll
1258 skip inserting all breakpoints here. Valid iff ASPACE is
1260 const address_space
*aspace
= nullptr;
1261 CORE_ADDR address
= 0;
1263 /* The instruction being stepped over triggers a nonsteppable
1264 watchpoint. If true, we'll skip inserting watchpoints. */
1265 int nonsteppable_watchpoint_p
= 0;
1267 /* The thread's global number. */
1271 /* The step-over info of the location that is being stepped over.
1273 Note that with async/breakpoint always-inserted mode, a user might
1274 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1275 being stepped over. As setting a new breakpoint inserts all
1276 breakpoints, we need to make sure the breakpoint being stepped over
1277 isn't inserted then. We do that by only clearing the step-over
1278 info when the step-over is actually finished (or aborted).
1280 Presently GDB can only step over one breakpoint at any given time.
1281 Given threads that can't run code in the same address space as the
1282 breakpoint's can't really miss the breakpoint, GDB could be taught
1283 to step-over at most one breakpoint per address space (so this info
1284 could move to the address space object if/when GDB is extended).
1285 The set of breakpoints being stepped over will normally be much
1286 smaller than the set of all breakpoints, so a flag in the
1287 breakpoint location structure would be wasteful. A separate list
1288 also saves complexity and run-time, as otherwise we'd have to go
1289 through all breakpoint locations clearing their flag whenever we
1290 start a new sequence. Similar considerations weigh against storing
1291 this info in the thread object. Plus, not all step overs actually
1292 have breakpoint locations -- e.g., stepping past a single-step
1293 breakpoint, or stepping to complete a non-continuable
1295 static struct step_over_info step_over_info
;
1297 /* Record the address of the breakpoint/instruction we're currently
1299 N.B. We record the aspace and address now, instead of say just the thread,
1300 because when we need the info later the thread may be running. */
1303 set_step_over_info (const address_space
*aspace
, CORE_ADDR address
,
1304 int nonsteppable_watchpoint_p
,
1307 step_over_info
.aspace
= aspace
;
1308 step_over_info
.address
= address
;
1309 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1310 step_over_info
.thread
= thread
;
1313 /* Called when we're not longer stepping over a breakpoint / an
1314 instruction, so all breakpoints are free to be (re)inserted. */
1317 clear_step_over_info (void)
1319 infrun_debug_printf ("clearing step over info");
1320 step_over_info
.aspace
= NULL
;
1321 step_over_info
.address
= 0;
1322 step_over_info
.nonsteppable_watchpoint_p
= 0;
1323 step_over_info
.thread
= -1;
1329 stepping_past_instruction_at (struct address_space
*aspace
,
1332 return (step_over_info
.aspace
!= NULL
1333 && breakpoint_address_match (aspace
, address
,
1334 step_over_info
.aspace
,
1335 step_over_info
.address
));
1341 thread_is_stepping_over_breakpoint (int thread
)
1343 return (step_over_info
.thread
!= -1
1344 && thread
== step_over_info
.thread
);
1350 stepping_past_nonsteppable_watchpoint (void)
1352 return step_over_info
.nonsteppable_watchpoint_p
;
1355 /* Returns true if step-over info is valid. */
1358 step_over_info_valid_p (void)
1360 return (step_over_info
.aspace
!= NULL
1361 || stepping_past_nonsteppable_watchpoint ());
1365 /* Displaced stepping. */
1367 /* In non-stop debugging mode, we must take special care to manage
1368 breakpoints properly; in particular, the traditional strategy for
1369 stepping a thread past a breakpoint it has hit is unsuitable.
1370 'Displaced stepping' is a tactic for stepping one thread past a
1371 breakpoint it has hit while ensuring that other threads running
1372 concurrently will hit the breakpoint as they should.
1374 The traditional way to step a thread T off a breakpoint in a
1375 multi-threaded program in all-stop mode is as follows:
1377 a0) Initially, all threads are stopped, and breakpoints are not
1379 a1) We single-step T, leaving breakpoints uninserted.
1380 a2) We insert breakpoints, and resume all threads.
1382 In non-stop debugging, however, this strategy is unsuitable: we
1383 don't want to have to stop all threads in the system in order to
1384 continue or step T past a breakpoint. Instead, we use displaced
1387 n0) Initially, T is stopped, other threads are running, and
1388 breakpoints are inserted.
1389 n1) We copy the instruction "under" the breakpoint to a separate
1390 location, outside the main code stream, making any adjustments
1391 to the instruction, register, and memory state as directed by
1393 n2) We single-step T over the instruction at its new location.
1394 n3) We adjust the resulting register and memory state as directed
1395 by T's architecture. This includes resetting T's PC to point
1396 back into the main instruction stream.
1399 This approach depends on the following gdbarch methods:
1401 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1402 indicate where to copy the instruction, and how much space must
1403 be reserved there. We use these in step n1.
1405 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1406 address, and makes any necessary adjustments to the instruction,
1407 register contents, and memory. We use this in step n1.
1409 - gdbarch_displaced_step_fixup adjusts registers and memory after
1410 we have successfully single-stepped the instruction, to yield the
1411 same effect the instruction would have had if we had executed it
1412 at its original address. We use this in step n3.
1414 The gdbarch_displaced_step_copy_insn and
1415 gdbarch_displaced_step_fixup functions must be written so that
1416 copying an instruction with gdbarch_displaced_step_copy_insn,
1417 single-stepping across the copied instruction, and then applying
1418 gdbarch_displaced_insn_fixup should have the same effects on the
1419 thread's memory and registers as stepping the instruction in place
1420 would have. Exactly which responsibilities fall to the copy and
1421 which fall to the fixup is up to the author of those functions.
1423 See the comments in gdbarch.sh for details.
1425 Note that displaced stepping and software single-step cannot
1426 currently be used in combination, although with some care I think
1427 they could be made to. Software single-step works by placing
1428 breakpoints on all possible subsequent instructions; if the
1429 displaced instruction is a PC-relative jump, those breakpoints
1430 could fall in very strange places --- on pages that aren't
1431 executable, or at addresses that are not proper instruction
1432 boundaries. (We do generally let other threads run while we wait
1433 to hit the software single-step breakpoint, and they might
1434 encounter such a corrupted instruction.) One way to work around
1435 this would be to have gdbarch_displaced_step_copy_insn fully
1436 simulate the effect of PC-relative instructions (and return NULL)
1437 on architectures that use software single-stepping.
1439 In non-stop mode, we can have independent and simultaneous step
1440 requests, so more than one thread may need to simultaneously step
1441 over a breakpoint. The current implementation assumes there is
1442 only one scratch space per process. In this case, we have to
1443 serialize access to the scratch space. If thread A wants to step
1444 over a breakpoint, but we are currently waiting for some other
1445 thread to complete a displaced step, we leave thread A stopped and
1446 place it in the displaced_step_request_queue. Whenever a displaced
1447 step finishes, we pick the next thread in the queue and start a new
1448 displaced step operation on it. See displaced_step_prepare and
1449 displaced_step_finish for details. */
1451 /* Return true if THREAD is doing a displaced step. */
1454 displaced_step_in_progress_thread (thread_info
*thread
)
1456 gdb_assert (thread
!= NULL
);
1458 return thread
->displaced_step_state
.in_progress ();
1461 /* Return true if INF has a thread doing a displaced step. */
1464 displaced_step_in_progress (inferior
*inf
)
1466 return inf
->displaced_step_state
.in_progress_count
> 0;
1469 /* Return true if any thread is doing a displaced step. */
1472 displaced_step_in_progress_any_thread ()
1474 for (inferior
*inf
: all_non_exited_inferiors ())
1476 if (displaced_step_in_progress (inf
))
1484 infrun_inferior_exit (struct inferior
*inf
)
1486 inf
->displaced_step_state
.reset ();
1490 infrun_inferior_execd (inferior
*inf
)
1492 /* If some threads where was doing a displaced step in this inferior at the
1493 moment of the exec, they no longer exist. Even if the exec'ing thread
1494 doing a displaced step, we don't want to to any fixup nor restore displaced
1495 stepping buffer bytes. */
1496 inf
->displaced_step_state
.reset ();
1498 for (thread_info
*thread
: inf
->threads ())
1499 thread
->displaced_step_state
.reset ();
1501 /* Since an in-line step is done with everything else stopped, if there was
1502 one in progress at the time of the exec, it must have been the exec'ing
1504 clear_step_over_info ();
1507 /* If ON, and the architecture supports it, GDB will use displaced
1508 stepping to step over breakpoints. If OFF, or if the architecture
1509 doesn't support it, GDB will instead use the traditional
1510 hold-and-step approach. If AUTO (which is the default), GDB will
1511 decide which technique to use to step over breakpoints depending on
1512 whether the target works in a non-stop way (see use_displaced_stepping). */
1514 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1517 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1518 struct cmd_list_element
*c
,
1521 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1522 fprintf_filtered (file
,
1523 _("Debugger's willingness to use displaced stepping "
1524 "to step over breakpoints is %s (currently %s).\n"),
1525 value
, target_is_non_stop_p () ? "on" : "off");
1527 fprintf_filtered (file
,
1528 _("Debugger's willingness to use displaced stepping "
1529 "to step over breakpoints is %s.\n"), value
);
1532 /* Return true if the gdbarch implements the required methods to use
1533 displaced stepping. */
1536 gdbarch_supports_displaced_stepping (gdbarch
*arch
)
1538 /* Only check for the presence of `prepare`. The gdbarch verification ensures
1539 that if `prepare` is provided, so is `finish`. */
1540 return gdbarch_displaced_step_prepare_p (arch
);
1543 /* Return non-zero if displaced stepping can/should be used to step
1544 over breakpoints of thread TP. */
1547 use_displaced_stepping (thread_info
*tp
)
1549 /* If the user disabled it explicitly, don't use displaced stepping. */
1550 if (can_use_displaced_stepping
== AUTO_BOOLEAN_FALSE
)
1553 /* If "auto", only use displaced stepping if the target operates in a non-stop
1555 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1556 && !target_is_non_stop_p ())
1559 gdbarch
*gdbarch
= get_thread_regcache (tp
)->arch ();
1561 /* If the architecture doesn't implement displaced stepping, don't use
1563 if (!gdbarch_supports_displaced_stepping (gdbarch
))
1566 /* If recording, don't use displaced stepping. */
1567 if (find_record_target () != nullptr)
1570 /* If displaced stepping failed before for this inferior, don't bother trying
1572 if (tp
->inf
->displaced_step_state
.failed_before
)
1578 /* Simple function wrapper around displaced_step_thread_state::reset. */
1581 displaced_step_reset (displaced_step_thread_state
*displaced
)
1583 displaced
->reset ();
1586 /* A cleanup that wraps displaced_step_reset. We use this instead of, say,
1587 SCOPE_EXIT, because it needs to be discardable with "cleanup.release ()". */
1589 using displaced_step_reset_cleanup
= FORWARD_SCOPE_EXIT (displaced_step_reset
);
1594 displaced_step_dump_bytes (const gdb_byte
*buf
, size_t len
)
1598 for (size_t i
= 0; i
< len
; i
++)
1601 ret
+= string_printf ("%02x", buf
[i
]);
1603 ret
+= string_printf (" %02x", buf
[i
]);
1609 /* Prepare to single-step, using displaced stepping.
1611 Note that we cannot use displaced stepping when we have a signal to
1612 deliver. If we have a signal to deliver and an instruction to step
1613 over, then after the step, there will be no indication from the
1614 target whether the thread entered a signal handler or ignored the
1615 signal and stepped over the instruction successfully --- both cases
1616 result in a simple SIGTRAP. In the first case we mustn't do a
1617 fixup, and in the second case we must --- but we can't tell which.
1618 Comments in the code for 'random signals' in handle_inferior_event
1619 explain how we handle this case instead.
1621 Returns DISPLACED_STEP_PREPARE_STATUS_OK if preparing was successful -- this
1622 thread is going to be stepped now; DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
1623 if displaced stepping this thread got queued; or
1624 DISPLACED_STEP_PREPARE_STATUS_CANT if this instruction can't be displaced
1627 static displaced_step_prepare_status
1628 displaced_step_prepare_throw (thread_info
*tp
)
1630 regcache
*regcache
= get_thread_regcache (tp
);
1631 struct gdbarch
*gdbarch
= regcache
->arch ();
1632 displaced_step_thread_state
&disp_step_thread_state
1633 = tp
->displaced_step_state
;
1635 /* We should never reach this function if the architecture does not
1636 support displaced stepping. */
1637 gdb_assert (gdbarch_supports_displaced_stepping (gdbarch
));
1639 /* Nor if the thread isn't meant to step over a breakpoint. */
1640 gdb_assert (tp
->control
.trap_expected
);
1642 /* Disable range stepping while executing in the scratch pad. We
1643 want a single-step even if executing the displaced instruction in
1644 the scratch buffer lands within the stepping range (e.g., a
1646 tp
->control
.may_range_step
= 0;
1648 /* We are about to start a displaced step for this thread. If one is already
1649 in progress, something's wrong. */
1650 gdb_assert (!disp_step_thread_state
.in_progress ());
1652 if (tp
->inf
->displaced_step_state
.unavailable
)
1654 /* The gdbarch tells us it's not worth asking to try a prepare because
1655 it is likely that it will return unavailable, so don't bother asking. */
1657 displaced_debug_printf ("deferring step of %s",
1658 tp
->ptid
.to_string ().c_str ());
1660 global_thread_step_over_chain_enqueue (tp
);
1661 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1664 displaced_debug_printf ("displaced-stepping %s now",
1665 tp
->ptid
.to_string ().c_str ());
1667 scoped_restore_current_thread restore_thread
;
1669 switch_to_thread (tp
);
1671 CORE_ADDR original_pc
= regcache_read_pc (regcache
);
1672 CORE_ADDR displaced_pc
;
1674 displaced_step_prepare_status status
1675 = gdbarch_displaced_step_prepare (gdbarch
, tp
, displaced_pc
);
1677 if (status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
1679 displaced_debug_printf ("failed to prepare (%s)",
1680 tp
->ptid
.to_string ().c_str ());
1682 return DISPLACED_STEP_PREPARE_STATUS_CANT
;
1684 else if (status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
1686 /* Not enough displaced stepping resources available, defer this
1687 request by placing it the queue. */
1689 displaced_debug_printf ("not enough resources available, "
1690 "deferring step of %s",
1691 tp
->ptid
.to_string ().c_str ());
1693 global_thread_step_over_chain_enqueue (tp
);
1695 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1698 gdb_assert (status
== DISPLACED_STEP_PREPARE_STATUS_OK
);
1700 /* Save the information we need to fix things up if the step
1702 disp_step_thread_state
.set (gdbarch
);
1704 tp
->inf
->displaced_step_state
.in_progress_count
++;
1706 displaced_debug_printf ("prepared successfully thread=%s, "
1707 "original_pc=%s, displaced_pc=%s",
1708 tp
->ptid
.to_string ().c_str (),
1709 paddress (gdbarch
, original_pc
),
1710 paddress (gdbarch
, displaced_pc
));
1712 return DISPLACED_STEP_PREPARE_STATUS_OK
;
1715 /* Wrapper for displaced_step_prepare_throw that disabled further
1716 attempts at displaced stepping if we get a memory error. */
1718 static displaced_step_prepare_status
1719 displaced_step_prepare (thread_info
*thread
)
1721 displaced_step_prepare_status status
1722 = DISPLACED_STEP_PREPARE_STATUS_CANT
;
1726 status
= displaced_step_prepare_throw (thread
);
1728 catch (const gdb_exception_error
&ex
)
1730 if (ex
.error
!= MEMORY_ERROR
1731 && ex
.error
!= NOT_SUPPORTED_ERROR
)
1734 infrun_debug_printf ("caught exception, disabling displaced stepping: %s",
1737 /* Be verbose if "set displaced-stepping" is "on", silent if
1739 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1741 warning (_("disabling displaced stepping: %s"),
1745 /* Disable further displaced stepping attempts. */
1746 thread
->inf
->displaced_step_state
.failed_before
= 1;
1752 /* If we displaced stepped an instruction successfully, adjust registers and
1753 memory to yield the same effect the instruction would have had if we had
1754 executed it at its original address, and return
1755 DISPLACED_STEP_FINISH_STATUS_OK. If the instruction didn't complete,
1756 relocate the PC and return DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED.
1758 If the thread wasn't displaced stepping, return
1759 DISPLACED_STEP_FINISH_STATUS_OK as well. */
1761 static displaced_step_finish_status
1762 displaced_step_finish (thread_info
*event_thread
, enum gdb_signal signal
)
1764 displaced_step_thread_state
*displaced
= &event_thread
->displaced_step_state
;
1766 /* Was this thread performing a displaced step? */
1767 if (!displaced
->in_progress ())
1768 return DISPLACED_STEP_FINISH_STATUS_OK
;
1770 gdb_assert (event_thread
->inf
->displaced_step_state
.in_progress_count
> 0);
1771 event_thread
->inf
->displaced_step_state
.in_progress_count
--;
1773 /* Fixup may need to read memory/registers. Switch to the thread
1774 that we're fixing up. Also, target_stopped_by_watchpoint checks
1775 the current thread, and displaced_step_restore performs ptid-dependent
1776 memory accesses using current_inferior(). */
1777 switch_to_thread (event_thread
);
1779 displaced_step_reset_cleanup
cleanup (displaced
);
1781 /* Do the fixup, and release the resources acquired to do the displaced
1783 return gdbarch_displaced_step_finish (displaced
->get_original_gdbarch (),
1784 event_thread
, signal
);
1787 /* Data to be passed around while handling an event. This data is
1788 discarded between events. */
1789 struct execution_control_state
1791 execution_control_state ()
1798 this->target
= nullptr;
1799 this->ptid
= null_ptid
;
1800 this->event_thread
= nullptr;
1801 ws
= target_waitstatus ();
1802 stop_func_filled_in
= 0;
1803 stop_func_start
= 0;
1805 stop_func_name
= nullptr;
1807 hit_singlestep_breakpoint
= 0;
1810 process_stratum_target
*target
;
1812 /* The thread that got the event, if this was a thread event; NULL
1814 struct thread_info
*event_thread
;
1816 struct target_waitstatus ws
;
1817 int stop_func_filled_in
;
1818 CORE_ADDR stop_func_start
;
1819 CORE_ADDR stop_func_end
;
1820 const char *stop_func_name
;
1823 /* True if the event thread hit the single-step breakpoint of
1824 another thread. Thus the event doesn't cause a stop, the thread
1825 needs to be single-stepped past the single-step breakpoint before
1826 we can switch back to the original stepping thread. */
1827 int hit_singlestep_breakpoint
;
1830 /* Clear ECS and set it to point at TP. */
1833 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
1836 ecs
->event_thread
= tp
;
1837 ecs
->ptid
= tp
->ptid
;
1840 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
1841 static void prepare_to_wait (struct execution_control_state
*ecs
);
1842 static bool keep_going_stepped_thread (struct thread_info
*tp
);
1843 static step_over_what
thread_still_needs_step_over (struct thread_info
*tp
);
1845 /* Are there any pending step-over requests? If so, run all we can
1846 now and return true. Otherwise, return false. */
1849 start_step_over (void)
1851 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
1853 /* Don't start a new step-over if we already have an in-line
1854 step-over operation ongoing. */
1855 if (step_over_info_valid_p ())
1858 /* Steal the global thread step over chain. As we try to initiate displaced
1859 steps, threads will be enqueued in the global chain if no buffers are
1860 available. If we iterated on the global chain directly, we might iterate
1862 thread_step_over_list threads_to_step
1863 = std::move (global_thread_step_over_list
);
1865 infrun_debug_printf ("stealing global queue of threads to step, length = %d",
1866 thread_step_over_chain_length (threads_to_step
));
1868 bool started
= false;
1870 /* On scope exit (whatever the reason, return or exception), if there are
1871 threads left in the THREADS_TO_STEP chain, put back these threads in the
1875 if (threads_to_step
.empty ())
1876 infrun_debug_printf ("step-over queue now empty");
1879 infrun_debug_printf ("putting back %d threads to step in global queue",
1880 thread_step_over_chain_length (threads_to_step
));
1882 global_thread_step_over_chain_enqueue_chain
1883 (std::move (threads_to_step
));
1887 thread_step_over_list_safe_range range
1888 = make_thread_step_over_list_safe_range (threads_to_step
);
1890 for (thread_info
*tp
: range
)
1892 struct execution_control_state ecss
;
1893 struct execution_control_state
*ecs
= &ecss
;
1894 step_over_what step_what
;
1895 int must_be_in_line
;
1897 gdb_assert (!tp
->stop_requested
);
1899 if (tp
->inf
->displaced_step_state
.unavailable
)
1901 /* The arch told us to not even try preparing another displaced step
1902 for this inferior. Just leave the thread in THREADS_TO_STEP, it
1903 will get moved to the global chain on scope exit. */
1907 /* Remove thread from the THREADS_TO_STEP chain. If anything goes wrong
1908 while we try to prepare the displaced step, we don't add it back to
1909 the global step over chain. This is to avoid a thread staying in the
1910 step over chain indefinitely if something goes wrong when resuming it
1911 If the error is intermittent and it still needs a step over, it will
1912 get enqueued again when we try to resume it normally. */
1913 threads_to_step
.erase (threads_to_step
.iterator_to (*tp
));
1915 step_what
= thread_still_needs_step_over (tp
);
1916 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
1917 || ((step_what
& STEP_OVER_BREAKPOINT
)
1918 && !use_displaced_stepping (tp
)));
1920 /* We currently stop all threads of all processes to step-over
1921 in-line. If we need to start a new in-line step-over, let
1922 any pending displaced steps finish first. */
1923 if (must_be_in_line
&& displaced_step_in_progress_any_thread ())
1925 global_thread_step_over_chain_enqueue (tp
);
1929 if (tp
->control
.trap_expected
1931 || tp
->executing ())
1933 internal_error (__FILE__
, __LINE__
,
1934 "[%s] has inconsistent state: "
1935 "trap_expected=%d, resumed=%d, executing=%d\n",
1936 tp
->ptid
.to_string ().c_str (),
1937 tp
->control
.trap_expected
,
1942 infrun_debug_printf ("resuming [%s] for step-over",
1943 tp
->ptid
.to_string ().c_str ());
1945 /* keep_going_pass_signal skips the step-over if the breakpoint
1946 is no longer inserted. In all-stop, we want to keep looking
1947 for a thread that needs a step-over instead of resuming TP,
1948 because we wouldn't be able to resume anything else until the
1949 target stops again. In non-stop, the resume always resumes
1950 only TP, so it's OK to let the thread resume freely. */
1951 if (!target_is_non_stop_p () && !step_what
)
1954 switch_to_thread (tp
);
1955 reset_ecs (ecs
, tp
);
1956 keep_going_pass_signal (ecs
);
1958 if (!ecs
->wait_some_more
)
1959 error (_("Command aborted."));
1961 /* If the thread's step over could not be initiated because no buffers
1962 were available, it was re-added to the global step over chain. */
1965 infrun_debug_printf ("[%s] was resumed.",
1966 tp
->ptid
.to_string ().c_str ());
1967 gdb_assert (!thread_is_in_step_over_chain (tp
));
1971 infrun_debug_printf ("[%s] was NOT resumed.",
1972 tp
->ptid
.to_string ().c_str ());
1973 gdb_assert (thread_is_in_step_over_chain (tp
));
1976 /* If we started a new in-line step-over, we're done. */
1977 if (step_over_info_valid_p ())
1979 gdb_assert (tp
->control
.trap_expected
);
1984 if (!target_is_non_stop_p ())
1986 /* On all-stop, shouldn't have resumed unless we needed a
1988 gdb_assert (tp
->control
.trap_expected
1989 || tp
->step_after_step_resume_breakpoint
);
1991 /* With remote targets (at least), in all-stop, we can't
1992 issue any further remote commands until the program stops
1998 /* Either the thread no longer needed a step-over, or a new
1999 displaced stepping sequence started. Even in the latter
2000 case, continue looking. Maybe we can also start another
2001 displaced step on a thread of other process. */
2007 /* Update global variables holding ptids to hold NEW_PTID if they were
2008 holding OLD_PTID. */
2010 infrun_thread_ptid_changed (process_stratum_target
*target
,
2011 ptid_t old_ptid
, ptid_t new_ptid
)
2013 if (inferior_ptid
== old_ptid
2014 && current_inferior ()->process_target () == target
)
2015 inferior_ptid
= new_ptid
;
2020 static const char schedlock_off
[] = "off";
2021 static const char schedlock_on
[] = "on";
2022 static const char schedlock_step
[] = "step";
2023 static const char schedlock_replay
[] = "replay";
2024 static const char *const scheduler_enums
[] = {
2031 static const char *scheduler_mode
= schedlock_replay
;
2033 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2034 struct cmd_list_element
*c
, const char *value
)
2036 fprintf_filtered (file
,
2037 _("Mode for locking scheduler "
2038 "during execution is \"%s\".\n"),
2043 set_schedlock_func (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2045 if (!target_can_lock_scheduler ())
2047 scheduler_mode
= schedlock_off
;
2048 error (_("Target '%s' cannot support this command."),
2049 target_shortname ());
2053 /* True if execution commands resume all threads of all processes by
2054 default; otherwise, resume only threads of the current inferior
2056 bool sched_multi
= false;
2058 /* Try to setup for software single stepping. Return true if target_resume()
2059 should use hardware single step.
2061 GDBARCH the current gdbarch. */
2064 maybe_software_singlestep (struct gdbarch
*gdbarch
)
2066 bool hw_step
= true;
2068 if (execution_direction
== EXEC_FORWARD
2069 && gdbarch_software_single_step_p (gdbarch
))
2070 hw_step
= !insert_single_step_breakpoints (gdbarch
);
2078 user_visible_resume_ptid (int step
)
2084 /* With non-stop mode on, threads are always handled
2086 resume_ptid
= inferior_ptid
;
2088 else if ((scheduler_mode
== schedlock_on
)
2089 || (scheduler_mode
== schedlock_step
&& step
))
2091 /* User-settable 'scheduler' mode requires solo thread
2093 resume_ptid
= inferior_ptid
;
2095 else if ((scheduler_mode
== schedlock_replay
)
2096 && target_record_will_replay (minus_one_ptid
, execution_direction
))
2098 /* User-settable 'scheduler' mode requires solo thread resume in replay
2100 resume_ptid
= inferior_ptid
;
2102 else if (!sched_multi
&& target_supports_multi_process ())
2104 /* Resume all threads of the current process (and none of other
2106 resume_ptid
= ptid_t (inferior_ptid
.pid ());
2110 /* Resume all threads of all processes. */
2111 resume_ptid
= RESUME_ALL
;
2119 process_stratum_target
*
2120 user_visible_resume_target (ptid_t resume_ptid
)
2122 return (resume_ptid
== minus_one_ptid
&& sched_multi
2124 : current_inferior ()->process_target ());
2127 /* Return a ptid representing the set of threads that we will resume,
2128 in the perspective of the target, assuming run control handling
2129 does not require leaving some threads stopped (e.g., stepping past
2130 breakpoint). USER_STEP indicates whether we're about to start the
2131 target for a stepping command. */
2134 internal_resume_ptid (int user_step
)
2136 /* In non-stop, we always control threads individually. Note that
2137 the target may always work in non-stop mode even with "set
2138 non-stop off", in which case user_visible_resume_ptid could
2139 return a wildcard ptid. */
2140 if (target_is_non_stop_p ())
2141 return inferior_ptid
;
2143 return user_visible_resume_ptid (user_step
);
2146 /* Wrapper for target_resume, that handles infrun-specific
2150 do_target_resume (ptid_t resume_ptid
, bool step
, enum gdb_signal sig
)
2152 struct thread_info
*tp
= inferior_thread ();
2154 gdb_assert (!tp
->stop_requested
);
2156 /* Install inferior's terminal modes. */
2157 target_terminal::inferior ();
2159 /* Avoid confusing the next resume, if the next stop/resume
2160 happens to apply to another thread. */
2161 tp
->set_stop_signal (GDB_SIGNAL_0
);
2163 /* Advise target which signals may be handled silently.
2165 If we have removed breakpoints because we are stepping over one
2166 in-line (in any thread), we need to receive all signals to avoid
2167 accidentally skipping a breakpoint during execution of a signal
2170 Likewise if we're displaced stepping, otherwise a trap for a
2171 breakpoint in a signal handler might be confused with the
2172 displaced step finishing. We don't make the displaced_step_finish
2173 step distinguish the cases instead, because:
2175 - a backtrace while stopped in the signal handler would show the
2176 scratch pad as frame older than the signal handler, instead of
2177 the real mainline code.
2179 - when the thread is later resumed, the signal handler would
2180 return to the scratch pad area, which would no longer be
2182 if (step_over_info_valid_p ()
2183 || displaced_step_in_progress (tp
->inf
))
2184 target_pass_signals ({});
2186 target_pass_signals (signal_pass
);
2188 target_resume (resume_ptid
, step
, sig
);
2190 if (target_can_async_p ())
2194 /* Resume the inferior. SIG is the signal to give the inferior
2195 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2196 call 'resume', which handles exceptions. */
2199 resume_1 (enum gdb_signal sig
)
2201 struct regcache
*regcache
= get_current_regcache ();
2202 struct gdbarch
*gdbarch
= regcache
->arch ();
2203 struct thread_info
*tp
= inferior_thread ();
2204 const address_space
*aspace
= regcache
->aspace ();
2206 /* This represents the user's step vs continue request. When
2207 deciding whether "set scheduler-locking step" applies, it's the
2208 user's intention that counts. */
2209 const int user_step
= tp
->control
.stepping_command
;
2210 /* This represents what we'll actually request the target to do.
2211 This can decay from a step to a continue, if e.g., we need to
2212 implement single-stepping with breakpoints (software
2216 gdb_assert (!tp
->stop_requested
);
2217 gdb_assert (!thread_is_in_step_over_chain (tp
));
2219 if (tp
->has_pending_waitstatus ())
2222 ("thread %s has pending wait "
2223 "status %s (currently_stepping=%d).",
2224 tp
->ptid
.to_string ().c_str (),
2225 tp
->pending_waitstatus ().to_string ().c_str (),
2226 currently_stepping (tp
));
2228 tp
->inf
->process_target ()->threads_executing
= true;
2229 tp
->set_resumed (true);
2231 /* FIXME: What should we do if we are supposed to resume this
2232 thread with a signal? Maybe we should maintain a queue of
2233 pending signals to deliver. */
2234 if (sig
!= GDB_SIGNAL_0
)
2236 warning (_("Couldn't deliver signal %s to %s."),
2237 gdb_signal_to_name (sig
),
2238 tp
->ptid
.to_string ().c_str ());
2241 tp
->set_stop_signal (GDB_SIGNAL_0
);
2243 if (target_can_async_p ())
2246 /* Tell the event loop we have an event to process. */
2247 mark_async_event_handler (infrun_async_inferior_event_token
);
2252 tp
->stepped_breakpoint
= 0;
2254 /* Depends on stepped_breakpoint. */
2255 step
= currently_stepping (tp
);
2257 if (current_inferior ()->waiting_for_vfork_done
)
2259 /* Don't try to single-step a vfork parent that is waiting for
2260 the child to get out of the shared memory region (by exec'ing
2261 or exiting). This is particularly important on software
2262 single-step archs, as the child process would trip on the
2263 software single step breakpoint inserted for the parent
2264 process. Since the parent will not actually execute any
2265 instruction until the child is out of the shared region (such
2266 are vfork's semantics), it is safe to simply continue it.
2267 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2268 the parent, and tell it to `keep_going', which automatically
2269 re-sets it stepping. */
2270 infrun_debug_printf ("resume : clear step");
2274 CORE_ADDR pc
= regcache_read_pc (regcache
);
2276 infrun_debug_printf ("step=%d, signal=%s, trap_expected=%d, "
2277 "current thread [%s] at %s",
2278 step
, gdb_signal_to_symbol_string (sig
),
2279 tp
->control
.trap_expected
,
2280 inferior_ptid
.to_string ().c_str (),
2281 paddress (gdbarch
, pc
));
2283 /* Normally, by the time we reach `resume', the breakpoints are either
2284 removed or inserted, as appropriate. The exception is if we're sitting
2285 at a permanent breakpoint; we need to step over it, but permanent
2286 breakpoints can't be removed. So we have to test for it here. */
2287 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2289 if (sig
!= GDB_SIGNAL_0
)
2291 /* We have a signal to pass to the inferior. The resume
2292 may, or may not take us to the signal handler. If this
2293 is a step, we'll need to stop in the signal handler, if
2294 there's one, (if the target supports stepping into
2295 handlers), or in the next mainline instruction, if
2296 there's no handler. If this is a continue, we need to be
2297 sure to run the handler with all breakpoints inserted.
2298 In all cases, set a breakpoint at the current address
2299 (where the handler returns to), and once that breakpoint
2300 is hit, resume skipping the permanent breakpoint. If
2301 that breakpoint isn't hit, then we've stepped into the
2302 signal handler (or hit some other event). We'll delete
2303 the step-resume breakpoint then. */
2305 infrun_debug_printf ("resume: skipping permanent breakpoint, "
2306 "deliver signal first");
2308 clear_step_over_info ();
2309 tp
->control
.trap_expected
= 0;
2311 if (tp
->control
.step_resume_breakpoint
== NULL
)
2313 /* Set a "high-priority" step-resume, as we don't want
2314 user breakpoints at PC to trigger (again) when this
2316 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2317 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2319 tp
->step_after_step_resume_breakpoint
= step
;
2322 insert_breakpoints ();
2326 /* There's no signal to pass, we can go ahead and skip the
2327 permanent breakpoint manually. */
2328 infrun_debug_printf ("skipping permanent breakpoint");
2329 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2330 /* Update pc to reflect the new address from which we will
2331 execute instructions. */
2332 pc
= regcache_read_pc (regcache
);
2336 /* We've already advanced the PC, so the stepping part
2337 is done. Now we need to arrange for a trap to be
2338 reported to handle_inferior_event. Set a breakpoint
2339 at the current PC, and run to it. Don't update
2340 prev_pc, because if we end in
2341 switch_back_to_stepped_thread, we want the "expected
2342 thread advanced also" branch to be taken. IOW, we
2343 don't want this thread to step further from PC
2345 gdb_assert (!step_over_info_valid_p ());
2346 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2347 insert_breakpoints ();
2349 resume_ptid
= internal_resume_ptid (user_step
);
2350 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
2351 tp
->set_resumed (true);
2357 /* If we have a breakpoint to step over, make sure to do a single
2358 step only. Same if we have software watchpoints. */
2359 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2360 tp
->control
.may_range_step
= 0;
2362 /* If displaced stepping is enabled, step over breakpoints by executing a
2363 copy of the instruction at a different address.
2365 We can't use displaced stepping when we have a signal to deliver;
2366 the comments for displaced_step_prepare explain why. The
2367 comments in the handle_inferior event for dealing with 'random
2368 signals' explain what we do instead.
2370 We can't use displaced stepping when we are waiting for vfork_done
2371 event, displaced stepping breaks the vfork child similarly as single
2372 step software breakpoint. */
2373 if (tp
->control
.trap_expected
2374 && use_displaced_stepping (tp
)
2375 && !step_over_info_valid_p ()
2376 && sig
== GDB_SIGNAL_0
2377 && !current_inferior ()->waiting_for_vfork_done
)
2379 displaced_step_prepare_status prepare_status
2380 = displaced_step_prepare (tp
);
2382 if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
2384 infrun_debug_printf ("Got placed in step-over queue");
2386 tp
->control
.trap_expected
= 0;
2389 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
2391 /* Fallback to stepping over the breakpoint in-line. */
2393 if (target_is_non_stop_p ())
2394 stop_all_threads ();
2396 set_step_over_info (regcache
->aspace (),
2397 regcache_read_pc (regcache
), 0, tp
->global_num
);
2399 step
= maybe_software_singlestep (gdbarch
);
2401 insert_breakpoints ();
2403 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_OK
)
2405 /* Update pc to reflect the new address from which we will
2406 execute instructions due to displaced stepping. */
2407 pc
= regcache_read_pc (get_thread_regcache (tp
));
2409 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
);
2412 gdb_assert_not_reached ("Invalid displaced_step_prepare_status "
2416 /* Do we need to do it the hard way, w/temp breakpoints? */
2418 step
= maybe_software_singlestep (gdbarch
);
2420 /* Currently, our software single-step implementation leads to different
2421 results than hardware single-stepping in one situation: when stepping
2422 into delivering a signal which has an associated signal handler,
2423 hardware single-step will stop at the first instruction of the handler,
2424 while software single-step will simply skip execution of the handler.
2426 For now, this difference in behavior is accepted since there is no
2427 easy way to actually implement single-stepping into a signal handler
2428 without kernel support.
2430 However, there is one scenario where this difference leads to follow-on
2431 problems: if we're stepping off a breakpoint by removing all breakpoints
2432 and then single-stepping. In this case, the software single-step
2433 behavior means that even if there is a *breakpoint* in the signal
2434 handler, GDB still would not stop.
2436 Fortunately, we can at least fix this particular issue. We detect
2437 here the case where we are about to deliver a signal while software
2438 single-stepping with breakpoints removed. In this situation, we
2439 revert the decisions to remove all breakpoints and insert single-
2440 step breakpoints, and instead we install a step-resume breakpoint
2441 at the current address, deliver the signal without stepping, and
2442 once we arrive back at the step-resume breakpoint, actually step
2443 over the breakpoint we originally wanted to step over. */
2444 if (thread_has_single_step_breakpoints_set (tp
)
2445 && sig
!= GDB_SIGNAL_0
2446 && step_over_info_valid_p ())
2448 /* If we have nested signals or a pending signal is delivered
2449 immediately after a handler returns, might already have
2450 a step-resume breakpoint set on the earlier handler. We cannot
2451 set another step-resume breakpoint; just continue on until the
2452 original breakpoint is hit. */
2453 if (tp
->control
.step_resume_breakpoint
== NULL
)
2455 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2456 tp
->step_after_step_resume_breakpoint
= 1;
2459 delete_single_step_breakpoints (tp
);
2461 clear_step_over_info ();
2462 tp
->control
.trap_expected
= 0;
2464 insert_breakpoints ();
2467 /* If STEP is set, it's a request to use hardware stepping
2468 facilities. But in that case, we should never
2469 use singlestep breakpoint. */
2470 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2472 /* Decide the set of threads to ask the target to resume. */
2473 if (tp
->control
.trap_expected
)
2475 /* We're allowing a thread to run past a breakpoint it has
2476 hit, either by single-stepping the thread with the breakpoint
2477 removed, or by displaced stepping, with the breakpoint inserted.
2478 In the former case, we need to single-step only this thread,
2479 and keep others stopped, as they can miss this breakpoint if
2480 allowed to run. That's not really a problem for displaced
2481 stepping, but, we still keep other threads stopped, in case
2482 another thread is also stopped for a breakpoint waiting for
2483 its turn in the displaced stepping queue. */
2484 resume_ptid
= inferior_ptid
;
2487 resume_ptid
= internal_resume_ptid (user_step
);
2489 if (execution_direction
!= EXEC_REVERSE
2490 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2492 /* There are two cases where we currently need to step a
2493 breakpoint instruction when we have a signal to deliver:
2495 - See handle_signal_stop where we handle random signals that
2496 could take out us out of the stepping range. Normally, in
2497 that case we end up continuing (instead of stepping) over the
2498 signal handler with a breakpoint at PC, but there are cases
2499 where we should _always_ single-step, even if we have a
2500 step-resume breakpoint, like when a software watchpoint is
2501 set. Assuming single-stepping and delivering a signal at the
2502 same time would takes us to the signal handler, then we could
2503 have removed the breakpoint at PC to step over it. However,
2504 some hardware step targets (like e.g., Mac OS) can't step
2505 into signal handlers, and for those, we need to leave the
2506 breakpoint at PC inserted, as otherwise if the handler
2507 recurses and executes PC again, it'll miss the breakpoint.
2508 So we leave the breakpoint inserted anyway, but we need to
2509 record that we tried to step a breakpoint instruction, so
2510 that adjust_pc_after_break doesn't end up confused.
2512 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2513 in one thread after another thread that was stepping had been
2514 momentarily paused for a step-over. When we re-resume the
2515 stepping thread, it may be resumed from that address with a
2516 breakpoint that hasn't trapped yet. Seen with
2517 gdb.threads/non-stop-fair-events.exp, on targets that don't
2518 do displaced stepping. */
2520 infrun_debug_printf ("resume: [%s] stepped breakpoint",
2521 tp
->ptid
.to_string ().c_str ());
2523 tp
->stepped_breakpoint
= 1;
2525 /* Most targets can step a breakpoint instruction, thus
2526 executing it normally. But if this one cannot, just
2527 continue and we will hit it anyway. */
2528 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2533 && tp
->control
.trap_expected
2534 && use_displaced_stepping (tp
)
2535 && !step_over_info_valid_p ())
2537 struct regcache
*resume_regcache
= get_thread_regcache (tp
);
2538 struct gdbarch
*resume_gdbarch
= resume_regcache
->arch ();
2539 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2542 read_memory (actual_pc
, buf
, sizeof (buf
));
2543 displaced_debug_printf ("run %s: %s",
2544 paddress (resume_gdbarch
, actual_pc
),
2545 displaced_step_dump_bytes
2546 (buf
, sizeof (buf
)).c_str ());
2549 if (tp
->control
.may_range_step
)
2551 /* If we're resuming a thread with the PC out of the step
2552 range, then we're doing some nested/finer run control
2553 operation, like stepping the thread out of the dynamic
2554 linker or the displaced stepping scratch pad. We
2555 shouldn't have allowed a range step then. */
2556 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2559 do_target_resume (resume_ptid
, step
, sig
);
2560 tp
->set_resumed (true);
2563 /* Resume the inferior. SIG is the signal to give the inferior
2564 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2565 rolls back state on error. */
2568 resume (gdb_signal sig
)
2574 catch (const gdb_exception
&ex
)
2576 /* If resuming is being aborted for any reason, delete any
2577 single-step breakpoint resume_1 may have created, to avoid
2578 confusing the following resumption, and to avoid leaving
2579 single-step breakpoints perturbing other threads, in case
2580 we're running in non-stop mode. */
2581 if (inferior_ptid
!= null_ptid
)
2582 delete_single_step_breakpoints (inferior_thread ());
2592 /* Counter that tracks number of user visible stops. This can be used
2593 to tell whether a command has proceeded the inferior past the
2594 current location. This allows e.g., inferior function calls in
2595 breakpoint commands to not interrupt the command list. When the
2596 call finishes successfully, the inferior is standing at the same
2597 breakpoint as if nothing happened (and so we don't call
2599 static ULONGEST current_stop_id
;
2606 return current_stop_id
;
2609 /* Called when we report a user visible stop. */
2617 /* Clear out all variables saying what to do when inferior is continued.
2618 First do this, then set the ones you want, then call `proceed'. */
2621 clear_proceed_status_thread (struct thread_info
*tp
)
2623 infrun_debug_printf ("%s", tp
->ptid
.to_string ().c_str ());
2625 /* If we're starting a new sequence, then the previous finished
2626 single-step is no longer relevant. */
2627 if (tp
->has_pending_waitstatus ())
2629 if (tp
->stop_reason () == TARGET_STOPPED_BY_SINGLE_STEP
)
2631 infrun_debug_printf ("pending event of %s was a finished step. "
2633 tp
->ptid
.to_string ().c_str ());
2635 tp
->clear_pending_waitstatus ();
2636 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
2641 ("thread %s has pending wait status %s (currently_stepping=%d).",
2642 tp
->ptid
.to_string ().c_str (),
2643 tp
->pending_waitstatus ().to_string ().c_str (),
2644 currently_stepping (tp
));
2648 /* If this signal should not be seen by program, give it zero.
2649 Used for debugging signals. */
2650 if (!signal_pass_state (tp
->stop_signal ()))
2651 tp
->set_stop_signal (GDB_SIGNAL_0
);
2653 delete tp
->thread_fsm
;
2654 tp
->thread_fsm
= NULL
;
2656 tp
->control
.trap_expected
= 0;
2657 tp
->control
.step_range_start
= 0;
2658 tp
->control
.step_range_end
= 0;
2659 tp
->control
.may_range_step
= 0;
2660 tp
->control
.step_frame_id
= null_frame_id
;
2661 tp
->control
.step_stack_frame_id
= null_frame_id
;
2662 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2663 tp
->control
.step_start_function
= NULL
;
2664 tp
->stop_requested
= 0;
2666 tp
->control
.stop_step
= 0;
2668 tp
->control
.proceed_to_finish
= 0;
2670 tp
->control
.stepping_command
= 0;
2672 /* Discard any remaining commands or status from previous stop. */
2673 bpstat_clear (&tp
->control
.stop_bpstat
);
2677 clear_proceed_status (int step
)
2679 /* With scheduler-locking replay, stop replaying other threads if we're
2680 not replaying the user-visible resume ptid.
2682 This is a convenience feature to not require the user to explicitly
2683 stop replaying the other threads. We're assuming that the user's
2684 intent is to resume tracing the recorded process. */
2685 if (!non_stop
&& scheduler_mode
== schedlock_replay
2686 && target_record_is_replaying (minus_one_ptid
)
2687 && !target_record_will_replay (user_visible_resume_ptid (step
),
2688 execution_direction
))
2689 target_record_stop_replaying ();
2691 if (!non_stop
&& inferior_ptid
!= null_ptid
)
2693 ptid_t resume_ptid
= user_visible_resume_ptid (step
);
2694 process_stratum_target
*resume_target
2695 = user_visible_resume_target (resume_ptid
);
2697 /* In all-stop mode, delete the per-thread status of all threads
2698 we're about to resume, implicitly and explicitly. */
2699 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
2700 clear_proceed_status_thread (tp
);
2703 if (inferior_ptid
!= null_ptid
)
2705 struct inferior
*inferior
;
2709 /* If in non-stop mode, only delete the per-thread status of
2710 the current thread. */
2711 clear_proceed_status_thread (inferior_thread ());
2714 inferior
= current_inferior ();
2715 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2718 gdb::observers::about_to_proceed
.notify ();
2721 /* Returns true if TP is still stopped at a breakpoint that needs
2722 stepping-over in order to make progress. If the breakpoint is gone
2723 meanwhile, we can skip the whole step-over dance. */
2726 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2728 if (tp
->stepping_over_breakpoint
)
2730 struct regcache
*regcache
= get_thread_regcache (tp
);
2732 if (breakpoint_here_p (regcache
->aspace (),
2733 regcache_read_pc (regcache
))
2734 == ordinary_breakpoint_here
)
2737 tp
->stepping_over_breakpoint
= 0;
2743 /* Check whether thread TP still needs to start a step-over in order
2744 to make progress when resumed. Returns an bitwise or of enum
2745 step_over_what bits, indicating what needs to be stepped over. */
2747 static step_over_what
2748 thread_still_needs_step_over (struct thread_info
*tp
)
2750 step_over_what what
= 0;
2752 if (thread_still_needs_step_over_bp (tp
))
2753 what
|= STEP_OVER_BREAKPOINT
;
2755 if (tp
->stepping_over_watchpoint
2756 && !target_have_steppable_watchpoint ())
2757 what
|= STEP_OVER_WATCHPOINT
;
2762 /* Returns true if scheduler locking applies. STEP indicates whether
2763 we're about to do a step/next-like command to a thread. */
2766 schedlock_applies (struct thread_info
*tp
)
2768 return (scheduler_mode
== schedlock_on
2769 || (scheduler_mode
== schedlock_step
2770 && tp
->control
.stepping_command
)
2771 || (scheduler_mode
== schedlock_replay
2772 && target_record_will_replay (minus_one_ptid
,
2773 execution_direction
)));
2776 /* Set process_stratum_target::COMMIT_RESUMED_STATE in all target
2777 stacks that have threads executing and don't have threads with
2781 maybe_set_commit_resumed_all_targets ()
2783 scoped_restore_current_thread restore_thread
;
2785 for (inferior
*inf
: all_non_exited_inferiors ())
2787 process_stratum_target
*proc_target
= inf
->process_target ();
2789 if (proc_target
->commit_resumed_state
)
2791 /* We already set this in a previous iteration, via another
2792 inferior sharing the process_stratum target. */
2796 /* If the target has no resumed threads, it would be useless to
2797 ask it to commit the resumed threads. */
2798 if (!proc_target
->threads_executing
)
2800 infrun_debug_printf ("not requesting commit-resumed for target "
2801 "%s, no resumed threads",
2802 proc_target
->shortname ());
2806 /* As an optimization, if a thread from this target has some
2807 status to report, handle it before requiring the target to
2808 commit its resumed threads: handling the status might lead to
2809 resuming more threads. */
2810 if (proc_target
->has_resumed_with_pending_wait_status ())
2812 infrun_debug_printf ("not requesting commit-resumed for target %s, a"
2813 " thread has a pending waitstatus",
2814 proc_target
->shortname ());
2818 switch_to_inferior_no_thread (inf
);
2820 if (target_has_pending_events ())
2822 infrun_debug_printf ("not requesting commit-resumed for target %s, "
2823 "target has pending events",
2824 proc_target
->shortname ());
2828 infrun_debug_printf ("enabling commit-resumed for target %s",
2829 proc_target
->shortname ());
2831 proc_target
->commit_resumed_state
= true;
2838 maybe_call_commit_resumed_all_targets ()
2840 scoped_restore_current_thread restore_thread
;
2842 for (inferior
*inf
: all_non_exited_inferiors ())
2844 process_stratum_target
*proc_target
= inf
->process_target ();
2846 if (!proc_target
->commit_resumed_state
)
2849 switch_to_inferior_no_thread (inf
);
2851 infrun_debug_printf ("calling commit_resumed for target %s",
2852 proc_target
->shortname());
2854 target_commit_resumed ();
2858 /* To track nesting of scoped_disable_commit_resumed objects, ensuring
2859 that only the outermost one attempts to re-enable
2861 static bool enable_commit_resumed
= true;
2865 scoped_disable_commit_resumed::scoped_disable_commit_resumed
2866 (const char *reason
)
2867 : m_reason (reason
),
2868 m_prev_enable_commit_resumed (enable_commit_resumed
)
2870 infrun_debug_printf ("reason=%s", m_reason
);
2872 enable_commit_resumed
= false;
2874 for (inferior
*inf
: all_non_exited_inferiors ())
2876 process_stratum_target
*proc_target
= inf
->process_target ();
2878 if (m_prev_enable_commit_resumed
)
2880 /* This is the outermost instance: force all
2881 COMMIT_RESUMED_STATE to false. */
2882 proc_target
->commit_resumed_state
= false;
2886 /* This is not the outermost instance, we expect
2887 COMMIT_RESUMED_STATE to have been cleared by the
2888 outermost instance. */
2889 gdb_assert (!proc_target
->commit_resumed_state
);
2897 scoped_disable_commit_resumed::reset ()
2903 infrun_debug_printf ("reason=%s", m_reason
);
2905 gdb_assert (!enable_commit_resumed
);
2907 enable_commit_resumed
= m_prev_enable_commit_resumed
;
2909 if (m_prev_enable_commit_resumed
)
2911 /* This is the outermost instance, re-enable
2912 COMMIT_RESUMED_STATE on the targets where it's possible. */
2913 maybe_set_commit_resumed_all_targets ();
2917 /* This is not the outermost instance, we expect
2918 COMMIT_RESUMED_STATE to still be false. */
2919 for (inferior
*inf
: all_non_exited_inferiors ())
2921 process_stratum_target
*proc_target
= inf
->process_target ();
2922 gdb_assert (!proc_target
->commit_resumed_state
);
2929 scoped_disable_commit_resumed::~scoped_disable_commit_resumed ()
2937 scoped_disable_commit_resumed::reset_and_commit ()
2940 maybe_call_commit_resumed_all_targets ();
2945 scoped_enable_commit_resumed::scoped_enable_commit_resumed
2946 (const char *reason
)
2947 : m_reason (reason
),
2948 m_prev_enable_commit_resumed (enable_commit_resumed
)
2950 infrun_debug_printf ("reason=%s", m_reason
);
2952 if (!enable_commit_resumed
)
2954 enable_commit_resumed
= true;
2956 /* Re-enable COMMIT_RESUMED_STATE on the targets where it's
2958 maybe_set_commit_resumed_all_targets ();
2960 maybe_call_commit_resumed_all_targets ();
2966 scoped_enable_commit_resumed::~scoped_enable_commit_resumed ()
2968 infrun_debug_printf ("reason=%s", m_reason
);
2970 gdb_assert (enable_commit_resumed
);
2972 enable_commit_resumed
= m_prev_enable_commit_resumed
;
2974 if (!enable_commit_resumed
)
2976 /* Force all COMMIT_RESUMED_STATE back to false. */
2977 for (inferior
*inf
: all_non_exited_inferiors ())
2979 process_stratum_target
*proc_target
= inf
->process_target ();
2980 proc_target
->commit_resumed_state
= false;
2985 /* Check that all the targets we're about to resume are in non-stop
2986 mode. Ideally, we'd only care whether all targets support
2987 target-async, but we're not there yet. E.g., stop_all_threads
2988 doesn't know how to handle all-stop targets. Also, the remote
2989 protocol in all-stop mode is synchronous, irrespective of
2990 target-async, which means that things like a breakpoint re-set
2991 triggered by one target would try to read memory from all targets
2995 check_multi_target_resumption (process_stratum_target
*resume_target
)
2997 if (!non_stop
&& resume_target
== nullptr)
2999 scoped_restore_current_thread restore_thread
;
3001 /* This is used to track whether we're resuming more than one
3003 process_stratum_target
*first_connection
= nullptr;
3005 /* The first inferior we see with a target that does not work in
3006 always-non-stop mode. */
3007 inferior
*first_not_non_stop
= nullptr;
3009 for (inferior
*inf
: all_non_exited_inferiors ())
3011 switch_to_inferior_no_thread (inf
);
3013 if (!target_has_execution ())
3016 process_stratum_target
*proc_target
3017 = current_inferior ()->process_target();
3019 if (!target_is_non_stop_p ())
3020 first_not_non_stop
= inf
;
3022 if (first_connection
== nullptr)
3023 first_connection
= proc_target
;
3024 else if (first_connection
!= proc_target
3025 && first_not_non_stop
!= nullptr)
3027 switch_to_inferior_no_thread (first_not_non_stop
);
3029 proc_target
= current_inferior ()->process_target();
3031 error (_("Connection %d (%s) does not support "
3032 "multi-target resumption."),
3033 proc_target
->connection_number
,
3034 make_target_connection_string (proc_target
).c_str ());
3040 /* Basic routine for continuing the program in various fashions.
3042 ADDR is the address to resume at, or -1 for resume where stopped.
3043 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
3044 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
3046 You should call clear_proceed_status before calling proceed. */
3049 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
3051 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
3053 struct regcache
*regcache
;
3054 struct gdbarch
*gdbarch
;
3056 struct execution_control_state ecss
;
3057 struct execution_control_state
*ecs
= &ecss
;
3060 /* If we're stopped at a fork/vfork, follow the branch set by the
3061 "set follow-fork-mode" command; otherwise, we'll just proceed
3062 resuming the current thread. */
3063 if (!follow_fork ())
3065 /* The target for some reason decided not to resume. */
3067 if (target_can_async_p ())
3068 inferior_event_handler (INF_EXEC_COMPLETE
);
3072 /* We'll update this if & when we switch to a new thread. */
3073 previous_inferior_ptid
= inferior_ptid
;
3075 regcache
= get_current_regcache ();
3076 gdbarch
= regcache
->arch ();
3077 const address_space
*aspace
= regcache
->aspace ();
3079 pc
= regcache_read_pc_protected (regcache
);
3081 thread_info
*cur_thr
= inferior_thread ();
3083 /* Fill in with reasonable starting values. */
3084 init_thread_stepping_state (cur_thr
);
3086 gdb_assert (!thread_is_in_step_over_chain (cur_thr
));
3089 = user_visible_resume_ptid (cur_thr
->control
.stepping_command
);
3090 process_stratum_target
*resume_target
3091 = user_visible_resume_target (resume_ptid
);
3093 check_multi_target_resumption (resume_target
);
3095 if (addr
== (CORE_ADDR
) -1)
3097 if (cur_thr
->stop_pc_p ()
3098 && pc
== cur_thr
->stop_pc ()
3099 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
3100 && execution_direction
!= EXEC_REVERSE
)
3101 /* There is a breakpoint at the address we will resume at,
3102 step one instruction before inserting breakpoints so that
3103 we do not stop right away (and report a second hit at this
3106 Note, we don't do this in reverse, because we won't
3107 actually be executing the breakpoint insn anyway.
3108 We'll be (un-)executing the previous instruction. */
3109 cur_thr
->stepping_over_breakpoint
= 1;
3110 else if (gdbarch_single_step_through_delay_p (gdbarch
)
3111 && gdbarch_single_step_through_delay (gdbarch
,
3112 get_current_frame ()))
3113 /* We stepped onto an instruction that needs to be stepped
3114 again before re-inserting the breakpoint, do so. */
3115 cur_thr
->stepping_over_breakpoint
= 1;
3119 regcache_write_pc (regcache
, addr
);
3122 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
3123 cur_thr
->set_stop_signal (siggnal
);
3125 /* If an exception is thrown from this point on, make sure to
3126 propagate GDB's knowledge of the executing state to the
3127 frontend/user running state. */
3128 scoped_finish_thread_state
finish_state (resume_target
, resume_ptid
);
3130 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3131 threads (e.g., we might need to set threads stepping over
3132 breakpoints first), from the user/frontend's point of view, all
3133 threads in RESUME_PTID are now running. Unless we're calling an
3134 inferior function, as in that case we pretend the inferior
3135 doesn't run at all. */
3136 if (!cur_thr
->control
.in_infcall
)
3137 set_running (resume_target
, resume_ptid
, true);
3139 infrun_debug_printf ("addr=%s, signal=%s", paddress (gdbarch
, addr
),
3140 gdb_signal_to_symbol_string (siggnal
));
3142 annotate_starting ();
3144 /* Make sure that output from GDB appears before output from the
3146 gdb_flush (gdb_stdout
);
3148 /* Since we've marked the inferior running, give it the terminal. A
3149 QUIT/Ctrl-C from here on is forwarded to the target (which can
3150 still detect attempts to unblock a stuck connection with repeated
3151 Ctrl-C from within target_pass_ctrlc). */
3152 target_terminal::inferior ();
3154 /* In a multi-threaded task we may select another thread and
3155 then continue or step.
3157 But if a thread that we're resuming had stopped at a breakpoint,
3158 it will immediately cause another breakpoint stop without any
3159 execution (i.e. it will report a breakpoint hit incorrectly). So
3160 we must step over it first.
3162 Look for threads other than the current (TP) that reported a
3163 breakpoint hit and haven't been resumed yet since. */
3165 /* If scheduler locking applies, we can avoid iterating over all
3167 if (!non_stop
&& !schedlock_applies (cur_thr
))
3169 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3172 switch_to_thread_no_regs (tp
);
3174 /* Ignore the current thread here. It's handled
3179 if (!thread_still_needs_step_over (tp
))
3182 gdb_assert (!thread_is_in_step_over_chain (tp
));
3184 infrun_debug_printf ("need to step-over [%s] first",
3185 tp
->ptid
.to_string ().c_str ());
3187 global_thread_step_over_chain_enqueue (tp
);
3190 switch_to_thread (cur_thr
);
3193 /* Enqueue the current thread last, so that we move all other
3194 threads over their breakpoints first. */
3195 if (cur_thr
->stepping_over_breakpoint
)
3196 global_thread_step_over_chain_enqueue (cur_thr
);
3198 /* If the thread isn't started, we'll still need to set its prev_pc,
3199 so that switch_back_to_stepped_thread knows the thread hasn't
3200 advanced. Must do this before resuming any thread, as in
3201 all-stop/remote, once we resume we can't send any other packet
3202 until the target stops again. */
3203 cur_thr
->prev_pc
= regcache_read_pc_protected (regcache
);
3206 scoped_disable_commit_resumed
disable_commit_resumed ("proceeding");
3208 started
= start_step_over ();
3210 if (step_over_info_valid_p ())
3212 /* Either this thread started a new in-line step over, or some
3213 other thread was already doing one. In either case, don't
3214 resume anything else until the step-over is finished. */
3216 else if (started
&& !target_is_non_stop_p ())
3218 /* A new displaced stepping sequence was started. In all-stop,
3219 we can't talk to the target anymore until it next stops. */
3221 else if (!non_stop
&& target_is_non_stop_p ())
3223 INFRUN_SCOPED_DEBUG_START_END
3224 ("resuming threads, all-stop-on-top-of-non-stop");
3226 /* In all-stop, but the target is always in non-stop mode.
3227 Start all other threads that are implicitly resumed too. */
3228 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3231 switch_to_thread_no_regs (tp
);
3233 if (!tp
->inf
->has_execution ())
3235 infrun_debug_printf ("[%s] target has no execution",
3236 tp
->ptid
.to_string ().c_str ());
3242 infrun_debug_printf ("[%s] resumed",
3243 tp
->ptid
.to_string ().c_str ());
3244 gdb_assert (tp
->executing () || tp
->has_pending_waitstatus ());
3248 if (thread_is_in_step_over_chain (tp
))
3250 infrun_debug_printf ("[%s] needs step-over",
3251 tp
->ptid
.to_string ().c_str ());
3255 infrun_debug_printf ("resuming %s",
3256 tp
->ptid
.to_string ().c_str ());
3258 reset_ecs (ecs
, tp
);
3259 switch_to_thread (tp
);
3260 keep_going_pass_signal (ecs
);
3261 if (!ecs
->wait_some_more
)
3262 error (_("Command aborted."));
3265 else if (!cur_thr
->resumed () && !thread_is_in_step_over_chain (cur_thr
))
3267 /* The thread wasn't started, and isn't queued, run it now. */
3268 reset_ecs (ecs
, cur_thr
);
3269 switch_to_thread (cur_thr
);
3270 keep_going_pass_signal (ecs
);
3271 if (!ecs
->wait_some_more
)
3272 error (_("Command aborted."));
3275 disable_commit_resumed
.reset_and_commit ();
3278 finish_state
.release ();
3280 /* If we've switched threads above, switch back to the previously
3281 current thread. We don't want the user to see a different
3283 switch_to_thread (cur_thr
);
3285 /* Tell the event loop to wait for it to stop. If the target
3286 supports asynchronous execution, it'll do this from within
3288 if (!target_can_async_p ())
3289 mark_async_event_handler (infrun_async_inferior_event_token
);
3293 /* Start remote-debugging of a machine over a serial link. */
3296 start_remote (int from_tty
)
3298 inferior
*inf
= current_inferior ();
3299 inf
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3301 /* Always go on waiting for the target, regardless of the mode. */
3302 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3303 indicate to wait_for_inferior that a target should timeout if
3304 nothing is returned (instead of just blocking). Because of this,
3305 targets expecting an immediate response need to, internally, set
3306 things up so that the target_wait() is forced to eventually
3308 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3309 differentiate to its caller what the state of the target is after
3310 the initial open has been performed. Here we're assuming that
3311 the target has stopped. It should be possible to eventually have
3312 target_open() return to the caller an indication that the target
3313 is currently running and GDB state should be set to the same as
3314 for an async run. */
3315 wait_for_inferior (inf
);
3317 /* Now that the inferior has stopped, do any bookkeeping like
3318 loading shared libraries. We want to do this before normal_stop,
3319 so that the displayed frame is up to date. */
3320 post_create_inferior (from_tty
);
3325 /* Initialize static vars when a new inferior begins. */
3328 init_wait_for_inferior (void)
3330 /* These are meaningless until the first time through wait_for_inferior. */
3332 breakpoint_init_inferior (inf_starting
);
3334 clear_proceed_status (0);
3336 nullify_last_target_wait_ptid ();
3338 previous_inferior_ptid
= inferior_ptid
;
3343 static void handle_inferior_event (struct execution_control_state
*ecs
);
3345 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3346 struct execution_control_state
*ecs
);
3347 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3348 struct execution_control_state
*ecs
);
3349 static void handle_signal_stop (struct execution_control_state
*ecs
);
3350 static void check_exception_resume (struct execution_control_state
*,
3351 struct frame_info
*);
3353 static void end_stepping_range (struct execution_control_state
*ecs
);
3354 static void stop_waiting (struct execution_control_state
*ecs
);
3355 static void keep_going (struct execution_control_state
*ecs
);
3356 static void process_event_stop_test (struct execution_control_state
*ecs
);
3357 static bool switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3359 /* This function is attached as a "thread_stop_requested" observer.
3360 Cleanup local state that assumed the PTID was to be resumed, and
3361 report the stop to the frontend. */
3364 infrun_thread_stop_requested (ptid_t ptid
)
3366 process_stratum_target
*curr_target
= current_inferior ()->process_target ();
3368 /* PTID was requested to stop. If the thread was already stopped,
3369 but the user/frontend doesn't know about that yet (e.g., the
3370 thread had been temporarily paused for some step-over), set up
3371 for reporting the stop now. */
3372 for (thread_info
*tp
: all_threads (curr_target
, ptid
))
3374 if (tp
->state
!= THREAD_RUNNING
)
3376 if (tp
->executing ())
3379 /* Remove matching threads from the step-over queue, so
3380 start_step_over doesn't try to resume them
3382 if (thread_is_in_step_over_chain (tp
))
3383 global_thread_step_over_chain_remove (tp
);
3385 /* If the thread is stopped, but the user/frontend doesn't
3386 know about that yet, queue a pending event, as if the
3387 thread had just stopped now. Unless the thread already had
3389 if (!tp
->has_pending_waitstatus ())
3391 target_waitstatus ws
;
3392 ws
.set_stopped (GDB_SIGNAL_0
);
3393 tp
->set_pending_waitstatus (ws
);
3396 /* Clear the inline-frame state, since we're re-processing the
3398 clear_inline_frame_state (tp
);
3400 /* If this thread was paused because some other thread was
3401 doing an inline-step over, let that finish first. Once
3402 that happens, we'll restart all threads and consume pending
3403 stop events then. */
3404 if (step_over_info_valid_p ())
3407 /* Otherwise we can process the (new) pending event now. Set
3408 it so this pending event is considered by
3410 tp
->set_resumed (true);
3415 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3417 if (target_last_proc_target
== tp
->inf
->process_target ()
3418 && target_last_wait_ptid
== tp
->ptid
)
3419 nullify_last_target_wait_ptid ();
3422 /* Delete the step resume, single-step and longjmp/exception resume
3423 breakpoints of TP. */
3426 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3428 delete_step_resume_breakpoint (tp
);
3429 delete_exception_resume_breakpoint (tp
);
3430 delete_single_step_breakpoints (tp
);
3433 /* If the target still has execution, call FUNC for each thread that
3434 just stopped. In all-stop, that's all the non-exited threads; in
3435 non-stop, that's the current thread, only. */
3437 typedef void (*for_each_just_stopped_thread_callback_func
)
3438 (struct thread_info
*tp
);
3441 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3443 if (!target_has_execution () || inferior_ptid
== null_ptid
)
3446 if (target_is_non_stop_p ())
3448 /* If in non-stop mode, only the current thread stopped. */
3449 func (inferior_thread ());
3453 /* In all-stop mode, all threads have stopped. */
3454 for (thread_info
*tp
: all_non_exited_threads ())
3459 /* Delete the step resume and longjmp/exception resume breakpoints of
3460 the threads that just stopped. */
3463 delete_just_stopped_threads_infrun_breakpoints (void)
3465 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3468 /* Delete the single-step breakpoints of the threads that just
3472 delete_just_stopped_threads_single_step_breakpoints (void)
3474 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3480 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3481 const struct target_waitstatus
&ws
)
3483 infrun_debug_printf ("target_wait (%s [%s], status) =",
3484 waiton_ptid
.to_string ().c_str (),
3485 target_pid_to_str (waiton_ptid
).c_str ());
3486 infrun_debug_printf (" %s [%s],",
3487 result_ptid
.to_string ().c_str (),
3488 target_pid_to_str (result_ptid
).c_str ());
3489 infrun_debug_printf (" %s", ws
.to_string ().c_str ());
3492 /* Select a thread at random, out of those which are resumed and have
3495 static struct thread_info
*
3496 random_pending_event_thread (inferior
*inf
, ptid_t waiton_ptid
)
3498 process_stratum_target
*proc_target
= inf
->process_target ();
3500 = proc_target
->random_resumed_with_pending_wait_status (inf
, waiton_ptid
);
3502 if (thread
== nullptr)
3504 infrun_debug_printf ("None found.");
3508 infrun_debug_printf ("Found %s.", thread
->ptid
.to_string ().c_str ());
3509 gdb_assert (thread
->resumed ());
3510 gdb_assert (thread
->has_pending_waitstatus ());
3515 /* Wrapper for target_wait that first checks whether threads have
3516 pending statuses to report before actually asking the target for
3517 more events. INF is the inferior we're using to call target_wait
3521 do_target_wait_1 (inferior
*inf
, ptid_t ptid
,
3522 target_waitstatus
*status
, target_wait_flags options
)
3525 struct thread_info
*tp
;
3527 /* We know that we are looking for an event in the target of inferior
3528 INF, but we don't know which thread the event might come from. As
3529 such we want to make sure that INFERIOR_PTID is reset so that none of
3530 the wait code relies on it - doing so is always a mistake. */
3531 switch_to_inferior_no_thread (inf
);
3533 /* First check if there is a resumed thread with a wait status
3535 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
3537 tp
= random_pending_event_thread (inf
, ptid
);
3541 infrun_debug_printf ("Waiting for specific thread %s.",
3542 ptid
.to_string ().c_str ());
3544 /* We have a specific thread to check. */
3545 tp
= find_thread_ptid (inf
, ptid
);
3546 gdb_assert (tp
!= NULL
);
3547 if (!tp
->has_pending_waitstatus ())
3552 && (tp
->stop_reason () == TARGET_STOPPED_BY_SW_BREAKPOINT
3553 || tp
->stop_reason () == TARGET_STOPPED_BY_HW_BREAKPOINT
))
3555 struct regcache
*regcache
= get_thread_regcache (tp
);
3556 struct gdbarch
*gdbarch
= regcache
->arch ();
3560 pc
= regcache_read_pc (regcache
);
3562 if (pc
!= tp
->stop_pc ())
3564 infrun_debug_printf ("PC of %s changed. was=%s, now=%s",
3565 tp
->ptid
.to_string ().c_str (),
3566 paddress (gdbarch
, tp
->stop_pc ()),
3567 paddress (gdbarch
, pc
));
3570 else if (!breakpoint_inserted_here_p (regcache
->aspace (), pc
))
3572 infrun_debug_printf ("previous breakpoint of %s, at %s gone",
3573 tp
->ptid
.to_string ().c_str (),
3574 paddress (gdbarch
, pc
));
3581 infrun_debug_printf ("pending event of %s cancelled.",
3582 tp
->ptid
.to_string ().c_str ());
3584 tp
->clear_pending_waitstatus ();
3585 target_waitstatus ws
;
3587 tp
->set_pending_waitstatus (ws
);
3588 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
3594 infrun_debug_printf ("Using pending wait status %s for %s.",
3595 tp
->pending_waitstatus ().to_string ().c_str (),
3596 tp
->ptid
.to_string ().c_str ());
3598 /* Now that we've selected our final event LWP, un-adjust its PC
3599 if it was a software breakpoint (and the target doesn't
3600 always adjust the PC itself). */
3601 if (tp
->stop_reason () == TARGET_STOPPED_BY_SW_BREAKPOINT
3602 && !target_supports_stopped_by_sw_breakpoint ())
3604 struct regcache
*regcache
;
3605 struct gdbarch
*gdbarch
;
3608 regcache
= get_thread_regcache (tp
);
3609 gdbarch
= regcache
->arch ();
3611 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3616 pc
= regcache_read_pc (regcache
);
3617 regcache_write_pc (regcache
, pc
+ decr_pc
);
3621 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
3622 *status
= tp
->pending_waitstatus ();
3623 tp
->clear_pending_waitstatus ();
3625 /* Wake up the event loop again, until all pending events are
3627 if (target_is_async_p ())
3628 mark_async_event_handler (infrun_async_inferior_event_token
);
3632 /* But if we don't find one, we'll have to wait. */
3634 /* We can't ask a non-async target to do a non-blocking wait, so this will be
3636 if (!target_can_async_p ())
3637 options
&= ~TARGET_WNOHANG
;
3639 if (deprecated_target_wait_hook
)
3640 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3642 event_ptid
= target_wait (ptid
, status
, options
);
3647 /* Wrapper for target_wait that first checks whether threads have
3648 pending statuses to report before actually asking the target for
3649 more events. Polls for events from all inferiors/targets. */
3652 do_target_wait (execution_control_state
*ecs
, target_wait_flags options
)
3654 int num_inferiors
= 0;
3655 int random_selector
;
3657 /* For fairness, we pick the first inferior/target to poll at random
3658 out of all inferiors that may report events, and then continue
3659 polling the rest of the inferior list starting from that one in a
3660 circular fashion until the whole list is polled once. */
3662 auto inferior_matches
= [] (inferior
*inf
)
3664 return inf
->process_target () != nullptr;
3667 /* First see how many matching inferiors we have. */
3668 for (inferior
*inf
: all_inferiors ())
3669 if (inferior_matches (inf
))
3672 if (num_inferiors
== 0)
3674 ecs
->ws
.set_ignore ();
3678 /* Now randomly pick an inferior out of those that matched. */
3679 random_selector
= (int)
3680 ((num_inferiors
* (double) rand ()) / (RAND_MAX
+ 1.0));
3682 if (num_inferiors
> 1)
3683 infrun_debug_printf ("Found %d inferiors, starting at #%d",
3684 num_inferiors
, random_selector
);
3686 /* Select the Nth inferior that matched. */
3688 inferior
*selected
= nullptr;
3690 for (inferior
*inf
: all_inferiors ())
3691 if (inferior_matches (inf
))
3692 if (random_selector
-- == 0)
3698 /* Now poll for events out of each of the matching inferior's
3699 targets, starting from the selected one. */
3701 auto do_wait
= [&] (inferior
*inf
)
3703 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, options
);
3704 ecs
->target
= inf
->process_target ();
3705 return (ecs
->ws
.kind () != TARGET_WAITKIND_IGNORE
);
3708 /* Needed in 'all-stop + target-non-stop' mode, because we end up
3709 here spuriously after the target is all stopped and we've already
3710 reported the stop to the user, polling for events. */
3711 scoped_restore_current_thread restore_thread
;
3713 intrusive_list_iterator
<inferior
> start
3714 = inferior_list
.iterator_to (*selected
);
3716 for (intrusive_list_iterator
<inferior
> it
= start
;
3717 it
!= inferior_list
.end ();
3720 inferior
*inf
= &*it
;
3722 if (inferior_matches (inf
) && do_wait (inf
))
3726 for (intrusive_list_iterator
<inferior
> it
= inferior_list
.begin ();
3730 inferior
*inf
= &*it
;
3732 if (inferior_matches (inf
) && do_wait (inf
))
3736 ecs
->ws
.set_ignore ();
3740 /* An event reported by wait_one. */
3742 struct wait_one_event
3744 /* The target the event came out of. */
3745 process_stratum_target
*target
;
3747 /* The PTID the event was for. */
3750 /* The waitstatus. */
3751 target_waitstatus ws
;
3754 static bool handle_one (const wait_one_event
&event
);
3755 static void restart_threads (struct thread_info
*event_thread
);
3757 /* Prepare and stabilize the inferior for detaching it. E.g.,
3758 detaching while a thread is displaced stepping is a recipe for
3759 crashing it, as nothing would readjust the PC out of the scratch
3763 prepare_for_detach (void)
3765 struct inferior
*inf
= current_inferior ();
3766 ptid_t pid_ptid
= ptid_t (inf
->pid
);
3767 scoped_restore_current_thread restore_thread
;
3769 scoped_restore restore_detaching
= make_scoped_restore (&inf
->detaching
, true);
3771 /* Remove all threads of INF from the global step-over chain. We
3772 want to stop any ongoing step-over, not start any new one. */
3773 thread_step_over_list_safe_range range
3774 = make_thread_step_over_list_safe_range (global_thread_step_over_list
);
3776 for (thread_info
*tp
: range
)
3779 infrun_debug_printf ("removing thread %s from global step over chain",
3780 tp
->ptid
.to_string ().c_str ());
3781 global_thread_step_over_chain_remove (tp
);
3784 /* If we were already in the middle of an inline step-over, and the
3785 thread stepping belongs to the inferior we're detaching, we need
3786 to restart the threads of other inferiors. */
3787 if (step_over_info
.thread
!= -1)
3789 infrun_debug_printf ("inline step-over in-process while detaching");
3791 thread_info
*thr
= find_thread_global_id (step_over_info
.thread
);
3792 if (thr
->inf
== inf
)
3794 /* Since we removed threads of INF from the step-over chain,
3795 we know this won't start a step-over for INF. */
3796 clear_step_over_info ();
3798 if (target_is_non_stop_p ())
3800 /* Start a new step-over in another thread if there's
3801 one that needs it. */
3804 /* Restart all other threads (except the
3805 previously-stepping thread, since that one is still
3807 if (!step_over_info_valid_p ())
3808 restart_threads (thr
);
3813 if (displaced_step_in_progress (inf
))
3815 infrun_debug_printf ("displaced-stepping in-process while detaching");
3817 /* Stop threads currently displaced stepping, aborting it. */
3819 for (thread_info
*thr
: inf
->non_exited_threads ())
3821 if (thr
->displaced_step_state
.in_progress ())
3823 if (thr
->executing ())
3825 if (!thr
->stop_requested
)
3827 target_stop (thr
->ptid
);
3828 thr
->stop_requested
= true;
3832 thr
->set_resumed (false);
3836 while (displaced_step_in_progress (inf
))
3838 wait_one_event event
;
3840 event
.target
= inf
->process_target ();
3841 event
.ptid
= do_target_wait_1 (inf
, pid_ptid
, &event
.ws
, 0);
3844 print_target_wait_results (pid_ptid
, event
.ptid
, event
.ws
);
3849 /* It's OK to leave some of the threads of INF stopped, since
3850 they'll be detached shortly. */
3854 /* Wait for control to return from inferior to debugger.
3856 If inferior gets a signal, we may decide to start it up again
3857 instead of returning. That is why there is a loop in this function.
3858 When this function actually returns it means the inferior
3859 should be left stopped and GDB should read more commands. */
3862 wait_for_inferior (inferior
*inf
)
3864 infrun_debug_printf ("wait_for_inferior ()");
3866 SCOPE_EXIT
{ delete_just_stopped_threads_infrun_breakpoints (); };
3868 /* If an error happens while handling the event, propagate GDB's
3869 knowledge of the executing state to the frontend/user running
3871 scoped_finish_thread_state finish_state
3872 (inf
->process_target (), minus_one_ptid
);
3876 struct execution_control_state ecss
;
3877 struct execution_control_state
*ecs
= &ecss
;
3879 overlay_cache_invalid
= 1;
3881 /* Flush target cache before starting to handle each event.
3882 Target was running and cache could be stale. This is just a
3883 heuristic. Running threads may modify target memory, but we
3884 don't get any event. */
3885 target_dcache_invalidate ();
3887 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, 0);
3888 ecs
->target
= inf
->process_target ();
3891 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, ecs
->ws
);
3893 /* Now figure out what to do with the result of the result. */
3894 handle_inferior_event (ecs
);
3896 if (!ecs
->wait_some_more
)
3900 /* No error, don't finish the state yet. */
3901 finish_state
.release ();
3904 /* Cleanup that reinstalls the readline callback handler, if the
3905 target is running in the background. If while handling the target
3906 event something triggered a secondary prompt, like e.g., a
3907 pagination prompt, we'll have removed the callback handler (see
3908 gdb_readline_wrapper_line). Need to do this as we go back to the
3909 event loop, ready to process further input. Note this has no
3910 effect if the handler hasn't actually been removed, because calling
3911 rl_callback_handler_install resets the line buffer, thus losing
3915 reinstall_readline_callback_handler_cleanup ()
3917 struct ui
*ui
= current_ui
;
3921 /* We're not going back to the top level event loop yet. Don't
3922 install the readline callback, as it'd prep the terminal,
3923 readline-style (raw, noecho) (e.g., --batch). We'll install
3924 it the next time the prompt is displayed, when we're ready
3929 if (ui
->command_editing
&& ui
->prompt_state
!= PROMPT_BLOCKED
)
3930 gdb_rl_callback_handler_reinstall ();
3933 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3934 that's just the event thread. In all-stop, that's all threads. */
3937 clean_up_just_stopped_threads_fsms (struct execution_control_state
*ecs
)
3939 if (ecs
->event_thread
!= NULL
3940 && ecs
->event_thread
->thread_fsm
!= NULL
)
3941 ecs
->event_thread
->thread_fsm
->clean_up (ecs
->event_thread
);
3945 for (thread_info
*thr
: all_non_exited_threads ())
3947 if (thr
->thread_fsm
== NULL
)
3949 if (thr
== ecs
->event_thread
)
3952 switch_to_thread (thr
);
3953 thr
->thread_fsm
->clean_up (thr
);
3956 if (ecs
->event_thread
!= NULL
)
3957 switch_to_thread (ecs
->event_thread
);
3961 /* Helper for all_uis_check_sync_execution_done that works on the
3965 check_curr_ui_sync_execution_done (void)
3967 struct ui
*ui
= current_ui
;
3969 if (ui
->prompt_state
== PROMPT_NEEDED
3971 && !gdb_in_secondary_prompt_p (ui
))
3973 target_terminal::ours ();
3974 gdb::observers::sync_execution_done
.notify ();
3975 ui_register_input_event_handler (ui
);
3982 all_uis_check_sync_execution_done (void)
3984 SWITCH_THRU_ALL_UIS ()
3986 check_curr_ui_sync_execution_done ();
3993 all_uis_on_sync_execution_starting (void)
3995 SWITCH_THRU_ALL_UIS ()
3997 if (current_ui
->prompt_state
== PROMPT_NEEDED
)
3998 async_disable_stdin ();
4002 /* Asynchronous version of wait_for_inferior. It is called by the
4003 event loop whenever a change of state is detected on the file
4004 descriptor corresponding to the target. It can be called more than
4005 once to complete a single execution command. In such cases we need
4006 to keep the state in a global variable ECSS. If it is the last time
4007 that this function is called for a single execution command, then
4008 report to the user that the inferior has stopped, and do the
4009 necessary cleanups. */
4012 fetch_inferior_event ()
4014 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
4016 struct execution_control_state ecss
;
4017 struct execution_control_state
*ecs
= &ecss
;
4020 /* Events are always processed with the main UI as current UI. This
4021 way, warnings, debug output, etc. are always consistently sent to
4022 the main console. */
4023 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, main_ui
);
4025 /* Temporarily disable pagination. Otherwise, the user would be
4026 given an option to press 'q' to quit, which would cause an early
4027 exit and could leave GDB in a half-baked state. */
4028 scoped_restore save_pagination
4029 = make_scoped_restore (&pagination_enabled
, false);
4031 /* End up with readline processing input, if necessary. */
4033 SCOPE_EXIT
{ reinstall_readline_callback_handler_cleanup (); };
4035 /* We're handling a live event, so make sure we're doing live
4036 debugging. If we're looking at traceframes while the target is
4037 running, we're going to need to get back to that mode after
4038 handling the event. */
4039 gdb::optional
<scoped_restore_current_traceframe
> maybe_restore_traceframe
;
4042 maybe_restore_traceframe
.emplace ();
4043 set_current_traceframe (-1);
4046 /* The user/frontend should not notice a thread switch due to
4047 internal events. Make sure we revert to the user selected
4048 thread and frame after handling the event and running any
4049 breakpoint commands. */
4050 scoped_restore_current_thread restore_thread
;
4052 overlay_cache_invalid
= 1;
4053 /* Flush target cache before starting to handle each event. Target
4054 was running and cache could be stale. This is just a heuristic.
4055 Running threads may modify target memory, but we don't get any
4057 target_dcache_invalidate ();
4059 scoped_restore save_exec_dir
4060 = make_scoped_restore (&execution_direction
,
4061 target_execution_direction ());
4063 /* Allow targets to pause their resumed threads while we handle
4065 scoped_disable_commit_resumed
disable_commit_resumed ("handling event");
4067 if (!do_target_wait (ecs
, TARGET_WNOHANG
))
4069 infrun_debug_printf ("do_target_wait returned no event");
4070 disable_commit_resumed
.reset_and_commit ();
4074 gdb_assert (ecs
->ws
.kind () != TARGET_WAITKIND_IGNORE
);
4076 /* Switch to the target that generated the event, so we can do
4078 switch_to_target_no_thread (ecs
->target
);
4081 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, ecs
->ws
);
4083 /* If an error happens while handling the event, propagate GDB's
4084 knowledge of the executing state to the frontend/user running
4086 ptid_t finish_ptid
= !target_is_non_stop_p () ? minus_one_ptid
: ecs
->ptid
;
4087 scoped_finish_thread_state
finish_state (ecs
->target
, finish_ptid
);
4089 /* Get executed before scoped_restore_current_thread above to apply
4090 still for the thread which has thrown the exception. */
4091 auto defer_bpstat_clear
4092 = make_scope_exit (bpstat_clear_actions
);
4093 auto defer_delete_threads
4094 = make_scope_exit (delete_just_stopped_threads_infrun_breakpoints
);
4096 /* Now figure out what to do with the result of the result. */
4097 handle_inferior_event (ecs
);
4099 if (!ecs
->wait_some_more
)
4101 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4102 bool should_stop
= true;
4103 struct thread_info
*thr
= ecs
->event_thread
;
4105 delete_just_stopped_threads_infrun_breakpoints ();
4109 struct thread_fsm
*thread_fsm
= thr
->thread_fsm
;
4111 if (thread_fsm
!= NULL
)
4112 should_stop
= thread_fsm
->should_stop (thr
);
4121 bool should_notify_stop
= true;
4124 clean_up_just_stopped_threads_fsms (ecs
);
4126 if (thr
!= NULL
&& thr
->thread_fsm
!= NULL
)
4127 should_notify_stop
= thr
->thread_fsm
->should_notify_stop ();
4129 if (should_notify_stop
)
4131 /* We may not find an inferior if this was a process exit. */
4132 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
4133 proceeded
= normal_stop ();
4138 inferior_event_handler (INF_EXEC_COMPLETE
);
4142 /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
4143 previously selected thread is gone. We have two
4144 choices - switch to no thread selected, or restore the
4145 previously selected thread (now exited). We chose the
4146 later, just because that's what GDB used to do. After
4147 this, "info threads" says "The current thread <Thread
4148 ID 2> has terminated." instead of "No thread
4152 && ecs
->ws
.kind () != TARGET_WAITKIND_NO_RESUMED
)
4153 restore_thread
.dont_restore ();
4157 defer_delete_threads
.release ();
4158 defer_bpstat_clear
.release ();
4160 /* No error, don't finish the thread states yet. */
4161 finish_state
.release ();
4163 disable_commit_resumed
.reset_and_commit ();
4165 /* This scope is used to ensure that readline callbacks are
4166 reinstalled here. */
4169 /* If a UI was in sync execution mode, and now isn't, restore its
4170 prompt (a synchronous execution command has finished, and we're
4171 ready for input). */
4172 all_uis_check_sync_execution_done ();
4175 && exec_done_display_p
4176 && (inferior_ptid
== null_ptid
4177 || inferior_thread ()->state
!= THREAD_RUNNING
))
4178 printf_unfiltered (_("completed.\n"));
4184 set_step_info (thread_info
*tp
, struct frame_info
*frame
,
4185 struct symtab_and_line sal
)
4187 /* This can be removed once this function no longer implicitly relies on the
4188 inferior_ptid value. */
4189 gdb_assert (inferior_ptid
== tp
->ptid
);
4191 tp
->control
.step_frame_id
= get_frame_id (frame
);
4192 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
4194 tp
->current_symtab
= sal
.symtab
;
4195 tp
->current_line
= sal
.line
;
4198 /* Clear context switchable stepping state. */
4201 init_thread_stepping_state (struct thread_info
*tss
)
4203 tss
->stepped_breakpoint
= 0;
4204 tss
->stepping_over_breakpoint
= 0;
4205 tss
->stepping_over_watchpoint
= 0;
4206 tss
->step_after_step_resume_breakpoint
= 0;
4212 set_last_target_status (process_stratum_target
*target
, ptid_t ptid
,
4213 const target_waitstatus
&status
)
4215 target_last_proc_target
= target
;
4216 target_last_wait_ptid
= ptid
;
4217 target_last_waitstatus
= status
;
4223 get_last_target_status (process_stratum_target
**target
, ptid_t
*ptid
,
4224 target_waitstatus
*status
)
4226 if (target
!= nullptr)
4227 *target
= target_last_proc_target
;
4228 if (ptid
!= nullptr)
4229 *ptid
= target_last_wait_ptid
;
4230 if (status
!= nullptr)
4231 *status
= target_last_waitstatus
;
4237 nullify_last_target_wait_ptid (void)
4239 target_last_proc_target
= nullptr;
4240 target_last_wait_ptid
= minus_one_ptid
;
4241 target_last_waitstatus
= {};
4244 /* Switch thread contexts. */
4247 context_switch (execution_control_state
*ecs
)
4249 if (ecs
->ptid
!= inferior_ptid
4250 && (inferior_ptid
== null_ptid
4251 || ecs
->event_thread
!= inferior_thread ()))
4253 infrun_debug_printf ("Switching context from %s to %s",
4254 inferior_ptid
.to_string ().c_str (),
4255 ecs
->ptid
.to_string ().c_str ());
4258 switch_to_thread (ecs
->event_thread
);
4261 /* If the target can't tell whether we've hit breakpoints
4262 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4263 check whether that could have been caused by a breakpoint. If so,
4264 adjust the PC, per gdbarch_decr_pc_after_break. */
4267 adjust_pc_after_break (struct thread_info
*thread
,
4268 const target_waitstatus
&ws
)
4270 struct regcache
*regcache
;
4271 struct gdbarch
*gdbarch
;
4272 CORE_ADDR breakpoint_pc
, decr_pc
;
4274 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4275 we aren't, just return.
4277 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4278 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4279 implemented by software breakpoints should be handled through the normal
4282 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4283 different signals (SIGILL or SIGEMT for instance), but it is less
4284 clear where the PC is pointing afterwards. It may not match
4285 gdbarch_decr_pc_after_break. I don't know any specific target that
4286 generates these signals at breakpoints (the code has been in GDB since at
4287 least 1992) so I can not guess how to handle them here.
4289 In earlier versions of GDB, a target with
4290 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4291 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4292 target with both of these set in GDB history, and it seems unlikely to be
4293 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4295 if (ws
.kind () != TARGET_WAITKIND_STOPPED
)
4298 if (ws
.sig () != GDB_SIGNAL_TRAP
)
4301 /* In reverse execution, when a breakpoint is hit, the instruction
4302 under it has already been de-executed. The reported PC always
4303 points at the breakpoint address, so adjusting it further would
4304 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4307 B1 0x08000000 : INSN1
4308 B2 0x08000001 : INSN2
4310 PC -> 0x08000003 : INSN4
4312 Say you're stopped at 0x08000003 as above. Reverse continuing
4313 from that point should hit B2 as below. Reading the PC when the
4314 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4315 been de-executed already.
4317 B1 0x08000000 : INSN1
4318 B2 PC -> 0x08000001 : INSN2
4322 We can't apply the same logic as for forward execution, because
4323 we would wrongly adjust the PC to 0x08000000, since there's a
4324 breakpoint at PC - 1. We'd then report a hit on B1, although
4325 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4327 if (execution_direction
== EXEC_REVERSE
)
4330 /* If the target can tell whether the thread hit a SW breakpoint,
4331 trust it. Targets that can tell also adjust the PC
4333 if (target_supports_stopped_by_sw_breakpoint ())
4336 /* Note that relying on whether a breakpoint is planted in memory to
4337 determine this can fail. E.g,. the breakpoint could have been
4338 removed since. Or the thread could have been told to step an
4339 instruction the size of a breakpoint instruction, and only
4340 _after_ was a breakpoint inserted at its address. */
4342 /* If this target does not decrement the PC after breakpoints, then
4343 we have nothing to do. */
4344 regcache
= get_thread_regcache (thread
);
4345 gdbarch
= regcache
->arch ();
4347 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4351 const address_space
*aspace
= regcache
->aspace ();
4353 /* Find the location where (if we've hit a breakpoint) the
4354 breakpoint would be. */
4355 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4357 /* If the target can't tell whether a software breakpoint triggered,
4358 fallback to figuring it out based on breakpoints we think were
4359 inserted in the target, and on whether the thread was stepped or
4362 /* Check whether there actually is a software breakpoint inserted at
4365 If in non-stop mode, a race condition is possible where we've
4366 removed a breakpoint, but stop events for that breakpoint were
4367 already queued and arrive later. To suppress those spurious
4368 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4369 and retire them after a number of stop events are reported. Note
4370 this is an heuristic and can thus get confused. The real fix is
4371 to get the "stopped by SW BP and needs adjustment" info out of
4372 the target/kernel (and thus never reach here; see above). */
4373 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4374 || (target_is_non_stop_p ()
4375 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4377 gdb::optional
<scoped_restore_tmpl
<int>> restore_operation_disable
;
4379 if (record_full_is_used ())
4380 restore_operation_disable
.emplace
4381 (record_full_gdb_operation_disable_set ());
4383 /* When using hardware single-step, a SIGTRAP is reported for both
4384 a completed single-step and a software breakpoint. Need to
4385 differentiate between the two, as the latter needs adjusting
4386 but the former does not.
4388 The SIGTRAP can be due to a completed hardware single-step only if
4389 - we didn't insert software single-step breakpoints
4390 - this thread is currently being stepped
4392 If any of these events did not occur, we must have stopped due
4393 to hitting a software breakpoint, and have to back up to the
4396 As a special case, we could have hardware single-stepped a
4397 software breakpoint. In this case (prev_pc == breakpoint_pc),
4398 we also need to back up to the breakpoint address. */
4400 if (thread_has_single_step_breakpoints_set (thread
)
4401 || !currently_stepping (thread
)
4402 || (thread
->stepped_breakpoint
4403 && thread
->prev_pc
== breakpoint_pc
))
4404 regcache_write_pc (regcache
, breakpoint_pc
);
4409 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4411 for (frame
= get_prev_frame (frame
);
4413 frame
= get_prev_frame (frame
))
4415 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4418 if (get_frame_type (frame
) != INLINE_FRAME
)
4425 /* Look for an inline frame that is marked for skip.
4426 If PREV_FRAME is TRUE start at the previous frame,
4427 otherwise start at the current frame. Stop at the
4428 first non-inline frame, or at the frame where the
4432 inline_frame_is_marked_for_skip (bool prev_frame
, struct thread_info
*tp
)
4434 struct frame_info
*frame
= get_current_frame ();
4437 frame
= get_prev_frame (frame
);
4439 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
4441 const char *fn
= NULL
;
4442 symtab_and_line sal
;
4445 if (frame_id_eq (get_frame_id (frame
), tp
->control
.step_frame_id
))
4447 if (get_frame_type (frame
) != INLINE_FRAME
)
4450 sal
= find_frame_sal (frame
);
4451 sym
= get_frame_function (frame
);
4454 fn
= sym
->print_name ();
4457 && function_name_is_marked_for_skip (fn
, sal
))
4464 /* If the event thread has the stop requested flag set, pretend it
4465 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4469 handle_stop_requested (struct execution_control_state
*ecs
)
4471 if (ecs
->event_thread
->stop_requested
)
4473 ecs
->ws
.set_stopped (GDB_SIGNAL_0
);
4474 handle_signal_stop (ecs
);
4480 /* Auxiliary function that handles syscall entry/return events.
4481 It returns true if the inferior should keep going (and GDB
4482 should ignore the event), or false if the event deserves to be
4486 handle_syscall_event (struct execution_control_state
*ecs
)
4488 struct regcache
*regcache
;
4491 context_switch (ecs
);
4493 regcache
= get_thread_regcache (ecs
->event_thread
);
4494 syscall_number
= ecs
->ws
.syscall_number ();
4495 ecs
->event_thread
->set_stop_pc (regcache_read_pc (regcache
));
4497 if (catch_syscall_enabled () > 0
4498 && catching_syscall_number (syscall_number
))
4500 infrun_debug_printf ("syscall number=%d", syscall_number
);
4502 ecs
->event_thread
->control
.stop_bpstat
4503 = bpstat_stop_status (regcache
->aspace (),
4504 ecs
->event_thread
->stop_pc (),
4505 ecs
->event_thread
, ecs
->ws
);
4507 if (handle_stop_requested (ecs
))
4510 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4512 /* Catchpoint hit. */
4517 if (handle_stop_requested (ecs
))
4520 /* If no catchpoint triggered for this, then keep going. */
4526 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4529 fill_in_stop_func (struct gdbarch
*gdbarch
,
4530 struct execution_control_state
*ecs
)
4532 if (!ecs
->stop_func_filled_in
)
4535 const general_symbol_info
*gsi
;
4537 /* Don't care about return value; stop_func_start and stop_func_name
4538 will both be 0 if it doesn't work. */
4539 find_pc_partial_function_sym (ecs
->event_thread
->stop_pc (),
4541 &ecs
->stop_func_start
,
4542 &ecs
->stop_func_end
,
4544 ecs
->stop_func_name
= gsi
== nullptr ? nullptr : gsi
->print_name ();
4546 /* The call to find_pc_partial_function, above, will set
4547 stop_func_start and stop_func_end to the start and end
4548 of the range containing the stop pc. If this range
4549 contains the entry pc for the block (which is always the
4550 case for contiguous blocks), advance stop_func_start past
4551 the function's start offset and entrypoint. Note that
4552 stop_func_start is NOT advanced when in a range of a
4553 non-contiguous block that does not contain the entry pc. */
4554 if (block
!= nullptr
4555 && ecs
->stop_func_start
<= BLOCK_ENTRY_PC (block
)
4556 && BLOCK_ENTRY_PC (block
) < ecs
->stop_func_end
)
4558 ecs
->stop_func_start
4559 += gdbarch_deprecated_function_start_offset (gdbarch
);
4561 if (gdbarch_skip_entrypoint_p (gdbarch
))
4562 ecs
->stop_func_start
4563 = gdbarch_skip_entrypoint (gdbarch
, ecs
->stop_func_start
);
4566 ecs
->stop_func_filled_in
= 1;
4571 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
4573 static enum stop_kind
4574 get_inferior_stop_soon (execution_control_state
*ecs
)
4576 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4578 gdb_assert (inf
!= NULL
);
4579 return inf
->control
.stop_soon
;
4582 /* Poll for one event out of the current target. Store the resulting
4583 waitstatus in WS, and return the event ptid. Does not block. */
4586 poll_one_curr_target (struct target_waitstatus
*ws
)
4590 overlay_cache_invalid
= 1;
4592 /* Flush target cache before starting to handle each event.
4593 Target was running and cache could be stale. This is just a
4594 heuristic. Running threads may modify target memory, but we
4595 don't get any event. */
4596 target_dcache_invalidate ();
4598 if (deprecated_target_wait_hook
)
4599 event_ptid
= deprecated_target_wait_hook (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4601 event_ptid
= target_wait (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4604 print_target_wait_results (minus_one_ptid
, event_ptid
, *ws
);
4609 /* Wait for one event out of any target. */
4611 static wait_one_event
4616 for (inferior
*inf
: all_inferiors ())
4618 process_stratum_target
*target
= inf
->process_target ();
4620 || !target
->is_async_p ()
4621 || !target
->threads_executing
)
4624 switch_to_inferior_no_thread (inf
);
4626 wait_one_event event
;
4627 event
.target
= target
;
4628 event
.ptid
= poll_one_curr_target (&event
.ws
);
4630 if (event
.ws
.kind () == TARGET_WAITKIND_NO_RESUMED
)
4632 /* If nothing is resumed, remove the target from the
4636 else if (event
.ws
.kind () != TARGET_WAITKIND_IGNORE
)
4640 /* Block waiting for some event. */
4647 for (inferior
*inf
: all_inferiors ())
4649 process_stratum_target
*target
= inf
->process_target ();
4651 || !target
->is_async_p ()
4652 || !target
->threads_executing
)
4655 int fd
= target
->async_wait_fd ();
4656 FD_SET (fd
, &readfds
);
4663 /* No waitable targets left. All must be stopped. */
4664 target_waitstatus ws
;
4665 ws
.set_no_resumed ();
4666 return {NULL
, minus_one_ptid
, std::move (ws
)};
4671 int numfds
= interruptible_select (nfds
, &readfds
, 0, NULL
, 0);
4677 perror_with_name ("interruptible_select");
4682 /* Save the thread's event and stop reason to process it later. */
4685 save_waitstatus (struct thread_info
*tp
, const target_waitstatus
&ws
)
4687 infrun_debug_printf ("saving status %s for %s",
4688 ws
.to_string ().c_str (),
4689 tp
->ptid
.to_string ().c_str ());
4691 /* Record for later. */
4692 tp
->set_pending_waitstatus (ws
);
4694 if (ws
.kind () == TARGET_WAITKIND_STOPPED
4695 && ws
.sig () == GDB_SIGNAL_TRAP
)
4697 struct regcache
*regcache
= get_thread_regcache (tp
);
4698 const address_space
*aspace
= regcache
->aspace ();
4699 CORE_ADDR pc
= regcache_read_pc (regcache
);
4701 adjust_pc_after_break (tp
, tp
->pending_waitstatus ());
4703 scoped_restore_current_thread restore_thread
;
4704 switch_to_thread (tp
);
4706 if (target_stopped_by_watchpoint ())
4707 tp
->set_stop_reason (TARGET_STOPPED_BY_WATCHPOINT
);
4708 else if (target_supports_stopped_by_sw_breakpoint ()
4709 && target_stopped_by_sw_breakpoint ())
4710 tp
->set_stop_reason (TARGET_STOPPED_BY_SW_BREAKPOINT
);
4711 else if (target_supports_stopped_by_hw_breakpoint ()
4712 && target_stopped_by_hw_breakpoint ())
4713 tp
->set_stop_reason (TARGET_STOPPED_BY_HW_BREAKPOINT
);
4714 else if (!target_supports_stopped_by_hw_breakpoint ()
4715 && hardware_breakpoint_inserted_here_p (aspace
, pc
))
4716 tp
->set_stop_reason (TARGET_STOPPED_BY_HW_BREAKPOINT
);
4717 else if (!target_supports_stopped_by_sw_breakpoint ()
4718 && software_breakpoint_inserted_here_p (aspace
, pc
))
4719 tp
->set_stop_reason (TARGET_STOPPED_BY_SW_BREAKPOINT
);
4720 else if (!thread_has_single_step_breakpoints_set (tp
)
4721 && currently_stepping (tp
))
4722 tp
->set_stop_reason (TARGET_STOPPED_BY_SINGLE_STEP
);
4726 /* Mark the non-executing threads accordingly. In all-stop, all
4727 threads of all processes are stopped when we get any event
4728 reported. In non-stop mode, only the event thread stops. */
4731 mark_non_executing_threads (process_stratum_target
*target
,
4733 const target_waitstatus
&ws
)
4737 if (!target_is_non_stop_p ())
4738 mark_ptid
= minus_one_ptid
;
4739 else if (ws
.kind () == TARGET_WAITKIND_SIGNALLED
4740 || ws
.kind () == TARGET_WAITKIND_EXITED
)
4742 /* If we're handling a process exit in non-stop mode, even
4743 though threads haven't been deleted yet, one would think
4744 that there is nothing to do, as threads of the dead process
4745 will be soon deleted, and threads of any other process were
4746 left running. However, on some targets, threads survive a
4747 process exit event. E.g., for the "checkpoint" command,
4748 when the current checkpoint/fork exits, linux-fork.c
4749 automatically switches to another fork from within
4750 target_mourn_inferior, by associating the same
4751 inferior/thread to another fork. We haven't mourned yet at
4752 this point, but we must mark any threads left in the
4753 process as not-executing so that finish_thread_state marks
4754 them stopped (in the user's perspective) if/when we present
4755 the stop to the user. */
4756 mark_ptid
= ptid_t (event_ptid
.pid ());
4759 mark_ptid
= event_ptid
;
4761 set_executing (target
, mark_ptid
, false);
4763 /* Likewise the resumed flag. */
4764 set_resumed (target
, mark_ptid
, false);
4767 /* Handle one event after stopping threads. If the eventing thread
4768 reports back any interesting event, we leave it pending. If the
4769 eventing thread was in the middle of a displaced step, we
4770 cancel/finish it, and unless the thread's inferior is being
4771 detached, put the thread back in the step-over chain. Returns true
4772 if there are no resumed threads left in the target (thus there's no
4773 point in waiting further), false otherwise. */
4776 handle_one (const wait_one_event
&event
)
4779 ("%s %s", event
.ws
.to_string ().c_str (),
4780 event
.ptid
.to_string ().c_str ());
4782 if (event
.ws
.kind () == TARGET_WAITKIND_NO_RESUMED
)
4784 /* All resumed threads exited. */
4787 else if (event
.ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
4788 || event
.ws
.kind () == TARGET_WAITKIND_EXITED
4789 || event
.ws
.kind () == TARGET_WAITKIND_SIGNALLED
)
4791 /* One thread/process exited/signalled. */
4793 thread_info
*t
= nullptr;
4795 /* The target may have reported just a pid. If so, try
4796 the first non-exited thread. */
4797 if (event
.ptid
.is_pid ())
4799 int pid
= event
.ptid
.pid ();
4800 inferior
*inf
= find_inferior_pid (event
.target
, pid
);
4801 for (thread_info
*tp
: inf
->non_exited_threads ())
4807 /* If there is no available thread, the event would
4808 have to be appended to a per-inferior event list,
4809 which does not exist (and if it did, we'd have
4810 to adjust run control command to be able to
4811 resume such an inferior). We assert here instead
4812 of going into an infinite loop. */
4813 gdb_assert (t
!= nullptr);
4816 ("using %s", t
->ptid
.to_string ().c_str ());
4820 t
= find_thread_ptid (event
.target
, event
.ptid
);
4821 /* Check if this is the first time we see this thread.
4822 Don't bother adding if it individually exited. */
4824 && event
.ws
.kind () != TARGET_WAITKIND_THREAD_EXITED
)
4825 t
= add_thread (event
.target
, event
.ptid
);
4830 /* Set the threads as non-executing to avoid
4831 another stop attempt on them. */
4832 switch_to_thread_no_regs (t
);
4833 mark_non_executing_threads (event
.target
, event
.ptid
,
4835 save_waitstatus (t
, event
.ws
);
4836 t
->stop_requested
= false;
4841 thread_info
*t
= find_thread_ptid (event
.target
, event
.ptid
);
4843 t
= add_thread (event
.target
, event
.ptid
);
4845 t
->stop_requested
= 0;
4846 t
->set_executing (false);
4847 t
->set_resumed (false);
4848 t
->control
.may_range_step
= 0;
4850 /* This may be the first time we see the inferior report
4852 inferior
*inf
= find_inferior_ptid (event
.target
, event
.ptid
);
4853 if (inf
->needs_setup
)
4855 switch_to_thread_no_regs (t
);
4859 if (event
.ws
.kind () == TARGET_WAITKIND_STOPPED
4860 && event
.ws
.sig () == GDB_SIGNAL_0
)
4862 /* We caught the event that we intended to catch, so
4863 there's no event to save as pending. */
4865 if (displaced_step_finish (t
, GDB_SIGNAL_0
)
4866 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
4868 /* Add it back to the step-over queue. */
4870 ("displaced-step of %s canceled",
4871 t
->ptid
.to_string ().c_str ());
4873 t
->control
.trap_expected
= 0;
4874 if (!t
->inf
->detaching
)
4875 global_thread_step_over_chain_enqueue (t
);
4880 enum gdb_signal sig
;
4881 struct regcache
*regcache
;
4884 ("target_wait %s, saving status for %s",
4885 event
.ws
.to_string ().c_str (),
4886 t
->ptid
.to_string ().c_str ());
4888 /* Record for later. */
4889 save_waitstatus (t
, event
.ws
);
4891 sig
= (event
.ws
.kind () == TARGET_WAITKIND_STOPPED
4892 ? event
.ws
.sig () : GDB_SIGNAL_0
);
4894 if (displaced_step_finish (t
, sig
)
4895 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
4897 /* Add it back to the step-over queue. */
4898 t
->control
.trap_expected
= 0;
4899 if (!t
->inf
->detaching
)
4900 global_thread_step_over_chain_enqueue (t
);
4903 regcache
= get_thread_regcache (t
);
4904 t
->set_stop_pc (regcache_read_pc (regcache
));
4906 infrun_debug_printf ("saved stop_pc=%s for %s "
4907 "(currently_stepping=%d)",
4908 paddress (target_gdbarch (), t
->stop_pc ()),
4909 t
->ptid
.to_string ().c_str (),
4910 currently_stepping (t
));
4920 stop_all_threads (void)
4922 /* We may need multiple passes to discover all threads. */
4926 gdb_assert (exists_non_stop_target ());
4928 infrun_debug_printf ("starting");
4930 scoped_restore_current_thread restore_thread
;
4932 /* Enable thread events of all targets. */
4933 for (auto *target
: all_non_exited_process_targets ())
4935 switch_to_target_no_thread (target
);
4936 target_thread_events (true);
4941 /* Disable thread events of all targets. */
4942 for (auto *target
: all_non_exited_process_targets ())
4944 switch_to_target_no_thread (target
);
4945 target_thread_events (false);
4948 /* Use debug_prefixed_printf directly to get a meaningful function
4951 debug_prefixed_printf ("infrun", "stop_all_threads", "done");
4954 /* Request threads to stop, and then wait for the stops. Because
4955 threads we already know about can spawn more threads while we're
4956 trying to stop them, and we only learn about new threads when we
4957 update the thread list, do this in a loop, and keep iterating
4958 until two passes find no threads that need to be stopped. */
4959 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4961 infrun_debug_printf ("pass=%d, iterations=%d", pass
, iterations
);
4964 int waits_needed
= 0;
4966 for (auto *target
: all_non_exited_process_targets ())
4968 switch_to_target_no_thread (target
);
4969 update_thread_list ();
4972 /* Go through all threads looking for threads that we need
4973 to tell the target to stop. */
4974 for (thread_info
*t
: all_non_exited_threads ())
4976 /* For a single-target setting with an all-stop target,
4977 we would not even arrive here. For a multi-target
4978 setting, until GDB is able to handle a mixture of
4979 all-stop and non-stop targets, simply skip all-stop
4980 targets' threads. This should be fine due to the
4981 protection of 'check_multi_target_resumption'. */
4983 switch_to_thread_no_regs (t
);
4984 if (!target_is_non_stop_p ())
4987 if (t
->executing ())
4989 /* If already stopping, don't request a stop again.
4990 We just haven't seen the notification yet. */
4991 if (!t
->stop_requested
)
4993 infrun_debug_printf (" %s executing, need stop",
4994 t
->ptid
.to_string ().c_str ());
4995 target_stop (t
->ptid
);
4996 t
->stop_requested
= 1;
5000 infrun_debug_printf (" %s executing, already stopping",
5001 t
->ptid
.to_string ().c_str ());
5004 if (t
->stop_requested
)
5009 infrun_debug_printf (" %s not executing",
5010 t
->ptid
.to_string ().c_str ());
5012 /* The thread may be not executing, but still be
5013 resumed with a pending status to process. */
5014 t
->set_resumed (false);
5018 if (waits_needed
== 0)
5021 /* If we find new threads on the second iteration, restart
5022 over. We want to see two iterations in a row with all
5027 for (int i
= 0; i
< waits_needed
; i
++)
5029 wait_one_event event
= wait_one ();
5030 if (handle_one (event
))
5037 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
5040 handle_no_resumed (struct execution_control_state
*ecs
)
5042 if (target_can_async_p ())
5044 bool any_sync
= false;
5046 for (ui
*ui
: all_uis ())
5048 if (ui
->prompt_state
== PROMPT_BLOCKED
)
5056 /* There were no unwaited-for children left in the target, but,
5057 we're not synchronously waiting for events either. Just
5060 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED (ignoring: bg)");
5061 prepare_to_wait (ecs
);
5066 /* Otherwise, if we were running a synchronous execution command, we
5067 may need to cancel it and give the user back the terminal.
5069 In non-stop mode, the target can't tell whether we've already
5070 consumed previous stop events, so it can end up sending us a
5071 no-resumed event like so:
5073 #0 - thread 1 is left stopped
5075 #1 - thread 2 is resumed and hits breakpoint
5076 -> TARGET_WAITKIND_STOPPED
5078 #2 - thread 3 is resumed and exits
5079 this is the last resumed thread, so
5080 -> TARGET_WAITKIND_NO_RESUMED
5082 #3 - gdb processes stop for thread 2 and decides to re-resume
5085 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
5086 thread 2 is now resumed, so the event should be ignored.
5088 IOW, if the stop for thread 2 doesn't end a foreground command,
5089 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
5090 event. But it could be that the event meant that thread 2 itself
5091 (or whatever other thread was the last resumed thread) exited.
5093 To address this we refresh the thread list and check whether we
5094 have resumed threads _now_. In the example above, this removes
5095 thread 3 from the thread list. If thread 2 was re-resumed, we
5096 ignore this event. If we find no thread resumed, then we cancel
5097 the synchronous command and show "no unwaited-for " to the
5100 inferior
*curr_inf
= current_inferior ();
5102 scoped_restore_current_thread restore_thread
;
5104 for (auto *target
: all_non_exited_process_targets ())
5106 switch_to_target_no_thread (target
);
5107 update_thread_list ();
5112 - the current target has no thread executing, and
5113 - the current inferior is native, and
5114 - the current inferior is the one which has the terminal, and
5117 then a Ctrl-C from this point on would remain stuck in the
5118 kernel, until a thread resumes and dequeues it. That would
5119 result in the GDB CLI not reacting to Ctrl-C, not able to
5120 interrupt the program. To address this, if the current inferior
5121 no longer has any thread executing, we give the terminal to some
5122 other inferior that has at least one thread executing. */
5123 bool swap_terminal
= true;
5125 /* Whether to ignore this TARGET_WAITKIND_NO_RESUMED event, or
5126 whether to report it to the user. */
5127 bool ignore_event
= false;
5129 for (thread_info
*thread
: all_non_exited_threads ())
5131 if (swap_terminal
&& thread
->executing ())
5133 if (thread
->inf
!= curr_inf
)
5135 target_terminal::ours ();
5137 switch_to_thread (thread
);
5138 target_terminal::inferior ();
5140 swap_terminal
= false;
5143 if (!ignore_event
&& thread
->resumed ())
5145 /* Either there were no unwaited-for children left in the
5146 target at some point, but there are now, or some target
5147 other than the eventing one has unwaited-for children
5148 left. Just ignore. */
5149 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED "
5150 "(ignoring: found resumed)");
5152 ignore_event
= true;
5155 if (ignore_event
&& !swap_terminal
)
5161 switch_to_inferior_no_thread (curr_inf
);
5162 prepare_to_wait (ecs
);
5166 /* Go ahead and report the event. */
5170 /* Given an execution control state that has been freshly filled in by
5171 an event from the inferior, figure out what it means and take
5174 The alternatives are:
5176 1) stop_waiting and return; to really stop and return to the
5179 2) keep_going and return; to wait for the next event (set
5180 ecs->event_thread->stepping_over_breakpoint to 1 to single step
5184 handle_inferior_event (struct execution_control_state
*ecs
)
5186 /* Make sure that all temporary struct value objects that were
5187 created during the handling of the event get deleted at the
5189 scoped_value_mark free_values
;
5191 infrun_debug_printf ("%s", ecs
->ws
.to_string ().c_str ());
5193 if (ecs
->ws
.kind () == TARGET_WAITKIND_IGNORE
)
5195 /* We had an event in the inferior, but we are not interested in
5196 handling it at this level. The lower layers have already
5197 done what needs to be done, if anything.
5199 One of the possible circumstances for this is when the
5200 inferior produces output for the console. The inferior has
5201 not stopped, and we are ignoring the event. Another possible
5202 circumstance is any event which the lower level knows will be
5203 reported multiple times without an intervening resume. */
5204 prepare_to_wait (ecs
);
5208 if (ecs
->ws
.kind () == TARGET_WAITKIND_THREAD_EXITED
)
5210 prepare_to_wait (ecs
);
5214 if (ecs
->ws
.kind () == TARGET_WAITKIND_NO_RESUMED
5215 && handle_no_resumed (ecs
))
5218 /* Cache the last target/ptid/waitstatus. */
5219 set_last_target_status (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5221 /* Always clear state belonging to the previous time we stopped. */
5222 stop_stack_dummy
= STOP_NONE
;
5224 if (ecs
->ws
.kind () == TARGET_WAITKIND_NO_RESUMED
)
5226 /* No unwaited-for children left. IOW, all resumed children
5228 stop_print_frame
= false;
5233 if (ecs
->ws
.kind () != TARGET_WAITKIND_EXITED
5234 && ecs
->ws
.kind () != TARGET_WAITKIND_SIGNALLED
)
5236 ecs
->event_thread
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5237 /* If it's a new thread, add it to the thread database. */
5238 if (ecs
->event_thread
== NULL
)
5239 ecs
->event_thread
= add_thread (ecs
->target
, ecs
->ptid
);
5241 /* Disable range stepping. If the next step request could use a
5242 range, this will be end up re-enabled then. */
5243 ecs
->event_thread
->control
.may_range_step
= 0;
5246 /* Dependent on valid ECS->EVENT_THREAD. */
5247 adjust_pc_after_break (ecs
->event_thread
, ecs
->ws
);
5249 /* Dependent on the current PC value modified by adjust_pc_after_break. */
5250 reinit_frame_cache ();
5252 breakpoint_retire_moribund ();
5254 /* First, distinguish signals caused by the debugger from signals
5255 that have to do with the program's own actions. Note that
5256 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
5257 on the operating system version. Here we detect when a SIGILL or
5258 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
5259 something similar for SIGSEGV, since a SIGSEGV will be generated
5260 when we're trying to execute a breakpoint instruction on a
5261 non-executable stack. This happens for call dummy breakpoints
5262 for architectures like SPARC that place call dummies on the
5264 if (ecs
->ws
.kind () == TARGET_WAITKIND_STOPPED
5265 && (ecs
->ws
.sig () == GDB_SIGNAL_ILL
5266 || ecs
->ws
.sig () == GDB_SIGNAL_SEGV
5267 || ecs
->ws
.sig () == GDB_SIGNAL_EMT
))
5269 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5271 if (breakpoint_inserted_here_p (regcache
->aspace (),
5272 regcache_read_pc (regcache
)))
5274 infrun_debug_printf ("Treating signal as SIGTRAP");
5275 ecs
->ws
.set_stopped (GDB_SIGNAL_TRAP
);
5279 mark_non_executing_threads (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5281 switch (ecs
->ws
.kind ())
5283 case TARGET_WAITKIND_LOADED
:
5285 context_switch (ecs
);
5286 /* Ignore gracefully during startup of the inferior, as it might
5287 be the shell which has just loaded some objects, otherwise
5288 add the symbols for the newly loaded objects. Also ignore at
5289 the beginning of an attach or remote session; we will query
5290 the full list of libraries once the connection is
5293 stop_kind stop_soon
= get_inferior_stop_soon (ecs
);
5294 if (stop_soon
== NO_STOP_QUIETLY
)
5296 struct regcache
*regcache
;
5298 regcache
= get_thread_regcache (ecs
->event_thread
);
5300 handle_solib_event ();
5302 ecs
->event_thread
->set_stop_pc (regcache_read_pc (regcache
));
5303 ecs
->event_thread
->control
.stop_bpstat
5304 = bpstat_stop_status (regcache
->aspace (),
5305 ecs
->event_thread
->stop_pc (),
5306 ecs
->event_thread
, ecs
->ws
);
5308 if (handle_stop_requested (ecs
))
5311 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5313 /* A catchpoint triggered. */
5314 process_event_stop_test (ecs
);
5318 /* If requested, stop when the dynamic linker notifies
5319 gdb of events. This allows the user to get control
5320 and place breakpoints in initializer routines for
5321 dynamically loaded objects (among other things). */
5322 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5323 if (stop_on_solib_events
)
5325 /* Make sure we print "Stopped due to solib-event" in
5327 stop_print_frame
= true;
5334 /* If we are skipping through a shell, or through shared library
5335 loading that we aren't interested in, resume the program. If
5336 we're running the program normally, also resume. */
5337 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
5339 /* Loading of shared libraries might have changed breakpoint
5340 addresses. Make sure new breakpoints are inserted. */
5341 if (stop_soon
== NO_STOP_QUIETLY
)
5342 insert_breakpoints ();
5343 resume (GDB_SIGNAL_0
);
5344 prepare_to_wait (ecs
);
5348 /* But stop if we're attaching or setting up a remote
5350 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5351 || stop_soon
== STOP_QUIETLY_REMOTE
)
5353 infrun_debug_printf ("quietly stopped");
5358 internal_error (__FILE__
, __LINE__
,
5359 _("unhandled stop_soon: %d"), (int) stop_soon
);
5362 case TARGET_WAITKIND_SPURIOUS
:
5363 if (handle_stop_requested (ecs
))
5365 context_switch (ecs
);
5366 resume (GDB_SIGNAL_0
);
5367 prepare_to_wait (ecs
);
5370 case TARGET_WAITKIND_THREAD_CREATED
:
5371 if (handle_stop_requested (ecs
))
5373 context_switch (ecs
);
5374 if (!switch_back_to_stepped_thread (ecs
))
5378 case TARGET_WAITKIND_EXITED
:
5379 case TARGET_WAITKIND_SIGNALLED
:
5381 /* Depending on the system, ecs->ptid may point to a thread or
5382 to a process. On some targets, target_mourn_inferior may
5383 need to have access to the just-exited thread. That is the
5384 case of GNU/Linux's "checkpoint" support, for example.
5385 Call the switch_to_xxx routine as appropriate. */
5386 thread_info
*thr
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5388 switch_to_thread (thr
);
5391 inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5392 switch_to_inferior_no_thread (inf
);
5395 handle_vfork_child_exec_or_exit (0);
5396 target_terminal::ours (); /* Must do this before mourn anyway. */
5398 /* Clearing any previous state of convenience variables. */
5399 clear_exit_convenience_vars ();
5401 if (ecs
->ws
.kind () == TARGET_WAITKIND_EXITED
)
5403 /* Record the exit code in the convenience variable $_exitcode, so
5404 that the user can inspect this again later. */
5405 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5406 (LONGEST
) ecs
->ws
.exit_status ());
5408 /* Also record this in the inferior itself. */
5409 current_inferior ()->has_exit_code
= 1;
5410 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.exit_status ();
5412 /* Support the --return-child-result option. */
5413 return_child_result_value
= ecs
->ws
.exit_status ();
5415 gdb::observers::exited
.notify (ecs
->ws
.exit_status ());
5419 struct gdbarch
*gdbarch
= current_inferior ()->gdbarch
;
5421 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
5423 /* Set the value of the internal variable $_exitsignal,
5424 which holds the signal uncaught by the inferior. */
5425 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5426 gdbarch_gdb_signal_to_target (gdbarch
,
5431 /* We don't have access to the target's method used for
5432 converting between signal numbers (GDB's internal
5433 representation <-> target's representation).
5434 Therefore, we cannot do a good job at displaying this
5435 information to the user. It's better to just warn
5436 her about it (if infrun debugging is enabled), and
5438 infrun_debug_printf ("Cannot fill $_exitsignal with the correct "
5442 gdb::observers::signal_exited
.notify (ecs
->ws
.sig ());
5445 gdb_flush (gdb_stdout
);
5446 target_mourn_inferior (inferior_ptid
);
5447 stop_print_frame
= false;
5451 case TARGET_WAITKIND_FORKED
:
5452 case TARGET_WAITKIND_VFORKED
:
5453 /* Check whether the inferior is displaced stepping. */
5455 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5456 struct gdbarch
*gdbarch
= regcache
->arch ();
5457 inferior
*parent_inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5459 /* If this is a fork (child gets its own address space copy)
5460 and some displaced step buffers were in use at the time of
5461 the fork, restore the displaced step buffer bytes in the
5464 Architectures which support displaced stepping and fork
5465 events must supply an implementation of
5466 gdbarch_displaced_step_restore_all_in_ptid. This is not
5467 enforced during gdbarch validation to support architectures
5468 which support displaced stepping but not forks. */
5469 if (ecs
->ws
.kind () == TARGET_WAITKIND_FORKED
5470 && gdbarch_supports_displaced_stepping (gdbarch
))
5471 gdbarch_displaced_step_restore_all_in_ptid
5472 (gdbarch
, parent_inf
, ecs
->ws
.child_ptid ());
5474 /* If displaced stepping is supported, and thread ecs->ptid is
5475 displaced stepping. */
5476 if (displaced_step_in_progress_thread (ecs
->event_thread
))
5478 struct regcache
*child_regcache
;
5479 CORE_ADDR parent_pc
;
5481 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5482 indicating that the displaced stepping of syscall instruction
5483 has been done. Perform cleanup for parent process here. Note
5484 that this operation also cleans up the child process for vfork,
5485 because their pages are shared. */
5486 displaced_step_finish (ecs
->event_thread
, GDB_SIGNAL_TRAP
);
5487 /* Start a new step-over in another thread if there's one
5491 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5492 the child's PC is also within the scratchpad. Set the child's PC
5493 to the parent's PC value, which has already been fixed up.
5494 FIXME: we use the parent's aspace here, although we're touching
5495 the child, because the child hasn't been added to the inferior
5496 list yet at this point. */
5499 = get_thread_arch_aspace_regcache (parent_inf
->process_target (),
5500 ecs
->ws
.child_ptid (),
5502 parent_inf
->aspace
);
5503 /* Read PC value of parent process. */
5504 parent_pc
= regcache_read_pc (regcache
);
5506 displaced_debug_printf ("write child pc from %s to %s",
5508 regcache_read_pc (child_regcache
)),
5509 paddress (gdbarch
, parent_pc
));
5511 regcache_write_pc (child_regcache
, parent_pc
);
5515 context_switch (ecs
);
5517 /* Immediately detach breakpoints from the child before there's
5518 any chance of letting the user delete breakpoints from the
5519 breakpoint lists. If we don't do this early, it's easy to
5520 leave left over traps in the child, vis: "break foo; catch
5521 fork; c; <fork>; del; c; <child calls foo>". We only follow
5522 the fork on the last `continue', and by that time the
5523 breakpoint at "foo" is long gone from the breakpoint table.
5524 If we vforked, then we don't need to unpatch here, since both
5525 parent and child are sharing the same memory pages; we'll
5526 need to unpatch at follow/detach time instead to be certain
5527 that new breakpoints added between catchpoint hit time and
5528 vfork follow are detached. */
5529 if (ecs
->ws
.kind () != TARGET_WAITKIND_VFORKED
)
5531 /* This won't actually modify the breakpoint list, but will
5532 physically remove the breakpoints from the child. */
5533 detach_breakpoints (ecs
->ws
.child_ptid ());
5536 delete_just_stopped_threads_single_step_breakpoints ();
5538 /* In case the event is caught by a catchpoint, remember that
5539 the event is to be followed at the next resume of the thread,
5540 and not immediately. */
5541 ecs
->event_thread
->pending_follow
= ecs
->ws
;
5543 ecs
->event_thread
->set_stop_pc
5544 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
5546 ecs
->event_thread
->control
.stop_bpstat
5547 = bpstat_stop_status (get_current_regcache ()->aspace (),
5548 ecs
->event_thread
->stop_pc (),
5549 ecs
->event_thread
, ecs
->ws
);
5551 if (handle_stop_requested (ecs
))
5554 /* If no catchpoint triggered for this, then keep going. Note
5555 that we're interested in knowing the bpstat actually causes a
5556 stop, not just if it may explain the signal. Software
5557 watchpoints, for example, always appear in the bpstat. */
5558 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5561 = (follow_fork_mode_string
== follow_fork_mode_child
);
5563 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5565 process_stratum_target
*targ
5566 = ecs
->event_thread
->inf
->process_target ();
5568 bool should_resume
= follow_fork ();
5570 /* Note that one of these may be an invalid pointer,
5571 depending on detach_fork. */
5572 thread_info
*parent
= ecs
->event_thread
;
5573 thread_info
*child
= find_thread_ptid (targ
, ecs
->ws
.child_ptid ());
5575 /* At this point, the parent is marked running, and the
5576 child is marked stopped. */
5578 /* If not resuming the parent, mark it stopped. */
5579 if (follow_child
&& !detach_fork
&& !non_stop
&& !sched_multi
)
5580 parent
->set_running (false);
5582 /* If resuming the child, mark it running. */
5583 if (follow_child
|| (!detach_fork
&& (non_stop
|| sched_multi
)))
5584 child
->set_running (true);
5586 /* In non-stop mode, also resume the other branch. */
5587 if (!detach_fork
&& (non_stop
5588 || (sched_multi
&& target_is_non_stop_p ())))
5591 switch_to_thread (parent
);
5593 switch_to_thread (child
);
5595 ecs
->event_thread
= inferior_thread ();
5596 ecs
->ptid
= inferior_ptid
;
5601 switch_to_thread (child
);
5603 switch_to_thread (parent
);
5605 ecs
->event_thread
= inferior_thread ();
5606 ecs
->ptid
= inferior_ptid
;
5614 process_event_stop_test (ecs
);
5617 case TARGET_WAITKIND_VFORK_DONE
:
5618 /* Done with the shared memory region. Re-insert breakpoints in
5619 the parent, and keep going. */
5621 context_switch (ecs
);
5623 current_inferior ()->waiting_for_vfork_done
= 0;
5624 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
5626 if (handle_stop_requested (ecs
))
5629 /* This also takes care of reinserting breakpoints in the
5630 previously locked inferior. */
5634 case TARGET_WAITKIND_EXECD
:
5636 /* Note we can't read registers yet (the stop_pc), because we
5637 don't yet know the inferior's post-exec architecture.
5638 'stop_pc' is explicitly read below instead. */
5639 switch_to_thread_no_regs (ecs
->event_thread
);
5641 /* Do whatever is necessary to the parent branch of the vfork. */
5642 handle_vfork_child_exec_or_exit (1);
5644 /* This causes the eventpoints and symbol table to be reset.
5645 Must do this now, before trying to determine whether to
5647 follow_exec (inferior_ptid
, ecs
->ws
.execd_pathname ());
5649 /* In follow_exec we may have deleted the original thread and
5650 created a new one. Make sure that the event thread is the
5651 execd thread for that case (this is a nop otherwise). */
5652 ecs
->event_thread
= inferior_thread ();
5654 ecs
->event_thread
->set_stop_pc
5655 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
5657 ecs
->event_thread
->control
.stop_bpstat
5658 = bpstat_stop_status (get_current_regcache ()->aspace (),
5659 ecs
->event_thread
->stop_pc (),
5660 ecs
->event_thread
, ecs
->ws
);
5662 if (handle_stop_requested (ecs
))
5665 /* If no catchpoint triggered for this, then keep going. */
5666 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5668 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5672 process_event_stop_test (ecs
);
5675 /* Be careful not to try to gather much state about a thread
5676 that's in a syscall. It's frequently a losing proposition. */
5677 case TARGET_WAITKIND_SYSCALL_ENTRY
:
5678 /* Getting the current syscall number. */
5679 if (handle_syscall_event (ecs
) == 0)
5680 process_event_stop_test (ecs
);
5683 /* Before examining the threads further, step this thread to
5684 get it entirely out of the syscall. (We get notice of the
5685 event when the thread is just on the verge of exiting a
5686 syscall. Stepping one instruction seems to get it back
5688 case TARGET_WAITKIND_SYSCALL_RETURN
:
5689 if (handle_syscall_event (ecs
) == 0)
5690 process_event_stop_test (ecs
);
5693 case TARGET_WAITKIND_STOPPED
:
5694 handle_signal_stop (ecs
);
5697 case TARGET_WAITKIND_NO_HISTORY
:
5698 /* Reverse execution: target ran out of history info. */
5700 /* Switch to the stopped thread. */
5701 context_switch (ecs
);
5702 infrun_debug_printf ("stopped");
5704 delete_just_stopped_threads_single_step_breakpoints ();
5705 ecs
->event_thread
->set_stop_pc
5706 (regcache_read_pc (get_thread_regcache (inferior_thread ())));
5708 if (handle_stop_requested (ecs
))
5711 gdb::observers::no_history
.notify ();
5717 /* Restart threads back to what they were trying to do back when we
5718 paused them for an in-line step-over. The EVENT_THREAD thread is
5722 restart_threads (struct thread_info
*event_thread
)
5724 /* In case the instruction just stepped spawned a new thread. */
5725 update_thread_list ();
5727 for (thread_info
*tp
: all_non_exited_threads ())
5729 if (tp
->inf
->detaching
)
5731 infrun_debug_printf ("restart threads: [%s] inferior detaching",
5732 tp
->ptid
.to_string ().c_str ());
5736 switch_to_thread_no_regs (tp
);
5738 if (tp
== event_thread
)
5740 infrun_debug_printf ("restart threads: [%s] is event thread",
5741 tp
->ptid
.to_string ().c_str ());
5745 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5747 infrun_debug_printf ("restart threads: [%s] not meant to be running",
5748 tp
->ptid
.to_string ().c_str ());
5754 infrun_debug_printf ("restart threads: [%s] resumed",
5755 tp
->ptid
.to_string ().c_str ());
5756 gdb_assert (tp
->executing () || tp
->has_pending_waitstatus ());
5760 if (thread_is_in_step_over_chain (tp
))
5762 infrun_debug_printf ("restart threads: [%s] needs step-over",
5763 tp
->ptid
.to_string ().c_str ());
5764 gdb_assert (!tp
->resumed ());
5769 if (tp
->has_pending_waitstatus ())
5771 infrun_debug_printf ("restart threads: [%s] has pending status",
5772 tp
->ptid
.to_string ().c_str ());
5773 tp
->set_resumed (true);
5777 gdb_assert (!tp
->stop_requested
);
5779 /* If some thread needs to start a step-over at this point, it
5780 should still be in the step-over queue, and thus skipped
5782 if (thread_still_needs_step_over (tp
))
5784 internal_error (__FILE__
, __LINE__
,
5785 "thread [%s] needs a step-over, but not in "
5786 "step-over queue\n",
5787 tp
->ptid
.to_string ().c_str ());
5790 if (currently_stepping (tp
))
5792 infrun_debug_printf ("restart threads: [%s] was stepping",
5793 tp
->ptid
.to_string ().c_str ());
5794 keep_going_stepped_thread (tp
);
5798 struct execution_control_state ecss
;
5799 struct execution_control_state
*ecs
= &ecss
;
5801 infrun_debug_printf ("restart threads: [%s] continuing",
5802 tp
->ptid
.to_string ().c_str ());
5803 reset_ecs (ecs
, tp
);
5804 switch_to_thread (tp
);
5805 keep_going_pass_signal (ecs
);
5810 /* Callback for iterate_over_threads. Find a resumed thread that has
5811 a pending waitstatus. */
5814 resumed_thread_with_pending_status (struct thread_info
*tp
,
5817 return tp
->resumed () && tp
->has_pending_waitstatus ();
5820 /* Called when we get an event that may finish an in-line or
5821 out-of-line (displaced stepping) step-over started previously.
5822 Return true if the event is processed and we should go back to the
5823 event loop; false if the caller should continue processing the
5827 finish_step_over (struct execution_control_state
*ecs
)
5829 displaced_step_finish (ecs
->event_thread
, ecs
->event_thread
->stop_signal ());
5831 bool had_step_over_info
= step_over_info_valid_p ();
5833 if (had_step_over_info
)
5835 /* If we're stepping over a breakpoint with all threads locked,
5836 then only the thread that was stepped should be reporting
5838 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5840 clear_step_over_info ();
5843 if (!target_is_non_stop_p ())
5846 /* Start a new step-over in another thread if there's one that
5850 /* If we were stepping over a breakpoint before, and haven't started
5851 a new in-line step-over sequence, then restart all other threads
5852 (except the event thread). We can't do this in all-stop, as then
5853 e.g., we wouldn't be able to issue any other remote packet until
5854 these other threads stop. */
5855 if (had_step_over_info
&& !step_over_info_valid_p ())
5857 struct thread_info
*pending
;
5859 /* If we only have threads with pending statuses, the restart
5860 below won't restart any thread and so nothing re-inserts the
5861 breakpoint we just stepped over. But we need it inserted
5862 when we later process the pending events, otherwise if
5863 another thread has a pending event for this breakpoint too,
5864 we'd discard its event (because the breakpoint that
5865 originally caused the event was no longer inserted). */
5866 context_switch (ecs
);
5867 insert_breakpoints ();
5869 restart_threads (ecs
->event_thread
);
5871 /* If we have events pending, go through handle_inferior_event
5872 again, picking up a pending event at random. This avoids
5873 thread starvation. */
5875 /* But not if we just stepped over a watchpoint in order to let
5876 the instruction execute so we can evaluate its expression.
5877 The set of watchpoints that triggered is recorded in the
5878 breakpoint objects themselves (see bp->watchpoint_triggered).
5879 If we processed another event first, that other event could
5880 clobber this info. */
5881 if (ecs
->event_thread
->stepping_over_watchpoint
)
5884 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5886 if (pending
!= NULL
)
5888 struct thread_info
*tp
= ecs
->event_thread
;
5889 struct regcache
*regcache
;
5891 infrun_debug_printf ("found resumed threads with "
5892 "pending events, saving status");
5894 gdb_assert (pending
!= tp
);
5896 /* Record the event thread's event for later. */
5897 save_waitstatus (tp
, ecs
->ws
);
5898 /* This was cleared early, by handle_inferior_event. Set it
5899 so this pending event is considered by
5901 tp
->set_resumed (true);
5903 gdb_assert (!tp
->executing ());
5905 regcache
= get_thread_regcache (tp
);
5906 tp
->set_stop_pc (regcache_read_pc (regcache
));
5908 infrun_debug_printf ("saved stop_pc=%s for %s "
5909 "(currently_stepping=%d)",
5910 paddress (target_gdbarch (), tp
->stop_pc ()),
5911 tp
->ptid
.to_string ().c_str (),
5912 currently_stepping (tp
));
5914 /* This in-line step-over finished; clear this so we won't
5915 start a new one. This is what handle_signal_stop would
5916 do, if we returned false. */
5917 tp
->stepping_over_breakpoint
= 0;
5919 /* Wake up the event loop again. */
5920 mark_async_event_handler (infrun_async_inferior_event_token
);
5922 prepare_to_wait (ecs
);
5930 /* Come here when the program has stopped with a signal. */
5933 handle_signal_stop (struct execution_control_state
*ecs
)
5935 struct frame_info
*frame
;
5936 struct gdbarch
*gdbarch
;
5937 int stopped_by_watchpoint
;
5938 enum stop_kind stop_soon
;
5941 gdb_assert (ecs
->ws
.kind () == TARGET_WAITKIND_STOPPED
);
5943 ecs
->event_thread
->set_stop_signal (ecs
->ws
.sig ());
5945 /* Do we need to clean up the state of a thread that has
5946 completed a displaced single-step? (Doing so usually affects
5947 the PC, so do it here, before we set stop_pc.) */
5948 if (finish_step_over (ecs
))
5951 /* If we either finished a single-step or hit a breakpoint, but
5952 the user wanted this thread to be stopped, pretend we got a
5953 SIG0 (generic unsignaled stop). */
5954 if (ecs
->event_thread
->stop_requested
5955 && ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
5956 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5958 ecs
->event_thread
->set_stop_pc
5959 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
5961 context_switch (ecs
);
5963 if (deprecated_context_hook
)
5964 deprecated_context_hook (ecs
->event_thread
->global_num
);
5968 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5969 struct gdbarch
*reg_gdbarch
= regcache
->arch ();
5972 ("stop_pc=%s", paddress (reg_gdbarch
, ecs
->event_thread
->stop_pc ()));
5973 if (target_stopped_by_watchpoint ())
5977 infrun_debug_printf ("stopped by watchpoint");
5979 if (target_stopped_data_address (current_inferior ()->top_target (),
5981 infrun_debug_printf ("stopped data address=%s",
5982 paddress (reg_gdbarch
, addr
));
5984 infrun_debug_printf ("(no data address available)");
5988 /* This is originated from start_remote(), start_inferior() and
5989 shared libraries hook functions. */
5990 stop_soon
= get_inferior_stop_soon (ecs
);
5991 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5993 infrun_debug_printf ("quietly stopped");
5994 stop_print_frame
= true;
5999 /* This originates from attach_command(). We need to overwrite
6000 the stop_signal here, because some kernels don't ignore a
6001 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
6002 See more comments in inferior.h. On the other hand, if we
6003 get a non-SIGSTOP, report it to the user - assume the backend
6004 will handle the SIGSTOP if it should show up later.
6006 Also consider that the attach is complete when we see a
6007 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
6008 target extended-remote report it instead of a SIGSTOP
6009 (e.g. gdbserver). We already rely on SIGTRAP being our
6010 signal, so this is no exception.
6012 Also consider that the attach is complete when we see a
6013 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
6014 the target to stop all threads of the inferior, in case the
6015 low level attach operation doesn't stop them implicitly. If
6016 they weren't stopped implicitly, then the stub will report a
6017 GDB_SIGNAL_0, meaning: stopped for no particular reason
6018 other than GDB's request. */
6019 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
6020 && (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_STOP
6021 || ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6022 || ecs
->event_thread
->stop_signal () == GDB_SIGNAL_0
))
6024 stop_print_frame
= true;
6026 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6030 /* At this point, get hold of the now-current thread's frame. */
6031 frame
= get_current_frame ();
6032 gdbarch
= get_frame_arch (frame
);
6034 /* Pull the single step breakpoints out of the target. */
6035 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
6037 struct regcache
*regcache
;
6040 regcache
= get_thread_regcache (ecs
->event_thread
);
6041 const address_space
*aspace
= regcache
->aspace ();
6043 pc
= regcache_read_pc (regcache
);
6045 /* However, before doing so, if this single-step breakpoint was
6046 actually for another thread, set this thread up for moving
6048 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
6051 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
6053 infrun_debug_printf ("[%s] hit another thread's single-step "
6055 ecs
->ptid
.to_string ().c_str ());
6056 ecs
->hit_singlestep_breakpoint
= 1;
6061 infrun_debug_printf ("[%s] hit its single-step breakpoint",
6062 ecs
->ptid
.to_string ().c_str ());
6065 delete_just_stopped_threads_single_step_breakpoints ();
6067 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6068 && ecs
->event_thread
->control
.trap_expected
6069 && ecs
->event_thread
->stepping_over_watchpoint
)
6070 stopped_by_watchpoint
= 0;
6072 stopped_by_watchpoint
= watchpoints_triggered (ecs
->ws
);
6074 /* If necessary, step over this watchpoint. We'll be back to display
6076 if (stopped_by_watchpoint
6077 && (target_have_steppable_watchpoint ()
6078 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
6080 /* At this point, we are stopped at an instruction which has
6081 attempted to write to a piece of memory under control of
6082 a watchpoint. The instruction hasn't actually executed
6083 yet. If we were to evaluate the watchpoint expression
6084 now, we would get the old value, and therefore no change
6085 would seem to have occurred.
6087 In order to make watchpoints work `right', we really need
6088 to complete the memory write, and then evaluate the
6089 watchpoint expression. We do this by single-stepping the
6092 It may not be necessary to disable the watchpoint to step over
6093 it. For example, the PA can (with some kernel cooperation)
6094 single step over a watchpoint without disabling the watchpoint.
6096 It is far more common to need to disable a watchpoint to step
6097 the inferior over it. If we have non-steppable watchpoints,
6098 we must disable the current watchpoint; it's simplest to
6099 disable all watchpoints.
6101 Any breakpoint at PC must also be stepped over -- if there's
6102 one, it will have already triggered before the watchpoint
6103 triggered, and we either already reported it to the user, or
6104 it didn't cause a stop and we called keep_going. In either
6105 case, if there was a breakpoint at PC, we must be trying to
6107 ecs
->event_thread
->stepping_over_watchpoint
= 1;
6112 ecs
->event_thread
->stepping_over_breakpoint
= 0;
6113 ecs
->event_thread
->stepping_over_watchpoint
= 0;
6114 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
6115 ecs
->event_thread
->control
.stop_step
= 0;
6116 stop_print_frame
= true;
6117 stopped_by_random_signal
= 0;
6118 bpstat
*stop_chain
= nullptr;
6120 /* Hide inlined functions starting here, unless we just performed stepi or
6121 nexti. After stepi and nexti, always show the innermost frame (not any
6122 inline function call sites). */
6123 if (ecs
->event_thread
->control
.step_range_end
!= 1)
6125 const address_space
*aspace
6126 = get_thread_regcache (ecs
->event_thread
)->aspace ();
6128 /* skip_inline_frames is expensive, so we avoid it if we can
6129 determine that the address is one where functions cannot have
6130 been inlined. This improves performance with inferiors that
6131 load a lot of shared libraries, because the solib event
6132 breakpoint is defined as the address of a function (i.e. not
6133 inline). Note that we have to check the previous PC as well
6134 as the current one to catch cases when we have just
6135 single-stepped off a breakpoint prior to reinstating it.
6136 Note that we're assuming that the code we single-step to is
6137 not inline, but that's not definitive: there's nothing
6138 preventing the event breakpoint function from containing
6139 inlined code, and the single-step ending up there. If the
6140 user had set a breakpoint on that inlined code, the missing
6141 skip_inline_frames call would break things. Fortunately
6142 that's an extremely unlikely scenario. */
6143 if (!pc_at_non_inline_function (aspace
,
6144 ecs
->event_thread
->stop_pc (),
6146 && !(ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6147 && ecs
->event_thread
->control
.trap_expected
6148 && pc_at_non_inline_function (aspace
,
6149 ecs
->event_thread
->prev_pc
,
6152 stop_chain
= build_bpstat_chain (aspace
,
6153 ecs
->event_thread
->stop_pc (),
6155 skip_inline_frames (ecs
->event_thread
, stop_chain
);
6157 /* Re-fetch current thread's frame in case that invalidated
6159 frame
= get_current_frame ();
6160 gdbarch
= get_frame_arch (frame
);
6164 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6165 && ecs
->event_thread
->control
.trap_expected
6166 && gdbarch_single_step_through_delay_p (gdbarch
)
6167 && currently_stepping (ecs
->event_thread
))
6169 /* We're trying to step off a breakpoint. Turns out that we're
6170 also on an instruction that needs to be stepped multiple
6171 times before it's been fully executing. E.g., architectures
6172 with a delay slot. It needs to be stepped twice, once for
6173 the instruction and once for the delay slot. */
6174 int step_through_delay
6175 = gdbarch_single_step_through_delay (gdbarch
, frame
);
6177 if (step_through_delay
)
6178 infrun_debug_printf ("step through delay");
6180 if (ecs
->event_thread
->control
.step_range_end
== 0
6181 && step_through_delay
)
6183 /* The user issued a continue when stopped at a breakpoint.
6184 Set up for another trap and get out of here. */
6185 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6189 else if (step_through_delay
)
6191 /* The user issued a step when stopped at a breakpoint.
6192 Maybe we should stop, maybe we should not - the delay
6193 slot *might* correspond to a line of source. In any
6194 case, don't decide that here, just set
6195 ecs->stepping_over_breakpoint, making sure we
6196 single-step again before breakpoints are re-inserted. */
6197 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6201 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
6202 handles this event. */
6203 ecs
->event_thread
->control
.stop_bpstat
6204 = bpstat_stop_status (get_current_regcache ()->aspace (),
6205 ecs
->event_thread
->stop_pc (),
6206 ecs
->event_thread
, ecs
->ws
, stop_chain
);
6208 /* Following in case break condition called a
6210 stop_print_frame
= true;
6212 /* This is where we handle "moribund" watchpoints. Unlike
6213 software breakpoints traps, hardware watchpoint traps are
6214 always distinguishable from random traps. If no high-level
6215 watchpoint is associated with the reported stop data address
6216 anymore, then the bpstat does not explain the signal ---
6217 simply make sure to ignore it if `stopped_by_watchpoint' is
6220 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6221 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6223 && stopped_by_watchpoint
)
6225 infrun_debug_printf ("no user watchpoint explains watchpoint SIGTRAP, "
6229 /* NOTE: cagney/2003-03-29: These checks for a random signal
6230 at one stage in the past included checks for an inferior
6231 function call's call dummy's return breakpoint. The original
6232 comment, that went with the test, read:
6234 ``End of a stack dummy. Some systems (e.g. Sony news) give
6235 another signal besides SIGTRAP, so check here as well as
6238 If someone ever tries to get call dummys on a
6239 non-executable stack to work (where the target would stop
6240 with something like a SIGSEGV), then those tests might need
6241 to be re-instated. Given, however, that the tests were only
6242 enabled when momentary breakpoints were not being used, I
6243 suspect that it won't be the case.
6245 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
6246 be necessary for call dummies on a non-executable stack on
6249 /* See if the breakpoints module can explain the signal. */
6251 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6252 ecs
->event_thread
->stop_signal ());
6254 /* Maybe this was a trap for a software breakpoint that has since
6256 if (random_signal
&& target_stopped_by_sw_breakpoint ())
6258 if (gdbarch_program_breakpoint_here_p (gdbarch
,
6259 ecs
->event_thread
->stop_pc ()))
6261 struct regcache
*regcache
;
6264 /* Re-adjust PC to what the program would see if GDB was not
6266 regcache
= get_thread_regcache (ecs
->event_thread
);
6267 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
6270 gdb::optional
<scoped_restore_tmpl
<int>>
6271 restore_operation_disable
;
6273 if (record_full_is_used ())
6274 restore_operation_disable
.emplace
6275 (record_full_gdb_operation_disable_set ());
6277 regcache_write_pc (regcache
,
6278 ecs
->event_thread
->stop_pc () + decr_pc
);
6283 /* A delayed software breakpoint event. Ignore the trap. */
6284 infrun_debug_printf ("delayed software breakpoint trap, ignoring");
6289 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6290 has since been removed. */
6291 if (random_signal
&& target_stopped_by_hw_breakpoint ())
6293 /* A delayed hardware breakpoint event. Ignore the trap. */
6294 infrun_debug_printf ("delayed hardware breakpoint/watchpoint "
6299 /* If not, perhaps stepping/nexting can. */
6301 random_signal
= !(ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6302 && currently_stepping (ecs
->event_thread
));
6304 /* Perhaps the thread hit a single-step breakpoint of _another_
6305 thread. Single-step breakpoints are transparent to the
6306 breakpoints module. */
6308 random_signal
= !ecs
->hit_singlestep_breakpoint
;
6310 /* No? Perhaps we got a moribund watchpoint. */
6312 random_signal
= !stopped_by_watchpoint
;
6314 /* Always stop if the user explicitly requested this thread to
6316 if (ecs
->event_thread
->stop_requested
)
6319 infrun_debug_printf ("user-requested stop");
6322 /* For the program's own signals, act according to
6323 the signal handling tables. */
6327 /* Signal not for debugging purposes. */
6328 enum gdb_signal stop_signal
= ecs
->event_thread
->stop_signal ();
6330 infrun_debug_printf ("random signal (%s)",
6331 gdb_signal_to_symbol_string (stop_signal
));
6333 stopped_by_random_signal
= 1;
6335 /* Always stop on signals if we're either just gaining control
6336 of the program, or the user explicitly requested this thread
6337 to remain stopped. */
6338 if (stop_soon
!= NO_STOP_QUIETLY
6339 || ecs
->event_thread
->stop_requested
6340 || signal_stop_state (ecs
->event_thread
->stop_signal ()))
6346 /* Notify observers the signal has "handle print" set. Note we
6347 returned early above if stopping; normal_stop handles the
6348 printing in that case. */
6349 if (signal_print
[ecs
->event_thread
->stop_signal ()])
6351 /* The signal table tells us to print about this signal. */
6352 target_terminal::ours_for_output ();
6353 gdb::observers::signal_received
.notify (ecs
->event_thread
->stop_signal ());
6354 target_terminal::inferior ();
6357 /* Clear the signal if it should not be passed. */
6358 if (signal_program
[ecs
->event_thread
->stop_signal ()] == 0)
6359 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6361 if (ecs
->event_thread
->prev_pc
== ecs
->event_thread
->stop_pc ()
6362 && ecs
->event_thread
->control
.trap_expected
6363 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6365 /* We were just starting a new sequence, attempting to
6366 single-step off of a breakpoint and expecting a SIGTRAP.
6367 Instead this signal arrives. This signal will take us out
6368 of the stepping range so GDB needs to remember to, when
6369 the signal handler returns, resume stepping off that
6371 /* To simplify things, "continue" is forced to use the same
6372 code paths as single-step - set a breakpoint at the
6373 signal return address and then, once hit, step off that
6375 infrun_debug_printf ("signal arrived while stepping over breakpoint");
6377 insert_hp_step_resume_breakpoint_at_frame (frame
);
6378 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6379 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6380 ecs
->event_thread
->control
.trap_expected
= 0;
6382 /* If we were nexting/stepping some other thread, switch to
6383 it, so that we don't continue it, losing control. */
6384 if (!switch_back_to_stepped_thread (ecs
))
6389 if (ecs
->event_thread
->stop_signal () != GDB_SIGNAL_0
6390 && (pc_in_thread_step_range (ecs
->event_thread
->stop_pc (),
6392 || ecs
->event_thread
->control
.step_range_end
== 1)
6393 && frame_id_eq (get_stack_frame_id (frame
),
6394 ecs
->event_thread
->control
.step_stack_frame_id
)
6395 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6397 /* The inferior is about to take a signal that will take it
6398 out of the single step range. Set a breakpoint at the
6399 current PC (which is presumably where the signal handler
6400 will eventually return) and then allow the inferior to
6403 Note that this is only needed for a signal delivered
6404 while in the single-step range. Nested signals aren't a
6405 problem as they eventually all return. */
6406 infrun_debug_printf ("signal may take us out of single-step range");
6408 clear_step_over_info ();
6409 insert_hp_step_resume_breakpoint_at_frame (frame
);
6410 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6411 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6412 ecs
->event_thread
->control
.trap_expected
= 0;
6417 /* Note: step_resume_breakpoint may be non-NULL. This occurs
6418 when either there's a nested signal, or when there's a
6419 pending signal enabled just as the signal handler returns
6420 (leaving the inferior at the step-resume-breakpoint without
6421 actually executing it). Either way continue until the
6422 breakpoint is really hit. */
6424 if (!switch_back_to_stepped_thread (ecs
))
6426 infrun_debug_printf ("random signal, keep going");
6433 process_event_stop_test (ecs
);
6436 /* Come here when we've got some debug event / signal we can explain
6437 (IOW, not a random signal), and test whether it should cause a
6438 stop, or whether we should resume the inferior (transparently).
6439 E.g., could be a breakpoint whose condition evaluates false; we
6440 could be still stepping within the line; etc. */
6443 process_event_stop_test (struct execution_control_state
*ecs
)
6445 struct symtab_and_line stop_pc_sal
;
6446 struct frame_info
*frame
;
6447 struct gdbarch
*gdbarch
;
6448 CORE_ADDR jmp_buf_pc
;
6449 struct bpstat_what what
;
6451 /* Handle cases caused by hitting a breakpoint. */
6453 frame
= get_current_frame ();
6454 gdbarch
= get_frame_arch (frame
);
6456 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
6458 if (what
.call_dummy
)
6460 stop_stack_dummy
= what
.call_dummy
;
6463 /* A few breakpoint types have callbacks associated (e.g.,
6464 bp_jit_event). Run them now. */
6465 bpstat_run_callbacks (ecs
->event_thread
->control
.stop_bpstat
);
6467 /* If we hit an internal event that triggers symbol changes, the
6468 current frame will be invalidated within bpstat_what (e.g., if we
6469 hit an internal solib event). Re-fetch it. */
6470 frame
= get_current_frame ();
6471 gdbarch
= get_frame_arch (frame
);
6473 switch (what
.main_action
)
6475 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
6476 /* If we hit the breakpoint at longjmp while stepping, we
6477 install a momentary breakpoint at the target of the
6480 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME");
6482 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6484 if (what
.is_longjmp
)
6486 struct value
*arg_value
;
6488 /* If we set the longjmp breakpoint via a SystemTap probe,
6489 then use it to extract the arguments. The destination PC
6490 is the third argument to the probe. */
6491 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
6494 jmp_buf_pc
= value_as_address (arg_value
);
6495 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
6497 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
6498 || !gdbarch_get_longjmp_target (gdbarch
,
6499 frame
, &jmp_buf_pc
))
6501 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME "
6502 "(!gdbarch_get_longjmp_target)");
6507 /* Insert a breakpoint at resume address. */
6508 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
6511 check_exception_resume (ecs
, frame
);
6515 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
6517 struct frame_info
*init_frame
;
6519 /* There are several cases to consider.
6521 1. The initiating frame no longer exists. In this case we
6522 must stop, because the exception or longjmp has gone too
6525 2. The initiating frame exists, and is the same as the
6526 current frame. We stop, because the exception or longjmp
6529 3. The initiating frame exists and is different from the
6530 current frame. This means the exception or longjmp has
6531 been caught beneath the initiating frame, so keep going.
6533 4. longjmp breakpoint has been placed just to protect
6534 against stale dummy frames and user is not interested in
6535 stopping around longjmps. */
6537 infrun_debug_printf ("BPSTAT_WHAT_CLEAR_LONGJMP_RESUME");
6539 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
6541 delete_exception_resume_breakpoint (ecs
->event_thread
);
6543 if (what
.is_longjmp
)
6545 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
6547 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
6555 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
6559 struct frame_id current_id
6560 = get_frame_id (get_current_frame ());
6561 if (frame_id_eq (current_id
,
6562 ecs
->event_thread
->initiating_frame
))
6564 /* Case 2. Fall through. */
6574 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6576 delete_step_resume_breakpoint (ecs
->event_thread
);
6578 end_stepping_range (ecs
);
6582 case BPSTAT_WHAT_SINGLE
:
6583 infrun_debug_printf ("BPSTAT_WHAT_SINGLE");
6584 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6585 /* Still need to check other stuff, at least the case where we
6586 are stepping and step out of the right range. */
6589 case BPSTAT_WHAT_STEP_RESUME
:
6590 infrun_debug_printf ("BPSTAT_WHAT_STEP_RESUME");
6592 delete_step_resume_breakpoint (ecs
->event_thread
);
6593 if (ecs
->event_thread
->control
.proceed_to_finish
6594 && execution_direction
== EXEC_REVERSE
)
6596 struct thread_info
*tp
= ecs
->event_thread
;
6598 /* We are finishing a function in reverse, and just hit the
6599 step-resume breakpoint at the start address of the
6600 function, and we're almost there -- just need to back up
6601 by one more single-step, which should take us back to the
6603 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6607 fill_in_stop_func (gdbarch
, ecs
);
6608 if (ecs
->event_thread
->stop_pc () == ecs
->stop_func_start
6609 && execution_direction
== EXEC_REVERSE
)
6611 /* We are stepping over a function call in reverse, and just
6612 hit the step-resume breakpoint at the start address of
6613 the function. Go back to single-stepping, which should
6614 take us back to the function call. */
6615 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6621 case BPSTAT_WHAT_STOP_NOISY
:
6622 infrun_debug_printf ("BPSTAT_WHAT_STOP_NOISY");
6623 stop_print_frame
= true;
6625 /* Assume the thread stopped for a breakpoint. We'll still check
6626 whether a/the breakpoint is there when the thread is next
6628 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6633 case BPSTAT_WHAT_STOP_SILENT
:
6634 infrun_debug_printf ("BPSTAT_WHAT_STOP_SILENT");
6635 stop_print_frame
= false;
6637 /* Assume the thread stopped for a breakpoint. We'll still check
6638 whether a/the breakpoint is there when the thread is next
6640 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6644 case BPSTAT_WHAT_HP_STEP_RESUME
:
6645 infrun_debug_printf ("BPSTAT_WHAT_HP_STEP_RESUME");
6647 delete_step_resume_breakpoint (ecs
->event_thread
);
6648 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6650 /* Back when the step-resume breakpoint was inserted, we
6651 were trying to single-step off a breakpoint. Go back to
6653 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6654 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6660 case BPSTAT_WHAT_KEEP_CHECKING
:
6664 /* If we stepped a permanent breakpoint and we had a high priority
6665 step-resume breakpoint for the address we stepped, but we didn't
6666 hit it, then we must have stepped into the signal handler. The
6667 step-resume was only necessary to catch the case of _not_
6668 stepping into the handler, so delete it, and fall through to
6669 checking whether the step finished. */
6670 if (ecs
->event_thread
->stepped_breakpoint
)
6672 struct breakpoint
*sr_bp
6673 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6676 && sr_bp
->loc
->permanent
6677 && sr_bp
->type
== bp_hp_step_resume
6678 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6680 infrun_debug_printf ("stepped permanent breakpoint, stopped in handler");
6681 delete_step_resume_breakpoint (ecs
->event_thread
);
6682 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6686 /* We come here if we hit a breakpoint but should not stop for it.
6687 Possibly we also were stepping and should stop for that. So fall
6688 through and test for stepping. But, if not stepping, do not
6691 /* In all-stop mode, if we're currently stepping but have stopped in
6692 some other thread, we need to switch back to the stepped thread. */
6693 if (switch_back_to_stepped_thread (ecs
))
6696 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6698 infrun_debug_printf ("step-resume breakpoint is inserted");
6700 /* Having a step-resume breakpoint overrides anything
6701 else having to do with stepping commands until
6702 that breakpoint is reached. */
6707 if (ecs
->event_thread
->control
.step_range_end
== 0)
6709 infrun_debug_printf ("no stepping, continue");
6710 /* Likewise if we aren't even stepping. */
6715 /* Re-fetch current thread's frame in case the code above caused
6716 the frame cache to be re-initialized, making our FRAME variable
6717 a dangling pointer. */
6718 frame
= get_current_frame ();
6719 gdbarch
= get_frame_arch (frame
);
6720 fill_in_stop_func (gdbarch
, ecs
);
6722 /* If stepping through a line, keep going if still within it.
6724 Note that step_range_end is the address of the first instruction
6725 beyond the step range, and NOT the address of the last instruction
6728 Note also that during reverse execution, we may be stepping
6729 through a function epilogue and therefore must detect when
6730 the current-frame changes in the middle of a line. */
6732 if (pc_in_thread_step_range (ecs
->event_thread
->stop_pc (),
6734 && (execution_direction
!= EXEC_REVERSE
6735 || frame_id_eq (get_frame_id (frame
),
6736 ecs
->event_thread
->control
.step_frame_id
)))
6739 ("stepping inside range [%s-%s]",
6740 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6741 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6743 /* Tentatively re-enable range stepping; `resume' disables it if
6744 necessary (e.g., if we're stepping over a breakpoint or we
6745 have software watchpoints). */
6746 ecs
->event_thread
->control
.may_range_step
= 1;
6748 /* When stepping backward, stop at beginning of line range
6749 (unless it's the function entry point, in which case
6750 keep going back to the call point). */
6751 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
6752 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6753 && stop_pc
!= ecs
->stop_func_start
6754 && execution_direction
== EXEC_REVERSE
)
6755 end_stepping_range (ecs
);
6762 /* We stepped out of the stepping range. */
6764 /* If we are stepping at the source level and entered the runtime
6765 loader dynamic symbol resolution code...
6767 EXEC_FORWARD: we keep on single stepping until we exit the run
6768 time loader code and reach the callee's address.
6770 EXEC_REVERSE: we've already executed the callee (backward), and
6771 the runtime loader code is handled just like any other
6772 undebuggable function call. Now we need only keep stepping
6773 backward through the trampoline code, and that's handled further
6774 down, so there is nothing for us to do here. */
6776 if (execution_direction
!= EXEC_REVERSE
6777 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6778 && in_solib_dynsym_resolve_code (ecs
->event_thread
->stop_pc ()))
6780 CORE_ADDR pc_after_resolver
=
6781 gdbarch_skip_solib_resolver (gdbarch
, ecs
->event_thread
->stop_pc ());
6783 infrun_debug_printf ("stepped into dynsym resolve code");
6785 if (pc_after_resolver
)
6787 /* Set up a step-resume breakpoint at the address
6788 indicated by SKIP_SOLIB_RESOLVER. */
6789 symtab_and_line sr_sal
;
6790 sr_sal
.pc
= pc_after_resolver
;
6791 sr_sal
.pspace
= get_frame_program_space (frame
);
6793 insert_step_resume_breakpoint_at_sal (gdbarch
,
6794 sr_sal
, null_frame_id
);
6801 /* Step through an indirect branch thunk. */
6802 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6803 && gdbarch_in_indirect_branch_thunk (gdbarch
,
6804 ecs
->event_thread
->stop_pc ()))
6806 infrun_debug_printf ("stepped into indirect branch thunk");
6811 if (ecs
->event_thread
->control
.step_range_end
!= 1
6812 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6813 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6814 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6816 infrun_debug_printf ("stepped into signal trampoline");
6817 /* The inferior, while doing a "step" or "next", has ended up in
6818 a signal trampoline (either by a signal being delivered or by
6819 the signal handler returning). Just single-step until the
6820 inferior leaves the trampoline (either by calling the handler
6826 /* If we're in the return path from a shared library trampoline,
6827 we want to proceed through the trampoline when stepping. */
6828 /* macro/2012-04-25: This needs to come before the subroutine
6829 call check below as on some targets return trampolines look
6830 like subroutine calls (MIPS16 return thunks). */
6831 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6832 ecs
->event_thread
->stop_pc (),
6833 ecs
->stop_func_name
)
6834 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6836 /* Determine where this trampoline returns. */
6837 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
6838 CORE_ADDR real_stop_pc
6839 = gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6841 infrun_debug_printf ("stepped into solib return tramp");
6843 /* Only proceed through if we know where it's going. */
6846 /* And put the step-breakpoint there and go until there. */
6847 symtab_and_line sr_sal
;
6848 sr_sal
.pc
= real_stop_pc
;
6849 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6850 sr_sal
.pspace
= get_frame_program_space (frame
);
6852 /* Do not specify what the fp should be when we stop since
6853 on some machines the prologue is where the new fp value
6855 insert_step_resume_breakpoint_at_sal (gdbarch
,
6856 sr_sal
, null_frame_id
);
6858 /* Restart without fiddling with the step ranges or
6865 /* Check for subroutine calls. The check for the current frame
6866 equalling the step ID is not necessary - the check of the
6867 previous frame's ID is sufficient - but it is a common case and
6868 cheaper than checking the previous frame's ID.
6870 NOTE: frame_id_eq will never report two invalid frame IDs as
6871 being equal, so to get into this block, both the current and
6872 previous frame must have valid frame IDs. */
6873 /* The outer_frame_id check is a heuristic to detect stepping
6874 through startup code. If we step over an instruction which
6875 sets the stack pointer from an invalid value to a valid value,
6876 we may detect that as a subroutine call from the mythical
6877 "outermost" function. This could be fixed by marking
6878 outermost frames as !stack_p,code_p,special_p. Then the
6879 initial outermost frame, before sp was valid, would
6880 have code_addr == &_start. See the comment in frame_id_eq
6882 if (!frame_id_eq (get_stack_frame_id (frame
),
6883 ecs
->event_thread
->control
.step_stack_frame_id
)
6884 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6885 ecs
->event_thread
->control
.step_stack_frame_id
)
6886 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6888 || (ecs
->event_thread
->control
.step_start_function
6889 != find_pc_function (ecs
->event_thread
->stop_pc ())))))
6891 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
6892 CORE_ADDR real_stop_pc
;
6894 infrun_debug_printf ("stepped into subroutine");
6896 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6898 /* I presume that step_over_calls is only 0 when we're
6899 supposed to be stepping at the assembly language level
6900 ("stepi"). Just stop. */
6901 /* And this works the same backward as frontward. MVS */
6902 end_stepping_range (ecs
);
6906 /* Reverse stepping through solib trampolines. */
6908 if (execution_direction
== EXEC_REVERSE
6909 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6910 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6911 || (ecs
->stop_func_start
== 0
6912 && in_solib_dynsym_resolve_code (stop_pc
))))
6914 /* Any solib trampoline code can be handled in reverse
6915 by simply continuing to single-step. We have already
6916 executed the solib function (backwards), and a few
6917 steps will take us back through the trampoline to the
6923 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6925 /* We're doing a "next".
6927 Normal (forward) execution: set a breakpoint at the
6928 callee's return address (the address at which the caller
6931 Reverse (backward) execution. set the step-resume
6932 breakpoint at the start of the function that we just
6933 stepped into (backwards), and continue to there. When we
6934 get there, we'll need to single-step back to the caller. */
6936 if (execution_direction
== EXEC_REVERSE
)
6938 /* If we're already at the start of the function, we've either
6939 just stepped backward into a single instruction function,
6940 or stepped back out of a signal handler to the first instruction
6941 of the function. Just keep going, which will single-step back
6943 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6945 /* Normal function call return (static or dynamic). */
6946 symtab_and_line sr_sal
;
6947 sr_sal
.pc
= ecs
->stop_func_start
;
6948 sr_sal
.pspace
= get_frame_program_space (frame
);
6949 insert_step_resume_breakpoint_at_sal (gdbarch
,
6950 sr_sal
, null_frame_id
);
6954 insert_step_resume_breakpoint_at_caller (frame
);
6960 /* If we are in a function call trampoline (a stub between the
6961 calling routine and the real function), locate the real
6962 function. That's what tells us (a) whether we want to step
6963 into it at all, and (b) what prologue we want to run to the
6964 end of, if we do step into it. */
6965 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6966 if (real_stop_pc
== 0)
6967 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6968 if (real_stop_pc
!= 0)
6969 ecs
->stop_func_start
= real_stop_pc
;
6971 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6973 symtab_and_line sr_sal
;
6974 sr_sal
.pc
= ecs
->stop_func_start
;
6975 sr_sal
.pspace
= get_frame_program_space (frame
);
6977 insert_step_resume_breakpoint_at_sal (gdbarch
,
6978 sr_sal
, null_frame_id
);
6983 /* If we have line number information for the function we are
6984 thinking of stepping into and the function isn't on the skip
6987 If there are several symtabs at that PC (e.g. with include
6988 files), just want to know whether *any* of them have line
6989 numbers. find_pc_line handles this. */
6991 struct symtab_and_line tmp_sal
;
6993 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6994 if (tmp_sal
.line
!= 0
6995 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6997 && !inline_frame_is_marked_for_skip (true, ecs
->event_thread
))
6999 if (execution_direction
== EXEC_REVERSE
)
7000 handle_step_into_function_backward (gdbarch
, ecs
);
7002 handle_step_into_function (gdbarch
, ecs
);
7007 /* If we have no line number and the step-stop-if-no-debug is
7008 set, we stop the step so that the user has a chance to switch
7009 in assembly mode. */
7010 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7011 && step_stop_if_no_debug
)
7013 end_stepping_range (ecs
);
7017 if (execution_direction
== EXEC_REVERSE
)
7019 /* If we're already at the start of the function, we've either just
7020 stepped backward into a single instruction function without line
7021 number info, or stepped back out of a signal handler to the first
7022 instruction of the function without line number info. Just keep
7023 going, which will single-step back to the caller. */
7024 if (ecs
->stop_func_start
!= stop_pc
)
7026 /* Set a breakpoint at callee's start address.
7027 From there we can step once and be back in the caller. */
7028 symtab_and_line sr_sal
;
7029 sr_sal
.pc
= ecs
->stop_func_start
;
7030 sr_sal
.pspace
= get_frame_program_space (frame
);
7031 insert_step_resume_breakpoint_at_sal (gdbarch
,
7032 sr_sal
, null_frame_id
);
7036 /* Set a breakpoint at callee's return address (the address
7037 at which the caller will resume). */
7038 insert_step_resume_breakpoint_at_caller (frame
);
7044 /* Reverse stepping through solib trampolines. */
7046 if (execution_direction
== EXEC_REVERSE
7047 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
7049 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
7051 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
7052 || (ecs
->stop_func_start
== 0
7053 && in_solib_dynsym_resolve_code (stop_pc
)))
7055 /* Any solib trampoline code can be handled in reverse
7056 by simply continuing to single-step. We have already
7057 executed the solib function (backwards), and a few
7058 steps will take us back through the trampoline to the
7063 else if (in_solib_dynsym_resolve_code (stop_pc
))
7065 /* Stepped backward into the solib dynsym resolver.
7066 Set a breakpoint at its start and continue, then
7067 one more step will take us out. */
7068 symtab_and_line sr_sal
;
7069 sr_sal
.pc
= ecs
->stop_func_start
;
7070 sr_sal
.pspace
= get_frame_program_space (frame
);
7071 insert_step_resume_breakpoint_at_sal (gdbarch
,
7072 sr_sal
, null_frame_id
);
7078 /* This always returns the sal for the inner-most frame when we are in a
7079 stack of inlined frames, even if GDB actually believes that it is in a
7080 more outer frame. This is checked for below by calls to
7081 inline_skipped_frames. */
7082 stop_pc_sal
= find_pc_line (ecs
->event_thread
->stop_pc (), 0);
7084 /* NOTE: tausq/2004-05-24: This if block used to be done before all
7085 the trampoline processing logic, however, there are some trampolines
7086 that have no names, so we should do trampoline handling first. */
7087 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7088 && ecs
->stop_func_name
== NULL
7089 && stop_pc_sal
.line
== 0)
7091 infrun_debug_printf ("stepped into undebuggable function");
7093 /* The inferior just stepped into, or returned to, an
7094 undebuggable function (where there is no debugging information
7095 and no line number corresponding to the address where the
7096 inferior stopped). Since we want to skip this kind of code,
7097 we keep going until the inferior returns from this
7098 function - unless the user has asked us not to (via
7099 set step-mode) or we no longer know how to get back
7100 to the call site. */
7101 if (step_stop_if_no_debug
7102 || !frame_id_p (frame_unwind_caller_id (frame
)))
7104 /* If we have no line number and the step-stop-if-no-debug
7105 is set, we stop the step so that the user has a chance to
7106 switch in assembly mode. */
7107 end_stepping_range (ecs
);
7112 /* Set a breakpoint at callee's return address (the address
7113 at which the caller will resume). */
7114 insert_step_resume_breakpoint_at_caller (frame
);
7120 if (ecs
->event_thread
->control
.step_range_end
== 1)
7122 /* It is stepi or nexti. We always want to stop stepping after
7124 infrun_debug_printf ("stepi/nexti");
7125 end_stepping_range (ecs
);
7129 if (stop_pc_sal
.line
== 0)
7131 /* We have no line number information. That means to stop
7132 stepping (does this always happen right after one instruction,
7133 when we do "s" in a function with no line numbers,
7134 or can this happen as a result of a return or longjmp?). */
7135 infrun_debug_printf ("line number info");
7136 end_stepping_range (ecs
);
7140 /* Look for "calls" to inlined functions, part one. If the inline
7141 frame machinery detected some skipped call sites, we have entered
7142 a new inline function. */
7144 if (frame_id_eq (get_frame_id (get_current_frame ()),
7145 ecs
->event_thread
->control
.step_frame_id
)
7146 && inline_skipped_frames (ecs
->event_thread
))
7148 infrun_debug_printf ("stepped into inlined function");
7150 symtab_and_line call_sal
= find_frame_sal (get_current_frame ());
7152 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
7154 /* For "step", we're going to stop. But if the call site
7155 for this inlined function is on the same source line as
7156 we were previously stepping, go down into the function
7157 first. Otherwise stop at the call site. */
7159 if (call_sal
.line
== ecs
->event_thread
->current_line
7160 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7162 step_into_inline_frame (ecs
->event_thread
);
7163 if (inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7170 end_stepping_range (ecs
);
7175 /* For "next", we should stop at the call site if it is on a
7176 different source line. Otherwise continue through the
7177 inlined function. */
7178 if (call_sal
.line
== ecs
->event_thread
->current_line
7179 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7182 end_stepping_range (ecs
);
7187 /* Look for "calls" to inlined functions, part two. If we are still
7188 in the same real function we were stepping through, but we have
7189 to go further up to find the exact frame ID, we are stepping
7190 through a more inlined call beyond its call site. */
7192 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
7193 && !frame_id_eq (get_frame_id (get_current_frame ()),
7194 ecs
->event_thread
->control
.step_frame_id
)
7195 && stepped_in_from (get_current_frame (),
7196 ecs
->event_thread
->control
.step_frame_id
))
7198 infrun_debug_printf ("stepping through inlined function");
7200 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
7201 || inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7204 end_stepping_range (ecs
);
7208 bool refresh_step_info
= true;
7209 if ((ecs
->event_thread
->stop_pc () == stop_pc_sal
.pc
)
7210 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
7211 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
7213 /* We are at a different line. */
7215 if (stop_pc_sal
.is_stmt
)
7217 /* We are at the start of a statement.
7219 So stop. Note that we don't stop if we step into the middle of a
7220 statement. That is said to make things like for (;;) statements
7222 infrun_debug_printf ("stepped to a different line");
7223 end_stepping_range (ecs
);
7226 else if (frame_id_eq (get_frame_id (get_current_frame ()),
7227 ecs
->event_thread
->control
.step_frame_id
))
7229 /* We are not at the start of a statement, and we have not changed
7232 We ignore this line table entry, and continue stepping forward,
7233 looking for a better place to stop. */
7234 refresh_step_info
= false;
7235 infrun_debug_printf ("stepped to a different line, but "
7236 "it's not the start of a statement");
7240 /* We are not the start of a statement, and we have changed frame.
7242 We ignore this line table entry, and continue stepping forward,
7243 looking for a better place to stop. Keep refresh_step_info at
7244 true to note that the frame has changed, but ignore the line
7245 number to make sure we don't ignore a subsequent entry with the
7246 same line number. */
7247 stop_pc_sal
.line
= 0;
7248 infrun_debug_printf ("stepped to a different frame, but "
7249 "it's not the start of a statement");
7253 /* We aren't done stepping.
7255 Optimize by setting the stepping range to the line.
7256 (We might not be in the original line, but if we entered a
7257 new line in mid-statement, we continue stepping. This makes
7258 things like for(;;) statements work better.)
7260 If we entered a SAL that indicates a non-statement line table entry,
7261 then we update the stepping range, but we don't update the step info,
7262 which includes things like the line number we are stepping away from.
7263 This means we will stop when we find a line table entry that is marked
7264 as is-statement, even if it matches the non-statement one we just
7267 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
7268 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
7269 ecs
->event_thread
->control
.may_range_step
= 1;
7270 if (refresh_step_info
)
7271 set_step_info (ecs
->event_thread
, frame
, stop_pc_sal
);
7273 infrun_debug_printf ("keep going");
7277 static bool restart_stepped_thread (process_stratum_target
*resume_target
,
7278 ptid_t resume_ptid
);
7280 /* In all-stop mode, if we're currently stepping but have stopped in
7281 some other thread, we may need to switch back to the stepped
7282 thread. Returns true we set the inferior running, false if we left
7283 it stopped (and the event needs further processing). */
7286 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
7288 if (!target_is_non_stop_p ())
7290 /* If any thread is blocked on some internal breakpoint, and we
7291 simply need to step over that breakpoint to get it going
7292 again, do that first. */
7294 /* However, if we see an event for the stepping thread, then we
7295 know all other threads have been moved past their breakpoints
7296 already. Let the caller check whether the step is finished,
7297 etc., before deciding to move it past a breakpoint. */
7298 if (ecs
->event_thread
->control
.step_range_end
!= 0)
7301 /* Check if the current thread is blocked on an incomplete
7302 step-over, interrupted by a random signal. */
7303 if (ecs
->event_thread
->control
.trap_expected
7304 && ecs
->event_thread
->stop_signal () != GDB_SIGNAL_TRAP
)
7307 ("need to finish step-over of [%s]",
7308 ecs
->event_thread
->ptid
.to_string ().c_str ());
7313 /* Check if the current thread is blocked by a single-step
7314 breakpoint of another thread. */
7315 if (ecs
->hit_singlestep_breakpoint
)
7317 infrun_debug_printf ("need to step [%s] over single-step breakpoint",
7318 ecs
->ptid
.to_string ().c_str ());
7323 /* If this thread needs yet another step-over (e.g., stepping
7324 through a delay slot), do it first before moving on to
7326 if (thread_still_needs_step_over (ecs
->event_thread
))
7329 ("thread [%s] still needs step-over",
7330 ecs
->event_thread
->ptid
.to_string ().c_str ());
7335 /* If scheduler locking applies even if not stepping, there's no
7336 need to walk over threads. Above we've checked whether the
7337 current thread is stepping. If some other thread not the
7338 event thread is stepping, then it must be that scheduler
7339 locking is not in effect. */
7340 if (schedlock_applies (ecs
->event_thread
))
7343 /* Otherwise, we no longer expect a trap in the current thread.
7344 Clear the trap_expected flag before switching back -- this is
7345 what keep_going does as well, if we call it. */
7346 ecs
->event_thread
->control
.trap_expected
= 0;
7348 /* Likewise, clear the signal if it should not be passed. */
7349 if (!signal_program
[ecs
->event_thread
->stop_signal ()])
7350 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
7352 if (restart_stepped_thread (ecs
->target
, ecs
->ptid
))
7354 prepare_to_wait (ecs
);
7358 switch_to_thread (ecs
->event_thread
);
7364 /* Look for the thread that was stepping, and resume it.
7365 RESUME_TARGET / RESUME_PTID indicate the set of threads the caller
7366 is resuming. Return true if a thread was started, false
7370 restart_stepped_thread (process_stratum_target
*resume_target
,
7373 /* Do all pending step-overs before actually proceeding with
7375 if (start_step_over ())
7378 for (thread_info
*tp
: all_threads_safe ())
7380 if (tp
->state
== THREAD_EXITED
)
7383 if (tp
->has_pending_waitstatus ())
7386 /* Ignore threads of processes the caller is not
7389 && (tp
->inf
->process_target () != resume_target
7390 || tp
->inf
->pid
!= resume_ptid
.pid ()))
7393 if (tp
->control
.trap_expected
)
7395 infrun_debug_printf ("switching back to stepped thread (step-over)");
7397 if (keep_going_stepped_thread (tp
))
7402 for (thread_info
*tp
: all_threads_safe ())
7404 if (tp
->state
== THREAD_EXITED
)
7407 if (tp
->has_pending_waitstatus ())
7410 /* Ignore threads of processes the caller is not
7413 && (tp
->inf
->process_target () != resume_target
7414 || tp
->inf
->pid
!= resume_ptid
.pid ()))
7417 /* Did we find the stepping thread? */
7418 if (tp
->control
.step_range_end
)
7420 infrun_debug_printf ("switching back to stepped thread (stepping)");
7422 if (keep_going_stepped_thread (tp
))
7433 restart_after_all_stop_detach (process_stratum_target
*proc_target
)
7435 /* Note we don't check target_is_non_stop_p() here, because the
7436 current inferior may no longer have a process_stratum target
7437 pushed, as we just detached. */
7439 /* See if we have a THREAD_RUNNING thread that need to be
7440 re-resumed. If we have any thread that is already executing,
7441 then we don't need to resume the target -- it is already been
7442 resumed. With the remote target (in all-stop), it's even
7443 impossible to issue another resumption if the target is already
7444 resumed, until the target reports a stop. */
7445 for (thread_info
*thr
: all_threads (proc_target
))
7447 if (thr
->state
!= THREAD_RUNNING
)
7450 /* If we have any thread that is already executing, then we
7451 don't need to resume the target -- it is already been
7453 if (thr
->executing ())
7456 /* If we have a pending event to process, skip resuming the
7457 target and go straight to processing it. */
7458 if (thr
->resumed () && thr
->has_pending_waitstatus ())
7462 /* Alright, we need to re-resume the target. If a thread was
7463 stepping, we need to restart it stepping. */
7464 if (restart_stepped_thread (proc_target
, minus_one_ptid
))
7467 /* Otherwise, find the first THREAD_RUNNING thread and resume
7469 for (thread_info
*thr
: all_threads (proc_target
))
7471 if (thr
->state
!= THREAD_RUNNING
)
7474 execution_control_state ecs
;
7475 reset_ecs (&ecs
, thr
);
7476 switch_to_thread (thr
);
7482 /* Set a previously stepped thread back to stepping. Returns true on
7483 success, false if the resume is not possible (e.g., the thread
7487 keep_going_stepped_thread (struct thread_info
*tp
)
7489 struct frame_info
*frame
;
7490 struct execution_control_state ecss
;
7491 struct execution_control_state
*ecs
= &ecss
;
7493 /* If the stepping thread exited, then don't try to switch back and
7494 resume it, which could fail in several different ways depending
7495 on the target. Instead, just keep going.
7497 We can find a stepping dead thread in the thread list in two
7500 - The target supports thread exit events, and when the target
7501 tries to delete the thread from the thread list, inferior_ptid
7502 pointed at the exiting thread. In such case, calling
7503 delete_thread does not really remove the thread from the list;
7504 instead, the thread is left listed, with 'exited' state.
7506 - The target's debug interface does not support thread exit
7507 events, and so we have no idea whatsoever if the previously
7508 stepping thread is still alive. For that reason, we need to
7509 synchronously query the target now. */
7511 if (tp
->state
== THREAD_EXITED
|| !target_thread_alive (tp
->ptid
))
7513 infrun_debug_printf ("not resuming previously stepped thread, it has "
7520 infrun_debug_printf ("resuming previously stepped thread");
7522 reset_ecs (ecs
, tp
);
7523 switch_to_thread (tp
);
7525 tp
->set_stop_pc (regcache_read_pc (get_thread_regcache (tp
)));
7526 frame
= get_current_frame ();
7528 /* If the PC of the thread we were trying to single-step has
7529 changed, then that thread has trapped or been signaled, but the
7530 event has not been reported to GDB yet. Re-poll the target
7531 looking for this particular thread's event (i.e. temporarily
7532 enable schedlock) by:
7534 - setting a break at the current PC
7535 - resuming that particular thread, only (by setting trap
7538 This prevents us continuously moving the single-step breakpoint
7539 forward, one instruction at a time, overstepping. */
7541 if (tp
->stop_pc () != tp
->prev_pc
)
7545 infrun_debug_printf ("expected thread advanced also (%s -> %s)",
7546 paddress (target_gdbarch (), tp
->prev_pc
),
7547 paddress (target_gdbarch (), tp
->stop_pc ()));
7549 /* Clear the info of the previous step-over, as it's no longer
7550 valid (if the thread was trying to step over a breakpoint, it
7551 has already succeeded). It's what keep_going would do too,
7552 if we called it. Do this before trying to insert the sss
7553 breakpoint, otherwise if we were previously trying to step
7554 over this exact address in another thread, the breakpoint is
7556 clear_step_over_info ();
7557 tp
->control
.trap_expected
= 0;
7559 insert_single_step_breakpoint (get_frame_arch (frame
),
7560 get_frame_address_space (frame
),
7563 tp
->set_resumed (true);
7564 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
7565 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
7569 infrun_debug_printf ("expected thread still hasn't advanced");
7571 keep_going_pass_signal (ecs
);
7577 /* Is thread TP in the middle of (software or hardware)
7578 single-stepping? (Note the result of this function must never be
7579 passed directly as target_resume's STEP parameter.) */
7582 currently_stepping (struct thread_info
*tp
)
7584 return ((tp
->control
.step_range_end
7585 && tp
->control
.step_resume_breakpoint
== NULL
)
7586 || tp
->control
.trap_expected
7587 || tp
->stepped_breakpoint
7588 || bpstat_should_step ());
7591 /* Inferior has stepped into a subroutine call with source code that
7592 we should not step over. Do step to the first line of code in
7596 handle_step_into_function (struct gdbarch
*gdbarch
,
7597 struct execution_control_state
*ecs
)
7599 fill_in_stop_func (gdbarch
, ecs
);
7601 compunit_symtab
*cust
7602 = find_pc_compunit_symtab (ecs
->event_thread
->stop_pc ());
7603 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7604 ecs
->stop_func_start
7605 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7607 symtab_and_line stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
7608 /* Use the step_resume_break to step until the end of the prologue,
7609 even if that involves jumps (as it seems to on the vax under
7611 /* If the prologue ends in the middle of a source line, continue to
7612 the end of that source line (if it is still within the function).
7613 Otherwise, just go to end of prologue. */
7614 if (stop_func_sal
.end
7615 && stop_func_sal
.pc
!= ecs
->stop_func_start
7616 && stop_func_sal
.end
< ecs
->stop_func_end
)
7617 ecs
->stop_func_start
= stop_func_sal
.end
;
7619 /* Architectures which require breakpoint adjustment might not be able
7620 to place a breakpoint at the computed address. If so, the test
7621 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7622 ecs->stop_func_start to an address at which a breakpoint may be
7623 legitimately placed.
7625 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7626 made, GDB will enter an infinite loop when stepping through
7627 optimized code consisting of VLIW instructions which contain
7628 subinstructions corresponding to different source lines. On
7629 FR-V, it's not permitted to place a breakpoint on any but the
7630 first subinstruction of a VLIW instruction. When a breakpoint is
7631 set, GDB will adjust the breakpoint address to the beginning of
7632 the VLIW instruction. Thus, we need to make the corresponding
7633 adjustment here when computing the stop address. */
7635 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7637 ecs
->stop_func_start
7638 = gdbarch_adjust_breakpoint_address (gdbarch
,
7639 ecs
->stop_func_start
);
7642 if (ecs
->stop_func_start
== ecs
->event_thread
->stop_pc ())
7644 /* We are already there: stop now. */
7645 end_stepping_range (ecs
);
7650 /* Put the step-breakpoint there and go until there. */
7651 symtab_and_line sr_sal
;
7652 sr_sal
.pc
= ecs
->stop_func_start
;
7653 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7654 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7656 /* Do not specify what the fp should be when we stop since on
7657 some machines the prologue is where the new fp value is
7659 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7661 /* And make sure stepping stops right away then. */
7662 ecs
->event_thread
->control
.step_range_end
7663 = ecs
->event_thread
->control
.step_range_start
;
7668 /* Inferior has stepped backward into a subroutine call with source
7669 code that we should not step over. Do step to the beginning of the
7670 last line of code in it. */
7673 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7674 struct execution_control_state
*ecs
)
7676 struct compunit_symtab
*cust
;
7677 struct symtab_and_line stop_func_sal
;
7679 fill_in_stop_func (gdbarch
, ecs
);
7681 cust
= find_pc_compunit_symtab (ecs
->event_thread
->stop_pc ());
7682 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7683 ecs
->stop_func_start
7684 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7686 stop_func_sal
= find_pc_line (ecs
->event_thread
->stop_pc (), 0);
7688 /* OK, we're just going to keep stepping here. */
7689 if (stop_func_sal
.pc
== ecs
->event_thread
->stop_pc ())
7691 /* We're there already. Just stop stepping now. */
7692 end_stepping_range (ecs
);
7696 /* Else just reset the step range and keep going.
7697 No step-resume breakpoint, they don't work for
7698 epilogues, which can have multiple entry paths. */
7699 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7700 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7706 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7707 This is used to both functions and to skip over code. */
7710 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7711 struct symtab_and_line sr_sal
,
7712 struct frame_id sr_id
,
7713 enum bptype sr_type
)
7715 /* There should never be more than one step-resume or longjmp-resume
7716 breakpoint per thread, so we should never be setting a new
7717 step_resume_breakpoint when one is already active. */
7718 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7719 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7721 infrun_debug_printf ("inserting step-resume breakpoint at %s",
7722 paddress (gdbarch
, sr_sal
.pc
));
7724 inferior_thread ()->control
.step_resume_breakpoint
7725 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
).release ();
7729 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7730 struct symtab_and_line sr_sal
,
7731 struct frame_id sr_id
)
7733 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7738 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7739 This is used to skip a potential signal handler.
7741 This is called with the interrupted function's frame. The signal
7742 handler, when it returns, will resume the interrupted function at
7746 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7748 gdb_assert (return_frame
!= NULL
);
7750 struct gdbarch
*gdbarch
= get_frame_arch (return_frame
);
7752 symtab_and_line sr_sal
;
7753 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7754 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7755 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7757 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7758 get_stack_frame_id (return_frame
),
7762 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7763 is used to skip a function after stepping into it (for "next" or if
7764 the called function has no debugging information).
7766 The current function has almost always been reached by single
7767 stepping a call or return instruction. NEXT_FRAME belongs to the
7768 current function, and the breakpoint will be set at the caller's
7771 This is a separate function rather than reusing
7772 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7773 get_prev_frame, which may stop prematurely (see the implementation
7774 of frame_unwind_caller_id for an example). */
7777 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7779 /* We shouldn't have gotten here if we don't know where the call site
7781 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7783 struct gdbarch
*gdbarch
= frame_unwind_caller_arch (next_frame
);
7785 symtab_and_line sr_sal
;
7786 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7787 frame_unwind_caller_pc (next_frame
));
7788 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7789 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7791 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7792 frame_unwind_caller_id (next_frame
));
7795 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7796 new breakpoint at the target of a jmp_buf. The handling of
7797 longjmp-resume uses the same mechanisms used for handling
7798 "step-resume" breakpoints. */
7801 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7803 /* There should never be more than one longjmp-resume breakpoint per
7804 thread, so we should never be setting a new
7805 longjmp_resume_breakpoint when one is already active. */
7806 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7808 infrun_debug_printf ("inserting longjmp-resume breakpoint at %s",
7809 paddress (gdbarch
, pc
));
7811 inferior_thread ()->control
.exception_resume_breakpoint
=
7812 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
).release ();
7815 /* Insert an exception resume breakpoint. TP is the thread throwing
7816 the exception. The block B is the block of the unwinder debug hook
7817 function. FRAME is the frame corresponding to the call to this
7818 function. SYM is the symbol of the function argument holding the
7819 target PC of the exception. */
7822 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7823 const struct block
*b
,
7824 struct frame_info
*frame
,
7829 struct block_symbol vsym
;
7830 struct value
*value
;
7832 struct breakpoint
*bp
;
7834 vsym
= lookup_symbol_search_name (sym
->search_name (),
7836 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
7837 /* If the value was optimized out, revert to the old behavior. */
7838 if (! value_optimized_out (value
))
7840 handler
= value_as_address (value
);
7842 infrun_debug_printf ("exception resume at %lx",
7843 (unsigned long) handler
);
7845 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7847 bp_exception_resume
).release ();
7849 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7852 bp
->thread
= tp
->global_num
;
7853 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7856 catch (const gdb_exception_error
&e
)
7858 /* We want to ignore errors here. */
7862 /* A helper for check_exception_resume that sets an
7863 exception-breakpoint based on a SystemTap probe. */
7866 insert_exception_resume_from_probe (struct thread_info
*tp
,
7867 const struct bound_probe
*probe
,
7868 struct frame_info
*frame
)
7870 struct value
*arg_value
;
7872 struct breakpoint
*bp
;
7874 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7878 handler
= value_as_address (arg_value
);
7880 infrun_debug_printf ("exception resume at %s",
7881 paddress (probe
->objfile
->arch (), handler
));
7883 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7884 handler
, bp_exception_resume
).release ();
7885 bp
->thread
= tp
->global_num
;
7886 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7889 /* This is called when an exception has been intercepted. Check to
7890 see whether the exception's destination is of interest, and if so,
7891 set an exception resume breakpoint there. */
7894 check_exception_resume (struct execution_control_state
*ecs
,
7895 struct frame_info
*frame
)
7897 struct bound_probe probe
;
7898 struct symbol
*func
;
7900 /* First see if this exception unwinding breakpoint was set via a
7901 SystemTap probe point. If so, the probe has two arguments: the
7902 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7903 set a breakpoint there. */
7904 probe
= find_probe_by_pc (get_frame_pc (frame
));
7907 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7911 func
= get_frame_function (frame
);
7917 const struct block
*b
;
7918 struct block_iterator iter
;
7922 /* The exception breakpoint is a thread-specific breakpoint on
7923 the unwinder's debug hook, declared as:
7925 void _Unwind_DebugHook (void *cfa, void *handler);
7927 The CFA argument indicates the frame to which control is
7928 about to be transferred. HANDLER is the destination PC.
7930 We ignore the CFA and set a temporary breakpoint at HANDLER.
7931 This is not extremely efficient but it avoids issues in gdb
7932 with computing the DWARF CFA, and it also works even in weird
7933 cases such as throwing an exception from inside a signal
7936 b
= SYMBOL_BLOCK_VALUE (func
);
7937 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7939 if (!SYMBOL_IS_ARGUMENT (sym
))
7946 insert_exception_resume_breakpoint (ecs
->event_thread
,
7952 catch (const gdb_exception_error
&e
)
7958 stop_waiting (struct execution_control_state
*ecs
)
7960 infrun_debug_printf ("stop_waiting");
7962 /* Let callers know we don't want to wait for the inferior anymore. */
7963 ecs
->wait_some_more
= 0;
7965 /* If all-stop, but there exists a non-stop target, stop all
7966 threads now that we're presenting the stop to the user. */
7967 if (!non_stop
&& exists_non_stop_target ())
7968 stop_all_threads ();
7971 /* Like keep_going, but passes the signal to the inferior, even if the
7972 signal is set to nopass. */
7975 keep_going_pass_signal (struct execution_control_state
*ecs
)
7977 gdb_assert (ecs
->event_thread
->ptid
== inferior_ptid
);
7978 gdb_assert (!ecs
->event_thread
->resumed ());
7980 /* Save the pc before execution, to compare with pc after stop. */
7981 ecs
->event_thread
->prev_pc
7982 = regcache_read_pc_protected (get_thread_regcache (ecs
->event_thread
));
7984 if (ecs
->event_thread
->control
.trap_expected
)
7986 struct thread_info
*tp
= ecs
->event_thread
;
7988 infrun_debug_printf ("%s has trap_expected set, "
7989 "resuming to collect trap",
7990 tp
->ptid
.to_string ().c_str ());
7992 /* We haven't yet gotten our trap, and either: intercepted a
7993 non-signal event (e.g., a fork); or took a signal which we
7994 are supposed to pass through to the inferior. Simply
7996 resume (ecs
->event_thread
->stop_signal ());
7998 else if (step_over_info_valid_p ())
8000 /* Another thread is stepping over a breakpoint in-line. If
8001 this thread needs a step-over too, queue the request. In
8002 either case, this resume must be deferred for later. */
8003 struct thread_info
*tp
= ecs
->event_thread
;
8005 if (ecs
->hit_singlestep_breakpoint
8006 || thread_still_needs_step_over (tp
))
8008 infrun_debug_printf ("step-over already in progress: "
8009 "step-over for %s deferred",
8010 tp
->ptid
.to_string ().c_str ());
8011 global_thread_step_over_chain_enqueue (tp
);
8014 infrun_debug_printf ("step-over in progress: resume of %s deferred",
8015 tp
->ptid
.to_string ().c_str ());
8019 struct regcache
*regcache
= get_current_regcache ();
8022 step_over_what step_what
;
8024 /* Either the trap was not expected, but we are continuing
8025 anyway (if we got a signal, the user asked it be passed to
8028 We got our expected trap, but decided we should resume from
8031 We're going to run this baby now!
8033 Note that insert_breakpoints won't try to re-insert
8034 already inserted breakpoints. Therefore, we don't
8035 care if breakpoints were already inserted, or not. */
8037 /* If we need to step over a breakpoint, and we're not using
8038 displaced stepping to do so, insert all breakpoints
8039 (watchpoints, etc.) but the one we're stepping over, step one
8040 instruction, and then re-insert the breakpoint when that step
8043 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
8045 remove_bp
= (ecs
->hit_singlestep_breakpoint
8046 || (step_what
& STEP_OVER_BREAKPOINT
));
8047 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
8049 /* We can't use displaced stepping if we need to step past a
8050 watchpoint. The instruction copied to the scratch pad would
8051 still trigger the watchpoint. */
8053 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
8055 set_step_over_info (regcache
->aspace (),
8056 regcache_read_pc (regcache
), remove_wps
,
8057 ecs
->event_thread
->global_num
);
8059 else if (remove_wps
)
8060 set_step_over_info (NULL
, 0, remove_wps
, -1);
8062 /* If we now need to do an in-line step-over, we need to stop
8063 all other threads. Note this must be done before
8064 insert_breakpoints below, because that removes the breakpoint
8065 we're about to step over, otherwise other threads could miss
8067 if (step_over_info_valid_p () && target_is_non_stop_p ())
8068 stop_all_threads ();
8070 /* Stop stepping if inserting breakpoints fails. */
8073 insert_breakpoints ();
8075 catch (const gdb_exception_error
&e
)
8077 exception_print (gdb_stderr
, e
);
8079 clear_step_over_info ();
8083 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
8085 resume (ecs
->event_thread
->stop_signal ());
8088 prepare_to_wait (ecs
);
8091 /* Called when we should continue running the inferior, because the
8092 current event doesn't cause a user visible stop. This does the
8093 resuming part; waiting for the next event is done elsewhere. */
8096 keep_going (struct execution_control_state
*ecs
)
8098 if (ecs
->event_thread
->control
.trap_expected
8099 && ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
8100 ecs
->event_thread
->control
.trap_expected
= 0;
8102 if (!signal_program
[ecs
->event_thread
->stop_signal ()])
8103 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
8104 keep_going_pass_signal (ecs
);
8107 /* This function normally comes after a resume, before
8108 handle_inferior_event exits. It takes care of any last bits of
8109 housekeeping, and sets the all-important wait_some_more flag. */
8112 prepare_to_wait (struct execution_control_state
*ecs
)
8114 infrun_debug_printf ("prepare_to_wait");
8116 ecs
->wait_some_more
= 1;
8118 /* If the target can't async, emulate it by marking the infrun event
8119 handler such that as soon as we get back to the event-loop, we
8120 immediately end up in fetch_inferior_event again calling
8122 if (!target_can_async_p ())
8123 mark_infrun_async_event_handler ();
8126 /* We are done with the step range of a step/next/si/ni command.
8127 Called once for each n of a "step n" operation. */
8130 end_stepping_range (struct execution_control_state
*ecs
)
8132 ecs
->event_thread
->control
.stop_step
= 1;
8136 /* Several print_*_reason functions to print why the inferior has stopped.
8137 We always print something when the inferior exits, or receives a signal.
8138 The rest of the cases are dealt with later on in normal_stop and
8139 print_it_typical. Ideally there should be a call to one of these
8140 print_*_reason functions functions from handle_inferior_event each time
8141 stop_waiting is called.
8143 Note that we don't call these directly, instead we delegate that to
8144 the interpreters, through observers. Interpreters then call these
8145 with whatever uiout is right. */
8148 print_end_stepping_range_reason (struct ui_out
*uiout
)
8150 /* For CLI-like interpreters, print nothing. */
8152 if (uiout
->is_mi_like_p ())
8154 uiout
->field_string ("reason",
8155 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
8160 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
8162 annotate_signalled ();
8163 if (uiout
->is_mi_like_p ())
8165 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
8166 uiout
->text ("\nProgram terminated with signal ");
8167 annotate_signal_name ();
8168 uiout
->field_string ("signal-name",
8169 gdb_signal_to_name (siggnal
));
8170 annotate_signal_name_end ();
8172 annotate_signal_string ();
8173 uiout
->field_string ("signal-meaning",
8174 gdb_signal_to_string (siggnal
));
8175 annotate_signal_string_end ();
8176 uiout
->text (".\n");
8177 uiout
->text ("The program no longer exists.\n");
8181 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
8183 struct inferior
*inf
= current_inferior ();
8184 std::string pidstr
= target_pid_to_str (ptid_t (inf
->pid
));
8186 annotate_exited (exitstatus
);
8189 if (uiout
->is_mi_like_p ())
8190 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED
));
8191 std::string exit_code_str
8192 = string_printf ("0%o", (unsigned int) exitstatus
);
8193 uiout
->message ("[Inferior %s (%s) exited with code %pF]\n",
8194 plongest (inf
->num
), pidstr
.c_str (),
8195 string_field ("exit-code", exit_code_str
.c_str ()));
8199 if (uiout
->is_mi_like_p ())
8201 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
8202 uiout
->message ("[Inferior %s (%s) exited normally]\n",
8203 plongest (inf
->num
), pidstr
.c_str ());
8208 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
8210 struct thread_info
*thr
= inferior_thread ();
8214 if (uiout
->is_mi_like_p ())
8216 else if (show_thread_that_caused_stop ())
8218 uiout
->text ("\nThread ");
8219 uiout
->field_string ("thread-id", print_thread_id (thr
));
8221 const char *name
= thread_name (thr
);
8224 uiout
->text (" \"");
8225 uiout
->field_string ("name", name
);
8230 uiout
->text ("\nProgram");
8232 if (siggnal
== GDB_SIGNAL_0
&& !uiout
->is_mi_like_p ())
8233 uiout
->text (" stopped");
8236 uiout
->text (" received signal ");
8237 annotate_signal_name ();
8238 if (uiout
->is_mi_like_p ())
8240 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
8241 uiout
->field_string ("signal-name", gdb_signal_to_name (siggnal
));
8242 annotate_signal_name_end ();
8244 annotate_signal_string ();
8245 uiout
->field_string ("signal-meaning", gdb_signal_to_string (siggnal
));
8247 struct regcache
*regcache
= get_current_regcache ();
8248 struct gdbarch
*gdbarch
= regcache
->arch ();
8249 if (gdbarch_report_signal_info_p (gdbarch
))
8250 gdbarch_report_signal_info (gdbarch
, uiout
, siggnal
);
8252 annotate_signal_string_end ();
8254 uiout
->text (".\n");
8258 print_no_history_reason (struct ui_out
*uiout
)
8260 uiout
->text ("\nNo more reverse-execution history.\n");
8263 /* Print current location without a level number, if we have changed
8264 functions or hit a breakpoint. Print source line if we have one.
8265 bpstat_print contains the logic deciding in detail what to print,
8266 based on the event(s) that just occurred. */
8269 print_stop_location (const target_waitstatus
&ws
)
8272 enum print_what source_flag
;
8273 int do_frame_printing
= 1;
8274 struct thread_info
*tp
= inferior_thread ();
8276 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
.kind ());
8280 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8281 should) carry around the function and does (or should) use
8282 that when doing a frame comparison. */
8283 if (tp
->control
.stop_step
8284 && frame_id_eq (tp
->control
.step_frame_id
,
8285 get_frame_id (get_current_frame ()))
8286 && (tp
->control
.step_start_function
8287 == find_pc_function (tp
->stop_pc ())))
8289 /* Finished step, just print source line. */
8290 source_flag
= SRC_LINE
;
8294 /* Print location and source line. */
8295 source_flag
= SRC_AND_LOC
;
8298 case PRINT_SRC_AND_LOC
:
8299 /* Print location and source line. */
8300 source_flag
= SRC_AND_LOC
;
8302 case PRINT_SRC_ONLY
:
8303 source_flag
= SRC_LINE
;
8306 /* Something bogus. */
8307 source_flag
= SRC_LINE
;
8308 do_frame_printing
= 0;
8311 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
8314 /* The behavior of this routine with respect to the source
8316 SRC_LINE: Print only source line
8317 LOCATION: Print only location
8318 SRC_AND_LOC: Print location and source line. */
8319 if (do_frame_printing
)
8320 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
8326 print_stop_event (struct ui_out
*uiout
, bool displays
)
8328 struct target_waitstatus last
;
8329 struct thread_info
*tp
;
8331 get_last_target_status (nullptr, nullptr, &last
);
8334 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
8336 print_stop_location (last
);
8338 /* Display the auto-display expressions. */
8343 tp
= inferior_thread ();
8344 if (tp
->thread_fsm
!= NULL
8345 && tp
->thread_fsm
->finished_p ())
8347 struct return_value_info
*rv
;
8349 rv
= tp
->thread_fsm
->return_value ();
8351 print_return_value (uiout
, rv
);
8358 maybe_remove_breakpoints (void)
8360 if (!breakpoints_should_be_inserted_now () && target_has_execution ())
8362 if (remove_breakpoints ())
8364 target_terminal::ours_for_output ();
8365 printf_filtered (_("Cannot remove breakpoints because "
8366 "program is no longer writable.\nFurther "
8367 "execution is probably impossible.\n"));
8372 /* The execution context that just caused a normal stop. */
8378 DISABLE_COPY_AND_ASSIGN (stop_context
);
8380 bool changed () const;
8385 /* The event PTID. */
8389 /* If stopp for a thread event, this is the thread that caused the
8391 thread_info_ref thread
;
8393 /* The inferior that caused the stop. */
8397 /* Initializes a new stop context. If stopped for a thread event, this
8398 takes a strong reference to the thread. */
8400 stop_context::stop_context ()
8402 stop_id
= get_stop_id ();
8403 ptid
= inferior_ptid
;
8404 inf_num
= current_inferior ()->num
;
8406 if (inferior_ptid
!= null_ptid
)
8408 /* Take a strong reference so that the thread can't be deleted
8410 thread
= thread_info_ref::new_reference (inferior_thread ());
8414 /* Return true if the current context no longer matches the saved stop
8418 stop_context::changed () const
8420 if (ptid
!= inferior_ptid
)
8422 if (inf_num
!= current_inferior ()->num
)
8424 if (thread
!= NULL
&& thread
->state
!= THREAD_STOPPED
)
8426 if (get_stop_id () != stop_id
)
8436 struct target_waitstatus last
;
8438 get_last_target_status (nullptr, nullptr, &last
);
8442 /* If an exception is thrown from this point on, make sure to
8443 propagate GDB's knowledge of the executing state to the
8444 frontend/user running state. A QUIT is an easy exception to see
8445 here, so do this before any filtered output. */
8447 ptid_t finish_ptid
= null_ptid
;
8450 finish_ptid
= minus_one_ptid
;
8451 else if (last
.kind () == TARGET_WAITKIND_SIGNALLED
8452 || last
.kind () == TARGET_WAITKIND_EXITED
)
8454 /* On some targets, we may still have live threads in the
8455 inferior when we get a process exit event. E.g., for
8456 "checkpoint", when the current checkpoint/fork exits,
8457 linux-fork.c automatically switches to another fork from
8458 within target_mourn_inferior. */
8459 if (inferior_ptid
!= null_ptid
)
8460 finish_ptid
= ptid_t (inferior_ptid
.pid ());
8462 else if (last
.kind () != TARGET_WAITKIND_NO_RESUMED
)
8463 finish_ptid
= inferior_ptid
;
8465 gdb::optional
<scoped_finish_thread_state
> maybe_finish_thread_state
;
8466 if (finish_ptid
!= null_ptid
)
8468 maybe_finish_thread_state
.emplace
8469 (user_visible_resume_target (finish_ptid
), finish_ptid
);
8472 /* As we're presenting a stop, and potentially removing breakpoints,
8473 update the thread list so we can tell whether there are threads
8474 running on the target. With target remote, for example, we can
8475 only learn about new threads when we explicitly update the thread
8476 list. Do this before notifying the interpreters about signal
8477 stops, end of stepping ranges, etc., so that the "new thread"
8478 output is emitted before e.g., "Program received signal FOO",
8479 instead of after. */
8480 update_thread_list ();
8482 if (last
.kind () == TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
8483 gdb::observers::signal_received
.notify (inferior_thread ()->stop_signal ());
8485 /* As with the notification of thread events, we want to delay
8486 notifying the user that we've switched thread context until
8487 the inferior actually stops.
8489 There's no point in saying anything if the inferior has exited.
8490 Note that SIGNALLED here means "exited with a signal", not
8491 "received a signal".
8493 Also skip saying anything in non-stop mode. In that mode, as we
8494 don't want GDB to switch threads behind the user's back, to avoid
8495 races where the user is typing a command to apply to thread x,
8496 but GDB switches to thread y before the user finishes entering
8497 the command, fetch_inferior_event installs a cleanup to restore
8498 the current thread back to the thread the user had selected right
8499 after this event is handled, so we're not really switching, only
8500 informing of a stop. */
8502 && previous_inferior_ptid
!= inferior_ptid
8503 && target_has_execution ()
8504 && last
.kind () != TARGET_WAITKIND_SIGNALLED
8505 && last
.kind () != TARGET_WAITKIND_EXITED
8506 && last
.kind () != TARGET_WAITKIND_NO_RESUMED
)
8508 SWITCH_THRU_ALL_UIS ()
8510 target_terminal::ours_for_output ();
8511 printf_filtered (_("[Switching to %s]\n"),
8512 target_pid_to_str (inferior_ptid
).c_str ());
8513 annotate_thread_changed ();
8515 previous_inferior_ptid
= inferior_ptid
;
8518 if (last
.kind () == TARGET_WAITKIND_NO_RESUMED
)
8520 SWITCH_THRU_ALL_UIS ()
8521 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
8523 target_terminal::ours_for_output ();
8524 printf_filtered (_("No unwaited-for children left.\n"));
8528 /* Note: this depends on the update_thread_list call above. */
8529 maybe_remove_breakpoints ();
8531 /* If an auto-display called a function and that got a signal,
8532 delete that auto-display to avoid an infinite recursion. */
8534 if (stopped_by_random_signal
)
8535 disable_current_display ();
8537 SWITCH_THRU_ALL_UIS ()
8539 async_enable_stdin ();
8542 /* Let the user/frontend see the threads as stopped. */
8543 maybe_finish_thread_state
.reset ();
8545 /* Select innermost stack frame - i.e., current frame is frame 0,
8546 and current location is based on that. Handle the case where the
8547 dummy call is returning after being stopped. E.g. the dummy call
8548 previously hit a breakpoint. (If the dummy call returns
8549 normally, we won't reach here.) Do this before the stop hook is
8550 run, so that it doesn't get to see the temporary dummy frame,
8551 which is not where we'll present the stop. */
8552 if (has_stack_frames ())
8554 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
8556 /* Pop the empty frame that contains the stack dummy. This
8557 also restores inferior state prior to the call (struct
8558 infcall_suspend_state). */
8559 struct frame_info
*frame
= get_current_frame ();
8561 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
8563 /* frame_pop calls reinit_frame_cache as the last thing it
8564 does which means there's now no selected frame. */
8567 select_frame (get_current_frame ());
8569 /* Set the current source location. */
8570 set_current_sal_from_frame (get_current_frame ());
8573 /* Look up the hook_stop and run it (CLI internally handles problem
8574 of stop_command's pre-hook not existing). */
8575 if (stop_command
!= NULL
)
8577 stop_context saved_context
;
8581 execute_cmd_pre_hook (stop_command
);
8583 catch (const gdb_exception
&ex
)
8585 exception_fprintf (gdb_stderr
, ex
,
8586 "Error while running hook_stop:\n");
8589 /* If the stop hook resumes the target, then there's no point in
8590 trying to notify about the previous stop; its context is
8591 gone. Likewise if the command switches thread or inferior --
8592 the observers would print a stop for the wrong
8594 if (saved_context
.changed ())
8598 /* Notify observers about the stop. This is where the interpreters
8599 print the stop event. */
8600 if (inferior_ptid
!= null_ptid
)
8601 gdb::observers::normal_stop
.notify (inferior_thread ()->control
.stop_bpstat
,
8604 gdb::observers::normal_stop
.notify (NULL
, stop_print_frame
);
8606 annotate_stopped ();
8608 if (target_has_execution ())
8610 if (last
.kind () != TARGET_WAITKIND_SIGNALLED
8611 && last
.kind () != TARGET_WAITKIND_EXITED
8612 && last
.kind () != TARGET_WAITKIND_NO_RESUMED
)
8613 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8614 Delete any breakpoint that is to be deleted at the next stop. */
8615 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
8618 /* Try to get rid of automatically added inferiors that are no
8619 longer needed. Keeping those around slows down things linearly.
8620 Note that this never removes the current inferior. */
8627 signal_stop_state (int signo
)
8629 return signal_stop
[signo
];
8633 signal_print_state (int signo
)
8635 return signal_print
[signo
];
8639 signal_pass_state (int signo
)
8641 return signal_program
[signo
];
8645 signal_cache_update (int signo
)
8649 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
8650 signal_cache_update (signo
);
8655 signal_pass
[signo
] = (signal_stop
[signo
] == 0
8656 && signal_print
[signo
] == 0
8657 && signal_program
[signo
] == 1
8658 && signal_catch
[signo
] == 0);
8662 signal_stop_update (int signo
, int state
)
8664 int ret
= signal_stop
[signo
];
8666 signal_stop
[signo
] = state
;
8667 signal_cache_update (signo
);
8672 signal_print_update (int signo
, int state
)
8674 int ret
= signal_print
[signo
];
8676 signal_print
[signo
] = state
;
8677 signal_cache_update (signo
);
8682 signal_pass_update (int signo
, int state
)
8684 int ret
= signal_program
[signo
];
8686 signal_program
[signo
] = state
;
8687 signal_cache_update (signo
);
8691 /* Update the global 'signal_catch' from INFO and notify the
8695 signal_catch_update (const unsigned int *info
)
8699 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8700 signal_catch
[i
] = info
[i
] > 0;
8701 signal_cache_update (-1);
8702 target_pass_signals (signal_pass
);
8706 sig_print_header (void)
8708 printf_filtered (_("Signal Stop\tPrint\tPass "
8709 "to program\tDescription\n"));
8713 sig_print_info (enum gdb_signal oursig
)
8715 const char *name
= gdb_signal_to_name (oursig
);
8716 int name_padding
= 13 - strlen (name
);
8718 if (name_padding
<= 0)
8721 printf_filtered ("%s", name
);
8722 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8723 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8724 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8725 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8726 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8729 /* Specify how various signals in the inferior should be handled. */
8732 handle_command (const char *args
, int from_tty
)
8734 int digits
, wordlen
;
8735 int sigfirst
, siglast
;
8736 enum gdb_signal oursig
;
8741 error_no_arg (_("signal to handle"));
8744 /* Allocate and zero an array of flags for which signals to handle. */
8746 const size_t nsigs
= GDB_SIGNAL_LAST
;
8747 unsigned char sigs
[nsigs
] {};
8749 /* Break the command line up into args. */
8751 gdb_argv
built_argv (args
);
8753 /* Walk through the args, looking for signal oursigs, signal names, and
8754 actions. Signal numbers and signal names may be interspersed with
8755 actions, with the actions being performed for all signals cumulatively
8756 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8758 for (char *arg
: built_argv
)
8760 wordlen
= strlen (arg
);
8761 for (digits
= 0; isdigit (arg
[digits
]); digits
++)
8765 sigfirst
= siglast
= -1;
8767 if (wordlen
>= 1 && !strncmp (arg
, "all", wordlen
))
8769 /* Apply action to all signals except those used by the
8770 debugger. Silently skip those. */
8773 siglast
= nsigs
- 1;
8775 else if (wordlen
>= 1 && !strncmp (arg
, "stop", wordlen
))
8777 SET_SIGS (nsigs
, sigs
, signal_stop
);
8778 SET_SIGS (nsigs
, sigs
, signal_print
);
8780 else if (wordlen
>= 1 && !strncmp (arg
, "ignore", wordlen
))
8782 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8784 else if (wordlen
>= 2 && !strncmp (arg
, "print", wordlen
))
8786 SET_SIGS (nsigs
, sigs
, signal_print
);
8788 else if (wordlen
>= 2 && !strncmp (arg
, "pass", wordlen
))
8790 SET_SIGS (nsigs
, sigs
, signal_program
);
8792 else if (wordlen
>= 3 && !strncmp (arg
, "nostop", wordlen
))
8794 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8796 else if (wordlen
>= 3 && !strncmp (arg
, "noignore", wordlen
))
8798 SET_SIGS (nsigs
, sigs
, signal_program
);
8800 else if (wordlen
>= 4 && !strncmp (arg
, "noprint", wordlen
))
8802 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8803 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8805 else if (wordlen
>= 4 && !strncmp (arg
, "nopass", wordlen
))
8807 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8809 else if (digits
> 0)
8811 /* It is numeric. The numeric signal refers to our own
8812 internal signal numbering from target.h, not to host/target
8813 signal number. This is a feature; users really should be
8814 using symbolic names anyway, and the common ones like
8815 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8817 sigfirst
= siglast
= (int)
8818 gdb_signal_from_command (atoi (arg
));
8819 if (arg
[digits
] == '-')
8822 gdb_signal_from_command (atoi (arg
+ digits
+ 1));
8824 if (sigfirst
> siglast
)
8826 /* Bet he didn't figure we'd think of this case... */
8827 std::swap (sigfirst
, siglast
);
8832 oursig
= gdb_signal_from_name (arg
);
8833 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8835 sigfirst
= siglast
= (int) oursig
;
8839 /* Not a number and not a recognized flag word => complain. */
8840 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg
);
8844 /* If any signal numbers or symbol names were found, set flags for
8845 which signals to apply actions to. */
8847 for (int signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8849 switch ((enum gdb_signal
) signum
)
8851 case GDB_SIGNAL_TRAP
:
8852 case GDB_SIGNAL_INT
:
8853 if (!allsigs
&& !sigs
[signum
])
8855 if (query (_("%s is used by the debugger.\n\
8856 Are you sure you want to change it? "),
8857 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8862 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8866 case GDB_SIGNAL_DEFAULT
:
8867 case GDB_SIGNAL_UNKNOWN
:
8868 /* Make sure that "all" doesn't print these. */
8877 for (int signum
= 0; signum
< nsigs
; signum
++)
8880 signal_cache_update (-1);
8881 target_pass_signals (signal_pass
);
8882 target_program_signals (signal_program
);
8886 /* Show the results. */
8887 sig_print_header ();
8888 for (; signum
< nsigs
; signum
++)
8890 sig_print_info ((enum gdb_signal
) signum
);
8897 /* Complete the "handle" command. */
8900 handle_completer (struct cmd_list_element
*ignore
,
8901 completion_tracker
&tracker
,
8902 const char *text
, const char *word
)
8904 static const char * const keywords
[] =
8918 signal_completer (ignore
, tracker
, text
, word
);
8919 complete_on_enum (tracker
, keywords
, word
, word
);
8923 gdb_signal_from_command (int num
)
8925 if (num
>= 1 && num
<= 15)
8926 return (enum gdb_signal
) num
;
8927 error (_("Only signals 1-15 are valid as numeric signals.\n\
8928 Use \"info signals\" for a list of symbolic signals."));
8931 /* Print current contents of the tables set by the handle command.
8932 It is possible we should just be printing signals actually used
8933 by the current target (but for things to work right when switching
8934 targets, all signals should be in the signal tables). */
8937 info_signals_command (const char *signum_exp
, int from_tty
)
8939 enum gdb_signal oursig
;
8941 sig_print_header ();
8945 /* First see if this is a symbol name. */
8946 oursig
= gdb_signal_from_name (signum_exp
);
8947 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8949 /* No, try numeric. */
8951 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8953 sig_print_info (oursig
);
8957 printf_filtered ("\n");
8958 /* These ugly casts brought to you by the native VAX compiler. */
8959 for (oursig
= GDB_SIGNAL_FIRST
;
8960 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8961 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8965 if (oursig
!= GDB_SIGNAL_UNKNOWN
8966 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8967 sig_print_info (oursig
);
8970 printf_filtered (_("\nUse the \"handle\" command "
8971 "to change these tables.\n"));
8974 /* The $_siginfo convenience variable is a bit special. We don't know
8975 for sure the type of the value until we actually have a chance to
8976 fetch the data. The type can change depending on gdbarch, so it is
8977 also dependent on which thread you have selected.
8979 1. making $_siginfo be an internalvar that creates a new value on
8982 2. making the value of $_siginfo be an lval_computed value. */
8984 /* This function implements the lval_computed support for reading a
8988 siginfo_value_read (struct value
*v
)
8990 LONGEST transferred
;
8992 /* If we can access registers, so can we access $_siginfo. Likewise
8994 validate_registers_access ();
8997 target_read (current_inferior ()->top_target (),
8998 TARGET_OBJECT_SIGNAL_INFO
,
9000 value_contents_all_raw (v
).data (),
9002 TYPE_LENGTH (value_type (v
)));
9004 if (transferred
!= TYPE_LENGTH (value_type (v
)))
9005 error (_("Unable to read siginfo"));
9008 /* This function implements the lval_computed support for writing a
9012 siginfo_value_write (struct value
*v
, struct value
*fromval
)
9014 LONGEST transferred
;
9016 /* If we can access registers, so can we access $_siginfo. Likewise
9018 validate_registers_access ();
9020 transferred
= target_write (current_inferior ()->top_target (),
9021 TARGET_OBJECT_SIGNAL_INFO
,
9023 value_contents_all_raw (fromval
).data (),
9025 TYPE_LENGTH (value_type (fromval
)));
9027 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
9028 error (_("Unable to write siginfo"));
9031 static const struct lval_funcs siginfo_value_funcs
=
9037 /* Return a new value with the correct type for the siginfo object of
9038 the current thread using architecture GDBARCH. Return a void value
9039 if there's no object available. */
9041 static struct value
*
9042 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
9045 if (target_has_stack ()
9046 && inferior_ptid
!= null_ptid
9047 && gdbarch_get_siginfo_type_p (gdbarch
))
9049 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9051 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
9054 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
9058 /* infcall_suspend_state contains state about the program itself like its
9059 registers and any signal it received when it last stopped.
9060 This state must be restored regardless of how the inferior function call
9061 ends (either successfully, or after it hits a breakpoint or signal)
9062 if the program is to properly continue where it left off. */
9064 class infcall_suspend_state
9067 /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
9068 once the inferior function call has finished. */
9069 infcall_suspend_state (struct gdbarch
*gdbarch
,
9070 const struct thread_info
*tp
,
9071 struct regcache
*regcache
)
9072 : m_registers (new readonly_detached_regcache (*regcache
))
9074 tp
->save_suspend_to (m_thread_suspend
);
9076 gdb::unique_xmalloc_ptr
<gdb_byte
> siginfo_data
;
9078 if (gdbarch_get_siginfo_type_p (gdbarch
))
9080 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9081 size_t len
= TYPE_LENGTH (type
);
9083 siginfo_data
.reset ((gdb_byte
*) xmalloc (len
));
9085 if (target_read (current_inferior ()->top_target (),
9086 TARGET_OBJECT_SIGNAL_INFO
, NULL
,
9087 siginfo_data
.get (), 0, len
) != len
)
9089 /* Errors ignored. */
9090 siginfo_data
.reset (nullptr);
9096 m_siginfo_gdbarch
= gdbarch
;
9097 m_siginfo_data
= std::move (siginfo_data
);
9101 /* Return a pointer to the stored register state. */
9103 readonly_detached_regcache
*registers () const
9105 return m_registers
.get ();
9108 /* Restores the stored state into GDBARCH, TP, and REGCACHE. */
9110 void restore (struct gdbarch
*gdbarch
,
9111 struct thread_info
*tp
,
9112 struct regcache
*regcache
) const
9114 tp
->restore_suspend_from (m_thread_suspend
);
9116 if (m_siginfo_gdbarch
== gdbarch
)
9118 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9120 /* Errors ignored. */
9121 target_write (current_inferior ()->top_target (),
9122 TARGET_OBJECT_SIGNAL_INFO
, NULL
,
9123 m_siginfo_data
.get (), 0, TYPE_LENGTH (type
));
9126 /* The inferior can be gone if the user types "print exit(0)"
9127 (and perhaps other times). */
9128 if (target_has_execution ())
9129 /* NB: The register write goes through to the target. */
9130 regcache
->restore (registers ());
9134 /* How the current thread stopped before the inferior function call was
9136 struct thread_suspend_state m_thread_suspend
;
9138 /* The registers before the inferior function call was executed. */
9139 std::unique_ptr
<readonly_detached_regcache
> m_registers
;
9141 /* Format of SIGINFO_DATA or NULL if it is not present. */
9142 struct gdbarch
*m_siginfo_gdbarch
= nullptr;
9144 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
9145 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
9146 content would be invalid. */
9147 gdb::unique_xmalloc_ptr
<gdb_byte
> m_siginfo_data
;
9150 infcall_suspend_state_up
9151 save_infcall_suspend_state ()
9153 struct thread_info
*tp
= inferior_thread ();
9154 struct regcache
*regcache
= get_current_regcache ();
9155 struct gdbarch
*gdbarch
= regcache
->arch ();
9157 infcall_suspend_state_up inf_state
9158 (new struct infcall_suspend_state (gdbarch
, tp
, regcache
));
9160 /* Having saved the current state, adjust the thread state, discarding
9161 any stop signal information. The stop signal is not useful when
9162 starting an inferior function call, and run_inferior_call will not use
9163 the signal due to its `proceed' call with GDB_SIGNAL_0. */
9164 tp
->set_stop_signal (GDB_SIGNAL_0
);
9169 /* Restore inferior session state to INF_STATE. */
9172 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
9174 struct thread_info
*tp
= inferior_thread ();
9175 struct regcache
*regcache
= get_current_regcache ();
9176 struct gdbarch
*gdbarch
= regcache
->arch ();
9178 inf_state
->restore (gdbarch
, tp
, regcache
);
9179 discard_infcall_suspend_state (inf_state
);
9183 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
9188 readonly_detached_regcache
*
9189 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
9191 return inf_state
->registers ();
9194 /* infcall_control_state contains state regarding gdb's control of the
9195 inferior itself like stepping control. It also contains session state like
9196 the user's currently selected frame. */
9198 struct infcall_control_state
9200 struct thread_control_state thread_control
;
9201 struct inferior_control_state inferior_control
;
9204 enum stop_stack_kind stop_stack_dummy
= STOP_NONE
;
9205 int stopped_by_random_signal
= 0;
9207 /* ID and level of the selected frame when the inferior function
9209 struct frame_id selected_frame_id
{};
9210 int selected_frame_level
= -1;
9213 /* Save all of the information associated with the inferior<==>gdb
9216 infcall_control_state_up
9217 save_infcall_control_state ()
9219 infcall_control_state_up
inf_status (new struct infcall_control_state
);
9220 struct thread_info
*tp
= inferior_thread ();
9221 struct inferior
*inf
= current_inferior ();
9223 inf_status
->thread_control
= tp
->control
;
9224 inf_status
->inferior_control
= inf
->control
;
9226 tp
->control
.step_resume_breakpoint
= NULL
;
9227 tp
->control
.exception_resume_breakpoint
= NULL
;
9229 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
9230 chain. If caller's caller is walking the chain, they'll be happier if we
9231 hand them back the original chain when restore_infcall_control_state is
9233 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
9236 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
9237 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
9239 save_selected_frame (&inf_status
->selected_frame_id
,
9240 &inf_status
->selected_frame_level
);
9245 /* Restore inferior session state to INF_STATUS. */
9248 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
9250 struct thread_info
*tp
= inferior_thread ();
9251 struct inferior
*inf
= current_inferior ();
9253 if (tp
->control
.step_resume_breakpoint
)
9254 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
9256 if (tp
->control
.exception_resume_breakpoint
)
9257 tp
->control
.exception_resume_breakpoint
->disposition
9258 = disp_del_at_next_stop
;
9260 /* Handle the bpstat_copy of the chain. */
9261 bpstat_clear (&tp
->control
.stop_bpstat
);
9263 tp
->control
= inf_status
->thread_control
;
9264 inf
->control
= inf_status
->inferior_control
;
9267 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
9268 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
9270 if (target_has_stack ())
9272 restore_selected_frame (inf_status
->selected_frame_id
,
9273 inf_status
->selected_frame_level
);
9280 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
9282 if (inf_status
->thread_control
.step_resume_breakpoint
)
9283 inf_status
->thread_control
.step_resume_breakpoint
->disposition
9284 = disp_del_at_next_stop
;
9286 if (inf_status
->thread_control
.exception_resume_breakpoint
)
9287 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
9288 = disp_del_at_next_stop
;
9290 /* See save_infcall_control_state for info on stop_bpstat. */
9291 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
9299 clear_exit_convenience_vars (void)
9301 clear_internalvar (lookup_internalvar ("_exitsignal"));
9302 clear_internalvar (lookup_internalvar ("_exitcode"));
9306 /* User interface for reverse debugging:
9307 Set exec-direction / show exec-direction commands
9308 (returns error unless target implements to_set_exec_direction method). */
9310 enum exec_direction_kind execution_direction
= EXEC_FORWARD
;
9311 static const char exec_forward
[] = "forward";
9312 static const char exec_reverse
[] = "reverse";
9313 static const char *exec_direction
= exec_forward
;
9314 static const char *const exec_direction_names
[] = {
9321 set_exec_direction_func (const char *args
, int from_tty
,
9322 struct cmd_list_element
*cmd
)
9324 if (target_can_execute_reverse ())
9326 if (!strcmp (exec_direction
, exec_forward
))
9327 execution_direction
= EXEC_FORWARD
;
9328 else if (!strcmp (exec_direction
, exec_reverse
))
9329 execution_direction
= EXEC_REVERSE
;
9333 exec_direction
= exec_forward
;
9334 error (_("Target does not support this operation."));
9339 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
9340 struct cmd_list_element
*cmd
, const char *value
)
9342 switch (execution_direction
) {
9344 fprintf_filtered (out
, _("Forward.\n"));
9347 fprintf_filtered (out
, _("Reverse.\n"));
9350 internal_error (__FILE__
, __LINE__
,
9351 _("bogus execution_direction value: %d"),
9352 (int) execution_direction
);
9357 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
9358 struct cmd_list_element
*c
, const char *value
)
9360 fprintf_filtered (file
, _("Resuming the execution of threads "
9361 "of all processes is %s.\n"), value
);
9364 /* Implementation of `siginfo' variable. */
9366 static const struct internalvar_funcs siginfo_funcs
=
9373 /* Callback for infrun's target events source. This is marked when a
9374 thread has a pending status to process. */
9377 infrun_async_inferior_event_handler (gdb_client_data data
)
9379 clear_async_event_handler (infrun_async_inferior_event_token
);
9380 inferior_event_handler (INF_REG_EVENT
);
9387 /* Verify that when two threads with the same ptid exist (from two different
9388 targets) and one of them changes ptid, we only update inferior_ptid if
9389 it is appropriate. */
9392 infrun_thread_ptid_changed ()
9394 gdbarch
*arch
= current_inferior ()->gdbarch
;
9396 /* The thread which inferior_ptid represents changes ptid. */
9398 scoped_restore_current_pspace_and_thread restore
;
9400 scoped_mock_context
<test_target_ops
> target1 (arch
);
9401 scoped_mock_context
<test_target_ops
> target2 (arch
);
9403 ptid_t
old_ptid (111, 222);
9404 ptid_t
new_ptid (111, 333);
9406 target1
.mock_inferior
.pid
= old_ptid
.pid ();
9407 target1
.mock_thread
.ptid
= old_ptid
;
9408 target1
.mock_inferior
.ptid_thread_map
.clear ();
9409 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
9411 target2
.mock_inferior
.pid
= old_ptid
.pid ();
9412 target2
.mock_thread
.ptid
= old_ptid
;
9413 target2
.mock_inferior
.ptid_thread_map
.clear ();
9414 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
9416 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
9417 set_current_inferior (&target1
.mock_inferior
);
9419 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
9421 gdb_assert (inferior_ptid
== new_ptid
);
9424 /* A thread with the same ptid as inferior_ptid, but from another target,
9427 scoped_restore_current_pspace_and_thread restore
;
9429 scoped_mock_context
<test_target_ops
> target1 (arch
);
9430 scoped_mock_context
<test_target_ops
> target2 (arch
);
9432 ptid_t
old_ptid (111, 222);
9433 ptid_t
new_ptid (111, 333);
9435 target1
.mock_inferior
.pid
= old_ptid
.pid ();
9436 target1
.mock_thread
.ptid
= old_ptid
;
9437 target1
.mock_inferior
.ptid_thread_map
.clear ();
9438 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
9440 target2
.mock_inferior
.pid
= old_ptid
.pid ();
9441 target2
.mock_thread
.ptid
= old_ptid
;
9442 target2
.mock_inferior
.ptid_thread_map
.clear ();
9443 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
9445 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
9446 set_current_inferior (&target2
.mock_inferior
);
9448 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
9450 gdb_assert (inferior_ptid
== old_ptid
);
9454 } /* namespace selftests */
9456 #endif /* GDB_SELF_TEST */
9458 void _initialize_infrun ();
9460 _initialize_infrun ()
9462 struct cmd_list_element
*c
;
9464 /* Register extra event sources in the event loop. */
9465 infrun_async_inferior_event_token
9466 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
,
9469 cmd_list_element
*info_signals_cmd
9470 = add_info ("signals", info_signals_command
, _("\
9471 What debugger does when program gets various signals.\n\
9472 Specify a signal as argument to print info on that signal only."));
9473 add_info_alias ("handle", info_signals_cmd
, 0);
9475 c
= add_com ("handle", class_run
, handle_command
, _("\
9476 Specify how to handle signals.\n\
9477 Usage: handle SIGNAL [ACTIONS]\n\
9478 Args are signals and actions to apply to those signals.\n\
9479 If no actions are specified, the current settings for the specified signals\n\
9480 will be displayed instead.\n\
9482 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9483 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9484 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9485 The special arg \"all\" is recognized to mean all signals except those\n\
9486 used by the debugger, typically SIGTRAP and SIGINT.\n\
9488 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9489 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9490 Stop means reenter debugger if this signal happens (implies print).\n\
9491 Print means print a message if this signal happens.\n\
9492 Pass means let program see this signal; otherwise program doesn't know.\n\
9493 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9494 Pass and Stop may be combined.\n\
9496 Multiple signals may be specified. Signal numbers and signal names\n\
9497 may be interspersed with actions, with the actions being performed for\n\
9498 all signals cumulatively specified."));
9499 set_cmd_completer (c
, handle_completer
);
9502 stop_command
= add_cmd ("stop", class_obscure
,
9503 not_just_help_class_command
, _("\
9504 There is no `stop' command, but you can set a hook on `stop'.\n\
9505 This allows you to set a list of commands to be run each time execution\n\
9506 of the program stops."), &cmdlist
);
9508 add_setshow_boolean_cmd
9509 ("infrun", class_maintenance
, &debug_infrun
,
9510 _("Set inferior debugging."),
9511 _("Show inferior debugging."),
9512 _("When non-zero, inferior specific debugging is enabled."),
9513 NULL
, show_debug_infrun
, &setdebuglist
, &showdebuglist
);
9515 add_setshow_boolean_cmd ("non-stop", no_class
,
9517 Set whether gdb controls the inferior in non-stop mode."), _("\
9518 Show whether gdb controls the inferior in non-stop mode."), _("\
9519 When debugging a multi-threaded program and this setting is\n\
9520 off (the default, also called all-stop mode), when one thread stops\n\
9521 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9522 all other threads in the program while you interact with the thread of\n\
9523 interest. When you continue or step a thread, you can allow the other\n\
9524 threads to run, or have them remain stopped, but while you inspect any\n\
9525 thread's state, all threads stop.\n\
9527 In non-stop mode, when one thread stops, other threads can continue\n\
9528 to run freely. You'll be able to step each thread independently,\n\
9529 leave it stopped or free to run as needed."),
9535 for (size_t i
= 0; i
< GDB_SIGNAL_LAST
; i
++)
9538 signal_print
[i
] = 1;
9539 signal_program
[i
] = 1;
9540 signal_catch
[i
] = 0;
9543 /* Signals caused by debugger's own actions should not be given to
9544 the program afterwards.
9546 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9547 explicitly specifies that it should be delivered to the target
9548 program. Typically, that would occur when a user is debugging a
9549 target monitor on a simulator: the target monitor sets a
9550 breakpoint; the simulator encounters this breakpoint and halts
9551 the simulation handing control to GDB; GDB, noting that the stop
9552 address doesn't map to any known breakpoint, returns control back
9553 to the simulator; the simulator then delivers the hardware
9554 equivalent of a GDB_SIGNAL_TRAP to the program being
9556 signal_program
[GDB_SIGNAL_TRAP
] = 0;
9557 signal_program
[GDB_SIGNAL_INT
] = 0;
9559 /* Signals that are not errors should not normally enter the debugger. */
9560 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
9561 signal_print
[GDB_SIGNAL_ALRM
] = 0;
9562 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
9563 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
9564 signal_stop
[GDB_SIGNAL_PROF
] = 0;
9565 signal_print
[GDB_SIGNAL_PROF
] = 0;
9566 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
9567 signal_print
[GDB_SIGNAL_CHLD
] = 0;
9568 signal_stop
[GDB_SIGNAL_IO
] = 0;
9569 signal_print
[GDB_SIGNAL_IO
] = 0;
9570 signal_stop
[GDB_SIGNAL_POLL
] = 0;
9571 signal_print
[GDB_SIGNAL_POLL
] = 0;
9572 signal_stop
[GDB_SIGNAL_URG
] = 0;
9573 signal_print
[GDB_SIGNAL_URG
] = 0;
9574 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
9575 signal_print
[GDB_SIGNAL_WINCH
] = 0;
9576 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
9577 signal_print
[GDB_SIGNAL_PRIO
] = 0;
9579 /* These signals are used internally by user-level thread
9580 implementations. (See signal(5) on Solaris.) Like the above
9581 signals, a healthy program receives and handles them as part of
9582 its normal operation. */
9583 signal_stop
[GDB_SIGNAL_LWP
] = 0;
9584 signal_print
[GDB_SIGNAL_LWP
] = 0;
9585 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
9586 signal_print
[GDB_SIGNAL_WAITING
] = 0;
9587 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
9588 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
9589 signal_stop
[GDB_SIGNAL_LIBRT
] = 0;
9590 signal_print
[GDB_SIGNAL_LIBRT
] = 0;
9592 /* Update cached state. */
9593 signal_cache_update (-1);
9595 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
9596 &stop_on_solib_events
, _("\
9597 Set stopping for shared library events."), _("\
9598 Show stopping for shared library events."), _("\
9599 If nonzero, gdb will give control to the user when the dynamic linker\n\
9600 notifies gdb of shared library events. The most common event of interest\n\
9601 to the user would be loading/unloading of a new library."),
9602 set_stop_on_solib_events
,
9603 show_stop_on_solib_events
,
9604 &setlist
, &showlist
);
9606 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
9607 follow_fork_mode_kind_names
,
9608 &follow_fork_mode_string
, _("\
9609 Set debugger response to a program call of fork or vfork."), _("\
9610 Show debugger response to a program call of fork or vfork."), _("\
9611 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9612 parent - the original process is debugged after a fork\n\
9613 child - the new process is debugged after a fork\n\
9614 The unfollowed process will continue to run.\n\
9615 By default, the debugger will follow the parent process."),
9617 show_follow_fork_mode_string
,
9618 &setlist
, &showlist
);
9620 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
9621 follow_exec_mode_names
,
9622 &follow_exec_mode_string
, _("\
9623 Set debugger response to a program call of exec."), _("\
9624 Show debugger response to a program call of exec."), _("\
9625 An exec call replaces the program image of a process.\n\
9627 follow-exec-mode can be:\n\
9629 new - the debugger creates a new inferior and rebinds the process\n\
9630 to this new inferior. The program the process was running before\n\
9631 the exec call can be restarted afterwards by restarting the original\n\
9634 same - the debugger keeps the process bound to the same inferior.\n\
9635 The new executable image replaces the previous executable loaded in\n\
9636 the inferior. Restarting the inferior after the exec call restarts\n\
9637 the executable the process was running after the exec call.\n\
9639 By default, the debugger will use the same inferior."),
9641 show_follow_exec_mode_string
,
9642 &setlist
, &showlist
);
9644 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9645 scheduler_enums
, &scheduler_mode
, _("\
9646 Set mode for locking scheduler during execution."), _("\
9647 Show mode for locking scheduler during execution."), _("\
9648 off == no locking (threads may preempt at any time)\n\
9649 on == full locking (no thread except the current thread may run)\n\
9650 This applies to both normal execution and replay mode.\n\
9651 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9652 In this mode, other threads may run during other commands.\n\
9653 This applies to both normal execution and replay mode.\n\
9654 replay == scheduler locked in replay mode and unlocked during normal execution."),
9655 set_schedlock_func
, /* traps on target vector */
9656 show_scheduler_mode
,
9657 &setlist
, &showlist
);
9659 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9660 Set mode for resuming threads of all processes."), _("\
9661 Show mode for resuming threads of all processes."), _("\
9662 When on, execution commands (such as 'continue' or 'next') resume all\n\
9663 threads of all processes. When off (which is the default), execution\n\
9664 commands only resume the threads of the current process. The set of\n\
9665 threads that are resumed is further refined by the scheduler-locking\n\
9666 mode (see help set scheduler-locking)."),
9668 show_schedule_multiple
,
9669 &setlist
, &showlist
);
9671 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9672 Set mode of the step operation."), _("\
9673 Show mode of the step operation."), _("\
9674 When set, doing a step over a function without debug line information\n\
9675 will stop at the first instruction of that function. Otherwise, the\n\
9676 function is skipped and the step command stops at a different source line."),
9678 show_step_stop_if_no_debug
,
9679 &setlist
, &showlist
);
9681 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9682 &can_use_displaced_stepping
, _("\
9683 Set debugger's willingness to use displaced stepping."), _("\
9684 Show debugger's willingness to use displaced stepping."), _("\
9685 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9686 supported by the target architecture. If off, gdb will not use displaced\n\
9687 stepping to step over breakpoints, even if such is supported by the target\n\
9688 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9689 if the target architecture supports it and non-stop mode is active, but will not\n\
9690 use it in all-stop mode (see help set non-stop)."),
9692 show_can_use_displaced_stepping
,
9693 &setlist
, &showlist
);
9695 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9696 &exec_direction
, _("Set direction of execution.\n\
9697 Options are 'forward' or 'reverse'."),
9698 _("Show direction of execution (forward/reverse)."),
9699 _("Tells gdb whether to execute forward or backward."),
9700 set_exec_direction_func
, show_exec_direction_func
,
9701 &setlist
, &showlist
);
9703 /* Set/show detach-on-fork: user-settable mode. */
9705 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9706 Set whether gdb will detach the child of a fork."), _("\
9707 Show whether gdb will detach the child of a fork."), _("\
9708 Tells gdb whether to detach the child of a fork."),
9709 NULL
, NULL
, &setlist
, &showlist
);
9711 /* Set/show disable address space randomization mode. */
9713 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9714 &disable_randomization
, _("\
9715 Set disabling of debuggee's virtual address space randomization."), _("\
9716 Show disabling of debuggee's virtual address space randomization."), _("\
9717 When this mode is on (which is the default), randomization of the virtual\n\
9718 address space is disabled. Standalone programs run with the randomization\n\
9719 enabled by default on some platforms."),
9720 &set_disable_randomization
,
9721 &show_disable_randomization
,
9722 &setlist
, &showlist
);
9724 /* ptid initializations */
9725 inferior_ptid
= null_ptid
;
9726 target_last_wait_ptid
= minus_one_ptid
;
9728 gdb::observers::thread_ptid_changed
.attach (infrun_thread_ptid_changed
,
9730 gdb::observers::thread_stop_requested
.attach (infrun_thread_stop_requested
,
9732 gdb::observers::thread_exit
.attach (infrun_thread_thread_exit
, "infrun");
9733 gdb::observers::inferior_exit
.attach (infrun_inferior_exit
, "infrun");
9734 gdb::observers::inferior_execd
.attach (infrun_inferior_execd
, "infrun");
9736 /* Explicitly create without lookup, since that tries to create a
9737 value with a void typed value, and when we get here, gdbarch
9738 isn't initialized yet. At this point, we're quite sure there
9739 isn't another convenience variable of the same name. */
9740 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9742 add_setshow_boolean_cmd ("observer", no_class
,
9743 &observer_mode_1
, _("\
9744 Set whether gdb controls the inferior in observer mode."), _("\
9745 Show whether gdb controls the inferior in observer mode."), _("\
9746 In observer mode, GDB can get data from the inferior, but not\n\
9747 affect its execution. Registers and memory may not be changed,\n\
9748 breakpoints may not be set, and the program cannot be interrupted\n\
9756 selftests::register_test ("infrun_thread_ptid_changed",
9757 selftests::infrun_thread_ptid_changed
);