1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2020 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
, CORE_ADDR pc
);
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 unsigned int debug_infrun
= 0;
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 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
)
408 ptid_t parent_ptid
, child_ptid
;
410 has_vforked
= (inferior_thread ()->pending_follow
.kind
411 == TARGET_WAITKIND_VFORKED
);
412 parent_ptid
= inferior_ptid
;
413 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
416 && !non_stop
/* Non-stop always resumes both branches. */
417 && current_ui
->prompt_state
== PROMPT_BLOCKED
418 && !(follow_child
|| detach_fork
|| sched_multi
))
420 /* The parent stays blocked inside the vfork syscall until the
421 child execs or exits. If we don't let the child run, then
422 the parent stays blocked. If we're telling the parent to run
423 in the foreground, the user will not be able to ctrl-c to get
424 back the terminal, effectively hanging the debug session. */
425 fprintf_filtered (gdb_stderr
, _("\
426 Can not resume the parent process over vfork in the foreground while\n\
427 holding the child stopped. Try \"set detach-on-fork\" or \
428 \"set schedule-multiple\".\n"));
434 /* Detach new forked process? */
437 /* Before detaching from the child, remove all breakpoints
438 from it. If we forked, then this has already been taken
439 care of by infrun.c. If we vforked however, any
440 breakpoint inserted in the parent is visible in the
441 child, even those added while stopped in a vfork
442 catchpoint. This will remove the breakpoints from the
443 parent also, but they'll be reinserted below. */
446 /* Keep breakpoints list in sync. */
447 remove_breakpoints_inf (current_inferior ());
450 if (print_inferior_events
)
452 /* Ensure that we have a process ptid. */
453 ptid_t process_ptid
= ptid_t (child_ptid
.pid ());
455 target_terminal::ours_for_output ();
456 fprintf_filtered (gdb_stdlog
,
457 _("[Detaching after %s from child %s]\n"),
458 has_vforked
? "vfork" : "fork",
459 target_pid_to_str (process_ptid
).c_str ());
464 struct inferior
*parent_inf
, *child_inf
;
466 /* Add process to GDB's tables. */
467 child_inf
= add_inferior (child_ptid
.pid ());
469 parent_inf
= current_inferior ();
470 child_inf
->attach_flag
= parent_inf
->attach_flag
;
471 copy_terminal_info (child_inf
, parent_inf
);
472 child_inf
->gdbarch
= parent_inf
->gdbarch
;
473 copy_inferior_target_desc_info (child_inf
, parent_inf
);
475 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
477 set_current_inferior (child_inf
);
478 switch_to_no_thread ();
479 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
480 push_target (parent_inf
->process_target ());
481 thread_info
*child_thr
482 = add_thread_silent (child_inf
->process_target (), child_ptid
);
484 /* If this is a vfork child, then the address-space is
485 shared with the parent. */
488 child_inf
->pspace
= parent_inf
->pspace
;
489 child_inf
->aspace
= parent_inf
->aspace
;
493 /* The parent will be frozen until the child is done
494 with the shared region. Keep track of the
496 child_inf
->vfork_parent
= parent_inf
;
497 child_inf
->pending_detach
= 0;
498 parent_inf
->vfork_child
= child_inf
;
499 parent_inf
->pending_detach
= 0;
501 /* Now that the inferiors and program spaces are all
502 wired up, we can switch to the child thread (which
503 switches inferior and program space too). */
504 switch_to_thread (child_thr
);
508 child_inf
->aspace
= new_address_space ();
509 child_inf
->pspace
= new program_space (child_inf
->aspace
);
510 child_inf
->removable
= 1;
511 set_current_program_space (child_inf
->pspace
);
512 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
514 /* solib_create_inferior_hook relies on the current
516 switch_to_thread (child_thr
);
518 /* Let the shared library layer (e.g., solib-svr4) learn
519 about this new process, relocate the cloned exec, pull
520 in shared libraries, and install the solib event
521 breakpoint. If a "cloned-VM" event was propagated
522 better throughout the core, this wouldn't be
524 solib_create_inferior_hook (0);
530 struct inferior
*parent_inf
;
532 parent_inf
= current_inferior ();
534 /* If we detached from the child, then we have to be careful
535 to not insert breakpoints in the parent until the child
536 is done with the shared memory region. However, if we're
537 staying attached to the child, then we can and should
538 insert breakpoints, so that we can debug it. A
539 subsequent child exec or exit is enough to know when does
540 the child stops using the parent's address space. */
541 parent_inf
->waiting_for_vfork_done
= detach_fork
;
542 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
547 /* Follow the child. */
548 struct inferior
*parent_inf
, *child_inf
;
549 struct program_space
*parent_pspace
;
551 if (print_inferior_events
)
553 std::string parent_pid
= target_pid_to_str (parent_ptid
);
554 std::string child_pid
= target_pid_to_str (child_ptid
);
556 target_terminal::ours_for_output ();
557 fprintf_filtered (gdb_stdlog
,
558 _("[Attaching after %s %s to child %s]\n"),
560 has_vforked
? "vfork" : "fork",
564 /* Add the new inferior first, so that the target_detach below
565 doesn't unpush the target. */
567 child_inf
= add_inferior (child_ptid
.pid ());
569 parent_inf
= current_inferior ();
570 child_inf
->attach_flag
= parent_inf
->attach_flag
;
571 copy_terminal_info (child_inf
, parent_inf
);
572 child_inf
->gdbarch
= parent_inf
->gdbarch
;
573 copy_inferior_target_desc_info (child_inf
, parent_inf
);
575 parent_pspace
= parent_inf
->pspace
;
577 process_stratum_target
*target
= parent_inf
->process_target ();
580 /* Hold a strong reference to the target while (maybe)
581 detaching the parent. Otherwise detaching could close the
583 auto target_ref
= target_ops_ref::new_reference (target
);
585 /* If we're vforking, we want to hold on to the parent until
586 the child exits or execs. At child exec or exit time we
587 can remove the old breakpoints from the parent and detach
588 or resume debugging it. Otherwise, detach the parent now;
589 we'll want to reuse it's program/address spaces, but we
590 can't set them to the child before removing breakpoints
591 from the parent, otherwise, the breakpoints module could
592 decide to remove breakpoints from the wrong process (since
593 they'd be assigned to the same address space). */
597 gdb_assert (child_inf
->vfork_parent
== NULL
);
598 gdb_assert (parent_inf
->vfork_child
== NULL
);
599 child_inf
->vfork_parent
= parent_inf
;
600 child_inf
->pending_detach
= 0;
601 parent_inf
->vfork_child
= child_inf
;
602 parent_inf
->pending_detach
= detach_fork
;
603 parent_inf
->waiting_for_vfork_done
= 0;
605 else if (detach_fork
)
607 if (print_inferior_events
)
609 /* Ensure that we have a process ptid. */
610 ptid_t process_ptid
= ptid_t (parent_ptid
.pid ());
612 target_terminal::ours_for_output ();
613 fprintf_filtered (gdb_stdlog
,
614 _("[Detaching after fork from "
616 target_pid_to_str (process_ptid
).c_str ());
619 target_detach (parent_inf
, 0);
623 /* Note that the detach above makes PARENT_INF dangling. */
625 /* Add the child thread to the appropriate lists, and switch
626 to this new thread, before cloning the program space, and
627 informing the solib layer about this new process. */
629 set_current_inferior (child_inf
);
630 push_target (target
);
633 thread_info
*child_thr
= add_thread_silent (target
, child_ptid
);
635 /* If this is a vfork child, then the address-space is shared
636 with the parent. If we detached from the parent, then we can
637 reuse the parent's program/address spaces. */
638 if (has_vforked
|| detach_fork
)
640 child_inf
->pspace
= parent_pspace
;
641 child_inf
->aspace
= child_inf
->pspace
->aspace
;
647 child_inf
->aspace
= new_address_space ();
648 child_inf
->pspace
= new program_space (child_inf
->aspace
);
649 child_inf
->removable
= 1;
650 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
651 set_current_program_space (child_inf
->pspace
);
652 clone_program_space (child_inf
->pspace
, parent_pspace
);
654 /* Let the shared library layer (e.g., solib-svr4) learn
655 about this new process, relocate the cloned exec, pull in
656 shared libraries, and install the solib event breakpoint.
657 If a "cloned-VM" event was propagated better throughout
658 the core, this wouldn't be required. */
659 solib_create_inferior_hook (0);
662 switch_to_thread (child_thr
);
665 return target_follow_fork (follow_child
, detach_fork
);
668 /* Tell the target to follow the fork we're stopped at. Returns true
669 if the inferior should be resumed; false, if the target for some
670 reason decided it's best not to resume. */
675 bool follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
676 bool should_resume
= true;
677 struct thread_info
*tp
;
679 /* Copy user stepping state to the new inferior thread. FIXME: the
680 followed fork child thread should have a copy of most of the
681 parent thread structure's run control related fields, not just these.
682 Initialized to avoid "may be used uninitialized" warnings from gcc. */
683 struct breakpoint
*step_resume_breakpoint
= NULL
;
684 struct breakpoint
*exception_resume_breakpoint
= NULL
;
685 CORE_ADDR step_range_start
= 0;
686 CORE_ADDR step_range_end
= 0;
687 int current_line
= 0;
688 symtab
*current_symtab
= NULL
;
689 struct frame_id step_frame_id
= { 0 };
690 struct thread_fsm
*thread_fsm
= NULL
;
694 process_stratum_target
*wait_target
;
696 struct target_waitstatus wait_status
;
698 /* Get the last target status returned by target_wait(). */
699 get_last_target_status (&wait_target
, &wait_ptid
, &wait_status
);
701 /* If not stopped at a fork event, then there's nothing else to
703 if (wait_status
.kind
!= TARGET_WAITKIND_FORKED
704 && wait_status
.kind
!= TARGET_WAITKIND_VFORKED
)
707 /* Check if we switched over from WAIT_PTID, since the event was
709 if (wait_ptid
!= minus_one_ptid
710 && (current_inferior ()->process_target () != wait_target
711 || inferior_ptid
!= wait_ptid
))
713 /* We did. Switch back to WAIT_PTID thread, to tell the
714 target to follow it (in either direction). We'll
715 afterwards refuse to resume, and inform the user what
717 thread_info
*wait_thread
= find_thread_ptid (wait_target
, wait_ptid
);
718 switch_to_thread (wait_thread
);
719 should_resume
= false;
723 tp
= inferior_thread ();
725 /* If there were any forks/vforks that were caught and are now to be
726 followed, then do so now. */
727 switch (tp
->pending_follow
.kind
)
729 case TARGET_WAITKIND_FORKED
:
730 case TARGET_WAITKIND_VFORKED
:
732 ptid_t parent
, child
;
734 /* If the user did a next/step, etc, over a fork call,
735 preserve the stepping state in the fork child. */
736 if (follow_child
&& should_resume
)
738 step_resume_breakpoint
= clone_momentary_breakpoint
739 (tp
->control
.step_resume_breakpoint
);
740 step_range_start
= tp
->control
.step_range_start
;
741 step_range_end
= tp
->control
.step_range_end
;
742 current_line
= tp
->current_line
;
743 current_symtab
= tp
->current_symtab
;
744 step_frame_id
= tp
->control
.step_frame_id
;
745 exception_resume_breakpoint
746 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
747 thread_fsm
= tp
->thread_fsm
;
749 /* For now, delete the parent's sr breakpoint, otherwise,
750 parent/child sr breakpoints are considered duplicates,
751 and the child version will not be installed. Remove
752 this when the breakpoints module becomes aware of
753 inferiors and address spaces. */
754 delete_step_resume_breakpoint (tp
);
755 tp
->control
.step_range_start
= 0;
756 tp
->control
.step_range_end
= 0;
757 tp
->control
.step_frame_id
= null_frame_id
;
758 delete_exception_resume_breakpoint (tp
);
759 tp
->thread_fsm
= NULL
;
762 parent
= inferior_ptid
;
763 child
= tp
->pending_follow
.value
.related_pid
;
765 process_stratum_target
*parent_targ
= tp
->inf
->process_target ();
766 /* Set up inferior(s) as specified by the caller, and tell the
767 target to do whatever is necessary to follow either parent
769 if (follow_fork_inferior (follow_child
, detach_fork
))
771 /* Target refused to follow, or there's some other reason
772 we shouldn't resume. */
777 /* This pending follow fork event is now handled, one way
778 or another. The previous selected thread may be gone
779 from the lists by now, but if it is still around, need
780 to clear the pending follow request. */
781 tp
= find_thread_ptid (parent_targ
, parent
);
783 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
785 /* This makes sure we don't try to apply the "Switched
786 over from WAIT_PID" logic above. */
787 nullify_last_target_wait_ptid ();
789 /* If we followed the child, switch to it... */
792 thread_info
*child_thr
= find_thread_ptid (parent_targ
, child
);
793 switch_to_thread (child_thr
);
795 /* ... and preserve the stepping state, in case the
796 user was stepping over the fork call. */
799 tp
= inferior_thread ();
800 tp
->control
.step_resume_breakpoint
801 = step_resume_breakpoint
;
802 tp
->control
.step_range_start
= step_range_start
;
803 tp
->control
.step_range_end
= step_range_end
;
804 tp
->current_line
= current_line
;
805 tp
->current_symtab
= current_symtab
;
806 tp
->control
.step_frame_id
= step_frame_id
;
807 tp
->control
.exception_resume_breakpoint
808 = exception_resume_breakpoint
;
809 tp
->thread_fsm
= thread_fsm
;
813 /* If we get here, it was because we're trying to
814 resume from a fork catchpoint, but, the user
815 has switched threads away from the thread that
816 forked. In that case, the resume command
817 issued is most likely not applicable to the
818 child, so just warn, and refuse to resume. */
819 warning (_("Not resuming: switched threads "
820 "before following fork child."));
823 /* Reset breakpoints in the child as appropriate. */
824 follow_inferior_reset_breakpoints ();
829 case TARGET_WAITKIND_SPURIOUS
:
830 /* Nothing to follow. */
833 internal_error (__FILE__
, __LINE__
,
834 "Unexpected pending_follow.kind %d\n",
835 tp
->pending_follow
.kind
);
839 return should_resume
;
843 follow_inferior_reset_breakpoints (void)
845 struct thread_info
*tp
= inferior_thread ();
847 /* Was there a step_resume breakpoint? (There was if the user
848 did a "next" at the fork() call.) If so, explicitly reset its
849 thread number. Cloned step_resume breakpoints are disabled on
850 creation, so enable it here now that it is associated with the
853 step_resumes are a form of bp that are made to be per-thread.
854 Since we created the step_resume bp when the parent process
855 was being debugged, and now are switching to the child process,
856 from the breakpoint package's viewpoint, that's a switch of
857 "threads". We must update the bp's notion of which thread
858 it is for, or it'll be ignored when it triggers. */
860 if (tp
->control
.step_resume_breakpoint
)
862 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
863 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
866 /* Treat exception_resume breakpoints like step_resume breakpoints. */
867 if (tp
->control
.exception_resume_breakpoint
)
869 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
870 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
873 /* Reinsert all breakpoints in the child. The user may have set
874 breakpoints after catching the fork, in which case those
875 were never set in the child, but only in the parent. This makes
876 sure the inserted breakpoints match the breakpoint list. */
878 breakpoint_re_set ();
879 insert_breakpoints ();
882 /* The child has exited or execed: resume threads of the parent the
883 user wanted to be executing. */
886 proceed_after_vfork_done (struct thread_info
*thread
,
889 int pid
= * (int *) arg
;
891 if (thread
->ptid
.pid () == pid
892 && thread
->state
== THREAD_RUNNING
893 && !thread
->executing
894 && !thread
->stop_requested
895 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
897 infrun_debug_printf ("resuming vfork parent thread %s",
898 target_pid_to_str (thread
->ptid
).c_str ());
900 switch_to_thread (thread
);
901 clear_proceed_status (0);
902 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
908 /* Called whenever we notice an exec or exit event, to handle
909 detaching or resuming a vfork parent. */
912 handle_vfork_child_exec_or_exit (int exec
)
914 struct inferior
*inf
= current_inferior ();
916 if (inf
->vfork_parent
)
918 int resume_parent
= -1;
920 /* This exec or exit marks the end of the shared memory region
921 between the parent and the child. Break the bonds. */
922 inferior
*vfork_parent
= inf
->vfork_parent
;
923 inf
->vfork_parent
->vfork_child
= NULL
;
924 inf
->vfork_parent
= NULL
;
926 /* If the user wanted to detach from the parent, now is the
928 if (vfork_parent
->pending_detach
)
930 struct program_space
*pspace
;
931 struct address_space
*aspace
;
933 /* follow-fork child, detach-on-fork on. */
935 vfork_parent
->pending_detach
= 0;
937 scoped_restore_current_pspace_and_thread restore_thread
;
939 /* We're letting loose of the parent. */
940 thread_info
*tp
= any_live_thread_of_inferior (vfork_parent
);
941 switch_to_thread (tp
);
943 /* We're about to detach from the parent, which implicitly
944 removes breakpoints from its address space. There's a
945 catch here: we want to reuse the spaces for the child,
946 but, parent/child are still sharing the pspace at this
947 point, although the exec in reality makes the kernel give
948 the child a fresh set of new pages. The problem here is
949 that the breakpoints module being unaware of this, would
950 likely chose the child process to write to the parent
951 address space. Swapping the child temporarily away from
952 the spaces has the desired effect. Yes, this is "sort
955 pspace
= inf
->pspace
;
956 aspace
= inf
->aspace
;
960 if (print_inferior_events
)
963 = target_pid_to_str (ptid_t (vfork_parent
->pid
));
965 target_terminal::ours_for_output ();
969 fprintf_filtered (gdb_stdlog
,
970 _("[Detaching vfork parent %s "
971 "after child exec]\n"), pidstr
.c_str ());
975 fprintf_filtered (gdb_stdlog
,
976 _("[Detaching vfork parent %s "
977 "after child exit]\n"), pidstr
.c_str ());
981 target_detach (vfork_parent
, 0);
984 inf
->pspace
= pspace
;
985 inf
->aspace
= aspace
;
989 /* We're staying attached to the parent, so, really give the
990 child a new address space. */
991 inf
->pspace
= new program_space (maybe_new_address_space ());
992 inf
->aspace
= inf
->pspace
->aspace
;
994 set_current_program_space (inf
->pspace
);
996 resume_parent
= vfork_parent
->pid
;
1000 /* If this is a vfork child exiting, then the pspace and
1001 aspaces were shared with the parent. Since we're
1002 reporting the process exit, we'll be mourning all that is
1003 found in the address space, and switching to null_ptid,
1004 preparing to start a new inferior. But, since we don't
1005 want to clobber the parent's address/program spaces, we
1006 go ahead and create a new one for this exiting
1009 /* Switch to no-thread while running clone_program_space, so
1010 that clone_program_space doesn't want to read the
1011 selected frame of a dead process. */
1012 scoped_restore_current_thread restore_thread
;
1013 switch_to_no_thread ();
1015 inf
->pspace
= new program_space (maybe_new_address_space ());
1016 inf
->aspace
= inf
->pspace
->aspace
;
1017 set_current_program_space (inf
->pspace
);
1019 inf
->symfile_flags
= SYMFILE_NO_READ
;
1020 clone_program_space (inf
->pspace
, vfork_parent
->pspace
);
1022 resume_parent
= vfork_parent
->pid
;
1025 gdb_assert (current_program_space
== inf
->pspace
);
1027 if (non_stop
&& resume_parent
!= -1)
1029 /* If the user wanted the parent to be running, let it go
1031 scoped_restore_current_thread restore_thread
;
1033 infrun_debug_printf ("resuming vfork parent process %d",
1036 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1041 /* Enum strings for "set|show follow-exec-mode". */
1043 static const char follow_exec_mode_new
[] = "new";
1044 static const char follow_exec_mode_same
[] = "same";
1045 static const char *const follow_exec_mode_names
[] =
1047 follow_exec_mode_new
,
1048 follow_exec_mode_same
,
1052 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1054 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1055 struct cmd_list_element
*c
, const char *value
)
1057 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1060 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1063 follow_exec (ptid_t ptid
, const char *exec_file_target
)
1065 struct inferior
*inf
= current_inferior ();
1066 int pid
= ptid
.pid ();
1067 ptid_t process_ptid
;
1069 /* Switch terminal for any messages produced e.g. by
1070 breakpoint_re_set. */
1071 target_terminal::ours_for_output ();
1073 /* This is an exec event that we actually wish to pay attention to.
1074 Refresh our symbol table to the newly exec'd program, remove any
1075 momentary bp's, etc.
1077 If there are breakpoints, they aren't really inserted now,
1078 since the exec() transformed our inferior into a fresh set
1081 We want to preserve symbolic breakpoints on the list, since
1082 we have hopes that they can be reset after the new a.out's
1083 symbol table is read.
1085 However, any "raw" breakpoints must be removed from the list
1086 (e.g., the solib bp's), since their address is probably invalid
1089 And, we DON'T want to call delete_breakpoints() here, since
1090 that may write the bp's "shadow contents" (the instruction
1091 value that was overwritten with a TRAP instruction). Since
1092 we now have a new a.out, those shadow contents aren't valid. */
1094 mark_breakpoints_out ();
1096 /* The target reports the exec event to the main thread, even if
1097 some other thread does the exec, and even if the main thread was
1098 stopped or already gone. We may still have non-leader threads of
1099 the process on our list. E.g., on targets that don't have thread
1100 exit events (like remote); or on native Linux in non-stop mode if
1101 there were only two threads in the inferior and the non-leader
1102 one is the one that execs (and nothing forces an update of the
1103 thread list up to here). When debugging remotely, it's best to
1104 avoid extra traffic, when possible, so avoid syncing the thread
1105 list with the target, and instead go ahead and delete all threads
1106 of the process but one that reported the event. Note this must
1107 be done before calling update_breakpoints_after_exec, as
1108 otherwise clearing the threads' resources would reference stale
1109 thread breakpoints -- it may have been one of these threads that
1110 stepped across the exec. We could just clear their stepping
1111 states, but as long as we're iterating, might as well delete
1112 them. Deleting them now rather than at the next user-visible
1113 stop provides a nicer sequence of events for user and MI
1115 for (thread_info
*th
: all_threads_safe ())
1116 if (th
->ptid
.pid () == pid
&& th
->ptid
!= ptid
)
1119 /* We also need to clear any left over stale state for the
1120 leader/event thread. E.g., if there was any step-resume
1121 breakpoint or similar, it's gone now. We cannot truly
1122 step-to-next statement through an exec(). */
1123 thread_info
*th
= inferior_thread ();
1124 th
->control
.step_resume_breakpoint
= NULL
;
1125 th
->control
.exception_resume_breakpoint
= NULL
;
1126 th
->control
.single_step_breakpoints
= NULL
;
1127 th
->control
.step_range_start
= 0;
1128 th
->control
.step_range_end
= 0;
1130 /* The user may have had the main thread held stopped in the
1131 previous image (e.g., schedlock on, or non-stop). Release
1133 th
->stop_requested
= 0;
1135 update_breakpoints_after_exec ();
1137 /* What is this a.out's name? */
1138 process_ptid
= ptid_t (pid
);
1139 printf_unfiltered (_("%s is executing new program: %s\n"),
1140 target_pid_to_str (process_ptid
).c_str (),
1143 /* We've followed the inferior through an exec. Therefore, the
1144 inferior has essentially been killed & reborn. */
1146 breakpoint_init_inferior (inf_execd
);
1148 gdb::unique_xmalloc_ptr
<char> exec_file_host
1149 = exec_file_find (exec_file_target
, NULL
);
1151 /* If we were unable to map the executable target pathname onto a host
1152 pathname, tell the user that. Otherwise GDB's subsequent behavior
1153 is confusing. Maybe it would even be better to stop at this point
1154 so that the user can specify a file manually before continuing. */
1155 if (exec_file_host
== NULL
)
1156 warning (_("Could not load symbols for executable %s.\n"
1157 "Do you need \"set sysroot\"?"),
1160 /* Reset the shared library package. This ensures that we get a
1161 shlib event when the child reaches "_start", at which point the
1162 dld will have had a chance to initialize the child. */
1163 /* Also, loading a symbol file below may trigger symbol lookups, and
1164 we don't want those to be satisfied by the libraries of the
1165 previous incarnation of this process. */
1166 no_shared_libraries (NULL
, 0);
1168 if (follow_exec_mode_string
== follow_exec_mode_new
)
1170 /* The user wants to keep the old inferior and program spaces
1171 around. Create a new fresh one, and switch to it. */
1173 /* Do exit processing for the original inferior before setting the new
1174 inferior's pid. Having two inferiors with the same pid would confuse
1175 find_inferior_p(t)id. Transfer the terminal state and info from the
1176 old to the new inferior. */
1177 inf
= add_inferior_with_spaces ();
1178 swap_terminal_info (inf
, current_inferior ());
1179 exit_inferior_silent (current_inferior ());
1182 target_follow_exec (inf
, exec_file_target
);
1184 inferior
*org_inferior
= current_inferior ();
1185 switch_to_inferior_no_thread (inf
);
1186 push_target (org_inferior
->process_target ());
1187 thread_info
*thr
= add_thread (inf
->process_target (), ptid
);
1188 switch_to_thread (thr
);
1192 /* The old description may no longer be fit for the new image.
1193 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1194 old description; we'll read a new one below. No need to do
1195 this on "follow-exec-mode new", as the old inferior stays
1196 around (its description is later cleared/refetched on
1198 target_clear_description ();
1201 gdb_assert (current_program_space
== inf
->pspace
);
1203 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1204 because the proper displacement for a PIE (Position Independent
1205 Executable) main symbol file will only be computed by
1206 solib_create_inferior_hook below. breakpoint_re_set would fail
1207 to insert the breakpoints with the zero displacement. */
1208 try_open_exec_file (exec_file_host
.get (), inf
, SYMFILE_DEFER_BP_RESET
);
1210 /* If the target can specify a description, read it. Must do this
1211 after flipping to the new executable (because the target supplied
1212 description must be compatible with the executable's
1213 architecture, and the old executable may e.g., be 32-bit, while
1214 the new one 64-bit), and before anything involving memory or
1216 target_find_description ();
1218 gdb::observers::inferior_execd
.notify (inf
);
1220 breakpoint_re_set ();
1222 /* Reinsert all breakpoints. (Those which were symbolic have
1223 been reset to the proper address in the new a.out, thanks
1224 to symbol_file_command...). */
1225 insert_breakpoints ();
1227 /* The next resume of this inferior should bring it to the shlib
1228 startup breakpoints. (If the user had also set bp's on
1229 "main" from the old (parent) process, then they'll auto-
1230 matically get reset there in the new process.). */
1233 /* The chain of threads that need to do a step-over operation to get
1234 past e.g., a breakpoint. What technique is used to step over the
1235 breakpoint/watchpoint does not matter -- all threads end up in the
1236 same queue, to maintain rough temporal order of execution, in order
1237 to avoid starvation, otherwise, we could e.g., find ourselves
1238 constantly stepping the same couple threads past their breakpoints
1239 over and over, if the single-step finish fast enough. */
1240 struct thread_info
*global_thread_step_over_chain_head
;
1242 /* Bit flags indicating what the thread needs to step over. */
1244 enum step_over_what_flag
1246 /* Step over a breakpoint. */
1247 STEP_OVER_BREAKPOINT
= 1,
1249 /* Step past a non-continuable watchpoint, in order to let the
1250 instruction execute so we can evaluate the watchpoint
1252 STEP_OVER_WATCHPOINT
= 2
1254 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag
, step_over_what
);
1256 /* Info about an instruction that is being stepped over. */
1258 struct step_over_info
1260 /* If we're stepping past a breakpoint, this is the address space
1261 and address of the instruction the breakpoint is set at. We'll
1262 skip inserting all breakpoints here. Valid iff ASPACE is
1264 const address_space
*aspace
;
1267 /* The instruction being stepped over triggers a nonsteppable
1268 watchpoint. If true, we'll skip inserting watchpoints. */
1269 int nonsteppable_watchpoint_p
;
1271 /* The thread's global number. */
1275 /* The step-over info of the location that is being stepped over.
1277 Note that with async/breakpoint always-inserted mode, a user might
1278 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1279 being stepped over. As setting a new breakpoint inserts all
1280 breakpoints, we need to make sure the breakpoint being stepped over
1281 isn't inserted then. We do that by only clearing the step-over
1282 info when the step-over is actually finished (or aborted).
1284 Presently GDB can only step over one breakpoint at any given time.
1285 Given threads that can't run code in the same address space as the
1286 breakpoint's can't really miss the breakpoint, GDB could be taught
1287 to step-over at most one breakpoint per address space (so this info
1288 could move to the address space object if/when GDB is extended).
1289 The set of breakpoints being stepped over will normally be much
1290 smaller than the set of all breakpoints, so a flag in the
1291 breakpoint location structure would be wasteful. A separate list
1292 also saves complexity and run-time, as otherwise we'd have to go
1293 through all breakpoint locations clearing their flag whenever we
1294 start a new sequence. Similar considerations weigh against storing
1295 this info in the thread object. Plus, not all step overs actually
1296 have breakpoint locations -- e.g., stepping past a single-step
1297 breakpoint, or stepping to complete a non-continuable
1299 static struct step_over_info step_over_info
;
1301 /* Record the address of the breakpoint/instruction we're currently
1303 N.B. We record the aspace and address now, instead of say just the thread,
1304 because when we need the info later the thread may be running. */
1307 set_step_over_info (const address_space
*aspace
, CORE_ADDR address
,
1308 int nonsteppable_watchpoint_p
,
1311 step_over_info
.aspace
= aspace
;
1312 step_over_info
.address
= address
;
1313 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1314 step_over_info
.thread
= thread
;
1317 /* Called when we're not longer stepping over a breakpoint / an
1318 instruction, so all breakpoints are free to be (re)inserted. */
1321 clear_step_over_info (void)
1323 infrun_debug_printf ("clearing step over info");
1324 step_over_info
.aspace
= NULL
;
1325 step_over_info
.address
= 0;
1326 step_over_info
.nonsteppable_watchpoint_p
= 0;
1327 step_over_info
.thread
= -1;
1333 stepping_past_instruction_at (struct address_space
*aspace
,
1336 return (step_over_info
.aspace
!= NULL
1337 && breakpoint_address_match (aspace
, address
,
1338 step_over_info
.aspace
,
1339 step_over_info
.address
));
1345 thread_is_stepping_over_breakpoint (int thread
)
1347 return (step_over_info
.thread
!= -1
1348 && thread
== step_over_info
.thread
);
1354 stepping_past_nonsteppable_watchpoint (void)
1356 return step_over_info
.nonsteppable_watchpoint_p
;
1359 /* Returns true if step-over info is valid. */
1362 step_over_info_valid_p (void)
1364 return (step_over_info
.aspace
!= NULL
1365 || stepping_past_nonsteppable_watchpoint ());
1369 /* Displaced stepping. */
1371 /* In non-stop debugging mode, we must take special care to manage
1372 breakpoints properly; in particular, the traditional strategy for
1373 stepping a thread past a breakpoint it has hit is unsuitable.
1374 'Displaced stepping' is a tactic for stepping one thread past a
1375 breakpoint it has hit while ensuring that other threads running
1376 concurrently will hit the breakpoint as they should.
1378 The traditional way to step a thread T off a breakpoint in a
1379 multi-threaded program in all-stop mode is as follows:
1381 a0) Initially, all threads are stopped, and breakpoints are not
1383 a1) We single-step T, leaving breakpoints uninserted.
1384 a2) We insert breakpoints, and resume all threads.
1386 In non-stop debugging, however, this strategy is unsuitable: we
1387 don't want to have to stop all threads in the system in order to
1388 continue or step T past a breakpoint. Instead, we use displaced
1391 n0) Initially, T is stopped, other threads are running, and
1392 breakpoints are inserted.
1393 n1) We copy the instruction "under" the breakpoint to a separate
1394 location, outside the main code stream, making any adjustments
1395 to the instruction, register, and memory state as directed by
1397 n2) We single-step T over the instruction at its new location.
1398 n3) We adjust the resulting register and memory state as directed
1399 by T's architecture. This includes resetting T's PC to point
1400 back into the main instruction stream.
1403 This approach depends on the following gdbarch methods:
1405 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1406 indicate where to copy the instruction, and how much space must
1407 be reserved there. We use these in step n1.
1409 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1410 address, and makes any necessary adjustments to the instruction,
1411 register contents, and memory. We use this in step n1.
1413 - gdbarch_displaced_step_fixup adjusts registers and memory after
1414 we have successfully single-stepped the instruction, to yield the
1415 same effect the instruction would have had if we had executed it
1416 at its original address. We use this in step n3.
1418 The gdbarch_displaced_step_copy_insn and
1419 gdbarch_displaced_step_fixup functions must be written so that
1420 copying an instruction with gdbarch_displaced_step_copy_insn,
1421 single-stepping across the copied instruction, and then applying
1422 gdbarch_displaced_insn_fixup should have the same effects on the
1423 thread's memory and registers as stepping the instruction in place
1424 would have. Exactly which responsibilities fall to the copy and
1425 which fall to the fixup is up to the author of those functions.
1427 See the comments in gdbarch.sh for details.
1429 Note that displaced stepping and software single-step cannot
1430 currently be used in combination, although with some care I think
1431 they could be made to. Software single-step works by placing
1432 breakpoints on all possible subsequent instructions; if the
1433 displaced instruction is a PC-relative jump, those breakpoints
1434 could fall in very strange places --- on pages that aren't
1435 executable, or at addresses that are not proper instruction
1436 boundaries. (We do generally let other threads run while we wait
1437 to hit the software single-step breakpoint, and they might
1438 encounter such a corrupted instruction.) One way to work around
1439 this would be to have gdbarch_displaced_step_copy_insn fully
1440 simulate the effect of PC-relative instructions (and return NULL)
1441 on architectures that use software single-stepping.
1443 In non-stop mode, we can have independent and simultaneous step
1444 requests, so more than one thread may need to simultaneously step
1445 over a breakpoint. The current implementation assumes there is
1446 only one scratch space per process. In this case, we have to
1447 serialize access to the scratch space. If thread A wants to step
1448 over a breakpoint, but we are currently waiting for some other
1449 thread to complete a displaced step, we leave thread A stopped and
1450 place it in the displaced_step_request_queue. Whenever a displaced
1451 step finishes, we pick the next thread in the queue and start a new
1452 displaced step operation on it. See displaced_step_prepare and
1453 displaced_step_finish for details. */
1455 /* Returns true if any inferior has a thread doing a displaced
1459 displaced_step_in_progress_any_inferior ()
1461 for (inferior
*i
: all_inferiors ())
1463 if (i
->displaced_step_state
.step_thread
!= nullptr)
1470 /* Return true if THREAD is doing a displaced step. */
1473 displaced_step_in_progress_thread (thread_info
*thread
)
1475 gdb_assert (thread
!= NULL
);
1477 return thread
->inf
->displaced_step_state
.step_thread
== thread
;
1480 /* Return true if INF has a thread doing a displaced step. */
1483 displaced_step_in_progress (inferior
*inf
)
1485 return inf
->displaced_step_state
.step_thread
!= nullptr;
1488 /* If inferior is in displaced stepping, and ADDR equals to starting address
1489 of copy area, return corresponding displaced_step_copy_insn_closure.
1490 Otherwise, return NULL. */
1492 displaced_step_copy_insn_closure
*
1493 get_displaced_step_copy_insn_closure_by_addr (CORE_ADDR addr
)
1495 displaced_step_inferior_state
&displaced
1496 = current_inferior ()->displaced_step_state
;
1498 /* If checking the mode of displaced instruction in copy area. */
1499 if (displaced
.step_thread
!= nullptr
1500 && displaced
.step_copy
== addr
)
1501 return displaced
.step_closure
.get ();
1507 infrun_inferior_exit (struct inferior
*inf
)
1509 inf
->displaced_step_state
.reset ();
1513 infrun_inferior_execd (inferior
*inf
)
1515 /* If a thread was doing a displaced step in this inferior at the moment of
1516 the exec, it no longer exists. Even if the exec'ing thread was the one
1517 doing a displaced step, we don't want to to any fixup nor restore displaced
1518 stepping buffer bytes. */
1519 inf
->displaced_step_state
.reset ();
1521 /* Since an in-line step is done with everything else stopped, if there was
1522 one in progress at the time of the exec, it must have been the exec'ing
1524 clear_step_over_info ();
1527 /* If ON, and the architecture supports it, GDB will use displaced
1528 stepping to step over breakpoints. If OFF, or if the architecture
1529 doesn't support it, GDB will instead use the traditional
1530 hold-and-step approach. If AUTO (which is the default), GDB will
1531 decide which technique to use to step over breakpoints depending on
1532 whether the target works in a non-stop way (see use_displaced_stepping). */
1534 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1537 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1538 struct cmd_list_element
*c
,
1541 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1542 fprintf_filtered (file
,
1543 _("Debugger's willingness to use displaced stepping "
1544 "to step over breakpoints is %s (currently %s).\n"),
1545 value
, target_is_non_stop_p () ? "on" : "off");
1547 fprintf_filtered (file
,
1548 _("Debugger's willingness to use displaced stepping "
1549 "to step over breakpoints is %s.\n"), value
);
1552 /* Return true if the gdbarch implements the required methods to use
1553 displaced stepping. */
1556 gdbarch_supports_displaced_stepping (gdbarch
*arch
)
1558 /* Only check for the presence of step_copy_insn. Other required methods
1559 are checked by the gdbarch validation. */
1560 return gdbarch_displaced_step_copy_insn_p (arch
);
1563 /* Return non-zero if displaced stepping can/should be used to step
1564 over breakpoints of thread TP. */
1567 use_displaced_stepping (thread_info
*tp
)
1569 /* If the user disabled it explicitly, don't use displaced stepping. */
1570 if (can_use_displaced_stepping
== AUTO_BOOLEAN_FALSE
)
1573 /* If "auto", only use displaced stepping if the target operates in a non-stop
1575 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1576 && !target_is_non_stop_p ())
1579 gdbarch
*gdbarch
= get_thread_regcache (tp
)->arch ();
1581 /* If the architecture doesn't implement displaced stepping, don't use
1583 if (!gdbarch_supports_displaced_stepping (gdbarch
))
1586 /* If recording, don't use displaced stepping. */
1587 if (find_record_target () != nullptr)
1590 /* If displaced stepping failed before for this inferior, don't bother trying
1592 if (tp
->inf
->displaced_step_state
.failed_before
)
1598 /* Simple function wrapper around displaced_step_inferior_state::reset. */
1601 displaced_step_reset (displaced_step_inferior_state
*displaced
)
1603 displaced
->reset ();
1606 /* A cleanup that wraps displaced_step_reset. We use this instead of, say,
1607 SCOPE_EXIT, because it needs to be discardable with "cleanup.release ()". */
1609 using displaced_step_reset_cleanup
= FORWARD_SCOPE_EXIT (displaced_step_reset
);
1614 displaced_step_dump_bytes (const gdb_byte
*buf
, size_t len
)
1618 for (size_t i
= 0; i
< len
; i
++)
1621 ret
+= string_printf ("%02x", buf
[i
]);
1623 ret
+= string_printf (" %02x", buf
[i
]);
1629 /* Prepare to single-step, using displaced stepping.
1631 Note that we cannot use displaced stepping when we have a signal to
1632 deliver. If we have a signal to deliver and an instruction to step
1633 over, then after the step, there will be no indication from the
1634 target whether the thread entered a signal handler or ignored the
1635 signal and stepped over the instruction successfully --- both cases
1636 result in a simple SIGTRAP. In the first case we mustn't do a
1637 fixup, and in the second case we must --- but we can't tell which.
1638 Comments in the code for 'random signals' in handle_inferior_event
1639 explain how we handle this case instead.
1641 Returns DISPLACED_STEP_PREPARE_STATUS_OK if preparing was successful -- this
1642 thread is going to be stepped now; DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
1643 if displaced stepping this thread got queued; or
1644 DISPLACED_STEP_PREPARE_STATUS_CANT if this instruction can't be displaced
1647 static displaced_step_prepare_status
1648 displaced_step_prepare_throw (thread_info
*tp
)
1650 regcache
*regcache
= get_thread_regcache (tp
);
1651 struct gdbarch
*gdbarch
= regcache
->arch ();
1652 const address_space
*aspace
= regcache
->aspace ();
1653 CORE_ADDR original
, copy
;
1657 /* We should never reach this function if the architecture does not
1658 support displaced stepping. */
1659 gdb_assert (gdbarch_supports_displaced_stepping (gdbarch
));
1661 /* Nor if the thread isn't meant to step over a breakpoint. */
1662 gdb_assert (tp
->control
.trap_expected
);
1664 /* Disable range stepping while executing in the scratch pad. We
1665 want a single-step even if executing the displaced instruction in
1666 the scratch buffer lands within the stepping range (e.g., a
1668 tp
->control
.may_range_step
= 0;
1670 /* We have to displaced step one thread at a time, as we only have
1671 access to a single scratch space per inferior. */
1673 displaced_step_inferior_state
*displaced
= &tp
->inf
->displaced_step_state
;
1675 if (displaced
->step_thread
!= nullptr)
1677 /* Already waiting for a displaced step to finish. Defer this
1678 request and place in queue. */
1680 displaced_debug_printf ("deferring step of %s",
1681 target_pid_to_str (tp
->ptid
).c_str ());
1683 global_thread_step_over_chain_enqueue (tp
);
1684 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1687 displaced_debug_printf ("stepping %s now",
1688 target_pid_to_str (tp
->ptid
).c_str ());
1690 displaced_step_reset (displaced
);
1692 scoped_restore_current_thread restore_thread
;
1694 switch_to_thread (tp
);
1696 original
= regcache_read_pc (regcache
);
1698 copy
= gdbarch_displaced_step_location (gdbarch
);
1699 len
= gdbarch_max_insn_length (gdbarch
);
1701 if (breakpoint_in_range_p (aspace
, copy
, len
))
1703 /* There's a breakpoint set in the scratch pad location range
1704 (which is usually around the entry point). We'd either
1705 install it before resuming, which would overwrite/corrupt the
1706 scratch pad, or if it was already inserted, this displaced
1707 step would overwrite it. The latter is OK in the sense that
1708 we already assume that no thread is going to execute the code
1709 in the scratch pad range (after initial startup) anyway, but
1710 the former is unacceptable. Simply punt and fallback to
1711 stepping over this breakpoint in-line. */
1712 displaced_debug_printf ("breakpoint set in scratch pad. "
1713 "Stepping over breakpoint in-line instead.");
1715 return DISPLACED_STEP_PREPARE_STATUS_CANT
;
1718 /* Save the original contents of the copy area. */
1719 displaced
->step_saved_copy
.resize (len
);
1720 status
= target_read_memory (copy
, displaced
->step_saved_copy
.data (), len
);
1722 throw_error (MEMORY_ERROR
,
1723 _("Error accessing memory address %s (%s) for "
1724 "displaced-stepping scratch space."),
1725 paddress (gdbarch
, copy
), safe_strerror (status
));
1727 displaced_debug_printf ("saved %s: %s",
1728 paddress (gdbarch
, copy
),
1729 displaced_step_dump_bytes
1730 (displaced
->step_saved_copy
.data (), len
).c_str ());
1732 displaced
->step_closure
1733 = gdbarch_displaced_step_copy_insn (gdbarch
, original
, copy
, regcache
);
1734 if (displaced
->step_closure
== NULL
)
1736 /* The architecture doesn't know how or want to displaced step
1737 this instruction or instruction sequence. Fallback to
1738 stepping over the breakpoint in-line. */
1739 return DISPLACED_STEP_PREPARE_STATUS_CANT
;
1742 /* Save the information we need to fix things up if the step
1744 displaced
->step_thread
= tp
;
1745 displaced
->step_gdbarch
= gdbarch
;
1746 displaced
->step_original
= original
;
1747 displaced
->step_copy
= copy
;
1750 displaced_step_reset_cleanup
cleanup (displaced
);
1752 /* Resume execution at the copy. */
1753 regcache_write_pc (regcache
, copy
);
1758 displaced_debug_printf ("displaced pc to %s", paddress (gdbarch
, copy
));
1760 return DISPLACED_STEP_PREPARE_STATUS_OK
;
1763 /* Wrapper for displaced_step_prepare_throw that disabled further
1764 attempts at displaced stepping if we get a memory error. */
1766 static displaced_step_prepare_status
1767 displaced_step_prepare (thread_info
*thread
)
1769 displaced_step_prepare_status status
1770 = DISPLACED_STEP_PREPARE_STATUS_CANT
;
1774 status
= displaced_step_prepare_throw (thread
);
1776 catch (const gdb_exception_error
&ex
)
1778 if (ex
.error
!= MEMORY_ERROR
1779 && ex
.error
!= NOT_SUPPORTED_ERROR
)
1782 infrun_debug_printf ("caught exception, disabling displaced stepping: %s",
1785 /* Be verbose if "set displaced-stepping" is "on", silent if
1787 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1789 warning (_("disabling displaced stepping: %s"),
1793 /* Disable further displaced stepping attempts. */
1794 thread
->inf
->displaced_step_state
.failed_before
= 1;
1801 write_memory_ptid (ptid_t ptid
, CORE_ADDR memaddr
,
1802 const gdb_byte
*myaddr
, int len
)
1804 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1806 inferior_ptid
= ptid
;
1807 write_memory (memaddr
, myaddr
, len
);
1810 /* Restore the contents of the copy area for thread PTID. */
1813 displaced_step_restore (struct displaced_step_inferior_state
*displaced
,
1816 ULONGEST len
= gdbarch_max_insn_length (displaced
->step_gdbarch
);
1818 write_memory_ptid (ptid
, displaced
->step_copy
,
1819 displaced
->step_saved_copy
.data (), len
);
1821 displaced_debug_printf ("restored %s %s",
1822 target_pid_to_str (ptid
).c_str (),
1823 paddress (displaced
->step_gdbarch
,
1824 displaced
->step_copy
));
1827 /* If we displaced stepped an instruction successfully, adjust registers and
1828 memory to yield the same effect the instruction would have had if we had
1829 executed it at its original address, and return
1830 DISPLACED_STEP_FINISH_STATUS_OK. If the instruction didn't complete,
1831 relocate the PC and return DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED.
1833 If the thread wasn't displaced stepping, return
1834 DISPLACED_STEP_FINISH_STATUS_OK as well. */
1836 static displaced_step_finish_status
1837 displaced_step_finish (thread_info
*event_thread
, enum gdb_signal signal
)
1839 displaced_step_inferior_state
*displaced
1840 = &event_thread
->inf
->displaced_step_state
;
1842 /* Was this event for the thread we displaced? */
1843 if (displaced
->step_thread
!= event_thread
)
1844 return DISPLACED_STEP_FINISH_STATUS_OK
;
1846 /* Fixup may need to read memory/registers. Switch to the thread
1847 that we're fixing up. Also, target_stopped_by_watchpoint checks
1848 the current thread, and displaced_step_restore performs ptid-dependent
1849 memory accesses using current_inferior() and current_top_target(). */
1850 switch_to_thread (event_thread
);
1852 displaced_step_reset_cleanup
cleanup (displaced
);
1854 displaced_step_restore (displaced
, displaced
->step_thread
->ptid
);
1856 /* Did the instruction complete successfully? */
1857 if (signal
== GDB_SIGNAL_TRAP
1858 && !(target_stopped_by_watchpoint ()
1859 && (gdbarch_have_nonsteppable_watchpoint (displaced
->step_gdbarch
)
1860 || target_have_steppable_watchpoint ())))
1862 /* Fix up the resulting state. */
1863 gdbarch_displaced_step_fixup (displaced
->step_gdbarch
,
1864 displaced
->step_closure
.get (),
1865 displaced
->step_original
,
1866 displaced
->step_copy
,
1867 get_thread_regcache (displaced
->step_thread
));
1869 return DISPLACED_STEP_FINISH_STATUS_OK
;
1873 /* Since the instruction didn't complete, all we can do is
1875 struct regcache
*regcache
= get_thread_regcache (event_thread
);
1876 CORE_ADDR pc
= regcache_read_pc (regcache
);
1878 pc
= displaced
->step_original
+ (pc
- displaced
->step_copy
);
1879 regcache_write_pc (regcache
, pc
);
1881 return DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
;
1885 /* Data to be passed around while handling an event. This data is
1886 discarded between events. */
1887 struct execution_control_state
1889 process_stratum_target
*target
;
1891 /* The thread that got the event, if this was a thread event; NULL
1893 struct thread_info
*event_thread
;
1895 struct target_waitstatus ws
;
1896 int stop_func_filled_in
;
1897 CORE_ADDR stop_func_start
;
1898 CORE_ADDR stop_func_end
;
1899 const char *stop_func_name
;
1902 /* True if the event thread hit the single-step breakpoint of
1903 another thread. Thus the event doesn't cause a stop, the thread
1904 needs to be single-stepped past the single-step breakpoint before
1905 we can switch back to the original stepping thread. */
1906 int hit_singlestep_breakpoint
;
1909 /* Clear ECS and set it to point at TP. */
1912 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
1914 memset (ecs
, 0, sizeof (*ecs
));
1915 ecs
->event_thread
= tp
;
1916 ecs
->ptid
= tp
->ptid
;
1919 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
1920 static void prepare_to_wait (struct execution_control_state
*ecs
);
1921 static bool keep_going_stepped_thread (struct thread_info
*tp
);
1922 static step_over_what
thread_still_needs_step_over (struct thread_info
*tp
);
1924 /* Are there any pending step-over requests? If so, run all we can
1925 now and return true. Otherwise, return false. */
1928 start_step_over (void)
1930 struct thread_info
*tp
, *next
;
1932 /* Don't start a new step-over if we already have an in-line
1933 step-over operation ongoing. */
1934 if (step_over_info_valid_p ())
1937 for (tp
= global_thread_step_over_chain_head
; tp
!= NULL
; tp
= next
)
1939 struct execution_control_state ecss
;
1940 struct execution_control_state
*ecs
= &ecss
;
1941 step_over_what step_what
;
1942 int must_be_in_line
;
1944 gdb_assert (!tp
->stop_requested
);
1946 next
= global_thread_step_over_chain_next (tp
);
1948 /* If this inferior already has a displaced step in process,
1949 don't start a new one. */
1950 if (displaced_step_in_progress (tp
->inf
))
1953 step_what
= thread_still_needs_step_over (tp
);
1954 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
1955 || ((step_what
& STEP_OVER_BREAKPOINT
)
1956 && !use_displaced_stepping (tp
)));
1958 /* We currently stop all threads of all processes to step-over
1959 in-line. If we need to start a new in-line step-over, let
1960 any pending displaced steps finish first. */
1961 if (must_be_in_line
&& displaced_step_in_progress_any_inferior ())
1964 global_thread_step_over_chain_remove (tp
);
1966 if (global_thread_step_over_chain_head
== NULL
)
1967 infrun_debug_printf ("step-over queue now empty");
1969 if (tp
->control
.trap_expected
1973 internal_error (__FILE__
, __LINE__
,
1974 "[%s] has inconsistent state: "
1975 "trap_expected=%d, resumed=%d, executing=%d\n",
1976 target_pid_to_str (tp
->ptid
).c_str (),
1977 tp
->control
.trap_expected
,
1982 infrun_debug_printf ("resuming [%s] for step-over",
1983 target_pid_to_str (tp
->ptid
).c_str ());
1985 /* keep_going_pass_signal skips the step-over if the breakpoint
1986 is no longer inserted. In all-stop, we want to keep looking
1987 for a thread that needs a step-over instead of resuming TP,
1988 because we wouldn't be able to resume anything else until the
1989 target stops again. In non-stop, the resume always resumes
1990 only TP, so it's OK to let the thread resume freely. */
1991 if (!target_is_non_stop_p () && !step_what
)
1994 switch_to_thread (tp
);
1995 reset_ecs (ecs
, tp
);
1996 keep_going_pass_signal (ecs
);
1998 if (!ecs
->wait_some_more
)
1999 error (_("Command aborted."));
2001 gdb_assert (tp
->resumed
);
2003 /* If we started a new in-line step-over, we're done. */
2004 if (step_over_info_valid_p ())
2006 gdb_assert (tp
->control
.trap_expected
);
2010 if (!target_is_non_stop_p ())
2012 /* On all-stop, shouldn't have resumed unless we needed a
2014 gdb_assert (tp
->control
.trap_expected
2015 || tp
->step_after_step_resume_breakpoint
);
2017 /* With remote targets (at least), in all-stop, we can't
2018 issue any further remote commands until the program stops
2023 /* Either the thread no longer needed a step-over, or a new
2024 displaced stepping sequence started. Even in the latter
2025 case, continue looking. Maybe we can also start another
2026 displaced step on a thread of other process. */
2032 /* Update global variables holding ptids to hold NEW_PTID if they were
2033 holding OLD_PTID. */
2035 infrun_thread_ptid_changed (process_stratum_target
*target
,
2036 ptid_t old_ptid
, ptid_t new_ptid
)
2038 if (inferior_ptid
== old_ptid
2039 && current_inferior ()->process_target () == target
)
2040 inferior_ptid
= new_ptid
;
2045 static const char schedlock_off
[] = "off";
2046 static const char schedlock_on
[] = "on";
2047 static const char schedlock_step
[] = "step";
2048 static const char schedlock_replay
[] = "replay";
2049 static const char *const scheduler_enums
[] = {
2056 static const char *scheduler_mode
= schedlock_replay
;
2058 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2059 struct cmd_list_element
*c
, const char *value
)
2061 fprintf_filtered (file
,
2062 _("Mode for locking scheduler "
2063 "during execution is \"%s\".\n"),
2068 set_schedlock_func (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2070 if (!target_can_lock_scheduler ())
2072 scheduler_mode
= schedlock_off
;
2073 error (_("Target '%s' cannot support this command."), target_shortname
);
2077 /* True if execution commands resume all threads of all processes by
2078 default; otherwise, resume only threads of the current inferior
2080 bool sched_multi
= false;
2082 /* Try to setup for software single stepping over the specified location.
2083 Return true if target_resume() should use hardware single step.
2085 GDBARCH the current gdbarch.
2086 PC the location to step over. */
2089 maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2091 bool hw_step
= true;
2093 if (execution_direction
== EXEC_FORWARD
2094 && gdbarch_software_single_step_p (gdbarch
))
2095 hw_step
= !insert_single_step_breakpoints (gdbarch
);
2103 user_visible_resume_ptid (int step
)
2109 /* With non-stop mode on, threads are always handled
2111 resume_ptid
= inferior_ptid
;
2113 else if ((scheduler_mode
== schedlock_on
)
2114 || (scheduler_mode
== schedlock_step
&& step
))
2116 /* User-settable 'scheduler' mode requires solo thread
2118 resume_ptid
= inferior_ptid
;
2120 else if ((scheduler_mode
== schedlock_replay
)
2121 && target_record_will_replay (minus_one_ptid
, execution_direction
))
2123 /* User-settable 'scheduler' mode requires solo thread resume in replay
2125 resume_ptid
= inferior_ptid
;
2127 else if (!sched_multi
&& target_supports_multi_process ())
2129 /* Resume all threads of the current process (and none of other
2131 resume_ptid
= ptid_t (inferior_ptid
.pid ());
2135 /* Resume all threads of all processes. */
2136 resume_ptid
= RESUME_ALL
;
2144 process_stratum_target
*
2145 user_visible_resume_target (ptid_t resume_ptid
)
2147 return (resume_ptid
== minus_one_ptid
&& sched_multi
2149 : current_inferior ()->process_target ());
2152 /* Return a ptid representing the set of threads that we will resume,
2153 in the perspective of the target, assuming run control handling
2154 does not require leaving some threads stopped (e.g., stepping past
2155 breakpoint). USER_STEP indicates whether we're about to start the
2156 target for a stepping command. */
2159 internal_resume_ptid (int user_step
)
2161 /* In non-stop, we always control threads individually. Note that
2162 the target may always work in non-stop mode even with "set
2163 non-stop off", in which case user_visible_resume_ptid could
2164 return a wildcard ptid. */
2165 if (target_is_non_stop_p ())
2166 return inferior_ptid
;
2168 return user_visible_resume_ptid (user_step
);
2171 /* Wrapper for target_resume, that handles infrun-specific
2175 do_target_resume (ptid_t resume_ptid
, bool step
, enum gdb_signal sig
)
2177 struct thread_info
*tp
= inferior_thread ();
2179 gdb_assert (!tp
->stop_requested
);
2181 /* Install inferior's terminal modes. */
2182 target_terminal::inferior ();
2184 /* Avoid confusing the next resume, if the next stop/resume
2185 happens to apply to another thread. */
2186 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2188 /* Advise target which signals may be handled silently.
2190 If we have removed breakpoints because we are stepping over one
2191 in-line (in any thread), we need to receive all signals to avoid
2192 accidentally skipping a breakpoint during execution of a signal
2195 Likewise if we're displaced stepping, otherwise a trap for a
2196 breakpoint in a signal handler might be confused with the
2197 displaced step finishing. We don't make the displaced_step_finish
2198 step distinguish the cases instead, because:
2200 - a backtrace while stopped in the signal handler would show the
2201 scratch pad as frame older than the signal handler, instead of
2202 the real mainline code.
2204 - when the thread is later resumed, the signal handler would
2205 return to the scratch pad area, which would no longer be
2207 if (step_over_info_valid_p ()
2208 || displaced_step_in_progress (tp
->inf
))
2209 target_pass_signals ({});
2211 target_pass_signals (signal_pass
);
2213 target_resume (resume_ptid
, step
, sig
);
2215 target_commit_resume ();
2217 if (target_can_async_p ())
2221 /* Resume the inferior. SIG is the signal to give the inferior
2222 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2223 call 'resume', which handles exceptions. */
2226 resume_1 (enum gdb_signal sig
)
2228 struct regcache
*regcache
= get_current_regcache ();
2229 struct gdbarch
*gdbarch
= regcache
->arch ();
2230 struct thread_info
*tp
= inferior_thread ();
2231 const address_space
*aspace
= regcache
->aspace ();
2233 /* This represents the user's step vs continue request. When
2234 deciding whether "set scheduler-locking step" applies, it's the
2235 user's intention that counts. */
2236 const int user_step
= tp
->control
.stepping_command
;
2237 /* This represents what we'll actually request the target to do.
2238 This can decay from a step to a continue, if e.g., we need to
2239 implement single-stepping with breakpoints (software
2243 gdb_assert (!tp
->stop_requested
);
2244 gdb_assert (!thread_is_in_step_over_chain (tp
));
2246 if (tp
->suspend
.waitstatus_pending_p
)
2249 ("thread %s has pending wait "
2250 "status %s (currently_stepping=%d).",
2251 target_pid_to_str (tp
->ptid
).c_str (),
2252 target_waitstatus_to_string (&tp
->suspend
.waitstatus
).c_str (),
2253 currently_stepping (tp
));
2255 tp
->inf
->process_target ()->threads_executing
= true;
2258 /* FIXME: What should we do if we are supposed to resume this
2259 thread with a signal? Maybe we should maintain a queue of
2260 pending signals to deliver. */
2261 if (sig
!= GDB_SIGNAL_0
)
2263 warning (_("Couldn't deliver signal %s to %s."),
2264 gdb_signal_to_name (sig
),
2265 target_pid_to_str (tp
->ptid
).c_str ());
2268 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2270 if (target_can_async_p ())
2273 /* Tell the event loop we have an event to process. */
2274 mark_async_event_handler (infrun_async_inferior_event_token
);
2279 tp
->stepped_breakpoint
= 0;
2281 /* Depends on stepped_breakpoint. */
2282 step
= currently_stepping (tp
);
2284 if (current_inferior ()->waiting_for_vfork_done
)
2286 /* Don't try to single-step a vfork parent that is waiting for
2287 the child to get out of the shared memory region (by exec'ing
2288 or exiting). This is particularly important on software
2289 single-step archs, as the child process would trip on the
2290 software single step breakpoint inserted for the parent
2291 process. Since the parent will not actually execute any
2292 instruction until the child is out of the shared region (such
2293 are vfork's semantics), it is safe to simply continue it.
2294 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2295 the parent, and tell it to `keep_going', which automatically
2296 re-sets it stepping. */
2297 infrun_debug_printf ("resume : clear step");
2301 CORE_ADDR pc
= regcache_read_pc (regcache
);
2303 infrun_debug_printf ("step=%d, signal=%s, trap_expected=%d, "
2304 "current thread [%s] at %s",
2305 step
, gdb_signal_to_symbol_string (sig
),
2306 tp
->control
.trap_expected
,
2307 target_pid_to_str (inferior_ptid
).c_str (),
2308 paddress (gdbarch
, pc
));
2310 /* Normally, by the time we reach `resume', the breakpoints are either
2311 removed or inserted, as appropriate. The exception is if we're sitting
2312 at a permanent breakpoint; we need to step over it, but permanent
2313 breakpoints can't be removed. So we have to test for it here. */
2314 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2316 if (sig
!= GDB_SIGNAL_0
)
2318 /* We have a signal to pass to the inferior. The resume
2319 may, or may not take us to the signal handler. If this
2320 is a step, we'll need to stop in the signal handler, if
2321 there's one, (if the target supports stepping into
2322 handlers), or in the next mainline instruction, if
2323 there's no handler. If this is a continue, we need to be
2324 sure to run the handler with all breakpoints inserted.
2325 In all cases, set a breakpoint at the current address
2326 (where the handler returns to), and once that breakpoint
2327 is hit, resume skipping the permanent breakpoint. If
2328 that breakpoint isn't hit, then we've stepped into the
2329 signal handler (or hit some other event). We'll delete
2330 the step-resume breakpoint then. */
2332 infrun_debug_printf ("resume: skipping permanent breakpoint, "
2333 "deliver signal first");
2335 clear_step_over_info ();
2336 tp
->control
.trap_expected
= 0;
2338 if (tp
->control
.step_resume_breakpoint
== NULL
)
2340 /* Set a "high-priority" step-resume, as we don't want
2341 user breakpoints at PC to trigger (again) when this
2343 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2344 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2346 tp
->step_after_step_resume_breakpoint
= step
;
2349 insert_breakpoints ();
2353 /* There's no signal to pass, we can go ahead and skip the
2354 permanent breakpoint manually. */
2355 infrun_debug_printf ("skipping permanent breakpoint");
2356 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2357 /* Update pc to reflect the new address from which we will
2358 execute instructions. */
2359 pc
= regcache_read_pc (regcache
);
2363 /* We've already advanced the PC, so the stepping part
2364 is done. Now we need to arrange for a trap to be
2365 reported to handle_inferior_event. Set a breakpoint
2366 at the current PC, and run to it. Don't update
2367 prev_pc, because if we end in
2368 switch_back_to_stepped_thread, we want the "expected
2369 thread advanced also" branch to be taken. IOW, we
2370 don't want this thread to step further from PC
2372 gdb_assert (!step_over_info_valid_p ());
2373 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2374 insert_breakpoints ();
2376 resume_ptid
= internal_resume_ptid (user_step
);
2377 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
2384 /* If we have a breakpoint to step over, make sure to do a single
2385 step only. Same if we have software watchpoints. */
2386 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2387 tp
->control
.may_range_step
= 0;
2389 /* If displaced stepping is enabled, step over breakpoints by executing a
2390 copy of the instruction at a different address.
2392 We can't use displaced stepping when we have a signal to deliver;
2393 the comments for displaced_step_prepare explain why. The
2394 comments in the handle_inferior event for dealing with 'random
2395 signals' explain what we do instead.
2397 We can't use displaced stepping when we are waiting for vfork_done
2398 event, displaced stepping breaks the vfork child similarly as single
2399 step software breakpoint. */
2400 if (tp
->control
.trap_expected
2401 && use_displaced_stepping (tp
)
2402 && !step_over_info_valid_p ()
2403 && sig
== GDB_SIGNAL_0
2404 && !current_inferior ()->waiting_for_vfork_done
)
2406 displaced_step_prepare_status prepare_status
2407 = displaced_step_prepare (tp
);
2409 if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
2411 infrun_debug_printf ("Got placed in step-over queue");
2413 tp
->control
.trap_expected
= 0;
2416 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
2418 /* Fallback to stepping over the breakpoint in-line. */
2420 if (target_is_non_stop_p ())
2421 stop_all_threads ();
2423 set_step_over_info (regcache
->aspace (),
2424 regcache_read_pc (regcache
), 0, tp
->global_num
);
2426 step
= maybe_software_singlestep (gdbarch
, pc
);
2428 insert_breakpoints ();
2430 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_OK
)
2432 /* Update pc to reflect the new address from which we will
2433 execute instructions due to displaced stepping. */
2434 pc
= regcache_read_pc (get_thread_regcache (tp
));
2436 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
);
2439 gdb_assert_not_reached (_("Invalid displaced_step_prepare_status "
2443 /* Do we need to do it the hard way, w/temp breakpoints? */
2445 step
= maybe_software_singlestep (gdbarch
, pc
);
2447 /* Currently, our software single-step implementation leads to different
2448 results than hardware single-stepping in one situation: when stepping
2449 into delivering a signal which has an associated signal handler,
2450 hardware single-step will stop at the first instruction of the handler,
2451 while software single-step will simply skip execution of the handler.
2453 For now, this difference in behavior is accepted since there is no
2454 easy way to actually implement single-stepping into a signal handler
2455 without kernel support.
2457 However, there is one scenario where this difference leads to follow-on
2458 problems: if we're stepping off a breakpoint by removing all breakpoints
2459 and then single-stepping. In this case, the software single-step
2460 behavior means that even if there is a *breakpoint* in the signal
2461 handler, GDB still would not stop.
2463 Fortunately, we can at least fix this particular issue. We detect
2464 here the case where we are about to deliver a signal while software
2465 single-stepping with breakpoints removed. In this situation, we
2466 revert the decisions to remove all breakpoints and insert single-
2467 step breakpoints, and instead we install a step-resume breakpoint
2468 at the current address, deliver the signal without stepping, and
2469 once we arrive back at the step-resume breakpoint, actually step
2470 over the breakpoint we originally wanted to step over. */
2471 if (thread_has_single_step_breakpoints_set (tp
)
2472 && sig
!= GDB_SIGNAL_0
2473 && step_over_info_valid_p ())
2475 /* If we have nested signals or a pending signal is delivered
2476 immediately after a handler returns, might already have
2477 a step-resume breakpoint set on the earlier handler. We cannot
2478 set another step-resume breakpoint; just continue on until the
2479 original breakpoint is hit. */
2480 if (tp
->control
.step_resume_breakpoint
== NULL
)
2482 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2483 tp
->step_after_step_resume_breakpoint
= 1;
2486 delete_single_step_breakpoints (tp
);
2488 clear_step_over_info ();
2489 tp
->control
.trap_expected
= 0;
2491 insert_breakpoints ();
2494 /* If STEP is set, it's a request to use hardware stepping
2495 facilities. But in that case, we should never
2496 use singlestep breakpoint. */
2497 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2499 /* Decide the set of threads to ask the target to resume. */
2500 if (tp
->control
.trap_expected
)
2502 /* We're allowing a thread to run past a breakpoint it has
2503 hit, either by single-stepping the thread with the breakpoint
2504 removed, or by displaced stepping, with the breakpoint inserted.
2505 In the former case, we need to single-step only this thread,
2506 and keep others stopped, as they can miss this breakpoint if
2507 allowed to run. That's not really a problem for displaced
2508 stepping, but, we still keep other threads stopped, in case
2509 another thread is also stopped for a breakpoint waiting for
2510 its turn in the displaced stepping queue. */
2511 resume_ptid
= inferior_ptid
;
2514 resume_ptid
= internal_resume_ptid (user_step
);
2516 if (execution_direction
!= EXEC_REVERSE
2517 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2519 /* There are two cases where we currently need to step a
2520 breakpoint instruction when we have a signal to deliver:
2522 - See handle_signal_stop where we handle random signals that
2523 could take out us out of the stepping range. Normally, in
2524 that case we end up continuing (instead of stepping) over the
2525 signal handler with a breakpoint at PC, but there are cases
2526 where we should _always_ single-step, even if we have a
2527 step-resume breakpoint, like when a software watchpoint is
2528 set. Assuming single-stepping and delivering a signal at the
2529 same time would takes us to the signal handler, then we could
2530 have removed the breakpoint at PC to step over it. However,
2531 some hardware step targets (like e.g., Mac OS) can't step
2532 into signal handlers, and for those, we need to leave the
2533 breakpoint at PC inserted, as otherwise if the handler
2534 recurses and executes PC again, it'll miss the breakpoint.
2535 So we leave the breakpoint inserted anyway, but we need to
2536 record that we tried to step a breakpoint instruction, so
2537 that adjust_pc_after_break doesn't end up confused.
2539 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2540 in one thread after another thread that was stepping had been
2541 momentarily paused for a step-over. When we re-resume the
2542 stepping thread, it may be resumed from that address with a
2543 breakpoint that hasn't trapped yet. Seen with
2544 gdb.threads/non-stop-fair-events.exp, on targets that don't
2545 do displaced stepping. */
2547 infrun_debug_printf ("resume: [%s] stepped breakpoint",
2548 target_pid_to_str (tp
->ptid
).c_str ());
2550 tp
->stepped_breakpoint
= 1;
2552 /* Most targets can step a breakpoint instruction, thus
2553 executing it normally. But if this one cannot, just
2554 continue and we will hit it anyway. */
2555 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2560 && tp
->control
.trap_expected
2561 && use_displaced_stepping (tp
)
2562 && !step_over_info_valid_p ())
2564 struct regcache
*resume_regcache
= get_thread_regcache (tp
);
2565 struct gdbarch
*resume_gdbarch
= resume_regcache
->arch ();
2566 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2569 read_memory (actual_pc
, buf
, sizeof (buf
));
2570 displaced_debug_printf ("run %s: %s",
2571 paddress (resume_gdbarch
, actual_pc
),
2572 displaced_step_dump_bytes
2573 (buf
, sizeof (buf
)).c_str ());
2576 if (tp
->control
.may_range_step
)
2578 /* If we're resuming a thread with the PC out of the step
2579 range, then we're doing some nested/finer run control
2580 operation, like stepping the thread out of the dynamic
2581 linker or the displaced stepping scratch pad. We
2582 shouldn't have allowed a range step then. */
2583 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2586 do_target_resume (resume_ptid
, step
, sig
);
2590 /* Resume the inferior. SIG is the signal to give the inferior
2591 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2592 rolls back state on error. */
2595 resume (gdb_signal sig
)
2601 catch (const gdb_exception
&ex
)
2603 /* If resuming is being aborted for any reason, delete any
2604 single-step breakpoint resume_1 may have created, to avoid
2605 confusing the following resumption, and to avoid leaving
2606 single-step breakpoints perturbing other threads, in case
2607 we're running in non-stop mode. */
2608 if (inferior_ptid
!= null_ptid
)
2609 delete_single_step_breakpoints (inferior_thread ());
2619 /* Counter that tracks number of user visible stops. This can be used
2620 to tell whether a command has proceeded the inferior past the
2621 current location. This allows e.g., inferior function calls in
2622 breakpoint commands to not interrupt the command list. When the
2623 call finishes successfully, the inferior is standing at the same
2624 breakpoint as if nothing happened (and so we don't call
2626 static ULONGEST current_stop_id
;
2633 return current_stop_id
;
2636 /* Called when we report a user visible stop. */
2644 /* Clear out all variables saying what to do when inferior is continued.
2645 First do this, then set the ones you want, then call `proceed'. */
2648 clear_proceed_status_thread (struct thread_info
*tp
)
2650 infrun_debug_printf ("%s", target_pid_to_str (tp
->ptid
).c_str ());
2652 /* If we're starting a new sequence, then the previous finished
2653 single-step is no longer relevant. */
2654 if (tp
->suspend
.waitstatus_pending_p
)
2656 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
2658 infrun_debug_printf ("pending event of %s was a finished step. "
2660 target_pid_to_str (tp
->ptid
).c_str ());
2662 tp
->suspend
.waitstatus_pending_p
= 0;
2663 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
2668 ("thread %s has pending wait status %s (currently_stepping=%d).",
2669 target_pid_to_str (tp
->ptid
).c_str (),
2670 target_waitstatus_to_string (&tp
->suspend
.waitstatus
).c_str (),
2671 currently_stepping (tp
));
2675 /* If this signal should not be seen by program, give it zero.
2676 Used for debugging signals. */
2677 if (!signal_pass_state (tp
->suspend
.stop_signal
))
2678 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2680 delete tp
->thread_fsm
;
2681 tp
->thread_fsm
= NULL
;
2683 tp
->control
.trap_expected
= 0;
2684 tp
->control
.step_range_start
= 0;
2685 tp
->control
.step_range_end
= 0;
2686 tp
->control
.may_range_step
= 0;
2687 tp
->control
.step_frame_id
= null_frame_id
;
2688 tp
->control
.step_stack_frame_id
= null_frame_id
;
2689 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2690 tp
->control
.step_start_function
= NULL
;
2691 tp
->stop_requested
= 0;
2693 tp
->control
.stop_step
= 0;
2695 tp
->control
.proceed_to_finish
= 0;
2697 tp
->control
.stepping_command
= 0;
2699 /* Discard any remaining commands or status from previous stop. */
2700 bpstat_clear (&tp
->control
.stop_bpstat
);
2704 clear_proceed_status (int step
)
2706 /* With scheduler-locking replay, stop replaying other threads if we're
2707 not replaying the user-visible resume ptid.
2709 This is a convenience feature to not require the user to explicitly
2710 stop replaying the other threads. We're assuming that the user's
2711 intent is to resume tracing the recorded process. */
2712 if (!non_stop
&& scheduler_mode
== schedlock_replay
2713 && target_record_is_replaying (minus_one_ptid
)
2714 && !target_record_will_replay (user_visible_resume_ptid (step
),
2715 execution_direction
))
2716 target_record_stop_replaying ();
2718 if (!non_stop
&& inferior_ptid
!= null_ptid
)
2720 ptid_t resume_ptid
= user_visible_resume_ptid (step
);
2721 process_stratum_target
*resume_target
2722 = user_visible_resume_target (resume_ptid
);
2724 /* In all-stop mode, delete the per-thread status of all threads
2725 we're about to resume, implicitly and explicitly. */
2726 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
2727 clear_proceed_status_thread (tp
);
2730 if (inferior_ptid
!= null_ptid
)
2732 struct inferior
*inferior
;
2736 /* If in non-stop mode, only delete the per-thread status of
2737 the current thread. */
2738 clear_proceed_status_thread (inferior_thread ());
2741 inferior
= current_inferior ();
2742 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2745 gdb::observers::about_to_proceed
.notify ();
2748 /* Returns true if TP is still stopped at a breakpoint that needs
2749 stepping-over in order to make progress. If the breakpoint is gone
2750 meanwhile, we can skip the whole step-over dance. */
2753 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2755 if (tp
->stepping_over_breakpoint
)
2757 struct regcache
*regcache
= get_thread_regcache (tp
);
2759 if (breakpoint_here_p (regcache
->aspace (),
2760 regcache_read_pc (regcache
))
2761 == ordinary_breakpoint_here
)
2764 tp
->stepping_over_breakpoint
= 0;
2770 /* Check whether thread TP still needs to start a step-over in order
2771 to make progress when resumed. Returns an bitwise or of enum
2772 step_over_what bits, indicating what needs to be stepped over. */
2774 static step_over_what
2775 thread_still_needs_step_over (struct thread_info
*tp
)
2777 step_over_what what
= 0;
2779 if (thread_still_needs_step_over_bp (tp
))
2780 what
|= STEP_OVER_BREAKPOINT
;
2782 if (tp
->stepping_over_watchpoint
2783 && !target_have_steppable_watchpoint ())
2784 what
|= STEP_OVER_WATCHPOINT
;
2789 /* Returns true if scheduler locking applies. STEP indicates whether
2790 we're about to do a step/next-like command to a thread. */
2793 schedlock_applies (struct thread_info
*tp
)
2795 return (scheduler_mode
== schedlock_on
2796 || (scheduler_mode
== schedlock_step
2797 && tp
->control
.stepping_command
)
2798 || (scheduler_mode
== schedlock_replay
2799 && target_record_will_replay (minus_one_ptid
,
2800 execution_direction
)));
2803 /* Calls target_commit_resume on all targets. */
2806 commit_resume_all_targets ()
2808 scoped_restore_current_thread restore_thread
;
2810 /* Map between process_target and a representative inferior. This
2811 is to avoid committing a resume in the same target more than
2812 once. Resumptions must be idempotent, so this is an
2814 std::unordered_map
<process_stratum_target
*, inferior
*> conn_inf
;
2816 for (inferior
*inf
: all_non_exited_inferiors ())
2817 if (inf
->has_execution ())
2818 conn_inf
[inf
->process_target ()] = inf
;
2820 for (const auto &ci
: conn_inf
)
2822 inferior
*inf
= ci
.second
;
2823 switch_to_inferior_no_thread (inf
);
2824 target_commit_resume ();
2828 /* Check that all the targets we're about to resume are in non-stop
2829 mode. Ideally, we'd only care whether all targets support
2830 target-async, but we're not there yet. E.g., stop_all_threads
2831 doesn't know how to handle all-stop targets. Also, the remote
2832 protocol in all-stop mode is synchronous, irrespective of
2833 target-async, which means that things like a breakpoint re-set
2834 triggered by one target would try to read memory from all targets
2838 check_multi_target_resumption (process_stratum_target
*resume_target
)
2840 if (!non_stop
&& resume_target
== nullptr)
2842 scoped_restore_current_thread restore_thread
;
2844 /* This is used to track whether we're resuming more than one
2846 process_stratum_target
*first_connection
= nullptr;
2848 /* The first inferior we see with a target that does not work in
2849 always-non-stop mode. */
2850 inferior
*first_not_non_stop
= nullptr;
2852 for (inferior
*inf
: all_non_exited_inferiors (resume_target
))
2854 switch_to_inferior_no_thread (inf
);
2856 if (!target_has_execution ())
2859 process_stratum_target
*proc_target
2860 = current_inferior ()->process_target();
2862 if (!target_is_non_stop_p ())
2863 first_not_non_stop
= inf
;
2865 if (first_connection
== nullptr)
2866 first_connection
= proc_target
;
2867 else if (first_connection
!= proc_target
2868 && first_not_non_stop
!= nullptr)
2870 switch_to_inferior_no_thread (first_not_non_stop
);
2872 proc_target
= current_inferior ()->process_target();
2874 error (_("Connection %d (%s) does not support "
2875 "multi-target resumption."),
2876 proc_target
->connection_number
,
2877 make_target_connection_string (proc_target
).c_str ());
2883 /* Basic routine for continuing the program in various fashions.
2885 ADDR is the address to resume at, or -1 for resume where stopped.
2886 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
2887 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
2889 You should call clear_proceed_status before calling proceed. */
2892 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
2894 struct regcache
*regcache
;
2895 struct gdbarch
*gdbarch
;
2897 struct execution_control_state ecss
;
2898 struct execution_control_state
*ecs
= &ecss
;
2901 /* If we're stopped at a fork/vfork, follow the branch set by the
2902 "set follow-fork-mode" command; otherwise, we'll just proceed
2903 resuming the current thread. */
2904 if (!follow_fork ())
2906 /* The target for some reason decided not to resume. */
2908 if (target_can_async_p ())
2909 inferior_event_handler (INF_EXEC_COMPLETE
);
2913 /* We'll update this if & when we switch to a new thread. */
2914 previous_inferior_ptid
= inferior_ptid
;
2916 regcache
= get_current_regcache ();
2917 gdbarch
= regcache
->arch ();
2918 const address_space
*aspace
= regcache
->aspace ();
2920 pc
= regcache_read_pc_protected (regcache
);
2922 thread_info
*cur_thr
= inferior_thread ();
2924 /* Fill in with reasonable starting values. */
2925 init_thread_stepping_state (cur_thr
);
2927 gdb_assert (!thread_is_in_step_over_chain (cur_thr
));
2930 = user_visible_resume_ptid (cur_thr
->control
.stepping_command
);
2931 process_stratum_target
*resume_target
2932 = user_visible_resume_target (resume_ptid
);
2934 check_multi_target_resumption (resume_target
);
2936 if (addr
== (CORE_ADDR
) -1)
2938 if (pc
== cur_thr
->suspend
.stop_pc
2939 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
2940 && execution_direction
!= EXEC_REVERSE
)
2941 /* There is a breakpoint at the address we will resume at,
2942 step one instruction before inserting breakpoints so that
2943 we do not stop right away (and report a second hit at this
2946 Note, we don't do this in reverse, because we won't
2947 actually be executing the breakpoint insn anyway.
2948 We'll be (un-)executing the previous instruction. */
2949 cur_thr
->stepping_over_breakpoint
= 1;
2950 else if (gdbarch_single_step_through_delay_p (gdbarch
)
2951 && gdbarch_single_step_through_delay (gdbarch
,
2952 get_current_frame ()))
2953 /* We stepped onto an instruction that needs to be stepped
2954 again before re-inserting the breakpoint, do so. */
2955 cur_thr
->stepping_over_breakpoint
= 1;
2959 regcache_write_pc (regcache
, addr
);
2962 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
2963 cur_thr
->suspend
.stop_signal
= siggnal
;
2965 /* If an exception is thrown from this point on, make sure to
2966 propagate GDB's knowledge of the executing state to the
2967 frontend/user running state. */
2968 scoped_finish_thread_state
finish_state (resume_target
, resume_ptid
);
2970 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
2971 threads (e.g., we might need to set threads stepping over
2972 breakpoints first), from the user/frontend's point of view, all
2973 threads in RESUME_PTID are now running. Unless we're calling an
2974 inferior function, as in that case we pretend the inferior
2975 doesn't run at all. */
2976 if (!cur_thr
->control
.in_infcall
)
2977 set_running (resume_target
, resume_ptid
, true);
2979 infrun_debug_printf ("addr=%s, signal=%s", paddress (gdbarch
, addr
),
2980 gdb_signal_to_symbol_string (siggnal
));
2982 annotate_starting ();
2984 /* Make sure that output from GDB appears before output from the
2986 gdb_flush (gdb_stdout
);
2988 /* Since we've marked the inferior running, give it the terminal. A
2989 QUIT/Ctrl-C from here on is forwarded to the target (which can
2990 still detect attempts to unblock a stuck connection with repeated
2991 Ctrl-C from within target_pass_ctrlc). */
2992 target_terminal::inferior ();
2994 /* In a multi-threaded task we may select another thread and
2995 then continue or step.
2997 But if a thread that we're resuming had stopped at a breakpoint,
2998 it will immediately cause another breakpoint stop without any
2999 execution (i.e. it will report a breakpoint hit incorrectly). So
3000 we must step over it first.
3002 Look for threads other than the current (TP) that reported a
3003 breakpoint hit and haven't been resumed yet since. */
3005 /* If scheduler locking applies, we can avoid iterating over all
3007 if (!non_stop
&& !schedlock_applies (cur_thr
))
3009 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3012 switch_to_thread_no_regs (tp
);
3014 /* Ignore the current thread here. It's handled
3019 if (!thread_still_needs_step_over (tp
))
3022 gdb_assert (!thread_is_in_step_over_chain (tp
));
3024 infrun_debug_printf ("need to step-over [%s] first",
3025 target_pid_to_str (tp
->ptid
).c_str ());
3027 global_thread_step_over_chain_enqueue (tp
);
3030 switch_to_thread (cur_thr
);
3033 /* Enqueue the current thread last, so that we move all other
3034 threads over their breakpoints first. */
3035 if (cur_thr
->stepping_over_breakpoint
)
3036 global_thread_step_over_chain_enqueue (cur_thr
);
3038 /* If the thread isn't started, we'll still need to set its prev_pc,
3039 so that switch_back_to_stepped_thread knows the thread hasn't
3040 advanced. Must do this before resuming any thread, as in
3041 all-stop/remote, once we resume we can't send any other packet
3042 until the target stops again. */
3043 cur_thr
->prev_pc
= regcache_read_pc_protected (regcache
);
3046 scoped_restore save_defer_tc
= make_scoped_defer_target_commit_resume ();
3048 started
= start_step_over ();
3050 if (step_over_info_valid_p ())
3052 /* Either this thread started a new in-line step over, or some
3053 other thread was already doing one. In either case, don't
3054 resume anything else until the step-over is finished. */
3056 else if (started
&& !target_is_non_stop_p ())
3058 /* A new displaced stepping sequence was started. In all-stop,
3059 we can't talk to the target anymore until it next stops. */
3061 else if (!non_stop
&& target_is_non_stop_p ())
3063 /* In all-stop, but the target is always in non-stop mode.
3064 Start all other threads that are implicitly resumed too. */
3065 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3068 switch_to_thread_no_regs (tp
);
3070 if (!tp
->inf
->has_execution ())
3072 infrun_debug_printf ("[%s] target has no execution",
3073 target_pid_to_str (tp
->ptid
).c_str ());
3079 infrun_debug_printf ("[%s] resumed",
3080 target_pid_to_str (tp
->ptid
).c_str ());
3081 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
3085 if (thread_is_in_step_over_chain (tp
))
3087 infrun_debug_printf ("[%s] needs step-over",
3088 target_pid_to_str (tp
->ptid
).c_str ());
3092 infrun_debug_printf ("resuming %s",
3093 target_pid_to_str (tp
->ptid
).c_str ());
3095 reset_ecs (ecs
, tp
);
3096 switch_to_thread (tp
);
3097 keep_going_pass_signal (ecs
);
3098 if (!ecs
->wait_some_more
)
3099 error (_("Command aborted."));
3102 else if (!cur_thr
->resumed
&& !thread_is_in_step_over_chain (cur_thr
))
3104 /* The thread wasn't started, and isn't queued, run it now. */
3105 reset_ecs (ecs
, cur_thr
);
3106 switch_to_thread (cur_thr
);
3107 keep_going_pass_signal (ecs
);
3108 if (!ecs
->wait_some_more
)
3109 error (_("Command aborted."));
3113 commit_resume_all_targets ();
3115 finish_state
.release ();
3117 /* If we've switched threads above, switch back to the previously
3118 current thread. We don't want the user to see a different
3120 switch_to_thread (cur_thr
);
3122 /* Tell the event loop to wait for it to stop. If the target
3123 supports asynchronous execution, it'll do this from within
3125 if (!target_can_async_p ())
3126 mark_async_event_handler (infrun_async_inferior_event_token
);
3130 /* Start remote-debugging of a machine over a serial link. */
3133 start_remote (int from_tty
)
3135 inferior
*inf
= current_inferior ();
3136 inf
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3138 /* Always go on waiting for the target, regardless of the mode. */
3139 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3140 indicate to wait_for_inferior that a target should timeout if
3141 nothing is returned (instead of just blocking). Because of this,
3142 targets expecting an immediate response need to, internally, set
3143 things up so that the target_wait() is forced to eventually
3145 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3146 differentiate to its caller what the state of the target is after
3147 the initial open has been performed. Here we're assuming that
3148 the target has stopped. It should be possible to eventually have
3149 target_open() return to the caller an indication that the target
3150 is currently running and GDB state should be set to the same as
3151 for an async run. */
3152 wait_for_inferior (inf
);
3154 /* Now that the inferior has stopped, do any bookkeeping like
3155 loading shared libraries. We want to do this before normal_stop,
3156 so that the displayed frame is up to date. */
3157 post_create_inferior (from_tty
);
3162 /* Initialize static vars when a new inferior begins. */
3165 init_wait_for_inferior (void)
3167 /* These are meaningless until the first time through wait_for_inferior. */
3169 breakpoint_init_inferior (inf_starting
);
3171 clear_proceed_status (0);
3173 nullify_last_target_wait_ptid ();
3175 previous_inferior_ptid
= inferior_ptid
;
3180 static void handle_inferior_event (struct execution_control_state
*ecs
);
3182 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3183 struct execution_control_state
*ecs
);
3184 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3185 struct execution_control_state
*ecs
);
3186 static void handle_signal_stop (struct execution_control_state
*ecs
);
3187 static void check_exception_resume (struct execution_control_state
*,
3188 struct frame_info
*);
3190 static void end_stepping_range (struct execution_control_state
*ecs
);
3191 static void stop_waiting (struct execution_control_state
*ecs
);
3192 static void keep_going (struct execution_control_state
*ecs
);
3193 static void process_event_stop_test (struct execution_control_state
*ecs
);
3194 static bool switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3196 /* This function is attached as a "thread_stop_requested" observer.
3197 Cleanup local state that assumed the PTID was to be resumed, and
3198 report the stop to the frontend. */
3201 infrun_thread_stop_requested (ptid_t ptid
)
3203 process_stratum_target
*curr_target
= current_inferior ()->process_target ();
3205 /* PTID was requested to stop. If the thread was already stopped,
3206 but the user/frontend doesn't know about that yet (e.g., the
3207 thread had been temporarily paused for some step-over), set up
3208 for reporting the stop now. */
3209 for (thread_info
*tp
: all_threads (curr_target
, ptid
))
3211 if (tp
->state
!= THREAD_RUNNING
)
3216 /* Remove matching threads from the step-over queue, so
3217 start_step_over doesn't try to resume them
3219 if (thread_is_in_step_over_chain (tp
))
3220 global_thread_step_over_chain_remove (tp
);
3222 /* If the thread is stopped, but the user/frontend doesn't
3223 know about that yet, queue a pending event, as if the
3224 thread had just stopped now. Unless the thread already had
3226 if (!tp
->suspend
.waitstatus_pending_p
)
3228 tp
->suspend
.waitstatus_pending_p
= 1;
3229 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_STOPPED
;
3230 tp
->suspend
.waitstatus
.value
.sig
= GDB_SIGNAL_0
;
3233 /* Clear the inline-frame state, since we're re-processing the
3235 clear_inline_frame_state (tp
);
3237 /* If this thread was paused because some other thread was
3238 doing an inline-step over, let that finish first. Once
3239 that happens, we'll restart all threads and consume pending
3240 stop events then. */
3241 if (step_over_info_valid_p ())
3244 /* Otherwise we can process the (new) pending event now. Set
3245 it so this pending event is considered by
3252 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3254 if (target_last_proc_target
== tp
->inf
->process_target ()
3255 && target_last_wait_ptid
== tp
->ptid
)
3256 nullify_last_target_wait_ptid ();
3259 /* Delete the step resume, single-step and longjmp/exception resume
3260 breakpoints of TP. */
3263 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3265 delete_step_resume_breakpoint (tp
);
3266 delete_exception_resume_breakpoint (tp
);
3267 delete_single_step_breakpoints (tp
);
3270 /* If the target still has execution, call FUNC for each thread that
3271 just stopped. In all-stop, that's all the non-exited threads; in
3272 non-stop, that's the current thread, only. */
3274 typedef void (*for_each_just_stopped_thread_callback_func
)
3275 (struct thread_info
*tp
);
3278 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3280 if (!target_has_execution () || inferior_ptid
== null_ptid
)
3283 if (target_is_non_stop_p ())
3285 /* If in non-stop mode, only the current thread stopped. */
3286 func (inferior_thread ());
3290 /* In all-stop mode, all threads have stopped. */
3291 for (thread_info
*tp
: all_non_exited_threads ())
3296 /* Delete the step resume and longjmp/exception resume breakpoints of
3297 the threads that just stopped. */
3300 delete_just_stopped_threads_infrun_breakpoints (void)
3302 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3305 /* Delete the single-step breakpoints of the threads that just
3309 delete_just_stopped_threads_single_step_breakpoints (void)
3311 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3317 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3318 const struct target_waitstatus
*ws
)
3320 std::string status_string
= target_waitstatus_to_string (ws
);
3323 /* The text is split over several lines because it was getting too long.
3324 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3325 output as a unit; we want only one timestamp printed if debug_timestamp
3328 stb
.printf ("[infrun] target_wait (%d.%ld.%ld",
3331 waiton_ptid
.tid ());
3332 if (waiton_ptid
.pid () != -1)
3333 stb
.printf (" [%s]", target_pid_to_str (waiton_ptid
).c_str ());
3334 stb
.printf (", status) =\n");
3335 stb
.printf ("[infrun] %d.%ld.%ld [%s],\n",
3339 target_pid_to_str (result_ptid
).c_str ());
3340 stb
.printf ("[infrun] %s\n", status_string
.c_str ());
3342 /* This uses %s in part to handle %'s in the text, but also to avoid
3343 a gcc error: the format attribute requires a string literal. */
3344 fprintf_unfiltered (gdb_stdlog
, "%s", stb
.c_str ());
3347 /* Select a thread at random, out of those which are resumed and have
3350 static struct thread_info
*
3351 random_pending_event_thread (inferior
*inf
, ptid_t waiton_ptid
)
3355 auto has_event
= [&] (thread_info
*tp
)
3357 return (tp
->ptid
.matches (waiton_ptid
)
3359 && tp
->suspend
.waitstatus_pending_p
);
3362 /* First see how many events we have. Count only resumed threads
3363 that have an event pending. */
3364 for (thread_info
*tp
: inf
->non_exited_threads ())
3368 if (num_events
== 0)
3371 /* Now randomly pick a thread out of those that have had events. */
3372 int random_selector
= (int) ((num_events
* (double) rand ())
3373 / (RAND_MAX
+ 1.0));
3376 infrun_debug_printf ("Found %d events, selecting #%d",
3377 num_events
, random_selector
);
3379 /* Select the Nth thread that has had an event. */
3380 for (thread_info
*tp
: inf
->non_exited_threads ())
3382 if (random_selector
-- == 0)
3385 gdb_assert_not_reached ("event thread not found");
3388 /* Wrapper for target_wait that first checks whether threads have
3389 pending statuses to report before actually asking the target for
3390 more events. INF is the inferior we're using to call target_wait
3394 do_target_wait_1 (inferior
*inf
, ptid_t ptid
,
3395 target_waitstatus
*status
, target_wait_flags options
)
3398 struct thread_info
*tp
;
3400 /* We know that we are looking for an event in the target of inferior
3401 INF, but we don't know which thread the event might come from. As
3402 such we want to make sure that INFERIOR_PTID is reset so that none of
3403 the wait code relies on it - doing so is always a mistake. */
3404 switch_to_inferior_no_thread (inf
);
3406 /* First check if there is a resumed thread with a wait status
3408 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
3410 tp
= random_pending_event_thread (inf
, ptid
);
3414 infrun_debug_printf ("Waiting for specific thread %s.",
3415 target_pid_to_str (ptid
).c_str ());
3417 /* We have a specific thread to check. */
3418 tp
= find_thread_ptid (inf
, ptid
);
3419 gdb_assert (tp
!= NULL
);
3420 if (!tp
->suspend
.waitstatus_pending_p
)
3425 && (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3426 || tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
3428 struct regcache
*regcache
= get_thread_regcache (tp
);
3429 struct gdbarch
*gdbarch
= regcache
->arch ();
3433 pc
= regcache_read_pc (regcache
);
3435 if (pc
!= tp
->suspend
.stop_pc
)
3437 infrun_debug_printf ("PC of %s changed. was=%s, now=%s",
3438 target_pid_to_str (tp
->ptid
).c_str (),
3439 paddress (gdbarch
, tp
->suspend
.stop_pc
),
3440 paddress (gdbarch
, pc
));
3443 else if (!breakpoint_inserted_here_p (regcache
->aspace (), pc
))
3445 infrun_debug_printf ("previous breakpoint of %s, at %s gone",
3446 target_pid_to_str (tp
->ptid
).c_str (),
3447 paddress (gdbarch
, pc
));
3454 infrun_debug_printf ("pending event of %s cancelled.",
3455 target_pid_to_str (tp
->ptid
).c_str ());
3457 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_SPURIOUS
;
3458 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3464 infrun_debug_printf ("Using pending wait status %s for %s.",
3465 target_waitstatus_to_string
3466 (&tp
->suspend
.waitstatus
).c_str (),
3467 target_pid_to_str (tp
->ptid
).c_str ());
3469 /* Now that we've selected our final event LWP, un-adjust its PC
3470 if it was a software breakpoint (and the target doesn't
3471 always adjust the PC itself). */
3472 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3473 && !target_supports_stopped_by_sw_breakpoint ())
3475 struct regcache
*regcache
;
3476 struct gdbarch
*gdbarch
;
3479 regcache
= get_thread_regcache (tp
);
3480 gdbarch
= regcache
->arch ();
3482 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3487 pc
= regcache_read_pc (regcache
);
3488 regcache_write_pc (regcache
, pc
+ decr_pc
);
3492 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3493 *status
= tp
->suspend
.waitstatus
;
3494 tp
->suspend
.waitstatus_pending_p
= 0;
3496 /* Wake up the event loop again, until all pending events are
3498 if (target_is_async_p ())
3499 mark_async_event_handler (infrun_async_inferior_event_token
);
3503 /* But if we don't find one, we'll have to wait. */
3505 /* We can't ask a non-async target to do a non-blocking wait, so this will be
3507 if (!target_can_async_p ())
3508 options
&= ~TARGET_WNOHANG
;
3510 if (deprecated_target_wait_hook
)
3511 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3513 event_ptid
= target_wait (ptid
, status
, options
);
3518 /* Wrapper for target_wait that first checks whether threads have
3519 pending statuses to report before actually asking the target for
3520 more events. Polls for events from all inferiors/targets. */
3523 do_target_wait (ptid_t wait_ptid
, execution_control_state
*ecs
,
3524 target_wait_flags options
)
3526 int num_inferiors
= 0;
3527 int random_selector
;
3529 /* For fairness, we pick the first inferior/target to poll at random
3530 out of all inferiors that may report events, and then continue
3531 polling the rest of the inferior list starting from that one in a
3532 circular fashion until the whole list is polled once. */
3534 auto inferior_matches
= [&wait_ptid
] (inferior
*inf
)
3536 return (inf
->process_target () != NULL
3537 && ptid_t (inf
->pid
).matches (wait_ptid
));
3540 /* First see how many matching inferiors we have. */
3541 for (inferior
*inf
: all_inferiors ())
3542 if (inferior_matches (inf
))
3545 if (num_inferiors
== 0)
3547 ecs
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
3551 /* Now randomly pick an inferior out of those that matched. */
3552 random_selector
= (int)
3553 ((num_inferiors
* (double) rand ()) / (RAND_MAX
+ 1.0));
3555 if (num_inferiors
> 1)
3556 infrun_debug_printf ("Found %d inferiors, starting at #%d",
3557 num_inferiors
, random_selector
);
3559 /* Select the Nth inferior that matched. */
3561 inferior
*selected
= nullptr;
3563 for (inferior
*inf
: all_inferiors ())
3564 if (inferior_matches (inf
))
3565 if (random_selector
-- == 0)
3571 /* Now poll for events out of each of the matching inferior's
3572 targets, starting from the selected one. */
3574 auto do_wait
= [&] (inferior
*inf
)
3576 ecs
->ptid
= do_target_wait_1 (inf
, wait_ptid
, &ecs
->ws
, options
);
3577 ecs
->target
= inf
->process_target ();
3578 return (ecs
->ws
.kind
!= TARGET_WAITKIND_IGNORE
);
3581 /* Needed in 'all-stop + target-non-stop' mode, because we end up
3582 here spuriously after the target is all stopped and we've already
3583 reported the stop to the user, polling for events. */
3584 scoped_restore_current_thread restore_thread
;
3586 int inf_num
= selected
->num
;
3587 for (inferior
*inf
= selected
; inf
!= NULL
; inf
= inf
->next
)
3588 if (inferior_matches (inf
))
3592 for (inferior
*inf
= inferior_list
;
3593 inf
!= NULL
&& inf
->num
< inf_num
;
3595 if (inferior_matches (inf
))
3599 ecs
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
3603 /* Prepare and stabilize the inferior for detaching it. E.g.,
3604 detaching while a thread is displaced stepping is a recipe for
3605 crashing it, as nothing would readjust the PC out of the scratch
3609 prepare_for_detach (void)
3611 struct inferior
*inf
= current_inferior ();
3612 ptid_t pid_ptid
= ptid_t (inf
->pid
);
3614 displaced_step_inferior_state
*displaced
= &inf
->displaced_step_state
;
3616 /* Is any thread of this process displaced stepping? If not,
3617 there's nothing else to do. */
3618 if (displaced
->step_thread
== nullptr)
3621 infrun_debug_printf ("displaced-stepping in-process while detaching");
3623 scoped_restore restore_detaching
= make_scoped_restore (&inf
->detaching
, true);
3625 while (displaced
->step_thread
!= nullptr)
3627 struct execution_control_state ecss
;
3628 struct execution_control_state
*ecs
;
3631 memset (ecs
, 0, sizeof (*ecs
));
3633 overlay_cache_invalid
= 1;
3634 /* Flush target cache before starting to handle each event.
3635 Target was running and cache could be stale. This is just a
3636 heuristic. Running threads may modify target memory, but we
3637 don't get any event. */
3638 target_dcache_invalidate ();
3640 do_target_wait (pid_ptid
, ecs
, 0);
3643 print_target_wait_results (pid_ptid
, ecs
->ptid
, &ecs
->ws
);
3645 /* If an error happens while handling the event, propagate GDB's
3646 knowledge of the executing state to the frontend/user running
3648 scoped_finish_thread_state
finish_state (inf
->process_target (),
3651 /* Now figure out what to do with the result of the result. */
3652 handle_inferior_event (ecs
);
3654 /* No error, don't finish the state yet. */
3655 finish_state
.release ();
3657 /* Breakpoints and watchpoints are not installed on the target
3658 at this point, and signals are passed directly to the
3659 inferior, so this must mean the process is gone. */
3660 if (!ecs
->wait_some_more
)
3662 restore_detaching
.release ();
3663 error (_("Program exited while detaching"));
3667 restore_detaching
.release ();
3670 /* Wait for control to return from inferior to debugger.
3672 If inferior gets a signal, we may decide to start it up again
3673 instead of returning. That is why there is a loop in this function.
3674 When this function actually returns it means the inferior
3675 should be left stopped and GDB should read more commands. */
3678 wait_for_inferior (inferior
*inf
)
3680 infrun_debug_printf ("wait_for_inferior ()");
3682 SCOPE_EXIT
{ delete_just_stopped_threads_infrun_breakpoints (); };
3684 /* If an error happens while handling the event, propagate GDB's
3685 knowledge of the executing state to the frontend/user running
3687 scoped_finish_thread_state finish_state
3688 (inf
->process_target (), minus_one_ptid
);
3692 struct execution_control_state ecss
;
3693 struct execution_control_state
*ecs
= &ecss
;
3695 memset (ecs
, 0, sizeof (*ecs
));
3697 overlay_cache_invalid
= 1;
3699 /* Flush target cache before starting to handle each event.
3700 Target was running and cache could be stale. This is just a
3701 heuristic. Running threads may modify target memory, but we
3702 don't get any event. */
3703 target_dcache_invalidate ();
3705 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, 0);
3706 ecs
->target
= inf
->process_target ();
3709 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, &ecs
->ws
);
3711 /* Now figure out what to do with the result of the result. */
3712 handle_inferior_event (ecs
);
3714 if (!ecs
->wait_some_more
)
3718 /* No error, don't finish the state yet. */
3719 finish_state
.release ();
3722 /* Cleanup that reinstalls the readline callback handler, if the
3723 target is running in the background. If while handling the target
3724 event something triggered a secondary prompt, like e.g., a
3725 pagination prompt, we'll have removed the callback handler (see
3726 gdb_readline_wrapper_line). Need to do this as we go back to the
3727 event loop, ready to process further input. Note this has no
3728 effect if the handler hasn't actually been removed, because calling
3729 rl_callback_handler_install resets the line buffer, thus losing
3733 reinstall_readline_callback_handler_cleanup ()
3735 struct ui
*ui
= current_ui
;
3739 /* We're not going back to the top level event loop yet. Don't
3740 install the readline callback, as it'd prep the terminal,
3741 readline-style (raw, noecho) (e.g., --batch). We'll install
3742 it the next time the prompt is displayed, when we're ready
3747 if (ui
->command_editing
&& ui
->prompt_state
!= PROMPT_BLOCKED
)
3748 gdb_rl_callback_handler_reinstall ();
3751 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3752 that's just the event thread. In all-stop, that's all threads. */
3755 clean_up_just_stopped_threads_fsms (struct execution_control_state
*ecs
)
3757 if (ecs
->event_thread
!= NULL
3758 && ecs
->event_thread
->thread_fsm
!= NULL
)
3759 ecs
->event_thread
->thread_fsm
->clean_up (ecs
->event_thread
);
3763 for (thread_info
*thr
: all_non_exited_threads ())
3765 if (thr
->thread_fsm
== NULL
)
3767 if (thr
== ecs
->event_thread
)
3770 switch_to_thread (thr
);
3771 thr
->thread_fsm
->clean_up (thr
);
3774 if (ecs
->event_thread
!= NULL
)
3775 switch_to_thread (ecs
->event_thread
);
3779 /* Helper for all_uis_check_sync_execution_done that works on the
3783 check_curr_ui_sync_execution_done (void)
3785 struct ui
*ui
= current_ui
;
3787 if (ui
->prompt_state
== PROMPT_NEEDED
3789 && !gdb_in_secondary_prompt_p (ui
))
3791 target_terminal::ours ();
3792 gdb::observers::sync_execution_done
.notify ();
3793 ui_register_input_event_handler (ui
);
3800 all_uis_check_sync_execution_done (void)
3802 SWITCH_THRU_ALL_UIS ()
3804 check_curr_ui_sync_execution_done ();
3811 all_uis_on_sync_execution_starting (void)
3813 SWITCH_THRU_ALL_UIS ()
3815 if (current_ui
->prompt_state
== PROMPT_NEEDED
)
3816 async_disable_stdin ();
3820 /* Asynchronous version of wait_for_inferior. It is called by the
3821 event loop whenever a change of state is detected on the file
3822 descriptor corresponding to the target. It can be called more than
3823 once to complete a single execution command. In such cases we need
3824 to keep the state in a global variable ECSS. If it is the last time
3825 that this function is called for a single execution command, then
3826 report to the user that the inferior has stopped, and do the
3827 necessary cleanups. */
3830 fetch_inferior_event ()
3832 struct execution_control_state ecss
;
3833 struct execution_control_state
*ecs
= &ecss
;
3836 memset (ecs
, 0, sizeof (*ecs
));
3838 /* Events are always processed with the main UI as current UI. This
3839 way, warnings, debug output, etc. are always consistently sent to
3840 the main console. */
3841 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, main_ui
);
3843 /* Temporarily disable pagination. Otherwise, the user would be
3844 given an option to press 'q' to quit, which would cause an early
3845 exit and could leave GDB in a half-baked state. */
3846 scoped_restore save_pagination
3847 = make_scoped_restore (&pagination_enabled
, false);
3849 /* End up with readline processing input, if necessary. */
3851 SCOPE_EXIT
{ reinstall_readline_callback_handler_cleanup (); };
3853 /* We're handling a live event, so make sure we're doing live
3854 debugging. If we're looking at traceframes while the target is
3855 running, we're going to need to get back to that mode after
3856 handling the event. */
3857 gdb::optional
<scoped_restore_current_traceframe
> maybe_restore_traceframe
;
3860 maybe_restore_traceframe
.emplace ();
3861 set_current_traceframe (-1);
3864 /* The user/frontend should not notice a thread switch due to
3865 internal events. Make sure we revert to the user selected
3866 thread and frame after handling the event and running any
3867 breakpoint commands. */
3868 scoped_restore_current_thread restore_thread
;
3870 overlay_cache_invalid
= 1;
3871 /* Flush target cache before starting to handle each event. Target
3872 was running and cache could be stale. This is just a heuristic.
3873 Running threads may modify target memory, but we don't get any
3875 target_dcache_invalidate ();
3877 scoped_restore save_exec_dir
3878 = make_scoped_restore (&execution_direction
,
3879 target_execution_direction ());
3881 if (!do_target_wait (minus_one_ptid
, ecs
, TARGET_WNOHANG
))
3884 gdb_assert (ecs
->ws
.kind
!= TARGET_WAITKIND_IGNORE
);
3886 /* Switch to the target that generated the event, so we can do
3888 switch_to_target_no_thread (ecs
->target
);
3891 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, &ecs
->ws
);
3893 /* If an error happens while handling the event, propagate GDB's
3894 knowledge of the executing state to the frontend/user running
3896 ptid_t finish_ptid
= !target_is_non_stop_p () ? minus_one_ptid
: ecs
->ptid
;
3897 scoped_finish_thread_state
finish_state (ecs
->target
, finish_ptid
);
3899 /* Get executed before scoped_restore_current_thread above to apply
3900 still for the thread which has thrown the exception. */
3901 auto defer_bpstat_clear
3902 = make_scope_exit (bpstat_clear_actions
);
3903 auto defer_delete_threads
3904 = make_scope_exit (delete_just_stopped_threads_infrun_breakpoints
);
3906 /* Now figure out what to do with the result of the result. */
3907 handle_inferior_event (ecs
);
3909 if (!ecs
->wait_some_more
)
3911 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
3912 bool should_stop
= true;
3913 struct thread_info
*thr
= ecs
->event_thread
;
3915 delete_just_stopped_threads_infrun_breakpoints ();
3919 struct thread_fsm
*thread_fsm
= thr
->thread_fsm
;
3921 if (thread_fsm
!= NULL
)
3922 should_stop
= thread_fsm
->should_stop (thr
);
3931 bool should_notify_stop
= true;
3934 clean_up_just_stopped_threads_fsms (ecs
);
3936 if (thr
!= NULL
&& thr
->thread_fsm
!= NULL
)
3937 should_notify_stop
= thr
->thread_fsm
->should_notify_stop ();
3939 if (should_notify_stop
)
3941 /* We may not find an inferior if this was a process exit. */
3942 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
3943 proceeded
= normal_stop ();
3948 inferior_event_handler (INF_EXEC_COMPLETE
);
3952 /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
3953 previously selected thread is gone. We have two
3954 choices - switch to no thread selected, or restore the
3955 previously selected thread (now exited). We chose the
3956 later, just because that's what GDB used to do. After
3957 this, "info threads" says "The current thread <Thread
3958 ID 2> has terminated." instead of "No thread
3962 && ecs
->ws
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
3963 restore_thread
.dont_restore ();
3967 defer_delete_threads
.release ();
3968 defer_bpstat_clear
.release ();
3970 /* No error, don't finish the thread states yet. */
3971 finish_state
.release ();
3973 /* This scope is used to ensure that readline callbacks are
3974 reinstalled here. */
3977 /* If a UI was in sync execution mode, and now isn't, restore its
3978 prompt (a synchronous execution command has finished, and we're
3979 ready for input). */
3980 all_uis_check_sync_execution_done ();
3983 && exec_done_display_p
3984 && (inferior_ptid
== null_ptid
3985 || inferior_thread ()->state
!= THREAD_RUNNING
))
3986 printf_unfiltered (_("completed.\n"));
3992 set_step_info (thread_info
*tp
, struct frame_info
*frame
,
3993 struct symtab_and_line sal
)
3995 /* This can be removed once this function no longer implicitly relies on the
3996 inferior_ptid value. */
3997 gdb_assert (inferior_ptid
== tp
->ptid
);
3999 tp
->control
.step_frame_id
= get_frame_id (frame
);
4000 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
4002 tp
->current_symtab
= sal
.symtab
;
4003 tp
->current_line
= sal
.line
;
4006 /* Clear context switchable stepping state. */
4009 init_thread_stepping_state (struct thread_info
*tss
)
4011 tss
->stepped_breakpoint
= 0;
4012 tss
->stepping_over_breakpoint
= 0;
4013 tss
->stepping_over_watchpoint
= 0;
4014 tss
->step_after_step_resume_breakpoint
= 0;
4020 set_last_target_status (process_stratum_target
*target
, ptid_t ptid
,
4021 target_waitstatus status
)
4023 target_last_proc_target
= target
;
4024 target_last_wait_ptid
= ptid
;
4025 target_last_waitstatus
= status
;
4031 get_last_target_status (process_stratum_target
**target
, ptid_t
*ptid
,
4032 target_waitstatus
*status
)
4034 if (target
!= nullptr)
4035 *target
= target_last_proc_target
;
4036 if (ptid
!= nullptr)
4037 *ptid
= target_last_wait_ptid
;
4038 if (status
!= nullptr)
4039 *status
= target_last_waitstatus
;
4045 nullify_last_target_wait_ptid (void)
4047 target_last_proc_target
= nullptr;
4048 target_last_wait_ptid
= minus_one_ptid
;
4049 target_last_waitstatus
= {};
4052 /* Switch thread contexts. */
4055 context_switch (execution_control_state
*ecs
)
4057 if (ecs
->ptid
!= inferior_ptid
4058 && (inferior_ptid
== null_ptid
4059 || ecs
->event_thread
!= inferior_thread ()))
4061 infrun_debug_printf ("Switching context from %s to %s",
4062 target_pid_to_str (inferior_ptid
).c_str (),
4063 target_pid_to_str (ecs
->ptid
).c_str ());
4066 switch_to_thread (ecs
->event_thread
);
4069 /* If the target can't tell whether we've hit breakpoints
4070 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4071 check whether that could have been caused by a breakpoint. If so,
4072 adjust the PC, per gdbarch_decr_pc_after_break. */
4075 adjust_pc_after_break (struct thread_info
*thread
,
4076 struct target_waitstatus
*ws
)
4078 struct regcache
*regcache
;
4079 struct gdbarch
*gdbarch
;
4080 CORE_ADDR breakpoint_pc
, decr_pc
;
4082 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4083 we aren't, just return.
4085 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4086 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4087 implemented by software breakpoints should be handled through the normal
4090 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4091 different signals (SIGILL or SIGEMT for instance), but it is less
4092 clear where the PC is pointing afterwards. It may not match
4093 gdbarch_decr_pc_after_break. I don't know any specific target that
4094 generates these signals at breakpoints (the code has been in GDB since at
4095 least 1992) so I can not guess how to handle them here.
4097 In earlier versions of GDB, a target with
4098 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4099 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4100 target with both of these set in GDB history, and it seems unlikely to be
4101 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4103 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
4106 if (ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
4109 /* In reverse execution, when a breakpoint is hit, the instruction
4110 under it has already been de-executed. The reported PC always
4111 points at the breakpoint address, so adjusting it further would
4112 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4115 B1 0x08000000 : INSN1
4116 B2 0x08000001 : INSN2
4118 PC -> 0x08000003 : INSN4
4120 Say you're stopped at 0x08000003 as above. Reverse continuing
4121 from that point should hit B2 as below. Reading the PC when the
4122 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4123 been de-executed already.
4125 B1 0x08000000 : INSN1
4126 B2 PC -> 0x08000001 : INSN2
4130 We can't apply the same logic as for forward execution, because
4131 we would wrongly adjust the PC to 0x08000000, since there's a
4132 breakpoint at PC - 1. We'd then report a hit on B1, although
4133 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4135 if (execution_direction
== EXEC_REVERSE
)
4138 /* If the target can tell whether the thread hit a SW breakpoint,
4139 trust it. Targets that can tell also adjust the PC
4141 if (target_supports_stopped_by_sw_breakpoint ())
4144 /* Note that relying on whether a breakpoint is planted in memory to
4145 determine this can fail. E.g,. the breakpoint could have been
4146 removed since. Or the thread could have been told to step an
4147 instruction the size of a breakpoint instruction, and only
4148 _after_ was a breakpoint inserted at its address. */
4150 /* If this target does not decrement the PC after breakpoints, then
4151 we have nothing to do. */
4152 regcache
= get_thread_regcache (thread
);
4153 gdbarch
= regcache
->arch ();
4155 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4159 const address_space
*aspace
= regcache
->aspace ();
4161 /* Find the location where (if we've hit a breakpoint) the
4162 breakpoint would be. */
4163 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4165 /* If the target can't tell whether a software breakpoint triggered,
4166 fallback to figuring it out based on breakpoints we think were
4167 inserted in the target, and on whether the thread was stepped or
4170 /* Check whether there actually is a software breakpoint inserted at
4173 If in non-stop mode, a race condition is possible where we've
4174 removed a breakpoint, but stop events for that breakpoint were
4175 already queued and arrive later. To suppress those spurious
4176 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4177 and retire them after a number of stop events are reported. Note
4178 this is an heuristic and can thus get confused. The real fix is
4179 to get the "stopped by SW BP and needs adjustment" info out of
4180 the target/kernel (and thus never reach here; see above). */
4181 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4182 || (target_is_non_stop_p ()
4183 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4185 gdb::optional
<scoped_restore_tmpl
<int>> restore_operation_disable
;
4187 if (record_full_is_used ())
4188 restore_operation_disable
.emplace
4189 (record_full_gdb_operation_disable_set ());
4191 /* When using hardware single-step, a SIGTRAP is reported for both
4192 a completed single-step and a software breakpoint. Need to
4193 differentiate between the two, as the latter needs adjusting
4194 but the former does not.
4196 The SIGTRAP can be due to a completed hardware single-step only if
4197 - we didn't insert software single-step breakpoints
4198 - this thread is currently being stepped
4200 If any of these events did not occur, we must have stopped due
4201 to hitting a software breakpoint, and have to back up to the
4204 As a special case, we could have hardware single-stepped a
4205 software breakpoint. In this case (prev_pc == breakpoint_pc),
4206 we also need to back up to the breakpoint address. */
4208 if (thread_has_single_step_breakpoints_set (thread
)
4209 || !currently_stepping (thread
)
4210 || (thread
->stepped_breakpoint
4211 && thread
->prev_pc
== breakpoint_pc
))
4212 regcache_write_pc (regcache
, breakpoint_pc
);
4217 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4219 for (frame
= get_prev_frame (frame
);
4221 frame
= get_prev_frame (frame
))
4223 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4226 if (get_frame_type (frame
) != INLINE_FRAME
)
4233 /* Look for an inline frame that is marked for skip.
4234 If PREV_FRAME is TRUE start at the previous frame,
4235 otherwise start at the current frame. Stop at the
4236 first non-inline frame, or at the frame where the
4240 inline_frame_is_marked_for_skip (bool prev_frame
, struct thread_info
*tp
)
4242 struct frame_info
*frame
= get_current_frame ();
4245 frame
= get_prev_frame (frame
);
4247 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
4249 const char *fn
= NULL
;
4250 symtab_and_line sal
;
4253 if (frame_id_eq (get_frame_id (frame
), tp
->control
.step_frame_id
))
4255 if (get_frame_type (frame
) != INLINE_FRAME
)
4258 sal
= find_frame_sal (frame
);
4259 sym
= get_frame_function (frame
);
4262 fn
= sym
->print_name ();
4265 && function_name_is_marked_for_skip (fn
, sal
))
4272 /* If the event thread has the stop requested flag set, pretend it
4273 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4277 handle_stop_requested (struct execution_control_state
*ecs
)
4279 if (ecs
->event_thread
->stop_requested
)
4281 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
4282 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
4283 handle_signal_stop (ecs
);
4289 /* Auxiliary function that handles syscall entry/return events.
4290 It returns true if the inferior should keep going (and GDB
4291 should ignore the event), or false if the event deserves to be
4295 handle_syscall_event (struct execution_control_state
*ecs
)
4297 struct regcache
*regcache
;
4300 context_switch (ecs
);
4302 regcache
= get_thread_regcache (ecs
->event_thread
);
4303 syscall_number
= ecs
->ws
.value
.syscall_number
;
4304 ecs
->event_thread
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4306 if (catch_syscall_enabled () > 0
4307 && catching_syscall_number (syscall_number
) > 0)
4309 infrun_debug_printf ("syscall number=%d", syscall_number
);
4311 ecs
->event_thread
->control
.stop_bpstat
4312 = bpstat_stop_status (regcache
->aspace (),
4313 ecs
->event_thread
->suspend
.stop_pc
,
4314 ecs
->event_thread
, &ecs
->ws
);
4316 if (handle_stop_requested (ecs
))
4319 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4321 /* Catchpoint hit. */
4326 if (handle_stop_requested (ecs
))
4329 /* If no catchpoint triggered for this, then keep going. */
4335 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4338 fill_in_stop_func (struct gdbarch
*gdbarch
,
4339 struct execution_control_state
*ecs
)
4341 if (!ecs
->stop_func_filled_in
)
4344 const general_symbol_info
*gsi
;
4346 /* Don't care about return value; stop_func_start and stop_func_name
4347 will both be 0 if it doesn't work. */
4348 find_pc_partial_function_sym (ecs
->event_thread
->suspend
.stop_pc
,
4350 &ecs
->stop_func_start
,
4351 &ecs
->stop_func_end
,
4353 ecs
->stop_func_name
= gsi
== nullptr ? nullptr : gsi
->print_name ();
4355 /* The call to find_pc_partial_function, above, will set
4356 stop_func_start and stop_func_end to the start and end
4357 of the range containing the stop pc. If this range
4358 contains the entry pc for the block (which is always the
4359 case for contiguous blocks), advance stop_func_start past
4360 the function's start offset and entrypoint. Note that
4361 stop_func_start is NOT advanced when in a range of a
4362 non-contiguous block that does not contain the entry pc. */
4363 if (block
!= nullptr
4364 && ecs
->stop_func_start
<= BLOCK_ENTRY_PC (block
)
4365 && BLOCK_ENTRY_PC (block
) < ecs
->stop_func_end
)
4367 ecs
->stop_func_start
4368 += gdbarch_deprecated_function_start_offset (gdbarch
);
4370 if (gdbarch_skip_entrypoint_p (gdbarch
))
4371 ecs
->stop_func_start
4372 = gdbarch_skip_entrypoint (gdbarch
, ecs
->stop_func_start
);
4375 ecs
->stop_func_filled_in
= 1;
4380 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
4382 static enum stop_kind
4383 get_inferior_stop_soon (execution_control_state
*ecs
)
4385 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4387 gdb_assert (inf
!= NULL
);
4388 return inf
->control
.stop_soon
;
4391 /* Poll for one event out of the current target. Store the resulting
4392 waitstatus in WS, and return the event ptid. Does not block. */
4395 poll_one_curr_target (struct target_waitstatus
*ws
)
4399 overlay_cache_invalid
= 1;
4401 /* Flush target cache before starting to handle each event.
4402 Target was running and cache could be stale. This is just a
4403 heuristic. Running threads may modify target memory, but we
4404 don't get any event. */
4405 target_dcache_invalidate ();
4407 if (deprecated_target_wait_hook
)
4408 event_ptid
= deprecated_target_wait_hook (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4410 event_ptid
= target_wait (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4413 print_target_wait_results (minus_one_ptid
, event_ptid
, ws
);
4418 /* An event reported by wait_one. */
4420 struct wait_one_event
4422 /* The target the event came out of. */
4423 process_stratum_target
*target
;
4425 /* The PTID the event was for. */
4428 /* The waitstatus. */
4429 target_waitstatus ws
;
4432 /* Wait for one event out of any target. */
4434 static wait_one_event
4439 for (inferior
*inf
: all_inferiors ())
4441 process_stratum_target
*target
= inf
->process_target ();
4443 || !target
->is_async_p ()
4444 || !target
->threads_executing
)
4447 switch_to_inferior_no_thread (inf
);
4449 wait_one_event event
;
4450 event
.target
= target
;
4451 event
.ptid
= poll_one_curr_target (&event
.ws
);
4453 if (event
.ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4455 /* If nothing is resumed, remove the target from the
4459 else if (event
.ws
.kind
!= TARGET_WAITKIND_IGNORE
)
4463 /* Block waiting for some event. */
4470 for (inferior
*inf
: all_inferiors ())
4472 process_stratum_target
*target
= inf
->process_target ();
4474 || !target
->is_async_p ()
4475 || !target
->threads_executing
)
4478 int fd
= target
->async_wait_fd ();
4479 FD_SET (fd
, &readfds
);
4486 /* No waitable targets left. All must be stopped. */
4487 return {NULL
, minus_one_ptid
, {TARGET_WAITKIND_NO_RESUMED
}};
4492 int numfds
= interruptible_select (nfds
, &readfds
, 0, NULL
, 0);
4498 perror_with_name ("interruptible_select");
4503 /* Save the thread's event and stop reason to process it later. */
4506 save_waitstatus (struct thread_info
*tp
, const target_waitstatus
*ws
)
4508 infrun_debug_printf ("saving status %s for %d.%ld.%ld",
4509 target_waitstatus_to_string (ws
).c_str (),
4514 /* Record for later. */
4515 tp
->suspend
.waitstatus
= *ws
;
4516 tp
->suspend
.waitstatus_pending_p
= 1;
4518 struct regcache
*regcache
= get_thread_regcache (tp
);
4519 const address_space
*aspace
= regcache
->aspace ();
4521 if (ws
->kind
== TARGET_WAITKIND_STOPPED
4522 && ws
->value
.sig
== GDB_SIGNAL_TRAP
)
4524 CORE_ADDR pc
= regcache_read_pc (regcache
);
4526 adjust_pc_after_break (tp
, &tp
->suspend
.waitstatus
);
4528 scoped_restore_current_thread restore_thread
;
4529 switch_to_thread (tp
);
4531 if (target_stopped_by_watchpoint ())
4533 tp
->suspend
.stop_reason
4534 = TARGET_STOPPED_BY_WATCHPOINT
;
4536 else if (target_supports_stopped_by_sw_breakpoint ()
4537 && target_stopped_by_sw_breakpoint ())
4539 tp
->suspend
.stop_reason
4540 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4542 else if (target_supports_stopped_by_hw_breakpoint ()
4543 && target_stopped_by_hw_breakpoint ())
4545 tp
->suspend
.stop_reason
4546 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4548 else if (!target_supports_stopped_by_hw_breakpoint ()
4549 && hardware_breakpoint_inserted_here_p (aspace
,
4552 tp
->suspend
.stop_reason
4553 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4555 else if (!target_supports_stopped_by_sw_breakpoint ()
4556 && software_breakpoint_inserted_here_p (aspace
,
4559 tp
->suspend
.stop_reason
4560 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4562 else if (!thread_has_single_step_breakpoints_set (tp
)
4563 && currently_stepping (tp
))
4565 tp
->suspend
.stop_reason
4566 = TARGET_STOPPED_BY_SINGLE_STEP
;
4571 /* Mark the non-executing threads accordingly. In all-stop, all
4572 threads of all processes are stopped when we get any event
4573 reported. In non-stop mode, only the event thread stops. */
4576 mark_non_executing_threads (process_stratum_target
*target
,
4578 struct target_waitstatus ws
)
4582 if (!target_is_non_stop_p ())
4583 mark_ptid
= minus_one_ptid
;
4584 else if (ws
.kind
== TARGET_WAITKIND_SIGNALLED
4585 || ws
.kind
== TARGET_WAITKIND_EXITED
)
4587 /* If we're handling a process exit in non-stop mode, even
4588 though threads haven't been deleted yet, one would think
4589 that there is nothing to do, as threads of the dead process
4590 will be soon deleted, and threads of any other process were
4591 left running. However, on some targets, threads survive a
4592 process exit event. E.g., for the "checkpoint" command,
4593 when the current checkpoint/fork exits, linux-fork.c
4594 automatically switches to another fork from within
4595 target_mourn_inferior, by associating the same
4596 inferior/thread to another fork. We haven't mourned yet at
4597 this point, but we must mark any threads left in the
4598 process as not-executing so that finish_thread_state marks
4599 them stopped (in the user's perspective) if/when we present
4600 the stop to the user. */
4601 mark_ptid
= ptid_t (event_ptid
.pid ());
4604 mark_ptid
= event_ptid
;
4606 set_executing (target
, mark_ptid
, false);
4608 /* Likewise the resumed flag. */
4609 set_resumed (target
, mark_ptid
, false);
4615 stop_all_threads (void)
4617 /* We may need multiple passes to discover all threads. */
4621 gdb_assert (exists_non_stop_target ());
4623 infrun_debug_printf ("starting");
4625 scoped_restore_current_thread restore_thread
;
4627 /* Enable thread events of all targets. */
4628 for (auto *target
: all_non_exited_process_targets ())
4630 switch_to_target_no_thread (target
);
4631 target_thread_events (true);
4636 /* Disable thread events of all targets. */
4637 for (auto *target
: all_non_exited_process_targets ())
4639 switch_to_target_no_thread (target
);
4640 target_thread_events (false);
4643 /* Use debug_prefixed_printf directly to get a meaningful function
4646 debug_prefixed_printf ("infrun", "stop_all_threads", "done");
4649 /* Request threads to stop, and then wait for the stops. Because
4650 threads we already know about can spawn more threads while we're
4651 trying to stop them, and we only learn about new threads when we
4652 update the thread list, do this in a loop, and keep iterating
4653 until two passes find no threads that need to be stopped. */
4654 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4656 infrun_debug_printf ("pass=%d, iterations=%d", pass
, iterations
);
4659 int waits_needed
= 0;
4661 for (auto *target
: all_non_exited_process_targets ())
4663 switch_to_target_no_thread (target
);
4664 update_thread_list ();
4667 /* Go through all threads looking for threads that we need
4668 to tell the target to stop. */
4669 for (thread_info
*t
: all_non_exited_threads ())
4671 /* For a single-target setting with an all-stop target,
4672 we would not even arrive here. For a multi-target
4673 setting, until GDB is able to handle a mixture of
4674 all-stop and non-stop targets, simply skip all-stop
4675 targets' threads. This should be fine due to the
4676 protection of 'check_multi_target_resumption'. */
4678 switch_to_thread_no_regs (t
);
4679 if (!target_is_non_stop_p ())
4684 /* If already stopping, don't request a stop again.
4685 We just haven't seen the notification yet. */
4686 if (!t
->stop_requested
)
4688 infrun_debug_printf (" %s executing, need stop",
4689 target_pid_to_str (t
->ptid
).c_str ());
4690 target_stop (t
->ptid
);
4691 t
->stop_requested
= 1;
4695 infrun_debug_printf (" %s executing, already stopping",
4696 target_pid_to_str (t
->ptid
).c_str ());
4699 if (t
->stop_requested
)
4704 infrun_debug_printf (" %s not executing",
4705 target_pid_to_str (t
->ptid
).c_str ());
4707 /* The thread may be not executing, but still be
4708 resumed with a pending status to process. */
4713 if (waits_needed
== 0)
4716 /* If we find new threads on the second iteration, restart
4717 over. We want to see two iterations in a row with all
4722 for (int i
= 0; i
< waits_needed
; i
++)
4724 wait_one_event event
= wait_one ();
4727 ("%s %s", target_waitstatus_to_string (&event
.ws
).c_str (),
4728 target_pid_to_str (event
.ptid
).c_str ());
4730 if (event
.ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4732 /* All resumed threads exited. */
4735 else if (event
.ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
4736 || event
.ws
.kind
== TARGET_WAITKIND_EXITED
4737 || event
.ws
.kind
== TARGET_WAITKIND_SIGNALLED
)
4739 /* One thread/process exited/signalled. */
4741 thread_info
*t
= nullptr;
4743 /* The target may have reported just a pid. If so, try
4744 the first non-exited thread. */
4745 if (event
.ptid
.is_pid ())
4747 int pid
= event
.ptid
.pid ();
4748 inferior
*inf
= find_inferior_pid (event
.target
, pid
);
4749 for (thread_info
*tp
: inf
->non_exited_threads ())
4755 /* If there is no available thread, the event would
4756 have to be appended to a per-inferior event list,
4757 which does not exist (and if it did, we'd have
4758 to adjust run control command to be able to
4759 resume such an inferior). We assert here instead
4760 of going into an infinite loop. */
4761 gdb_assert (t
!= nullptr);
4764 ("using %s", target_pid_to_str (t
->ptid
).c_str ());
4768 t
= find_thread_ptid (event
.target
, event
.ptid
);
4769 /* Check if this is the first time we see this thread.
4770 Don't bother adding if it individually exited. */
4772 && event
.ws
.kind
!= TARGET_WAITKIND_THREAD_EXITED
)
4773 t
= add_thread (event
.target
, event
.ptid
);
4778 /* Set the threads as non-executing to avoid
4779 another stop attempt on them. */
4780 switch_to_thread_no_regs (t
);
4781 mark_non_executing_threads (event
.target
, event
.ptid
,
4783 save_waitstatus (t
, &event
.ws
);
4784 t
->stop_requested
= false;
4789 thread_info
*t
= find_thread_ptid (event
.target
, event
.ptid
);
4791 t
= add_thread (event
.target
, event
.ptid
);
4793 t
->stop_requested
= 0;
4796 t
->control
.may_range_step
= 0;
4798 /* This may be the first time we see the inferior report
4800 inferior
*inf
= find_inferior_ptid (event
.target
, event
.ptid
);
4801 if (inf
->needs_setup
)
4803 switch_to_thread_no_regs (t
);
4807 if (event
.ws
.kind
== TARGET_WAITKIND_STOPPED
4808 && event
.ws
.value
.sig
== GDB_SIGNAL_0
)
4810 /* We caught the event that we intended to catch, so
4811 there's no event pending. */
4812 t
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
4813 t
->suspend
.waitstatus_pending_p
= 0;
4815 if (displaced_step_finish (t
, GDB_SIGNAL_0
)
4816 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
4818 /* Add it back to the step-over queue. */
4820 ("displaced-step of %s canceled: adding back to "
4821 "the step-over queue",
4822 target_pid_to_str (t
->ptid
).c_str ());
4824 t
->control
.trap_expected
= 0;
4825 global_thread_step_over_chain_enqueue (t
);
4830 enum gdb_signal sig
;
4831 struct regcache
*regcache
;
4834 ("target_wait %s, saving status for %d.%ld.%ld",
4835 target_waitstatus_to_string (&event
.ws
).c_str (),
4836 t
->ptid
.pid (), t
->ptid
.lwp (), t
->ptid
.tid ());
4838 /* Record for later. */
4839 save_waitstatus (t
, &event
.ws
);
4841 sig
= (event
.ws
.kind
== TARGET_WAITKIND_STOPPED
4842 ? event
.ws
.value
.sig
: GDB_SIGNAL_0
);
4844 if (displaced_step_finish (t
, sig
)
4845 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
4847 /* Add it back to the step-over queue. */
4848 t
->control
.trap_expected
= 0;
4849 global_thread_step_over_chain_enqueue (t
);
4852 regcache
= get_thread_regcache (t
);
4853 t
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4855 infrun_debug_printf ("saved stop_pc=%s for %s "
4856 "(currently_stepping=%d)",
4857 paddress (target_gdbarch (),
4858 t
->suspend
.stop_pc
),
4859 target_pid_to_str (t
->ptid
).c_str (),
4860 currently_stepping (t
));
4868 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
4871 handle_no_resumed (struct execution_control_state
*ecs
)
4873 if (target_can_async_p ())
4875 bool any_sync
= false;
4877 for (ui
*ui
: all_uis ())
4879 if (ui
->prompt_state
== PROMPT_BLOCKED
)
4887 /* There were no unwaited-for children left in the target, but,
4888 we're not synchronously waiting for events either. Just
4891 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED (ignoring: bg)");
4892 prepare_to_wait (ecs
);
4897 /* Otherwise, if we were running a synchronous execution command, we
4898 may need to cancel it and give the user back the terminal.
4900 In non-stop mode, the target can't tell whether we've already
4901 consumed previous stop events, so it can end up sending us a
4902 no-resumed event like so:
4904 #0 - thread 1 is left stopped
4906 #1 - thread 2 is resumed and hits breakpoint
4907 -> TARGET_WAITKIND_STOPPED
4909 #2 - thread 3 is resumed and exits
4910 this is the last resumed thread, so
4911 -> TARGET_WAITKIND_NO_RESUMED
4913 #3 - gdb processes stop for thread 2 and decides to re-resume
4916 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
4917 thread 2 is now resumed, so the event should be ignored.
4919 IOW, if the stop for thread 2 doesn't end a foreground command,
4920 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
4921 event. But it could be that the event meant that thread 2 itself
4922 (or whatever other thread was the last resumed thread) exited.
4924 To address this we refresh the thread list and check whether we
4925 have resumed threads _now_. In the example above, this removes
4926 thread 3 from the thread list. If thread 2 was re-resumed, we
4927 ignore this event. If we find no thread resumed, then we cancel
4928 the synchronous command and show "no unwaited-for " to the
4931 inferior
*curr_inf
= current_inferior ();
4933 scoped_restore_current_thread restore_thread
;
4935 for (auto *target
: all_non_exited_process_targets ())
4937 switch_to_target_no_thread (target
);
4938 update_thread_list ();
4943 - the current target has no thread executing, and
4944 - the current inferior is native, and
4945 - the current inferior is the one which has the terminal, and
4948 then a Ctrl-C from this point on would remain stuck in the
4949 kernel, until a thread resumes and dequeues it. That would
4950 result in the GDB CLI not reacting to Ctrl-C, not able to
4951 interrupt the program. To address this, if the current inferior
4952 no longer has any thread executing, we give the terminal to some
4953 other inferior that has at least one thread executing. */
4954 bool swap_terminal
= true;
4956 /* Whether to ignore this TARGET_WAITKIND_NO_RESUMED event, or
4957 whether to report it to the user. */
4958 bool ignore_event
= false;
4960 for (thread_info
*thread
: all_non_exited_threads ())
4962 if (swap_terminal
&& thread
->executing
)
4964 if (thread
->inf
!= curr_inf
)
4966 target_terminal::ours ();
4968 switch_to_thread (thread
);
4969 target_terminal::inferior ();
4971 swap_terminal
= false;
4975 && (thread
->executing
4976 || thread
->suspend
.waitstatus_pending_p
))
4978 /* Either there were no unwaited-for children left in the
4979 target at some point, but there are now, or some target
4980 other than the eventing one has unwaited-for children
4981 left. Just ignore. */
4982 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED "
4983 "(ignoring: found resumed)");
4985 ignore_event
= true;
4988 if (ignore_event
&& !swap_terminal
)
4994 switch_to_inferior_no_thread (curr_inf
);
4995 prepare_to_wait (ecs
);
4999 /* Go ahead and report the event. */
5003 /* Given an execution control state that has been freshly filled in by
5004 an event from the inferior, figure out what it means and take
5007 The alternatives are:
5009 1) stop_waiting and return; to really stop and return to the
5012 2) keep_going and return; to wait for the next event (set
5013 ecs->event_thread->stepping_over_breakpoint to 1 to single step
5017 handle_inferior_event (struct execution_control_state
*ecs
)
5019 /* Make sure that all temporary struct value objects that were
5020 created during the handling of the event get deleted at the
5022 scoped_value_mark free_values
;
5024 enum stop_kind stop_soon
;
5026 infrun_debug_printf ("%s", target_waitstatus_to_string (&ecs
->ws
).c_str ());
5028 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
5030 /* We had an event in the inferior, but we are not interested in
5031 handling it at this level. The lower layers have already
5032 done what needs to be done, if anything.
5034 One of the possible circumstances for this is when the
5035 inferior produces output for the console. The inferior has
5036 not stopped, and we are ignoring the event. Another possible
5037 circumstance is any event which the lower level knows will be
5038 reported multiple times without an intervening resume. */
5039 prepare_to_wait (ecs
);
5043 if (ecs
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
5045 prepare_to_wait (ecs
);
5049 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
5050 && handle_no_resumed (ecs
))
5053 /* Cache the last target/ptid/waitstatus. */
5054 set_last_target_status (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5056 /* Always clear state belonging to the previous time we stopped. */
5057 stop_stack_dummy
= STOP_NONE
;
5059 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
5061 /* No unwaited-for children left. IOW, all resumed children
5063 stop_print_frame
= false;
5068 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
5069 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
5071 ecs
->event_thread
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5072 /* If it's a new thread, add it to the thread database. */
5073 if (ecs
->event_thread
== NULL
)
5074 ecs
->event_thread
= add_thread (ecs
->target
, ecs
->ptid
);
5076 /* Disable range stepping. If the next step request could use a
5077 range, this will be end up re-enabled then. */
5078 ecs
->event_thread
->control
.may_range_step
= 0;
5081 /* Dependent on valid ECS->EVENT_THREAD. */
5082 adjust_pc_after_break (ecs
->event_thread
, &ecs
->ws
);
5084 /* Dependent on the current PC value modified by adjust_pc_after_break. */
5085 reinit_frame_cache ();
5087 breakpoint_retire_moribund ();
5089 /* First, distinguish signals caused by the debugger from signals
5090 that have to do with the program's own actions. Note that
5091 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
5092 on the operating system version. Here we detect when a SIGILL or
5093 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
5094 something similar for SIGSEGV, since a SIGSEGV will be generated
5095 when we're trying to execute a breakpoint instruction on a
5096 non-executable stack. This happens for call dummy breakpoints
5097 for architectures like SPARC that place call dummies on the
5099 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
5100 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
5101 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
5102 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
5104 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5106 if (breakpoint_inserted_here_p (regcache
->aspace (),
5107 regcache_read_pc (regcache
)))
5109 infrun_debug_printf ("Treating signal as SIGTRAP");
5110 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
5114 mark_non_executing_threads (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5116 switch (ecs
->ws
.kind
)
5118 case TARGET_WAITKIND_LOADED
:
5119 context_switch (ecs
);
5120 /* Ignore gracefully during startup of the inferior, as it might
5121 be the shell which has just loaded some objects, otherwise
5122 add the symbols for the newly loaded objects. Also ignore at
5123 the beginning of an attach or remote session; we will query
5124 the full list of libraries once the connection is
5127 stop_soon
= get_inferior_stop_soon (ecs
);
5128 if (stop_soon
== NO_STOP_QUIETLY
)
5130 struct regcache
*regcache
;
5132 regcache
= get_thread_regcache (ecs
->event_thread
);
5134 handle_solib_event ();
5136 ecs
->event_thread
->control
.stop_bpstat
5137 = bpstat_stop_status (regcache
->aspace (),
5138 ecs
->event_thread
->suspend
.stop_pc
,
5139 ecs
->event_thread
, &ecs
->ws
);
5141 if (handle_stop_requested (ecs
))
5144 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5146 /* A catchpoint triggered. */
5147 process_event_stop_test (ecs
);
5151 /* If requested, stop when the dynamic linker notifies
5152 gdb of events. This allows the user to get control
5153 and place breakpoints in initializer routines for
5154 dynamically loaded objects (among other things). */
5155 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5156 if (stop_on_solib_events
)
5158 /* Make sure we print "Stopped due to solib-event" in
5160 stop_print_frame
= true;
5167 /* If we are skipping through a shell, or through shared library
5168 loading that we aren't interested in, resume the program. If
5169 we're running the program normally, also resume. */
5170 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
5172 /* Loading of shared libraries might have changed breakpoint
5173 addresses. Make sure new breakpoints are inserted. */
5174 if (stop_soon
== NO_STOP_QUIETLY
)
5175 insert_breakpoints ();
5176 resume (GDB_SIGNAL_0
);
5177 prepare_to_wait (ecs
);
5181 /* But stop if we're attaching or setting up a remote
5183 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5184 || stop_soon
== STOP_QUIETLY_REMOTE
)
5186 infrun_debug_printf ("quietly stopped");
5191 internal_error (__FILE__
, __LINE__
,
5192 _("unhandled stop_soon: %d"), (int) stop_soon
);
5194 case TARGET_WAITKIND_SPURIOUS
:
5195 if (handle_stop_requested (ecs
))
5197 context_switch (ecs
);
5198 resume (GDB_SIGNAL_0
);
5199 prepare_to_wait (ecs
);
5202 case TARGET_WAITKIND_THREAD_CREATED
:
5203 if (handle_stop_requested (ecs
))
5205 context_switch (ecs
);
5206 if (!switch_back_to_stepped_thread (ecs
))
5210 case TARGET_WAITKIND_EXITED
:
5211 case TARGET_WAITKIND_SIGNALLED
:
5213 /* Depending on the system, ecs->ptid may point to a thread or
5214 to a process. On some targets, target_mourn_inferior may
5215 need to have access to the just-exited thread. That is the
5216 case of GNU/Linux's "checkpoint" support, for example.
5217 Call the switch_to_xxx routine as appropriate. */
5218 thread_info
*thr
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5220 switch_to_thread (thr
);
5223 inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5224 switch_to_inferior_no_thread (inf
);
5227 handle_vfork_child_exec_or_exit (0);
5228 target_terminal::ours (); /* Must do this before mourn anyway. */
5230 /* Clearing any previous state of convenience variables. */
5231 clear_exit_convenience_vars ();
5233 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
5235 /* Record the exit code in the convenience variable $_exitcode, so
5236 that the user can inspect this again later. */
5237 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5238 (LONGEST
) ecs
->ws
.value
.integer
);
5240 /* Also record this in the inferior itself. */
5241 current_inferior ()->has_exit_code
= 1;
5242 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
5244 /* Support the --return-child-result option. */
5245 return_child_result_value
= ecs
->ws
.value
.integer
;
5247 gdb::observers::exited
.notify (ecs
->ws
.value
.integer
);
5251 struct gdbarch
*gdbarch
= current_inferior ()->gdbarch
;
5253 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
5255 /* Set the value of the internal variable $_exitsignal,
5256 which holds the signal uncaught by the inferior. */
5257 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5258 gdbarch_gdb_signal_to_target (gdbarch
,
5259 ecs
->ws
.value
.sig
));
5263 /* We don't have access to the target's method used for
5264 converting between signal numbers (GDB's internal
5265 representation <-> target's representation).
5266 Therefore, we cannot do a good job at displaying this
5267 information to the user. It's better to just warn
5268 her about it (if infrun debugging is enabled), and
5270 infrun_debug_printf ("Cannot fill $_exitsignal with the correct "
5274 gdb::observers::signal_exited
.notify (ecs
->ws
.value
.sig
);
5277 gdb_flush (gdb_stdout
);
5278 target_mourn_inferior (inferior_ptid
);
5279 stop_print_frame
= false;
5283 case TARGET_WAITKIND_FORKED
:
5284 case TARGET_WAITKIND_VFORKED
:
5285 /* Check whether the inferior is displaced stepping. */
5287 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5288 struct gdbarch
*gdbarch
= regcache
->arch ();
5289 inferior
*parent_inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5291 /* If this is a fork (child gets its own address space copy) and the
5292 displaced step buffer was in use at the time of the fork, restore
5293 displaced step buffer bytes in the child process. */
5294 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
5296 displaced_step_inferior_state
*displaced
5297 = &parent_inf
->displaced_step_state
;
5299 if (displaced
->step_thread
!= nullptr)
5300 displaced_step_restore (displaced
, ecs
->ws
.value
.related_pid
);
5303 /* If displaced stepping is supported, and thread ecs->ptid is
5304 displaced stepping. */
5305 if (displaced_step_in_progress_thread (ecs
->event_thread
))
5307 struct regcache
*child_regcache
;
5308 CORE_ADDR parent_pc
;
5310 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5311 indicating that the displaced stepping of syscall instruction
5312 has been done. Perform cleanup for parent process here. Note
5313 that this operation also cleans up the child process for vfork,
5314 because their pages are shared. */
5315 displaced_step_finish (ecs
->event_thread
, GDB_SIGNAL_TRAP
);
5316 /* Start a new step-over in another thread if there's one
5320 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5321 the child's PC is also within the scratchpad. Set the child's PC
5322 to the parent's PC value, which has already been fixed up.
5323 FIXME: we use the parent's aspace here, although we're touching
5324 the child, because the child hasn't been added to the inferior
5325 list yet at this point. */
5328 = get_thread_arch_aspace_regcache (parent_inf
->process_target (),
5329 ecs
->ws
.value
.related_pid
,
5331 parent_inf
->aspace
);
5332 /* Read PC value of parent process. */
5333 parent_pc
= regcache_read_pc (regcache
);
5335 displaced_debug_printf ("write child pc from %s to %s",
5337 regcache_read_pc (child_regcache
)),
5338 paddress (gdbarch
, parent_pc
));
5340 regcache_write_pc (child_regcache
, parent_pc
);
5344 context_switch (ecs
);
5346 /* Immediately detach breakpoints from the child before there's
5347 any chance of letting the user delete breakpoints from the
5348 breakpoint lists. If we don't do this early, it's easy to
5349 leave left over traps in the child, vis: "break foo; catch
5350 fork; c; <fork>; del; c; <child calls foo>". We only follow
5351 the fork on the last `continue', and by that time the
5352 breakpoint at "foo" is long gone from the breakpoint table.
5353 If we vforked, then we don't need to unpatch here, since both
5354 parent and child are sharing the same memory pages; we'll
5355 need to unpatch at follow/detach time instead to be certain
5356 that new breakpoints added between catchpoint hit time and
5357 vfork follow are detached. */
5358 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
5360 /* This won't actually modify the breakpoint list, but will
5361 physically remove the breakpoints from the child. */
5362 detach_breakpoints (ecs
->ws
.value
.related_pid
);
5365 delete_just_stopped_threads_single_step_breakpoints ();
5367 /* In case the event is caught by a catchpoint, remember that
5368 the event is to be followed at the next resume of the thread,
5369 and not immediately. */
5370 ecs
->event_thread
->pending_follow
= ecs
->ws
;
5372 ecs
->event_thread
->suspend
.stop_pc
5373 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
5375 ecs
->event_thread
->control
.stop_bpstat
5376 = bpstat_stop_status (get_current_regcache ()->aspace (),
5377 ecs
->event_thread
->suspend
.stop_pc
,
5378 ecs
->event_thread
, &ecs
->ws
);
5380 if (handle_stop_requested (ecs
))
5383 /* If no catchpoint triggered for this, then keep going. Note
5384 that we're interested in knowing the bpstat actually causes a
5385 stop, not just if it may explain the signal. Software
5386 watchpoints, for example, always appear in the bpstat. */
5387 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5390 = (follow_fork_mode_string
== follow_fork_mode_child
);
5392 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5394 process_stratum_target
*targ
5395 = ecs
->event_thread
->inf
->process_target ();
5397 bool should_resume
= follow_fork ();
5399 /* Note that one of these may be an invalid pointer,
5400 depending on detach_fork. */
5401 thread_info
*parent
= ecs
->event_thread
;
5403 = find_thread_ptid (targ
, ecs
->ws
.value
.related_pid
);
5405 /* At this point, the parent is marked running, and the
5406 child is marked stopped. */
5408 /* If not resuming the parent, mark it stopped. */
5409 if (follow_child
&& !detach_fork
&& !non_stop
&& !sched_multi
)
5410 parent
->set_running (false);
5412 /* If resuming the child, mark it running. */
5413 if (follow_child
|| (!detach_fork
&& (non_stop
|| sched_multi
)))
5414 child
->set_running (true);
5416 /* In non-stop mode, also resume the other branch. */
5417 if (!detach_fork
&& (non_stop
5418 || (sched_multi
&& target_is_non_stop_p ())))
5421 switch_to_thread (parent
);
5423 switch_to_thread (child
);
5425 ecs
->event_thread
= inferior_thread ();
5426 ecs
->ptid
= inferior_ptid
;
5431 switch_to_thread (child
);
5433 switch_to_thread (parent
);
5435 ecs
->event_thread
= inferior_thread ();
5436 ecs
->ptid
= inferior_ptid
;
5444 process_event_stop_test (ecs
);
5447 case TARGET_WAITKIND_VFORK_DONE
:
5448 /* Done with the shared memory region. Re-insert breakpoints in
5449 the parent, and keep going. */
5451 context_switch (ecs
);
5453 current_inferior ()->waiting_for_vfork_done
= 0;
5454 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
5456 if (handle_stop_requested (ecs
))
5459 /* This also takes care of reinserting breakpoints in the
5460 previously locked inferior. */
5464 case TARGET_WAITKIND_EXECD
:
5466 /* Note we can't read registers yet (the stop_pc), because we
5467 don't yet know the inferior's post-exec architecture.
5468 'stop_pc' is explicitly read below instead. */
5469 switch_to_thread_no_regs (ecs
->event_thread
);
5471 /* Do whatever is necessary to the parent branch of the vfork. */
5472 handle_vfork_child_exec_or_exit (1);
5474 /* This causes the eventpoints and symbol table to be reset.
5475 Must do this now, before trying to determine whether to
5477 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
5479 /* In follow_exec we may have deleted the original thread and
5480 created a new one. Make sure that the event thread is the
5481 execd thread for that case (this is a nop otherwise). */
5482 ecs
->event_thread
= inferior_thread ();
5484 ecs
->event_thread
->suspend
.stop_pc
5485 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
5487 ecs
->event_thread
->control
.stop_bpstat
5488 = bpstat_stop_status (get_current_regcache ()->aspace (),
5489 ecs
->event_thread
->suspend
.stop_pc
,
5490 ecs
->event_thread
, &ecs
->ws
);
5492 /* Note that this may be referenced from inside
5493 bpstat_stop_status above, through inferior_has_execd. */
5494 xfree (ecs
->ws
.value
.execd_pathname
);
5495 ecs
->ws
.value
.execd_pathname
= NULL
;
5497 if (handle_stop_requested (ecs
))
5500 /* If no catchpoint triggered for this, then keep going. */
5501 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5503 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5507 process_event_stop_test (ecs
);
5510 /* Be careful not to try to gather much state about a thread
5511 that's in a syscall. It's frequently a losing proposition. */
5512 case TARGET_WAITKIND_SYSCALL_ENTRY
:
5513 /* Getting the current syscall number. */
5514 if (handle_syscall_event (ecs
) == 0)
5515 process_event_stop_test (ecs
);
5518 /* Before examining the threads further, step this thread to
5519 get it entirely out of the syscall. (We get notice of the
5520 event when the thread is just on the verge of exiting a
5521 syscall. Stepping one instruction seems to get it back
5523 case TARGET_WAITKIND_SYSCALL_RETURN
:
5524 if (handle_syscall_event (ecs
) == 0)
5525 process_event_stop_test (ecs
);
5528 case TARGET_WAITKIND_STOPPED
:
5529 handle_signal_stop (ecs
);
5532 case TARGET_WAITKIND_NO_HISTORY
:
5533 /* Reverse execution: target ran out of history info. */
5535 /* Switch to the stopped thread. */
5536 context_switch (ecs
);
5537 infrun_debug_printf ("stopped");
5539 delete_just_stopped_threads_single_step_breakpoints ();
5540 ecs
->event_thread
->suspend
.stop_pc
5541 = regcache_read_pc (get_thread_regcache (inferior_thread ()));
5543 if (handle_stop_requested (ecs
))
5546 gdb::observers::no_history
.notify ();
5552 /* Restart threads back to what they were trying to do back when we
5553 paused them for an in-line step-over. The EVENT_THREAD thread is
5557 restart_threads (struct thread_info
*event_thread
)
5559 /* In case the instruction just stepped spawned a new thread. */
5560 update_thread_list ();
5562 for (thread_info
*tp
: all_non_exited_threads ())
5564 switch_to_thread_no_regs (tp
);
5566 if (tp
== event_thread
)
5568 infrun_debug_printf ("restart threads: [%s] is event thread",
5569 target_pid_to_str (tp
->ptid
).c_str ());
5573 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5575 infrun_debug_printf ("restart threads: [%s] not meant to be running",
5576 target_pid_to_str (tp
->ptid
).c_str ());
5582 infrun_debug_printf ("restart threads: [%s] resumed",
5583 target_pid_to_str (tp
->ptid
).c_str ());
5584 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
5588 if (thread_is_in_step_over_chain (tp
))
5590 infrun_debug_printf ("restart threads: [%s] needs step-over",
5591 target_pid_to_str (tp
->ptid
).c_str ());
5592 gdb_assert (!tp
->resumed
);
5597 if (tp
->suspend
.waitstatus_pending_p
)
5599 infrun_debug_printf ("restart threads: [%s] has pending status",
5600 target_pid_to_str (tp
->ptid
).c_str ());
5605 gdb_assert (!tp
->stop_requested
);
5607 /* If some thread needs to start a step-over at this point, it
5608 should still be in the step-over queue, and thus skipped
5610 if (thread_still_needs_step_over (tp
))
5612 internal_error (__FILE__
, __LINE__
,
5613 "thread [%s] needs a step-over, but not in "
5614 "step-over queue\n",
5615 target_pid_to_str (tp
->ptid
).c_str ());
5618 if (currently_stepping (tp
))
5620 infrun_debug_printf ("restart threads: [%s] was stepping",
5621 target_pid_to_str (tp
->ptid
).c_str ());
5622 keep_going_stepped_thread (tp
);
5626 struct execution_control_state ecss
;
5627 struct execution_control_state
*ecs
= &ecss
;
5629 infrun_debug_printf ("restart threads: [%s] continuing",
5630 target_pid_to_str (tp
->ptid
).c_str ());
5631 reset_ecs (ecs
, tp
);
5632 switch_to_thread (tp
);
5633 keep_going_pass_signal (ecs
);
5638 /* Callback for iterate_over_threads. Find a resumed thread that has
5639 a pending waitstatus. */
5642 resumed_thread_with_pending_status (struct thread_info
*tp
,
5646 && tp
->suspend
.waitstatus_pending_p
);
5649 /* Called when we get an event that may finish an in-line or
5650 out-of-line (displaced stepping) step-over started previously.
5651 Return true if the event is processed and we should go back to the
5652 event loop; false if the caller should continue processing the
5656 finish_step_over (struct execution_control_state
*ecs
)
5658 displaced_step_finish (ecs
->event_thread
,
5659 ecs
->event_thread
->suspend
.stop_signal
);
5661 bool had_step_over_info
= step_over_info_valid_p ();
5663 if (had_step_over_info
)
5665 /* If we're stepping over a breakpoint with all threads locked,
5666 then only the thread that was stepped should be reporting
5668 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5670 clear_step_over_info ();
5673 if (!target_is_non_stop_p ())
5676 /* Start a new step-over in another thread if there's one that
5680 /* If we were stepping over a breakpoint before, and haven't started
5681 a new in-line step-over sequence, then restart all other threads
5682 (except the event thread). We can't do this in all-stop, as then
5683 e.g., we wouldn't be able to issue any other remote packet until
5684 these other threads stop. */
5685 if (had_step_over_info
&& !step_over_info_valid_p ())
5687 struct thread_info
*pending
;
5689 /* If we only have threads with pending statuses, the restart
5690 below won't restart any thread and so nothing re-inserts the
5691 breakpoint we just stepped over. But we need it inserted
5692 when we later process the pending events, otherwise if
5693 another thread has a pending event for this breakpoint too,
5694 we'd discard its event (because the breakpoint that
5695 originally caused the event was no longer inserted). */
5696 context_switch (ecs
);
5697 insert_breakpoints ();
5699 restart_threads (ecs
->event_thread
);
5701 /* If we have events pending, go through handle_inferior_event
5702 again, picking up a pending event at random. This avoids
5703 thread starvation. */
5705 /* But not if we just stepped over a watchpoint in order to let
5706 the instruction execute so we can evaluate its expression.
5707 The set of watchpoints that triggered is recorded in the
5708 breakpoint objects themselves (see bp->watchpoint_triggered).
5709 If we processed another event first, that other event could
5710 clobber this info. */
5711 if (ecs
->event_thread
->stepping_over_watchpoint
)
5714 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5716 if (pending
!= NULL
)
5718 struct thread_info
*tp
= ecs
->event_thread
;
5719 struct regcache
*regcache
;
5721 infrun_debug_printf ("found resumed threads with "
5722 "pending events, saving status");
5724 gdb_assert (pending
!= tp
);
5726 /* Record the event thread's event for later. */
5727 save_waitstatus (tp
, &ecs
->ws
);
5728 /* This was cleared early, by handle_inferior_event. Set it
5729 so this pending event is considered by
5733 gdb_assert (!tp
->executing
);
5735 regcache
= get_thread_regcache (tp
);
5736 tp
->suspend
.stop_pc
= regcache_read_pc (regcache
);
5738 infrun_debug_printf ("saved stop_pc=%s for %s "
5739 "(currently_stepping=%d)",
5740 paddress (target_gdbarch (),
5741 tp
->suspend
.stop_pc
),
5742 target_pid_to_str (tp
->ptid
).c_str (),
5743 currently_stepping (tp
));
5745 /* This in-line step-over finished; clear this so we won't
5746 start a new one. This is what handle_signal_stop would
5747 do, if we returned false. */
5748 tp
->stepping_over_breakpoint
= 0;
5750 /* Wake up the event loop again. */
5751 mark_async_event_handler (infrun_async_inferior_event_token
);
5753 prepare_to_wait (ecs
);
5761 /* Come here when the program has stopped with a signal. */
5764 handle_signal_stop (struct execution_control_state
*ecs
)
5766 struct frame_info
*frame
;
5767 struct gdbarch
*gdbarch
;
5768 int stopped_by_watchpoint
;
5769 enum stop_kind stop_soon
;
5772 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5774 ecs
->event_thread
->suspend
.stop_signal
= ecs
->ws
.value
.sig
;
5776 /* Do we need to clean up the state of a thread that has
5777 completed a displaced single-step? (Doing so usually affects
5778 the PC, so do it here, before we set stop_pc.) */
5779 if (finish_step_over (ecs
))
5782 /* If we either finished a single-step or hit a breakpoint, but
5783 the user wanted this thread to be stopped, pretend we got a
5784 SIG0 (generic unsignaled stop). */
5785 if (ecs
->event_thread
->stop_requested
5786 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5787 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5789 ecs
->event_thread
->suspend
.stop_pc
5790 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
5794 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5795 struct gdbarch
*reg_gdbarch
= regcache
->arch ();
5797 switch_to_thread (ecs
->event_thread
);
5799 infrun_debug_printf ("stop_pc=%s",
5800 paddress (reg_gdbarch
,
5801 ecs
->event_thread
->suspend
.stop_pc
));
5802 if (target_stopped_by_watchpoint ())
5806 infrun_debug_printf ("stopped by watchpoint");
5808 if (target_stopped_data_address (current_top_target (), &addr
))
5809 infrun_debug_printf ("stopped data address=%s",
5810 paddress (reg_gdbarch
, addr
));
5812 infrun_debug_printf ("(no data address available)");
5816 /* This is originated from start_remote(), start_inferior() and
5817 shared libraries hook functions. */
5818 stop_soon
= get_inferior_stop_soon (ecs
);
5819 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5821 context_switch (ecs
);
5822 infrun_debug_printf ("quietly stopped");
5823 stop_print_frame
= true;
5828 /* This originates from attach_command(). We need to overwrite
5829 the stop_signal here, because some kernels don't ignore a
5830 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5831 See more comments in inferior.h. On the other hand, if we
5832 get a non-SIGSTOP, report it to the user - assume the backend
5833 will handle the SIGSTOP if it should show up later.
5835 Also consider that the attach is complete when we see a
5836 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5837 target extended-remote report it instead of a SIGSTOP
5838 (e.g. gdbserver). We already rely on SIGTRAP being our
5839 signal, so this is no exception.
5841 Also consider that the attach is complete when we see a
5842 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5843 the target to stop all threads of the inferior, in case the
5844 low level attach operation doesn't stop them implicitly. If
5845 they weren't stopped implicitly, then the stub will report a
5846 GDB_SIGNAL_0, meaning: stopped for no particular reason
5847 other than GDB's request. */
5848 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5849 && (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_STOP
5850 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5851 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_0
))
5853 stop_print_frame
= true;
5855 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5859 /* See if something interesting happened to the non-current thread. If
5860 so, then switch to that thread. */
5861 if (ecs
->ptid
!= inferior_ptid
)
5863 infrun_debug_printf ("context switch");
5865 context_switch (ecs
);
5867 if (deprecated_context_hook
)
5868 deprecated_context_hook (ecs
->event_thread
->global_num
);
5871 /* At this point, get hold of the now-current thread's frame. */
5872 frame
= get_current_frame ();
5873 gdbarch
= get_frame_arch (frame
);
5875 /* Pull the single step breakpoints out of the target. */
5876 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5878 struct regcache
*regcache
;
5881 regcache
= get_thread_regcache (ecs
->event_thread
);
5882 const address_space
*aspace
= regcache
->aspace ();
5884 pc
= regcache_read_pc (regcache
);
5886 /* However, before doing so, if this single-step breakpoint was
5887 actually for another thread, set this thread up for moving
5889 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
5892 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
5894 infrun_debug_printf ("[%s] hit another thread's single-step "
5896 target_pid_to_str (ecs
->ptid
).c_str ());
5897 ecs
->hit_singlestep_breakpoint
= 1;
5902 infrun_debug_printf ("[%s] hit its single-step breakpoint",
5903 target_pid_to_str (ecs
->ptid
).c_str ());
5906 delete_just_stopped_threads_single_step_breakpoints ();
5908 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5909 && ecs
->event_thread
->control
.trap_expected
5910 && ecs
->event_thread
->stepping_over_watchpoint
)
5911 stopped_by_watchpoint
= 0;
5913 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
5915 /* If necessary, step over this watchpoint. We'll be back to display
5917 if (stopped_by_watchpoint
5918 && (target_have_steppable_watchpoint ()
5919 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
5921 /* At this point, we are stopped at an instruction which has
5922 attempted to write to a piece of memory under control of
5923 a watchpoint. The instruction hasn't actually executed
5924 yet. If we were to evaluate the watchpoint expression
5925 now, we would get the old value, and therefore no change
5926 would seem to have occurred.
5928 In order to make watchpoints work `right', we really need
5929 to complete the memory write, and then evaluate the
5930 watchpoint expression. We do this by single-stepping the
5933 It may not be necessary to disable the watchpoint to step over
5934 it. For example, the PA can (with some kernel cooperation)
5935 single step over a watchpoint without disabling the watchpoint.
5937 It is far more common to need to disable a watchpoint to step
5938 the inferior over it. If we have non-steppable watchpoints,
5939 we must disable the current watchpoint; it's simplest to
5940 disable all watchpoints.
5942 Any breakpoint at PC must also be stepped over -- if there's
5943 one, it will have already triggered before the watchpoint
5944 triggered, and we either already reported it to the user, or
5945 it didn't cause a stop and we called keep_going. In either
5946 case, if there was a breakpoint at PC, we must be trying to
5948 ecs
->event_thread
->stepping_over_watchpoint
= 1;
5953 ecs
->event_thread
->stepping_over_breakpoint
= 0;
5954 ecs
->event_thread
->stepping_over_watchpoint
= 0;
5955 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
5956 ecs
->event_thread
->control
.stop_step
= 0;
5957 stop_print_frame
= true;
5958 stopped_by_random_signal
= 0;
5959 bpstat stop_chain
= NULL
;
5961 /* Hide inlined functions starting here, unless we just performed stepi or
5962 nexti. After stepi and nexti, always show the innermost frame (not any
5963 inline function call sites). */
5964 if (ecs
->event_thread
->control
.step_range_end
!= 1)
5966 const address_space
*aspace
5967 = get_thread_regcache (ecs
->event_thread
)->aspace ();
5969 /* skip_inline_frames is expensive, so we avoid it if we can
5970 determine that the address is one where functions cannot have
5971 been inlined. This improves performance with inferiors that
5972 load a lot of shared libraries, because the solib event
5973 breakpoint is defined as the address of a function (i.e. not
5974 inline). Note that we have to check the previous PC as well
5975 as the current one to catch cases when we have just
5976 single-stepped off a breakpoint prior to reinstating it.
5977 Note that we're assuming that the code we single-step to is
5978 not inline, but that's not definitive: there's nothing
5979 preventing the event breakpoint function from containing
5980 inlined code, and the single-step ending up there. If the
5981 user had set a breakpoint on that inlined code, the missing
5982 skip_inline_frames call would break things. Fortunately
5983 that's an extremely unlikely scenario. */
5984 if (!pc_at_non_inline_function (aspace
,
5985 ecs
->event_thread
->suspend
.stop_pc
,
5987 && !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5988 && ecs
->event_thread
->control
.trap_expected
5989 && pc_at_non_inline_function (aspace
,
5990 ecs
->event_thread
->prev_pc
,
5993 stop_chain
= build_bpstat_chain (aspace
,
5994 ecs
->event_thread
->suspend
.stop_pc
,
5996 skip_inline_frames (ecs
->event_thread
, stop_chain
);
5998 /* Re-fetch current thread's frame in case that invalidated
6000 frame
= get_current_frame ();
6001 gdbarch
= get_frame_arch (frame
);
6005 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6006 && ecs
->event_thread
->control
.trap_expected
6007 && gdbarch_single_step_through_delay_p (gdbarch
)
6008 && currently_stepping (ecs
->event_thread
))
6010 /* We're trying to step off a breakpoint. Turns out that we're
6011 also on an instruction that needs to be stepped multiple
6012 times before it's been fully executing. E.g., architectures
6013 with a delay slot. It needs to be stepped twice, once for
6014 the instruction and once for the delay slot. */
6015 int step_through_delay
6016 = gdbarch_single_step_through_delay (gdbarch
, frame
);
6018 if (step_through_delay
)
6019 infrun_debug_printf ("step through delay");
6021 if (ecs
->event_thread
->control
.step_range_end
== 0
6022 && step_through_delay
)
6024 /* The user issued a continue when stopped at a breakpoint.
6025 Set up for another trap and get out of here. */
6026 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6030 else if (step_through_delay
)
6032 /* The user issued a step when stopped at a breakpoint.
6033 Maybe we should stop, maybe we should not - the delay
6034 slot *might* correspond to a line of source. In any
6035 case, don't decide that here, just set
6036 ecs->stepping_over_breakpoint, making sure we
6037 single-step again before breakpoints are re-inserted. */
6038 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6042 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
6043 handles this event. */
6044 ecs
->event_thread
->control
.stop_bpstat
6045 = bpstat_stop_status (get_current_regcache ()->aspace (),
6046 ecs
->event_thread
->suspend
.stop_pc
,
6047 ecs
->event_thread
, &ecs
->ws
, stop_chain
);
6049 /* Following in case break condition called a
6051 stop_print_frame
= true;
6053 /* This is where we handle "moribund" watchpoints. Unlike
6054 software breakpoints traps, hardware watchpoint traps are
6055 always distinguishable from random traps. If no high-level
6056 watchpoint is associated with the reported stop data address
6057 anymore, then the bpstat does not explain the signal ---
6058 simply make sure to ignore it if `stopped_by_watchpoint' is
6061 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6062 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6064 && stopped_by_watchpoint
)
6066 infrun_debug_printf ("no user watchpoint explains watchpoint SIGTRAP, "
6070 /* NOTE: cagney/2003-03-29: These checks for a random signal
6071 at one stage in the past included checks for an inferior
6072 function call's call dummy's return breakpoint. The original
6073 comment, that went with the test, read:
6075 ``End of a stack dummy. Some systems (e.g. Sony news) give
6076 another signal besides SIGTRAP, so check here as well as
6079 If someone ever tries to get call dummys on a
6080 non-executable stack to work (where the target would stop
6081 with something like a SIGSEGV), then those tests might need
6082 to be re-instated. Given, however, that the tests were only
6083 enabled when momentary breakpoints were not being used, I
6084 suspect that it won't be the case.
6086 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
6087 be necessary for call dummies on a non-executable stack on
6090 /* See if the breakpoints module can explain the signal. */
6092 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6093 ecs
->event_thread
->suspend
.stop_signal
);
6095 /* Maybe this was a trap for a software breakpoint that has since
6097 if (random_signal
&& target_stopped_by_sw_breakpoint ())
6099 if (gdbarch_program_breakpoint_here_p (gdbarch
,
6100 ecs
->event_thread
->suspend
.stop_pc
))
6102 struct regcache
*regcache
;
6105 /* Re-adjust PC to what the program would see if GDB was not
6107 regcache
= get_thread_regcache (ecs
->event_thread
);
6108 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
6111 gdb::optional
<scoped_restore_tmpl
<int>>
6112 restore_operation_disable
;
6114 if (record_full_is_used ())
6115 restore_operation_disable
.emplace
6116 (record_full_gdb_operation_disable_set ());
6118 regcache_write_pc (regcache
,
6119 ecs
->event_thread
->suspend
.stop_pc
+ decr_pc
);
6124 /* A delayed software breakpoint event. Ignore the trap. */
6125 infrun_debug_printf ("delayed software breakpoint trap, ignoring");
6130 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6131 has since been removed. */
6132 if (random_signal
&& target_stopped_by_hw_breakpoint ())
6134 /* A delayed hardware breakpoint event. Ignore the trap. */
6135 infrun_debug_printf ("delayed hardware breakpoint/watchpoint "
6140 /* If not, perhaps stepping/nexting can. */
6142 random_signal
= !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6143 && currently_stepping (ecs
->event_thread
));
6145 /* Perhaps the thread hit a single-step breakpoint of _another_
6146 thread. Single-step breakpoints are transparent to the
6147 breakpoints module. */
6149 random_signal
= !ecs
->hit_singlestep_breakpoint
;
6151 /* No? Perhaps we got a moribund watchpoint. */
6153 random_signal
= !stopped_by_watchpoint
;
6155 /* Always stop if the user explicitly requested this thread to
6157 if (ecs
->event_thread
->stop_requested
)
6160 infrun_debug_printf ("user-requested stop");
6163 /* For the program's own signals, act according to
6164 the signal handling tables. */
6168 /* Signal not for debugging purposes. */
6169 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
6170 enum gdb_signal stop_signal
= ecs
->event_thread
->suspend
.stop_signal
;
6172 infrun_debug_printf ("random signal (%s)",
6173 gdb_signal_to_symbol_string (stop_signal
));
6175 stopped_by_random_signal
= 1;
6177 /* Always stop on signals if we're either just gaining control
6178 of the program, or the user explicitly requested this thread
6179 to remain stopped. */
6180 if (stop_soon
!= NO_STOP_QUIETLY
6181 || ecs
->event_thread
->stop_requested
6183 && signal_stop_state (ecs
->event_thread
->suspend
.stop_signal
)))
6189 /* Notify observers the signal has "handle print" set. Note we
6190 returned early above if stopping; normal_stop handles the
6191 printing in that case. */
6192 if (signal_print
[ecs
->event_thread
->suspend
.stop_signal
])
6194 /* The signal table tells us to print about this signal. */
6195 target_terminal::ours_for_output ();
6196 gdb::observers::signal_received
.notify (ecs
->event_thread
->suspend
.stop_signal
);
6197 target_terminal::inferior ();
6200 /* Clear the signal if it should not be passed. */
6201 if (signal_program
[ecs
->event_thread
->suspend
.stop_signal
] == 0)
6202 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6204 if (ecs
->event_thread
->prev_pc
== ecs
->event_thread
->suspend
.stop_pc
6205 && ecs
->event_thread
->control
.trap_expected
6206 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6208 /* We were just starting a new sequence, attempting to
6209 single-step off of a breakpoint and expecting a SIGTRAP.
6210 Instead this signal arrives. This signal will take us out
6211 of the stepping range so GDB needs to remember to, when
6212 the signal handler returns, resume stepping off that
6214 /* To simplify things, "continue" is forced to use the same
6215 code paths as single-step - set a breakpoint at the
6216 signal return address and then, once hit, step off that
6218 infrun_debug_printf ("signal arrived while stepping over breakpoint");
6220 insert_hp_step_resume_breakpoint_at_frame (frame
);
6221 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6222 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6223 ecs
->event_thread
->control
.trap_expected
= 0;
6225 /* If we were nexting/stepping some other thread, switch to
6226 it, so that we don't continue it, losing control. */
6227 if (!switch_back_to_stepped_thread (ecs
))
6232 if (ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
6233 && (pc_in_thread_step_range (ecs
->event_thread
->suspend
.stop_pc
,
6235 || ecs
->event_thread
->control
.step_range_end
== 1)
6236 && frame_id_eq (get_stack_frame_id (frame
),
6237 ecs
->event_thread
->control
.step_stack_frame_id
)
6238 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6240 /* The inferior is about to take a signal that will take it
6241 out of the single step range. Set a breakpoint at the
6242 current PC (which is presumably where the signal handler
6243 will eventually return) and then allow the inferior to
6246 Note that this is only needed for a signal delivered
6247 while in the single-step range. Nested signals aren't a
6248 problem as they eventually all return. */
6249 infrun_debug_printf ("signal may take us out of single-step range");
6251 clear_step_over_info ();
6252 insert_hp_step_resume_breakpoint_at_frame (frame
);
6253 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6254 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6255 ecs
->event_thread
->control
.trap_expected
= 0;
6260 /* Note: step_resume_breakpoint may be non-NULL. This occurs
6261 when either there's a nested signal, or when there's a
6262 pending signal enabled just as the signal handler returns
6263 (leaving the inferior at the step-resume-breakpoint without
6264 actually executing it). Either way continue until the
6265 breakpoint is really hit. */
6267 if (!switch_back_to_stepped_thread (ecs
))
6269 infrun_debug_printf ("random signal, keep going");
6276 process_event_stop_test (ecs
);
6279 /* Come here when we've got some debug event / signal we can explain
6280 (IOW, not a random signal), and test whether it should cause a
6281 stop, or whether we should resume the inferior (transparently).
6282 E.g., could be a breakpoint whose condition evaluates false; we
6283 could be still stepping within the line; etc. */
6286 process_event_stop_test (struct execution_control_state
*ecs
)
6288 struct symtab_and_line stop_pc_sal
;
6289 struct frame_info
*frame
;
6290 struct gdbarch
*gdbarch
;
6291 CORE_ADDR jmp_buf_pc
;
6292 struct bpstat_what what
;
6294 /* Handle cases caused by hitting a breakpoint. */
6296 frame
= get_current_frame ();
6297 gdbarch
= get_frame_arch (frame
);
6299 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
6301 if (what
.call_dummy
)
6303 stop_stack_dummy
= what
.call_dummy
;
6306 /* A few breakpoint types have callbacks associated (e.g.,
6307 bp_jit_event). Run them now. */
6308 bpstat_run_callbacks (ecs
->event_thread
->control
.stop_bpstat
);
6310 /* If we hit an internal event that triggers symbol changes, the
6311 current frame will be invalidated within bpstat_what (e.g., if we
6312 hit an internal solib event). Re-fetch it. */
6313 frame
= get_current_frame ();
6314 gdbarch
= get_frame_arch (frame
);
6316 switch (what
.main_action
)
6318 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
6319 /* If we hit the breakpoint at longjmp while stepping, we
6320 install a momentary breakpoint at the target of the
6323 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME");
6325 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6327 if (what
.is_longjmp
)
6329 struct value
*arg_value
;
6331 /* If we set the longjmp breakpoint via a SystemTap probe,
6332 then use it to extract the arguments. The destination PC
6333 is the third argument to the probe. */
6334 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
6337 jmp_buf_pc
= value_as_address (arg_value
);
6338 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
6340 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
6341 || !gdbarch_get_longjmp_target (gdbarch
,
6342 frame
, &jmp_buf_pc
))
6344 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME "
6345 "(!gdbarch_get_longjmp_target)");
6350 /* Insert a breakpoint at resume address. */
6351 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
6354 check_exception_resume (ecs
, frame
);
6358 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
6360 struct frame_info
*init_frame
;
6362 /* There are several cases to consider.
6364 1. The initiating frame no longer exists. In this case we
6365 must stop, because the exception or longjmp has gone too
6368 2. The initiating frame exists, and is the same as the
6369 current frame. We stop, because the exception or longjmp
6372 3. The initiating frame exists and is different from the
6373 current frame. This means the exception or longjmp has
6374 been caught beneath the initiating frame, so keep going.
6376 4. longjmp breakpoint has been placed just to protect
6377 against stale dummy frames and user is not interested in
6378 stopping around longjmps. */
6380 infrun_debug_printf ("BPSTAT_WHAT_CLEAR_LONGJMP_RESUME");
6382 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
6384 delete_exception_resume_breakpoint (ecs
->event_thread
);
6386 if (what
.is_longjmp
)
6388 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
6390 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
6398 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
6402 struct frame_id current_id
6403 = get_frame_id (get_current_frame ());
6404 if (frame_id_eq (current_id
,
6405 ecs
->event_thread
->initiating_frame
))
6407 /* Case 2. Fall through. */
6417 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6419 delete_step_resume_breakpoint (ecs
->event_thread
);
6421 end_stepping_range (ecs
);
6425 case BPSTAT_WHAT_SINGLE
:
6426 infrun_debug_printf ("BPSTAT_WHAT_SINGLE");
6427 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6428 /* Still need to check other stuff, at least the case where we
6429 are stepping and step out of the right range. */
6432 case BPSTAT_WHAT_STEP_RESUME
:
6433 infrun_debug_printf ("BPSTAT_WHAT_STEP_RESUME");
6435 delete_step_resume_breakpoint (ecs
->event_thread
);
6436 if (ecs
->event_thread
->control
.proceed_to_finish
6437 && execution_direction
== EXEC_REVERSE
)
6439 struct thread_info
*tp
= ecs
->event_thread
;
6441 /* We are finishing a function in reverse, and just hit the
6442 step-resume breakpoint at the start address of the
6443 function, and we're almost there -- just need to back up
6444 by one more single-step, which should take us back to the
6446 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6450 fill_in_stop_func (gdbarch
, ecs
);
6451 if (ecs
->event_thread
->suspend
.stop_pc
== ecs
->stop_func_start
6452 && execution_direction
== EXEC_REVERSE
)
6454 /* We are stepping over a function call in reverse, and just
6455 hit the step-resume breakpoint at the start address of
6456 the function. Go back to single-stepping, which should
6457 take us back to the function call. */
6458 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6464 case BPSTAT_WHAT_STOP_NOISY
:
6465 infrun_debug_printf ("BPSTAT_WHAT_STOP_NOISY");
6466 stop_print_frame
= true;
6468 /* Assume the thread stopped for a breakpoint. We'll still check
6469 whether a/the breakpoint is there when the thread is next
6471 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6476 case BPSTAT_WHAT_STOP_SILENT
:
6477 infrun_debug_printf ("BPSTAT_WHAT_STOP_SILENT");
6478 stop_print_frame
= false;
6480 /* Assume the thread stopped for a breakpoint. We'll still check
6481 whether a/the breakpoint is there when the thread is next
6483 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6487 case BPSTAT_WHAT_HP_STEP_RESUME
:
6488 infrun_debug_printf ("BPSTAT_WHAT_HP_STEP_RESUME");
6490 delete_step_resume_breakpoint (ecs
->event_thread
);
6491 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6493 /* Back when the step-resume breakpoint was inserted, we
6494 were trying to single-step off a breakpoint. Go back to
6496 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6497 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6503 case BPSTAT_WHAT_KEEP_CHECKING
:
6507 /* If we stepped a permanent breakpoint and we had a high priority
6508 step-resume breakpoint for the address we stepped, but we didn't
6509 hit it, then we must have stepped into the signal handler. The
6510 step-resume was only necessary to catch the case of _not_
6511 stepping into the handler, so delete it, and fall through to
6512 checking whether the step finished. */
6513 if (ecs
->event_thread
->stepped_breakpoint
)
6515 struct breakpoint
*sr_bp
6516 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6519 && sr_bp
->loc
->permanent
6520 && sr_bp
->type
== bp_hp_step_resume
6521 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6523 infrun_debug_printf ("stepped permanent breakpoint, stopped in handler");
6524 delete_step_resume_breakpoint (ecs
->event_thread
);
6525 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6529 /* We come here if we hit a breakpoint but should not stop for it.
6530 Possibly we also were stepping and should stop for that. So fall
6531 through and test for stepping. But, if not stepping, do not
6534 /* In all-stop mode, if we're currently stepping but have stopped in
6535 some other thread, we need to switch back to the stepped thread. */
6536 if (switch_back_to_stepped_thread (ecs
))
6539 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6541 infrun_debug_printf ("step-resume breakpoint is inserted");
6543 /* Having a step-resume breakpoint overrides anything
6544 else having to do with stepping commands until
6545 that breakpoint is reached. */
6550 if (ecs
->event_thread
->control
.step_range_end
== 0)
6552 infrun_debug_printf ("no stepping, continue");
6553 /* Likewise if we aren't even stepping. */
6558 /* Re-fetch current thread's frame in case the code above caused
6559 the frame cache to be re-initialized, making our FRAME variable
6560 a dangling pointer. */
6561 frame
= get_current_frame ();
6562 gdbarch
= get_frame_arch (frame
);
6563 fill_in_stop_func (gdbarch
, ecs
);
6565 /* If stepping through a line, keep going if still within it.
6567 Note that step_range_end is the address of the first instruction
6568 beyond the step range, and NOT the address of the last instruction
6571 Note also that during reverse execution, we may be stepping
6572 through a function epilogue and therefore must detect when
6573 the current-frame changes in the middle of a line. */
6575 if (pc_in_thread_step_range (ecs
->event_thread
->suspend
.stop_pc
,
6577 && (execution_direction
!= EXEC_REVERSE
6578 || frame_id_eq (get_frame_id (frame
),
6579 ecs
->event_thread
->control
.step_frame_id
)))
6582 ("stepping inside range [%s-%s]",
6583 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6584 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6586 /* Tentatively re-enable range stepping; `resume' disables it if
6587 necessary (e.g., if we're stepping over a breakpoint or we
6588 have software watchpoints). */
6589 ecs
->event_thread
->control
.may_range_step
= 1;
6591 /* When stepping backward, stop at beginning of line range
6592 (unless it's the function entry point, in which case
6593 keep going back to the call point). */
6594 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6595 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6596 && stop_pc
!= ecs
->stop_func_start
6597 && execution_direction
== EXEC_REVERSE
)
6598 end_stepping_range (ecs
);
6605 /* We stepped out of the stepping range. */
6607 /* If we are stepping at the source level and entered the runtime
6608 loader dynamic symbol resolution code...
6610 EXEC_FORWARD: we keep on single stepping until we exit the run
6611 time loader code and reach the callee's address.
6613 EXEC_REVERSE: we've already executed the callee (backward), and
6614 the runtime loader code is handled just like any other
6615 undebuggable function call. Now we need only keep stepping
6616 backward through the trampoline code, and that's handled further
6617 down, so there is nothing for us to do here. */
6619 if (execution_direction
!= EXEC_REVERSE
6620 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6621 && in_solib_dynsym_resolve_code (ecs
->event_thread
->suspend
.stop_pc
))
6623 CORE_ADDR pc_after_resolver
=
6624 gdbarch_skip_solib_resolver (gdbarch
,
6625 ecs
->event_thread
->suspend
.stop_pc
);
6627 infrun_debug_printf ("stepped into dynsym resolve code");
6629 if (pc_after_resolver
)
6631 /* Set up a step-resume breakpoint at the address
6632 indicated by SKIP_SOLIB_RESOLVER. */
6633 symtab_and_line sr_sal
;
6634 sr_sal
.pc
= pc_after_resolver
;
6635 sr_sal
.pspace
= get_frame_program_space (frame
);
6637 insert_step_resume_breakpoint_at_sal (gdbarch
,
6638 sr_sal
, null_frame_id
);
6645 /* Step through an indirect branch thunk. */
6646 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6647 && gdbarch_in_indirect_branch_thunk (gdbarch
,
6648 ecs
->event_thread
->suspend
.stop_pc
))
6650 infrun_debug_printf ("stepped into indirect branch thunk");
6655 if (ecs
->event_thread
->control
.step_range_end
!= 1
6656 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6657 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6658 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6660 infrun_debug_printf ("stepped into signal trampoline");
6661 /* The inferior, while doing a "step" or "next", has ended up in
6662 a signal trampoline (either by a signal being delivered or by
6663 the signal handler returning). Just single-step until the
6664 inferior leaves the trampoline (either by calling the handler
6670 /* If we're in the return path from a shared library trampoline,
6671 we want to proceed through the trampoline when stepping. */
6672 /* macro/2012-04-25: This needs to come before the subroutine
6673 call check below as on some targets return trampolines look
6674 like subroutine calls (MIPS16 return thunks). */
6675 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6676 ecs
->event_thread
->suspend
.stop_pc
,
6677 ecs
->stop_func_name
)
6678 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6680 /* Determine where this trampoline returns. */
6681 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6682 CORE_ADDR real_stop_pc
6683 = gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6685 infrun_debug_printf ("stepped into solib return tramp");
6687 /* Only proceed through if we know where it's going. */
6690 /* And put the step-breakpoint there and go until there. */
6691 symtab_and_line sr_sal
;
6692 sr_sal
.pc
= real_stop_pc
;
6693 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6694 sr_sal
.pspace
= get_frame_program_space (frame
);
6696 /* Do not specify what the fp should be when we stop since
6697 on some machines the prologue is where the new fp value
6699 insert_step_resume_breakpoint_at_sal (gdbarch
,
6700 sr_sal
, null_frame_id
);
6702 /* Restart without fiddling with the step ranges or
6709 /* Check for subroutine calls. The check for the current frame
6710 equalling the step ID is not necessary - the check of the
6711 previous frame's ID is sufficient - but it is a common case and
6712 cheaper than checking the previous frame's ID.
6714 NOTE: frame_id_eq will never report two invalid frame IDs as
6715 being equal, so to get into this block, both the current and
6716 previous frame must have valid frame IDs. */
6717 /* The outer_frame_id check is a heuristic to detect stepping
6718 through startup code. If we step over an instruction which
6719 sets the stack pointer from an invalid value to a valid value,
6720 we may detect that as a subroutine call from the mythical
6721 "outermost" function. This could be fixed by marking
6722 outermost frames as !stack_p,code_p,special_p. Then the
6723 initial outermost frame, before sp was valid, would
6724 have code_addr == &_start. See the comment in frame_id_eq
6726 if (!frame_id_eq (get_stack_frame_id (frame
),
6727 ecs
->event_thread
->control
.step_stack_frame_id
)
6728 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6729 ecs
->event_thread
->control
.step_stack_frame_id
)
6730 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6732 || (ecs
->event_thread
->control
.step_start_function
6733 != find_pc_function (ecs
->event_thread
->suspend
.stop_pc
)))))
6735 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6736 CORE_ADDR real_stop_pc
;
6738 infrun_debug_printf ("stepped into subroutine");
6740 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6742 /* I presume that step_over_calls is only 0 when we're
6743 supposed to be stepping at the assembly language level
6744 ("stepi"). Just stop. */
6745 /* And this works the same backward as frontward. MVS */
6746 end_stepping_range (ecs
);
6750 /* Reverse stepping through solib trampolines. */
6752 if (execution_direction
== EXEC_REVERSE
6753 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6754 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6755 || (ecs
->stop_func_start
== 0
6756 && in_solib_dynsym_resolve_code (stop_pc
))))
6758 /* Any solib trampoline code can be handled in reverse
6759 by simply continuing to single-step. We have already
6760 executed the solib function (backwards), and a few
6761 steps will take us back through the trampoline to the
6767 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6769 /* We're doing a "next".
6771 Normal (forward) execution: set a breakpoint at the
6772 callee's return address (the address at which the caller
6775 Reverse (backward) execution. set the step-resume
6776 breakpoint at the start of the function that we just
6777 stepped into (backwards), and continue to there. When we
6778 get there, we'll need to single-step back to the caller. */
6780 if (execution_direction
== EXEC_REVERSE
)
6782 /* If we're already at the start of the function, we've either
6783 just stepped backward into a single instruction function,
6784 or stepped back out of a signal handler to the first instruction
6785 of the function. Just keep going, which will single-step back
6787 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6789 /* Normal function call return (static or dynamic). */
6790 symtab_and_line sr_sal
;
6791 sr_sal
.pc
= ecs
->stop_func_start
;
6792 sr_sal
.pspace
= get_frame_program_space (frame
);
6793 insert_step_resume_breakpoint_at_sal (gdbarch
,
6794 sr_sal
, null_frame_id
);
6798 insert_step_resume_breakpoint_at_caller (frame
);
6804 /* If we are in a function call trampoline (a stub between the
6805 calling routine and the real function), locate the real
6806 function. That's what tells us (a) whether we want to step
6807 into it at all, and (b) what prologue we want to run to the
6808 end of, if we do step into it. */
6809 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6810 if (real_stop_pc
== 0)
6811 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6812 if (real_stop_pc
!= 0)
6813 ecs
->stop_func_start
= real_stop_pc
;
6815 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6817 symtab_and_line sr_sal
;
6818 sr_sal
.pc
= ecs
->stop_func_start
;
6819 sr_sal
.pspace
= get_frame_program_space (frame
);
6821 insert_step_resume_breakpoint_at_sal (gdbarch
,
6822 sr_sal
, null_frame_id
);
6827 /* If we have line number information for the function we are
6828 thinking of stepping into and the function isn't on the skip
6831 If there are several symtabs at that PC (e.g. with include
6832 files), just want to know whether *any* of them have line
6833 numbers. find_pc_line handles this. */
6835 struct symtab_and_line tmp_sal
;
6837 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6838 if (tmp_sal
.line
!= 0
6839 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6841 && !inline_frame_is_marked_for_skip (true, ecs
->event_thread
))
6843 if (execution_direction
== EXEC_REVERSE
)
6844 handle_step_into_function_backward (gdbarch
, ecs
);
6846 handle_step_into_function (gdbarch
, ecs
);
6851 /* If we have no line number and the step-stop-if-no-debug is
6852 set, we stop the step so that the user has a chance to switch
6853 in assembly mode. */
6854 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6855 && step_stop_if_no_debug
)
6857 end_stepping_range (ecs
);
6861 if (execution_direction
== EXEC_REVERSE
)
6863 /* If we're already at the start of the function, we've either just
6864 stepped backward into a single instruction function without line
6865 number info, or stepped back out of a signal handler to the first
6866 instruction of the function without line number info. Just keep
6867 going, which will single-step back to the caller. */
6868 if (ecs
->stop_func_start
!= stop_pc
)
6870 /* Set a breakpoint at callee's start address.
6871 From there we can step once and be back in the caller. */
6872 symtab_and_line sr_sal
;
6873 sr_sal
.pc
= ecs
->stop_func_start
;
6874 sr_sal
.pspace
= get_frame_program_space (frame
);
6875 insert_step_resume_breakpoint_at_sal (gdbarch
,
6876 sr_sal
, null_frame_id
);
6880 /* Set a breakpoint at callee's return address (the address
6881 at which the caller will resume). */
6882 insert_step_resume_breakpoint_at_caller (frame
);
6888 /* Reverse stepping through solib trampolines. */
6890 if (execution_direction
== EXEC_REVERSE
6891 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6893 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6895 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6896 || (ecs
->stop_func_start
== 0
6897 && in_solib_dynsym_resolve_code (stop_pc
)))
6899 /* Any solib trampoline code can be handled in reverse
6900 by simply continuing to single-step. We have already
6901 executed the solib function (backwards), and a few
6902 steps will take us back through the trampoline to the
6907 else if (in_solib_dynsym_resolve_code (stop_pc
))
6909 /* Stepped backward into the solib dynsym resolver.
6910 Set a breakpoint at its start and continue, then
6911 one more step will take us out. */
6912 symtab_and_line sr_sal
;
6913 sr_sal
.pc
= ecs
->stop_func_start
;
6914 sr_sal
.pspace
= get_frame_program_space (frame
);
6915 insert_step_resume_breakpoint_at_sal (gdbarch
,
6916 sr_sal
, null_frame_id
);
6922 /* This always returns the sal for the inner-most frame when we are in a
6923 stack of inlined frames, even if GDB actually believes that it is in a
6924 more outer frame. This is checked for below by calls to
6925 inline_skipped_frames. */
6926 stop_pc_sal
= find_pc_line (ecs
->event_thread
->suspend
.stop_pc
, 0);
6928 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6929 the trampoline processing logic, however, there are some trampolines
6930 that have no names, so we should do trampoline handling first. */
6931 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6932 && ecs
->stop_func_name
== NULL
6933 && stop_pc_sal
.line
== 0)
6935 infrun_debug_printf ("stepped into undebuggable function");
6937 /* The inferior just stepped into, or returned to, an
6938 undebuggable function (where there is no debugging information
6939 and no line number corresponding to the address where the
6940 inferior stopped). Since we want to skip this kind of code,
6941 we keep going until the inferior returns from this
6942 function - unless the user has asked us not to (via
6943 set step-mode) or we no longer know how to get back
6944 to the call site. */
6945 if (step_stop_if_no_debug
6946 || !frame_id_p (frame_unwind_caller_id (frame
)))
6948 /* If we have no line number and the step-stop-if-no-debug
6949 is set, we stop the step so that the user has a chance to
6950 switch in assembly mode. */
6951 end_stepping_range (ecs
);
6956 /* Set a breakpoint at callee's return address (the address
6957 at which the caller will resume). */
6958 insert_step_resume_breakpoint_at_caller (frame
);
6964 if (ecs
->event_thread
->control
.step_range_end
== 1)
6966 /* It is stepi or nexti. We always want to stop stepping after
6968 infrun_debug_printf ("stepi/nexti");
6969 end_stepping_range (ecs
);
6973 if (stop_pc_sal
.line
== 0)
6975 /* We have no line number information. That means to stop
6976 stepping (does this always happen right after one instruction,
6977 when we do "s" in a function with no line numbers,
6978 or can this happen as a result of a return or longjmp?). */
6979 infrun_debug_printf ("line number info");
6980 end_stepping_range (ecs
);
6984 /* Look for "calls" to inlined functions, part one. If the inline
6985 frame machinery detected some skipped call sites, we have entered
6986 a new inline function. */
6988 if (frame_id_eq (get_frame_id (get_current_frame ()),
6989 ecs
->event_thread
->control
.step_frame_id
)
6990 && inline_skipped_frames (ecs
->event_thread
))
6992 infrun_debug_printf ("stepped into inlined function");
6994 symtab_and_line call_sal
= find_frame_sal (get_current_frame ());
6996 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
6998 /* For "step", we're going to stop. But if the call site
6999 for this inlined function is on the same source line as
7000 we were previously stepping, go down into the function
7001 first. Otherwise stop at the call site. */
7003 if (call_sal
.line
== ecs
->event_thread
->current_line
7004 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7006 step_into_inline_frame (ecs
->event_thread
);
7007 if (inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7014 end_stepping_range (ecs
);
7019 /* For "next", we should stop at the call site if it is on a
7020 different source line. Otherwise continue through the
7021 inlined function. */
7022 if (call_sal
.line
== ecs
->event_thread
->current_line
7023 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7026 end_stepping_range (ecs
);
7031 /* Look for "calls" to inlined functions, part two. If we are still
7032 in the same real function we were stepping through, but we have
7033 to go further up to find the exact frame ID, we are stepping
7034 through a more inlined call beyond its call site. */
7036 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
7037 && !frame_id_eq (get_frame_id (get_current_frame ()),
7038 ecs
->event_thread
->control
.step_frame_id
)
7039 && stepped_in_from (get_current_frame (),
7040 ecs
->event_thread
->control
.step_frame_id
))
7042 infrun_debug_printf ("stepping through inlined function");
7044 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
7045 || inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7048 end_stepping_range (ecs
);
7052 bool refresh_step_info
= true;
7053 if ((ecs
->event_thread
->suspend
.stop_pc
== stop_pc_sal
.pc
)
7054 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
7055 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
7057 if (stop_pc_sal
.is_stmt
)
7059 /* We are at the start of a different line. So stop. Note that
7060 we don't stop if we step into the middle of a different line.
7061 That is said to make things like for (;;) statements work
7063 infrun_debug_printf ("stepped to a different line");
7064 end_stepping_range (ecs
);
7067 else if (frame_id_eq (get_frame_id (get_current_frame ()),
7068 ecs
->event_thread
->control
.step_frame_id
))
7070 /* We are at the start of a different line, however, this line is
7071 not marked as a statement, and we have not changed frame. We
7072 ignore this line table entry, and continue stepping forward,
7073 looking for a better place to stop. */
7074 refresh_step_info
= false;
7075 infrun_debug_printf ("stepped to a different line, but "
7076 "it's not the start of a statement");
7080 /* We aren't done stepping.
7082 Optimize by setting the stepping range to the line.
7083 (We might not be in the original line, but if we entered a
7084 new line in mid-statement, we continue stepping. This makes
7085 things like for(;;) statements work better.)
7087 If we entered a SAL that indicates a non-statement line table entry,
7088 then we update the stepping range, but we don't update the step info,
7089 which includes things like the line number we are stepping away from.
7090 This means we will stop when we find a line table entry that is marked
7091 as is-statement, even if it matches the non-statement one we just
7094 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
7095 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
7096 ecs
->event_thread
->control
.may_range_step
= 1;
7097 if (refresh_step_info
)
7098 set_step_info (ecs
->event_thread
, frame
, stop_pc_sal
);
7100 infrun_debug_printf ("keep going");
7104 /* In all-stop mode, if we're currently stepping but have stopped in
7105 some other thread, we may need to switch back to the stepped
7106 thread. Returns true we set the inferior running, false if we left
7107 it stopped (and the event needs further processing). */
7110 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
7112 if (!target_is_non_stop_p ())
7114 struct thread_info
*stepping_thread
;
7116 /* If any thread is blocked on some internal breakpoint, and we
7117 simply need to step over that breakpoint to get it going
7118 again, do that first. */
7120 /* However, if we see an event for the stepping thread, then we
7121 know all other threads have been moved past their breakpoints
7122 already. Let the caller check whether the step is finished,
7123 etc., before deciding to move it past a breakpoint. */
7124 if (ecs
->event_thread
->control
.step_range_end
!= 0)
7127 /* Check if the current thread is blocked on an incomplete
7128 step-over, interrupted by a random signal. */
7129 if (ecs
->event_thread
->control
.trap_expected
7130 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
7133 ("need to finish step-over of [%s]",
7134 target_pid_to_str (ecs
->event_thread
->ptid
).c_str ());
7139 /* Check if the current thread is blocked by a single-step
7140 breakpoint of another thread. */
7141 if (ecs
->hit_singlestep_breakpoint
)
7143 infrun_debug_printf ("need to step [%s] over single-step breakpoint",
7144 target_pid_to_str (ecs
->ptid
).c_str ());
7149 /* If this thread needs yet another step-over (e.g., stepping
7150 through a delay slot), do it first before moving on to
7152 if (thread_still_needs_step_over (ecs
->event_thread
))
7155 ("thread [%s] still needs step-over",
7156 target_pid_to_str (ecs
->event_thread
->ptid
).c_str ());
7161 /* If scheduler locking applies even if not stepping, there's no
7162 need to walk over threads. Above we've checked whether the
7163 current thread is stepping. If some other thread not the
7164 event thread is stepping, then it must be that scheduler
7165 locking is not in effect. */
7166 if (schedlock_applies (ecs
->event_thread
))
7169 /* Otherwise, we no longer expect a trap in the current thread.
7170 Clear the trap_expected flag before switching back -- this is
7171 what keep_going does as well, if we call it. */
7172 ecs
->event_thread
->control
.trap_expected
= 0;
7174 /* Likewise, clear the signal if it should not be passed. */
7175 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7176 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7178 /* Do all pending step-overs before actually proceeding with
7180 if (start_step_over ())
7182 prepare_to_wait (ecs
);
7186 /* Look for the stepping/nexting thread. */
7187 stepping_thread
= NULL
;
7189 for (thread_info
*tp
: all_non_exited_threads ())
7191 switch_to_thread_no_regs (tp
);
7193 /* Ignore threads of processes the caller is not
7196 && (tp
->inf
->process_target () != ecs
->target
7197 || tp
->inf
->pid
!= ecs
->ptid
.pid ()))
7200 /* When stepping over a breakpoint, we lock all threads
7201 except the one that needs to move past the breakpoint.
7202 If a non-event thread has this set, the "incomplete
7203 step-over" check above should have caught it earlier. */
7204 if (tp
->control
.trap_expected
)
7206 internal_error (__FILE__
, __LINE__
,
7207 "[%s] has inconsistent state: "
7208 "trap_expected=%d\n",
7209 target_pid_to_str (tp
->ptid
).c_str (),
7210 tp
->control
.trap_expected
);
7213 /* Did we find the stepping thread? */
7214 if (tp
->control
.step_range_end
)
7216 /* Yep. There should only one though. */
7217 gdb_assert (stepping_thread
== NULL
);
7219 /* The event thread is handled at the top, before we
7221 gdb_assert (tp
!= ecs
->event_thread
);
7223 /* If some thread other than the event thread is
7224 stepping, then scheduler locking can't be in effect,
7225 otherwise we wouldn't have resumed the current event
7226 thread in the first place. */
7227 gdb_assert (!schedlock_applies (tp
));
7229 stepping_thread
= tp
;
7233 if (stepping_thread
!= NULL
)
7235 infrun_debug_printf ("switching back to stepped thread");
7237 if (keep_going_stepped_thread (stepping_thread
))
7239 prepare_to_wait (ecs
);
7244 switch_to_thread (ecs
->event_thread
);
7250 /* Set a previously stepped thread back to stepping. Returns true on
7251 success, false if the resume is not possible (e.g., the thread
7255 keep_going_stepped_thread (struct thread_info
*tp
)
7257 struct frame_info
*frame
;
7258 struct execution_control_state ecss
;
7259 struct execution_control_state
*ecs
= &ecss
;
7261 /* If the stepping thread exited, then don't try to switch back and
7262 resume it, which could fail in several different ways depending
7263 on the target. Instead, just keep going.
7265 We can find a stepping dead thread in the thread list in two
7268 - The target supports thread exit events, and when the target
7269 tries to delete the thread from the thread list, inferior_ptid
7270 pointed at the exiting thread. In such case, calling
7271 delete_thread does not really remove the thread from the list;
7272 instead, the thread is left listed, with 'exited' state.
7274 - The target's debug interface does not support thread exit
7275 events, and so we have no idea whatsoever if the previously
7276 stepping thread is still alive. For that reason, we need to
7277 synchronously query the target now. */
7279 if (tp
->state
== THREAD_EXITED
|| !target_thread_alive (tp
->ptid
))
7281 infrun_debug_printf ("not resuming previously stepped thread, it has "
7288 infrun_debug_printf ("resuming previously stepped thread");
7290 reset_ecs (ecs
, tp
);
7291 switch_to_thread (tp
);
7293 tp
->suspend
.stop_pc
= regcache_read_pc (get_thread_regcache (tp
));
7294 frame
= get_current_frame ();
7296 /* If the PC of the thread we were trying to single-step has
7297 changed, then that thread has trapped or been signaled, but the
7298 event has not been reported to GDB yet. Re-poll the target
7299 looking for this particular thread's event (i.e. temporarily
7300 enable schedlock) by:
7302 - setting a break at the current PC
7303 - resuming that particular thread, only (by setting trap
7306 This prevents us continuously moving the single-step breakpoint
7307 forward, one instruction at a time, overstepping. */
7309 if (tp
->suspend
.stop_pc
!= tp
->prev_pc
)
7313 infrun_debug_printf ("expected thread advanced also (%s -> %s)",
7314 paddress (target_gdbarch (), tp
->prev_pc
),
7315 paddress (target_gdbarch (), tp
->suspend
.stop_pc
));
7317 /* Clear the info of the previous step-over, as it's no longer
7318 valid (if the thread was trying to step over a breakpoint, it
7319 has already succeeded). It's what keep_going would do too,
7320 if we called it. Do this before trying to insert the sss
7321 breakpoint, otherwise if we were previously trying to step
7322 over this exact address in another thread, the breakpoint is
7324 clear_step_over_info ();
7325 tp
->control
.trap_expected
= 0;
7327 insert_single_step_breakpoint (get_frame_arch (frame
),
7328 get_frame_address_space (frame
),
7329 tp
->suspend
.stop_pc
);
7332 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
7333 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
7337 infrun_debug_printf ("expected thread still hasn't advanced");
7339 keep_going_pass_signal (ecs
);
7345 /* Is thread TP in the middle of (software or hardware)
7346 single-stepping? (Note the result of this function must never be
7347 passed directly as target_resume's STEP parameter.) */
7350 currently_stepping (struct thread_info
*tp
)
7352 return ((tp
->control
.step_range_end
7353 && tp
->control
.step_resume_breakpoint
== NULL
)
7354 || tp
->control
.trap_expected
7355 || tp
->stepped_breakpoint
7356 || bpstat_should_step ());
7359 /* Inferior has stepped into a subroutine call with source code that
7360 we should not step over. Do step to the first line of code in
7364 handle_step_into_function (struct gdbarch
*gdbarch
,
7365 struct execution_control_state
*ecs
)
7367 fill_in_stop_func (gdbarch
, ecs
);
7369 compunit_symtab
*cust
7370 = find_pc_compunit_symtab (ecs
->event_thread
->suspend
.stop_pc
);
7371 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7372 ecs
->stop_func_start
7373 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7375 symtab_and_line stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
7376 /* Use the step_resume_break to step until the end of the prologue,
7377 even if that involves jumps (as it seems to on the vax under
7379 /* If the prologue ends in the middle of a source line, continue to
7380 the end of that source line (if it is still within the function).
7381 Otherwise, just go to end of prologue. */
7382 if (stop_func_sal
.end
7383 && stop_func_sal
.pc
!= ecs
->stop_func_start
7384 && stop_func_sal
.end
< ecs
->stop_func_end
)
7385 ecs
->stop_func_start
= stop_func_sal
.end
;
7387 /* Architectures which require breakpoint adjustment might not be able
7388 to place a breakpoint at the computed address. If so, the test
7389 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7390 ecs->stop_func_start to an address at which a breakpoint may be
7391 legitimately placed.
7393 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7394 made, GDB will enter an infinite loop when stepping through
7395 optimized code consisting of VLIW instructions which contain
7396 subinstructions corresponding to different source lines. On
7397 FR-V, it's not permitted to place a breakpoint on any but the
7398 first subinstruction of a VLIW instruction. When a breakpoint is
7399 set, GDB will adjust the breakpoint address to the beginning of
7400 the VLIW instruction. Thus, we need to make the corresponding
7401 adjustment here when computing the stop address. */
7403 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7405 ecs
->stop_func_start
7406 = gdbarch_adjust_breakpoint_address (gdbarch
,
7407 ecs
->stop_func_start
);
7410 if (ecs
->stop_func_start
== ecs
->event_thread
->suspend
.stop_pc
)
7412 /* We are already there: stop now. */
7413 end_stepping_range (ecs
);
7418 /* Put the step-breakpoint there and go until there. */
7419 symtab_and_line sr_sal
;
7420 sr_sal
.pc
= ecs
->stop_func_start
;
7421 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7422 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7424 /* Do not specify what the fp should be when we stop since on
7425 some machines the prologue is where the new fp value is
7427 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7429 /* And make sure stepping stops right away then. */
7430 ecs
->event_thread
->control
.step_range_end
7431 = ecs
->event_thread
->control
.step_range_start
;
7436 /* Inferior has stepped backward into a subroutine call with source
7437 code that we should not step over. Do step to the beginning of the
7438 last line of code in it. */
7441 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7442 struct execution_control_state
*ecs
)
7444 struct compunit_symtab
*cust
;
7445 struct symtab_and_line stop_func_sal
;
7447 fill_in_stop_func (gdbarch
, ecs
);
7449 cust
= find_pc_compunit_symtab (ecs
->event_thread
->suspend
.stop_pc
);
7450 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7451 ecs
->stop_func_start
7452 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7454 stop_func_sal
= find_pc_line (ecs
->event_thread
->suspend
.stop_pc
, 0);
7456 /* OK, we're just going to keep stepping here. */
7457 if (stop_func_sal
.pc
== ecs
->event_thread
->suspend
.stop_pc
)
7459 /* We're there already. Just stop stepping now. */
7460 end_stepping_range (ecs
);
7464 /* Else just reset the step range and keep going.
7465 No step-resume breakpoint, they don't work for
7466 epilogues, which can have multiple entry paths. */
7467 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7468 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7474 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7475 This is used to both functions and to skip over code. */
7478 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7479 struct symtab_and_line sr_sal
,
7480 struct frame_id sr_id
,
7481 enum bptype sr_type
)
7483 /* There should never be more than one step-resume or longjmp-resume
7484 breakpoint per thread, so we should never be setting a new
7485 step_resume_breakpoint when one is already active. */
7486 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7487 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7489 infrun_debug_printf ("inserting step-resume breakpoint at %s",
7490 paddress (gdbarch
, sr_sal
.pc
));
7492 inferior_thread ()->control
.step_resume_breakpoint
7493 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
).release ();
7497 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7498 struct symtab_and_line sr_sal
,
7499 struct frame_id sr_id
)
7501 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7506 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7507 This is used to skip a potential signal handler.
7509 This is called with the interrupted function's frame. The signal
7510 handler, when it returns, will resume the interrupted function at
7514 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7516 gdb_assert (return_frame
!= NULL
);
7518 struct gdbarch
*gdbarch
= get_frame_arch (return_frame
);
7520 symtab_and_line sr_sal
;
7521 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7522 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7523 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7525 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7526 get_stack_frame_id (return_frame
),
7530 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7531 is used to skip a function after stepping into it (for "next" or if
7532 the called function has no debugging information).
7534 The current function has almost always been reached by single
7535 stepping a call or return instruction. NEXT_FRAME belongs to the
7536 current function, and the breakpoint will be set at the caller's
7539 This is a separate function rather than reusing
7540 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7541 get_prev_frame, which may stop prematurely (see the implementation
7542 of frame_unwind_caller_id for an example). */
7545 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7547 /* We shouldn't have gotten here if we don't know where the call site
7549 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7551 struct gdbarch
*gdbarch
= frame_unwind_caller_arch (next_frame
);
7553 symtab_and_line sr_sal
;
7554 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7555 frame_unwind_caller_pc (next_frame
));
7556 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7557 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7559 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7560 frame_unwind_caller_id (next_frame
));
7563 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7564 new breakpoint at the target of a jmp_buf. The handling of
7565 longjmp-resume uses the same mechanisms used for handling
7566 "step-resume" breakpoints. */
7569 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7571 /* There should never be more than one longjmp-resume breakpoint per
7572 thread, so we should never be setting a new
7573 longjmp_resume_breakpoint when one is already active. */
7574 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7576 infrun_debug_printf ("inserting longjmp-resume breakpoint at %s",
7577 paddress (gdbarch
, pc
));
7579 inferior_thread ()->control
.exception_resume_breakpoint
=
7580 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
).release ();
7583 /* Insert an exception resume breakpoint. TP is the thread throwing
7584 the exception. The block B is the block of the unwinder debug hook
7585 function. FRAME is the frame corresponding to the call to this
7586 function. SYM is the symbol of the function argument holding the
7587 target PC of the exception. */
7590 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7591 const struct block
*b
,
7592 struct frame_info
*frame
,
7597 struct block_symbol vsym
;
7598 struct value
*value
;
7600 struct breakpoint
*bp
;
7602 vsym
= lookup_symbol_search_name (sym
->search_name (),
7604 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
7605 /* If the value was optimized out, revert to the old behavior. */
7606 if (! value_optimized_out (value
))
7608 handler
= value_as_address (value
);
7610 infrun_debug_printf ("exception resume at %lx",
7611 (unsigned long) handler
);
7613 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7615 bp_exception_resume
).release ();
7617 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7620 bp
->thread
= tp
->global_num
;
7621 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7624 catch (const gdb_exception_error
&e
)
7626 /* We want to ignore errors here. */
7630 /* A helper for check_exception_resume that sets an
7631 exception-breakpoint based on a SystemTap probe. */
7634 insert_exception_resume_from_probe (struct thread_info
*tp
,
7635 const struct bound_probe
*probe
,
7636 struct frame_info
*frame
)
7638 struct value
*arg_value
;
7640 struct breakpoint
*bp
;
7642 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7646 handler
= value_as_address (arg_value
);
7648 infrun_debug_printf ("exception resume at %s",
7649 paddress (probe
->objfile
->arch (), handler
));
7651 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7652 handler
, bp_exception_resume
).release ();
7653 bp
->thread
= tp
->global_num
;
7654 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7657 /* This is called when an exception has been intercepted. Check to
7658 see whether the exception's destination is of interest, and if so,
7659 set an exception resume breakpoint there. */
7662 check_exception_resume (struct execution_control_state
*ecs
,
7663 struct frame_info
*frame
)
7665 struct bound_probe probe
;
7666 struct symbol
*func
;
7668 /* First see if this exception unwinding breakpoint was set via a
7669 SystemTap probe point. If so, the probe has two arguments: the
7670 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7671 set a breakpoint there. */
7672 probe
= find_probe_by_pc (get_frame_pc (frame
));
7675 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7679 func
= get_frame_function (frame
);
7685 const struct block
*b
;
7686 struct block_iterator iter
;
7690 /* The exception breakpoint is a thread-specific breakpoint on
7691 the unwinder's debug hook, declared as:
7693 void _Unwind_DebugHook (void *cfa, void *handler);
7695 The CFA argument indicates the frame to which control is
7696 about to be transferred. HANDLER is the destination PC.
7698 We ignore the CFA and set a temporary breakpoint at HANDLER.
7699 This is not extremely efficient but it avoids issues in gdb
7700 with computing the DWARF CFA, and it also works even in weird
7701 cases such as throwing an exception from inside a signal
7704 b
= SYMBOL_BLOCK_VALUE (func
);
7705 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7707 if (!SYMBOL_IS_ARGUMENT (sym
))
7714 insert_exception_resume_breakpoint (ecs
->event_thread
,
7720 catch (const gdb_exception_error
&e
)
7726 stop_waiting (struct execution_control_state
*ecs
)
7728 infrun_debug_printf ("stop_waiting");
7730 /* Let callers know we don't want to wait for the inferior anymore. */
7731 ecs
->wait_some_more
= 0;
7733 /* If all-stop, but there exists a non-stop target, stop all
7734 threads now that we're presenting the stop to the user. */
7735 if (!non_stop
&& exists_non_stop_target ())
7736 stop_all_threads ();
7739 /* Like keep_going, but passes the signal to the inferior, even if the
7740 signal is set to nopass. */
7743 keep_going_pass_signal (struct execution_control_state
*ecs
)
7745 gdb_assert (ecs
->event_thread
->ptid
== inferior_ptid
);
7746 gdb_assert (!ecs
->event_thread
->resumed
);
7748 /* Save the pc before execution, to compare with pc after stop. */
7749 ecs
->event_thread
->prev_pc
7750 = regcache_read_pc_protected (get_thread_regcache (ecs
->event_thread
));
7752 if (ecs
->event_thread
->control
.trap_expected
)
7754 struct thread_info
*tp
= ecs
->event_thread
;
7756 infrun_debug_printf ("%s has trap_expected set, "
7757 "resuming to collect trap",
7758 target_pid_to_str (tp
->ptid
).c_str ());
7760 /* We haven't yet gotten our trap, and either: intercepted a
7761 non-signal event (e.g., a fork); or took a signal which we
7762 are supposed to pass through to the inferior. Simply
7764 resume (ecs
->event_thread
->suspend
.stop_signal
);
7766 else if (step_over_info_valid_p ())
7768 /* Another thread is stepping over a breakpoint in-line. If
7769 this thread needs a step-over too, queue the request. In
7770 either case, this resume must be deferred for later. */
7771 struct thread_info
*tp
= ecs
->event_thread
;
7773 if (ecs
->hit_singlestep_breakpoint
7774 || thread_still_needs_step_over (tp
))
7776 infrun_debug_printf ("step-over already in progress: "
7777 "step-over for %s deferred",
7778 target_pid_to_str (tp
->ptid
).c_str ());
7779 global_thread_step_over_chain_enqueue (tp
);
7783 infrun_debug_printf ("step-over in progress: resume of %s deferred",
7784 target_pid_to_str (tp
->ptid
).c_str ());
7789 struct regcache
*regcache
= get_current_regcache ();
7792 step_over_what step_what
;
7794 /* Either the trap was not expected, but we are continuing
7795 anyway (if we got a signal, the user asked it be passed to
7798 We got our expected trap, but decided we should resume from
7801 We're going to run this baby now!
7803 Note that insert_breakpoints won't try to re-insert
7804 already inserted breakpoints. Therefore, we don't
7805 care if breakpoints were already inserted, or not. */
7807 /* If we need to step over a breakpoint, and we're not using
7808 displaced stepping to do so, insert all breakpoints
7809 (watchpoints, etc.) but the one we're stepping over, step one
7810 instruction, and then re-insert the breakpoint when that step
7813 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
7815 remove_bp
= (ecs
->hit_singlestep_breakpoint
7816 || (step_what
& STEP_OVER_BREAKPOINT
));
7817 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
7819 /* We can't use displaced stepping if we need to step past a
7820 watchpoint. The instruction copied to the scratch pad would
7821 still trigger the watchpoint. */
7823 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
7825 set_step_over_info (regcache
->aspace (),
7826 regcache_read_pc (regcache
), remove_wps
,
7827 ecs
->event_thread
->global_num
);
7829 else if (remove_wps
)
7830 set_step_over_info (NULL
, 0, remove_wps
, -1);
7832 /* If we now need to do an in-line step-over, we need to stop
7833 all other threads. Note this must be done before
7834 insert_breakpoints below, because that removes the breakpoint
7835 we're about to step over, otherwise other threads could miss
7837 if (step_over_info_valid_p () && target_is_non_stop_p ())
7838 stop_all_threads ();
7840 /* Stop stepping if inserting breakpoints fails. */
7843 insert_breakpoints ();
7845 catch (const gdb_exception_error
&e
)
7847 exception_print (gdb_stderr
, e
);
7849 clear_step_over_info ();
7853 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
7855 resume (ecs
->event_thread
->suspend
.stop_signal
);
7858 prepare_to_wait (ecs
);
7861 /* Called when we should continue running the inferior, because the
7862 current event doesn't cause a user visible stop. This does the
7863 resuming part; waiting for the next event is done elsewhere. */
7866 keep_going (struct execution_control_state
*ecs
)
7868 if (ecs
->event_thread
->control
.trap_expected
7869 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
7870 ecs
->event_thread
->control
.trap_expected
= 0;
7872 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7873 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7874 keep_going_pass_signal (ecs
);
7877 /* This function normally comes after a resume, before
7878 handle_inferior_event exits. It takes care of any last bits of
7879 housekeeping, and sets the all-important wait_some_more flag. */
7882 prepare_to_wait (struct execution_control_state
*ecs
)
7884 infrun_debug_printf ("prepare_to_wait");
7886 ecs
->wait_some_more
= 1;
7888 /* If the target can't async, emulate it by marking the infrun event
7889 handler such that as soon as we get back to the event-loop, we
7890 immediately end up in fetch_inferior_event again calling
7892 if (!target_can_async_p ())
7893 mark_infrun_async_event_handler ();
7896 /* We are done with the step range of a step/next/si/ni command.
7897 Called once for each n of a "step n" operation. */
7900 end_stepping_range (struct execution_control_state
*ecs
)
7902 ecs
->event_thread
->control
.stop_step
= 1;
7906 /* Several print_*_reason functions to print why the inferior has stopped.
7907 We always print something when the inferior exits, or receives a signal.
7908 The rest of the cases are dealt with later on in normal_stop and
7909 print_it_typical. Ideally there should be a call to one of these
7910 print_*_reason functions functions from handle_inferior_event each time
7911 stop_waiting is called.
7913 Note that we don't call these directly, instead we delegate that to
7914 the interpreters, through observers. Interpreters then call these
7915 with whatever uiout is right. */
7918 print_end_stepping_range_reason (struct ui_out
*uiout
)
7920 /* For CLI-like interpreters, print nothing. */
7922 if (uiout
->is_mi_like_p ())
7924 uiout
->field_string ("reason",
7925 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
7930 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7932 annotate_signalled ();
7933 if (uiout
->is_mi_like_p ())
7935 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
7936 uiout
->text ("\nProgram terminated with signal ");
7937 annotate_signal_name ();
7938 uiout
->field_string ("signal-name",
7939 gdb_signal_to_name (siggnal
));
7940 annotate_signal_name_end ();
7942 annotate_signal_string ();
7943 uiout
->field_string ("signal-meaning",
7944 gdb_signal_to_string (siggnal
));
7945 annotate_signal_string_end ();
7946 uiout
->text (".\n");
7947 uiout
->text ("The program no longer exists.\n");
7951 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
7953 struct inferior
*inf
= current_inferior ();
7954 std::string pidstr
= target_pid_to_str (ptid_t (inf
->pid
));
7956 annotate_exited (exitstatus
);
7959 if (uiout
->is_mi_like_p ())
7960 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED
));
7961 std::string exit_code_str
7962 = string_printf ("0%o", (unsigned int) exitstatus
);
7963 uiout
->message ("[Inferior %s (%s) exited with code %pF]\n",
7964 plongest (inf
->num
), pidstr
.c_str (),
7965 string_field ("exit-code", exit_code_str
.c_str ()));
7969 if (uiout
->is_mi_like_p ())
7971 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
7972 uiout
->message ("[Inferior %s (%s) exited normally]\n",
7973 plongest (inf
->num
), pidstr
.c_str ());
7978 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7980 struct thread_info
*thr
= inferior_thread ();
7984 if (uiout
->is_mi_like_p ())
7986 else if (show_thread_that_caused_stop ())
7990 uiout
->text ("\nThread ");
7991 uiout
->field_string ("thread-id", print_thread_id (thr
));
7993 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
7996 uiout
->text (" \"");
7997 uiout
->field_string ("name", name
);
8002 uiout
->text ("\nProgram");
8004 if (siggnal
== GDB_SIGNAL_0
&& !uiout
->is_mi_like_p ())
8005 uiout
->text (" stopped");
8008 uiout
->text (" received signal ");
8009 annotate_signal_name ();
8010 if (uiout
->is_mi_like_p ())
8012 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
8013 uiout
->field_string ("signal-name", gdb_signal_to_name (siggnal
));
8014 annotate_signal_name_end ();
8016 annotate_signal_string ();
8017 uiout
->field_string ("signal-meaning", gdb_signal_to_string (siggnal
));
8019 struct regcache
*regcache
= get_current_regcache ();
8020 struct gdbarch
*gdbarch
= regcache
->arch ();
8021 if (gdbarch_report_signal_info_p (gdbarch
))
8022 gdbarch_report_signal_info (gdbarch
, uiout
, siggnal
);
8024 annotate_signal_string_end ();
8026 uiout
->text (".\n");
8030 print_no_history_reason (struct ui_out
*uiout
)
8032 uiout
->text ("\nNo more reverse-execution history.\n");
8035 /* Print current location without a level number, if we have changed
8036 functions or hit a breakpoint. Print source line if we have one.
8037 bpstat_print contains the logic deciding in detail what to print,
8038 based on the event(s) that just occurred. */
8041 print_stop_location (struct target_waitstatus
*ws
)
8044 enum print_what source_flag
;
8045 int do_frame_printing
= 1;
8046 struct thread_info
*tp
= inferior_thread ();
8048 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
8052 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8053 should) carry around the function and does (or should) use
8054 that when doing a frame comparison. */
8055 if (tp
->control
.stop_step
8056 && frame_id_eq (tp
->control
.step_frame_id
,
8057 get_frame_id (get_current_frame ()))
8058 && (tp
->control
.step_start_function
8059 == find_pc_function (tp
->suspend
.stop_pc
)))
8061 /* Finished step, just print source line. */
8062 source_flag
= SRC_LINE
;
8066 /* Print location and source line. */
8067 source_flag
= SRC_AND_LOC
;
8070 case PRINT_SRC_AND_LOC
:
8071 /* Print location and source line. */
8072 source_flag
= SRC_AND_LOC
;
8074 case PRINT_SRC_ONLY
:
8075 source_flag
= SRC_LINE
;
8078 /* Something bogus. */
8079 source_flag
= SRC_LINE
;
8080 do_frame_printing
= 0;
8083 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
8086 /* The behavior of this routine with respect to the source
8088 SRC_LINE: Print only source line
8089 LOCATION: Print only location
8090 SRC_AND_LOC: Print location and source line. */
8091 if (do_frame_printing
)
8092 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
8098 print_stop_event (struct ui_out
*uiout
, bool displays
)
8100 struct target_waitstatus last
;
8101 struct thread_info
*tp
;
8103 get_last_target_status (nullptr, nullptr, &last
);
8106 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
8108 print_stop_location (&last
);
8110 /* Display the auto-display expressions. */
8115 tp
= inferior_thread ();
8116 if (tp
->thread_fsm
!= NULL
8117 && tp
->thread_fsm
->finished_p ())
8119 struct return_value_info
*rv
;
8121 rv
= tp
->thread_fsm
->return_value ();
8123 print_return_value (uiout
, rv
);
8130 maybe_remove_breakpoints (void)
8132 if (!breakpoints_should_be_inserted_now () && target_has_execution ())
8134 if (remove_breakpoints ())
8136 target_terminal::ours_for_output ();
8137 printf_filtered (_("Cannot remove breakpoints because "
8138 "program is no longer writable.\nFurther "
8139 "execution is probably impossible.\n"));
8144 /* The execution context that just caused a normal stop. */
8151 DISABLE_COPY_AND_ASSIGN (stop_context
);
8153 bool changed () const;
8158 /* The event PTID. */
8162 /* If stopp for a thread event, this is the thread that caused the
8164 struct thread_info
*thread
;
8166 /* The inferior that caused the stop. */
8170 /* Initializes a new stop context. If stopped for a thread event, this
8171 takes a strong reference to the thread. */
8173 stop_context::stop_context ()
8175 stop_id
= get_stop_id ();
8176 ptid
= inferior_ptid
;
8177 inf_num
= current_inferior ()->num
;
8179 if (inferior_ptid
!= null_ptid
)
8181 /* Take a strong reference so that the thread can't be deleted
8183 thread
= inferior_thread ();
8190 /* Release a stop context previously created with save_stop_context.
8191 Releases the strong reference to the thread as well. */
8193 stop_context::~stop_context ()
8199 /* Return true if the current context no longer matches the saved stop
8203 stop_context::changed () const
8205 if (ptid
!= inferior_ptid
)
8207 if (inf_num
!= current_inferior ()->num
)
8209 if (thread
!= NULL
&& thread
->state
!= THREAD_STOPPED
)
8211 if (get_stop_id () != stop_id
)
8221 struct target_waitstatus last
;
8223 get_last_target_status (nullptr, nullptr, &last
);
8227 /* If an exception is thrown from this point on, make sure to
8228 propagate GDB's knowledge of the executing state to the
8229 frontend/user running state. A QUIT is an easy exception to see
8230 here, so do this before any filtered output. */
8232 ptid_t finish_ptid
= null_ptid
;
8235 finish_ptid
= minus_one_ptid
;
8236 else if (last
.kind
== TARGET_WAITKIND_SIGNALLED
8237 || last
.kind
== TARGET_WAITKIND_EXITED
)
8239 /* On some targets, we may still have live threads in the
8240 inferior when we get a process exit event. E.g., for
8241 "checkpoint", when the current checkpoint/fork exits,
8242 linux-fork.c automatically switches to another fork from
8243 within target_mourn_inferior. */
8244 if (inferior_ptid
!= null_ptid
)
8245 finish_ptid
= ptid_t (inferior_ptid
.pid ());
8247 else if (last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8248 finish_ptid
= inferior_ptid
;
8250 gdb::optional
<scoped_finish_thread_state
> maybe_finish_thread_state
;
8251 if (finish_ptid
!= null_ptid
)
8253 maybe_finish_thread_state
.emplace
8254 (user_visible_resume_target (finish_ptid
), finish_ptid
);
8257 /* As we're presenting a stop, and potentially removing breakpoints,
8258 update the thread list so we can tell whether there are threads
8259 running on the target. With target remote, for example, we can
8260 only learn about new threads when we explicitly update the thread
8261 list. Do this before notifying the interpreters about signal
8262 stops, end of stepping ranges, etc., so that the "new thread"
8263 output is emitted before e.g., "Program received signal FOO",
8264 instead of after. */
8265 update_thread_list ();
8267 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
8268 gdb::observers::signal_received
.notify (inferior_thread ()->suspend
.stop_signal
);
8270 /* As with the notification of thread events, we want to delay
8271 notifying the user that we've switched thread context until
8272 the inferior actually stops.
8274 There's no point in saying anything if the inferior has exited.
8275 Note that SIGNALLED here means "exited with a signal", not
8276 "received a signal".
8278 Also skip saying anything in non-stop mode. In that mode, as we
8279 don't want GDB to switch threads behind the user's back, to avoid
8280 races where the user is typing a command to apply to thread x,
8281 but GDB switches to thread y before the user finishes entering
8282 the command, fetch_inferior_event installs a cleanup to restore
8283 the current thread back to the thread the user had selected right
8284 after this event is handled, so we're not really switching, only
8285 informing of a stop. */
8287 && previous_inferior_ptid
!= inferior_ptid
8288 && target_has_execution ()
8289 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
8290 && last
.kind
!= TARGET_WAITKIND_EXITED
8291 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8293 SWITCH_THRU_ALL_UIS ()
8295 target_terminal::ours_for_output ();
8296 printf_filtered (_("[Switching to %s]\n"),
8297 target_pid_to_str (inferior_ptid
).c_str ());
8298 annotate_thread_changed ();
8300 previous_inferior_ptid
= inferior_ptid
;
8303 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
8305 SWITCH_THRU_ALL_UIS ()
8306 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
8308 target_terminal::ours_for_output ();
8309 printf_filtered (_("No unwaited-for children left.\n"));
8313 /* Note: this depends on the update_thread_list call above. */
8314 maybe_remove_breakpoints ();
8316 /* If an auto-display called a function and that got a signal,
8317 delete that auto-display to avoid an infinite recursion. */
8319 if (stopped_by_random_signal
)
8320 disable_current_display ();
8322 SWITCH_THRU_ALL_UIS ()
8324 async_enable_stdin ();
8327 /* Let the user/frontend see the threads as stopped. */
8328 maybe_finish_thread_state
.reset ();
8330 /* Select innermost stack frame - i.e., current frame is frame 0,
8331 and current location is based on that. Handle the case where the
8332 dummy call is returning after being stopped. E.g. the dummy call
8333 previously hit a breakpoint. (If the dummy call returns
8334 normally, we won't reach here.) Do this before the stop hook is
8335 run, so that it doesn't get to see the temporary dummy frame,
8336 which is not where we'll present the stop. */
8337 if (has_stack_frames ())
8339 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
8341 /* Pop the empty frame that contains the stack dummy. This
8342 also restores inferior state prior to the call (struct
8343 infcall_suspend_state). */
8344 struct frame_info
*frame
= get_current_frame ();
8346 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
8348 /* frame_pop calls reinit_frame_cache as the last thing it
8349 does which means there's now no selected frame. */
8352 select_frame (get_current_frame ());
8354 /* Set the current source location. */
8355 set_current_sal_from_frame (get_current_frame ());
8358 /* Look up the hook_stop and run it (CLI internally handles problem
8359 of stop_command's pre-hook not existing). */
8360 if (stop_command
!= NULL
)
8362 stop_context saved_context
;
8366 execute_cmd_pre_hook (stop_command
);
8368 catch (const gdb_exception
&ex
)
8370 exception_fprintf (gdb_stderr
, ex
,
8371 "Error while running hook_stop:\n");
8374 /* If the stop hook resumes the target, then there's no point in
8375 trying to notify about the previous stop; its context is
8376 gone. Likewise if the command switches thread or inferior --
8377 the observers would print a stop for the wrong
8379 if (saved_context
.changed ())
8383 /* Notify observers about the stop. This is where the interpreters
8384 print the stop event. */
8385 if (inferior_ptid
!= null_ptid
)
8386 gdb::observers::normal_stop
.notify (inferior_thread ()->control
.stop_bpstat
,
8389 gdb::observers::normal_stop
.notify (NULL
, stop_print_frame
);
8391 annotate_stopped ();
8393 if (target_has_execution ())
8395 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
8396 && last
.kind
!= TARGET_WAITKIND_EXITED
8397 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8398 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8399 Delete any breakpoint that is to be deleted at the next stop. */
8400 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
8403 /* Try to get rid of automatically added inferiors that are no
8404 longer needed. Keeping those around slows down things linearly.
8405 Note that this never removes the current inferior. */
8412 signal_stop_state (int signo
)
8414 return signal_stop
[signo
];
8418 signal_print_state (int signo
)
8420 return signal_print
[signo
];
8424 signal_pass_state (int signo
)
8426 return signal_program
[signo
];
8430 signal_cache_update (int signo
)
8434 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
8435 signal_cache_update (signo
);
8440 signal_pass
[signo
] = (signal_stop
[signo
] == 0
8441 && signal_print
[signo
] == 0
8442 && signal_program
[signo
] == 1
8443 && signal_catch
[signo
] == 0);
8447 signal_stop_update (int signo
, int state
)
8449 int ret
= signal_stop
[signo
];
8451 signal_stop
[signo
] = state
;
8452 signal_cache_update (signo
);
8457 signal_print_update (int signo
, int state
)
8459 int ret
= signal_print
[signo
];
8461 signal_print
[signo
] = state
;
8462 signal_cache_update (signo
);
8467 signal_pass_update (int signo
, int state
)
8469 int ret
= signal_program
[signo
];
8471 signal_program
[signo
] = state
;
8472 signal_cache_update (signo
);
8476 /* Update the global 'signal_catch' from INFO and notify the
8480 signal_catch_update (const unsigned int *info
)
8484 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8485 signal_catch
[i
] = info
[i
] > 0;
8486 signal_cache_update (-1);
8487 target_pass_signals (signal_pass
);
8491 sig_print_header (void)
8493 printf_filtered (_("Signal Stop\tPrint\tPass "
8494 "to program\tDescription\n"));
8498 sig_print_info (enum gdb_signal oursig
)
8500 const char *name
= gdb_signal_to_name (oursig
);
8501 int name_padding
= 13 - strlen (name
);
8503 if (name_padding
<= 0)
8506 printf_filtered ("%s", name
);
8507 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8508 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8509 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8510 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8511 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8514 /* Specify how various signals in the inferior should be handled. */
8517 handle_command (const char *args
, int from_tty
)
8519 int digits
, wordlen
;
8520 int sigfirst
, siglast
;
8521 enum gdb_signal oursig
;
8526 error_no_arg (_("signal to handle"));
8529 /* Allocate and zero an array of flags for which signals to handle. */
8531 const size_t nsigs
= GDB_SIGNAL_LAST
;
8532 unsigned char sigs
[nsigs
] {};
8534 /* Break the command line up into args. */
8536 gdb_argv
built_argv (args
);
8538 /* Walk through the args, looking for signal oursigs, signal names, and
8539 actions. Signal numbers and signal names may be interspersed with
8540 actions, with the actions being performed for all signals cumulatively
8541 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8543 for (char *arg
: built_argv
)
8545 wordlen
= strlen (arg
);
8546 for (digits
= 0; isdigit (arg
[digits
]); digits
++)
8550 sigfirst
= siglast
= -1;
8552 if (wordlen
>= 1 && !strncmp (arg
, "all", wordlen
))
8554 /* Apply action to all signals except those used by the
8555 debugger. Silently skip those. */
8558 siglast
= nsigs
- 1;
8560 else if (wordlen
>= 1 && !strncmp (arg
, "stop", wordlen
))
8562 SET_SIGS (nsigs
, sigs
, signal_stop
);
8563 SET_SIGS (nsigs
, sigs
, signal_print
);
8565 else if (wordlen
>= 1 && !strncmp (arg
, "ignore", wordlen
))
8567 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8569 else if (wordlen
>= 2 && !strncmp (arg
, "print", wordlen
))
8571 SET_SIGS (nsigs
, sigs
, signal_print
);
8573 else if (wordlen
>= 2 && !strncmp (arg
, "pass", wordlen
))
8575 SET_SIGS (nsigs
, sigs
, signal_program
);
8577 else if (wordlen
>= 3 && !strncmp (arg
, "nostop", wordlen
))
8579 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8581 else if (wordlen
>= 3 && !strncmp (arg
, "noignore", wordlen
))
8583 SET_SIGS (nsigs
, sigs
, signal_program
);
8585 else if (wordlen
>= 4 && !strncmp (arg
, "noprint", wordlen
))
8587 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8588 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8590 else if (wordlen
>= 4 && !strncmp (arg
, "nopass", wordlen
))
8592 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8594 else if (digits
> 0)
8596 /* It is numeric. The numeric signal refers to our own
8597 internal signal numbering from target.h, not to host/target
8598 signal number. This is a feature; users really should be
8599 using symbolic names anyway, and the common ones like
8600 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8602 sigfirst
= siglast
= (int)
8603 gdb_signal_from_command (atoi (arg
));
8604 if (arg
[digits
] == '-')
8607 gdb_signal_from_command (atoi (arg
+ digits
+ 1));
8609 if (sigfirst
> siglast
)
8611 /* Bet he didn't figure we'd think of this case... */
8612 std::swap (sigfirst
, siglast
);
8617 oursig
= gdb_signal_from_name (arg
);
8618 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8620 sigfirst
= siglast
= (int) oursig
;
8624 /* Not a number and not a recognized flag word => complain. */
8625 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg
);
8629 /* If any signal numbers or symbol names were found, set flags for
8630 which signals to apply actions to. */
8632 for (int signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8634 switch ((enum gdb_signal
) signum
)
8636 case GDB_SIGNAL_TRAP
:
8637 case GDB_SIGNAL_INT
:
8638 if (!allsigs
&& !sigs
[signum
])
8640 if (query (_("%s is used by the debugger.\n\
8641 Are you sure you want to change it? "),
8642 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8647 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8651 case GDB_SIGNAL_DEFAULT
:
8652 case GDB_SIGNAL_UNKNOWN
:
8653 /* Make sure that "all" doesn't print these. */
8662 for (int signum
= 0; signum
< nsigs
; signum
++)
8665 signal_cache_update (-1);
8666 target_pass_signals (signal_pass
);
8667 target_program_signals (signal_program
);
8671 /* Show the results. */
8672 sig_print_header ();
8673 for (; signum
< nsigs
; signum
++)
8675 sig_print_info ((enum gdb_signal
) signum
);
8682 /* Complete the "handle" command. */
8685 handle_completer (struct cmd_list_element
*ignore
,
8686 completion_tracker
&tracker
,
8687 const char *text
, const char *word
)
8689 static const char * const keywords
[] =
8703 signal_completer (ignore
, tracker
, text
, word
);
8704 complete_on_enum (tracker
, keywords
, word
, word
);
8708 gdb_signal_from_command (int num
)
8710 if (num
>= 1 && num
<= 15)
8711 return (enum gdb_signal
) num
;
8712 error (_("Only signals 1-15 are valid as numeric signals.\n\
8713 Use \"info signals\" for a list of symbolic signals."));
8716 /* Print current contents of the tables set by the handle command.
8717 It is possible we should just be printing signals actually used
8718 by the current target (but for things to work right when switching
8719 targets, all signals should be in the signal tables). */
8722 info_signals_command (const char *signum_exp
, int from_tty
)
8724 enum gdb_signal oursig
;
8726 sig_print_header ();
8730 /* First see if this is a symbol name. */
8731 oursig
= gdb_signal_from_name (signum_exp
);
8732 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8734 /* No, try numeric. */
8736 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8738 sig_print_info (oursig
);
8742 printf_filtered ("\n");
8743 /* These ugly casts brought to you by the native VAX compiler. */
8744 for (oursig
= GDB_SIGNAL_FIRST
;
8745 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8746 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8750 if (oursig
!= GDB_SIGNAL_UNKNOWN
8751 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8752 sig_print_info (oursig
);
8755 printf_filtered (_("\nUse the \"handle\" command "
8756 "to change these tables.\n"));
8759 /* The $_siginfo convenience variable is a bit special. We don't know
8760 for sure the type of the value until we actually have a chance to
8761 fetch the data. The type can change depending on gdbarch, so it is
8762 also dependent on which thread you have selected.
8764 1. making $_siginfo be an internalvar that creates a new value on
8767 2. making the value of $_siginfo be an lval_computed value. */
8769 /* This function implements the lval_computed support for reading a
8773 siginfo_value_read (struct value
*v
)
8775 LONGEST transferred
;
8777 /* If we can access registers, so can we access $_siginfo. Likewise
8779 validate_registers_access ();
8782 target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
,
8784 value_contents_all_raw (v
),
8786 TYPE_LENGTH (value_type (v
)));
8788 if (transferred
!= TYPE_LENGTH (value_type (v
)))
8789 error (_("Unable to read siginfo"));
8792 /* This function implements the lval_computed support for writing a
8796 siginfo_value_write (struct value
*v
, struct value
*fromval
)
8798 LONGEST transferred
;
8800 /* If we can access registers, so can we access $_siginfo. Likewise
8802 validate_registers_access ();
8804 transferred
= target_write (current_top_target (),
8805 TARGET_OBJECT_SIGNAL_INFO
,
8807 value_contents_all_raw (fromval
),
8809 TYPE_LENGTH (value_type (fromval
)));
8811 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
8812 error (_("Unable to write siginfo"));
8815 static const struct lval_funcs siginfo_value_funcs
=
8821 /* Return a new value with the correct type for the siginfo object of
8822 the current thread using architecture GDBARCH. Return a void value
8823 if there's no object available. */
8825 static struct value
*
8826 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
8829 if (target_has_stack ()
8830 && inferior_ptid
!= null_ptid
8831 && gdbarch_get_siginfo_type_p (gdbarch
))
8833 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8835 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
8838 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
8842 /* infcall_suspend_state contains state about the program itself like its
8843 registers and any signal it received when it last stopped.
8844 This state must be restored regardless of how the inferior function call
8845 ends (either successfully, or after it hits a breakpoint or signal)
8846 if the program is to properly continue where it left off. */
8848 class infcall_suspend_state
8851 /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
8852 once the inferior function call has finished. */
8853 infcall_suspend_state (struct gdbarch
*gdbarch
,
8854 const struct thread_info
*tp
,
8855 struct regcache
*regcache
)
8856 : m_thread_suspend (tp
->suspend
),
8857 m_registers (new readonly_detached_regcache (*regcache
))
8859 gdb::unique_xmalloc_ptr
<gdb_byte
> siginfo_data
;
8861 if (gdbarch_get_siginfo_type_p (gdbarch
))
8863 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8864 size_t len
= TYPE_LENGTH (type
);
8866 siginfo_data
.reset ((gdb_byte
*) xmalloc (len
));
8868 if (target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8869 siginfo_data
.get (), 0, len
) != len
)
8871 /* Errors ignored. */
8872 siginfo_data
.reset (nullptr);
8878 m_siginfo_gdbarch
= gdbarch
;
8879 m_siginfo_data
= std::move (siginfo_data
);
8883 /* Return a pointer to the stored register state. */
8885 readonly_detached_regcache
*registers () const
8887 return m_registers
.get ();
8890 /* Restores the stored state into GDBARCH, TP, and REGCACHE. */
8892 void restore (struct gdbarch
*gdbarch
,
8893 struct thread_info
*tp
,
8894 struct regcache
*regcache
) const
8896 tp
->suspend
= m_thread_suspend
;
8898 if (m_siginfo_gdbarch
== gdbarch
)
8900 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8902 /* Errors ignored. */
8903 target_write (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8904 m_siginfo_data
.get (), 0, TYPE_LENGTH (type
));
8907 /* The inferior can be gone if the user types "print exit(0)"
8908 (and perhaps other times). */
8909 if (target_has_execution ())
8910 /* NB: The register write goes through to the target. */
8911 regcache
->restore (registers ());
8915 /* How the current thread stopped before the inferior function call was
8917 struct thread_suspend_state m_thread_suspend
;
8919 /* The registers before the inferior function call was executed. */
8920 std::unique_ptr
<readonly_detached_regcache
> m_registers
;
8922 /* Format of SIGINFO_DATA or NULL if it is not present. */
8923 struct gdbarch
*m_siginfo_gdbarch
= nullptr;
8925 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8926 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8927 content would be invalid. */
8928 gdb::unique_xmalloc_ptr
<gdb_byte
> m_siginfo_data
;
8931 infcall_suspend_state_up
8932 save_infcall_suspend_state ()
8934 struct thread_info
*tp
= inferior_thread ();
8935 struct regcache
*regcache
= get_current_regcache ();
8936 struct gdbarch
*gdbarch
= regcache
->arch ();
8938 infcall_suspend_state_up inf_state
8939 (new struct infcall_suspend_state (gdbarch
, tp
, regcache
));
8941 /* Having saved the current state, adjust the thread state, discarding
8942 any stop signal information. The stop signal is not useful when
8943 starting an inferior function call, and run_inferior_call will not use
8944 the signal due to its `proceed' call with GDB_SIGNAL_0. */
8945 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
8950 /* Restore inferior session state to INF_STATE. */
8953 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8955 struct thread_info
*tp
= inferior_thread ();
8956 struct regcache
*regcache
= get_current_regcache ();
8957 struct gdbarch
*gdbarch
= regcache
->arch ();
8959 inf_state
->restore (gdbarch
, tp
, regcache
);
8960 discard_infcall_suspend_state (inf_state
);
8964 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8969 readonly_detached_regcache
*
8970 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
8972 return inf_state
->registers ();
8975 /* infcall_control_state contains state regarding gdb's control of the
8976 inferior itself like stepping control. It also contains session state like
8977 the user's currently selected frame. */
8979 struct infcall_control_state
8981 struct thread_control_state thread_control
;
8982 struct inferior_control_state inferior_control
;
8985 enum stop_stack_kind stop_stack_dummy
= STOP_NONE
;
8986 int stopped_by_random_signal
= 0;
8988 /* ID and level of the selected frame when the inferior function
8990 struct frame_id selected_frame_id
{};
8991 int selected_frame_level
= -1;
8994 /* Save all of the information associated with the inferior<==>gdb
8997 infcall_control_state_up
8998 save_infcall_control_state ()
9000 infcall_control_state_up
inf_status (new struct infcall_control_state
);
9001 struct thread_info
*tp
= inferior_thread ();
9002 struct inferior
*inf
= current_inferior ();
9004 inf_status
->thread_control
= tp
->control
;
9005 inf_status
->inferior_control
= inf
->control
;
9007 tp
->control
.step_resume_breakpoint
= NULL
;
9008 tp
->control
.exception_resume_breakpoint
= NULL
;
9010 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
9011 chain. If caller's caller is walking the chain, they'll be happier if we
9012 hand them back the original chain when restore_infcall_control_state is
9014 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
9017 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
9018 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
9020 save_selected_frame (&inf_status
->selected_frame_id
,
9021 &inf_status
->selected_frame_level
);
9026 /* Restore inferior session state to INF_STATUS. */
9029 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
9031 struct thread_info
*tp
= inferior_thread ();
9032 struct inferior
*inf
= current_inferior ();
9034 if (tp
->control
.step_resume_breakpoint
)
9035 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
9037 if (tp
->control
.exception_resume_breakpoint
)
9038 tp
->control
.exception_resume_breakpoint
->disposition
9039 = disp_del_at_next_stop
;
9041 /* Handle the bpstat_copy of the chain. */
9042 bpstat_clear (&tp
->control
.stop_bpstat
);
9044 tp
->control
= inf_status
->thread_control
;
9045 inf
->control
= inf_status
->inferior_control
;
9048 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
9049 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
9051 if (target_has_stack ())
9053 restore_selected_frame (inf_status
->selected_frame_id
,
9054 inf_status
->selected_frame_level
);
9061 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
9063 if (inf_status
->thread_control
.step_resume_breakpoint
)
9064 inf_status
->thread_control
.step_resume_breakpoint
->disposition
9065 = disp_del_at_next_stop
;
9067 if (inf_status
->thread_control
.exception_resume_breakpoint
)
9068 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
9069 = disp_del_at_next_stop
;
9071 /* See save_infcall_control_state for info on stop_bpstat. */
9072 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
9080 clear_exit_convenience_vars (void)
9082 clear_internalvar (lookup_internalvar ("_exitsignal"));
9083 clear_internalvar (lookup_internalvar ("_exitcode"));
9087 /* User interface for reverse debugging:
9088 Set exec-direction / show exec-direction commands
9089 (returns error unless target implements to_set_exec_direction method). */
9091 enum exec_direction_kind execution_direction
= EXEC_FORWARD
;
9092 static const char exec_forward
[] = "forward";
9093 static const char exec_reverse
[] = "reverse";
9094 static const char *exec_direction
= exec_forward
;
9095 static const char *const exec_direction_names
[] = {
9102 set_exec_direction_func (const char *args
, int from_tty
,
9103 struct cmd_list_element
*cmd
)
9105 if (target_can_execute_reverse ())
9107 if (!strcmp (exec_direction
, exec_forward
))
9108 execution_direction
= EXEC_FORWARD
;
9109 else if (!strcmp (exec_direction
, exec_reverse
))
9110 execution_direction
= EXEC_REVERSE
;
9114 exec_direction
= exec_forward
;
9115 error (_("Target does not support this operation."));
9120 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
9121 struct cmd_list_element
*cmd
, const char *value
)
9123 switch (execution_direction
) {
9125 fprintf_filtered (out
, _("Forward.\n"));
9128 fprintf_filtered (out
, _("Reverse.\n"));
9131 internal_error (__FILE__
, __LINE__
,
9132 _("bogus execution_direction value: %d"),
9133 (int) execution_direction
);
9138 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
9139 struct cmd_list_element
*c
, const char *value
)
9141 fprintf_filtered (file
, _("Resuming the execution of threads "
9142 "of all processes is %s.\n"), value
);
9145 /* Implementation of `siginfo' variable. */
9147 static const struct internalvar_funcs siginfo_funcs
=
9154 /* Callback for infrun's target events source. This is marked when a
9155 thread has a pending status to process. */
9158 infrun_async_inferior_event_handler (gdb_client_data data
)
9160 inferior_event_handler (INF_REG_EVENT
);
9167 /* Verify that when two threads with the same ptid exist (from two different
9168 targets) and one of them changes ptid, we only update inferior_ptid if
9169 it is appropriate. */
9172 infrun_thread_ptid_changed ()
9174 gdbarch
*arch
= current_inferior ()->gdbarch
;
9176 /* The thread which inferior_ptid represents changes ptid. */
9178 scoped_restore_current_pspace_and_thread restore
;
9180 scoped_mock_context
<test_target_ops
> target1 (arch
);
9181 scoped_mock_context
<test_target_ops
> target2 (arch
);
9182 target2
.mock_inferior
.next
= &target1
.mock_inferior
;
9184 ptid_t
old_ptid (111, 222);
9185 ptid_t
new_ptid (111, 333);
9187 target1
.mock_inferior
.pid
= old_ptid
.pid ();
9188 target1
.mock_thread
.ptid
= old_ptid
;
9189 target2
.mock_inferior
.pid
= old_ptid
.pid ();
9190 target2
.mock_thread
.ptid
= old_ptid
;
9192 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
9193 set_current_inferior (&target1
.mock_inferior
);
9195 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
9197 gdb_assert (inferior_ptid
== new_ptid
);
9200 /* A thread with the same ptid as inferior_ptid, but from another target,
9203 scoped_restore_current_pspace_and_thread restore
;
9205 scoped_mock_context
<test_target_ops
> target1 (arch
);
9206 scoped_mock_context
<test_target_ops
> target2 (arch
);
9207 target2
.mock_inferior
.next
= &target1
.mock_inferior
;
9209 ptid_t
old_ptid (111, 222);
9210 ptid_t
new_ptid (111, 333);
9212 target1
.mock_inferior
.pid
= old_ptid
.pid ();
9213 target1
.mock_thread
.ptid
= old_ptid
;
9214 target2
.mock_inferior
.pid
= old_ptid
.pid ();
9215 target2
.mock_thread
.ptid
= old_ptid
;
9217 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
9218 set_current_inferior (&target2
.mock_inferior
);
9220 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
9222 gdb_assert (inferior_ptid
== old_ptid
);
9226 } /* namespace selftests */
9228 #endif /* GDB_SELF_TEST */
9230 void _initialize_infrun ();
9232 _initialize_infrun ()
9234 struct cmd_list_element
*c
;
9236 /* Register extra event sources in the event loop. */
9237 infrun_async_inferior_event_token
9238 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
,
9241 add_info ("signals", info_signals_command
, _("\
9242 What debugger does when program gets various signals.\n\
9243 Specify a signal as argument to print info on that signal only."));
9244 add_info_alias ("handle", "signals", 0);
9246 c
= add_com ("handle", class_run
, handle_command
, _("\
9247 Specify how to handle signals.\n\
9248 Usage: handle SIGNAL [ACTIONS]\n\
9249 Args are signals and actions to apply to those signals.\n\
9250 If no actions are specified, the current settings for the specified signals\n\
9251 will be displayed instead.\n\
9253 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9254 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9255 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9256 The special arg \"all\" is recognized to mean all signals except those\n\
9257 used by the debugger, typically SIGTRAP and SIGINT.\n\
9259 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9260 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9261 Stop means reenter debugger if this signal happens (implies print).\n\
9262 Print means print a message if this signal happens.\n\
9263 Pass means let program see this signal; otherwise program doesn't know.\n\
9264 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9265 Pass and Stop may be combined.\n\
9267 Multiple signals may be specified. Signal numbers and signal names\n\
9268 may be interspersed with actions, with the actions being performed for\n\
9269 all signals cumulatively specified."));
9270 set_cmd_completer (c
, handle_completer
);
9273 stop_command
= add_cmd ("stop", class_obscure
,
9274 not_just_help_class_command
, _("\
9275 There is no `stop' command, but you can set a hook on `stop'.\n\
9276 This allows you to set a list of commands to be run each time execution\n\
9277 of the program stops."), &cmdlist
);
9279 add_setshow_zuinteger_cmd ("infrun", class_maintenance
, &debug_infrun
, _("\
9280 Set inferior debugging."), _("\
9281 Show inferior debugging."), _("\
9282 When non-zero, inferior specific debugging is enabled."),
9285 &setdebuglist
, &showdebuglist
);
9287 add_setshow_boolean_cmd ("non-stop", no_class
,
9289 Set whether gdb controls the inferior in non-stop mode."), _("\
9290 Show whether gdb controls the inferior in non-stop mode."), _("\
9291 When debugging a multi-threaded program and this setting is\n\
9292 off (the default, also called all-stop mode), when one thread stops\n\
9293 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9294 all other threads in the program while you interact with the thread of\n\
9295 interest. When you continue or step a thread, you can allow the other\n\
9296 threads to run, or have them remain stopped, but while you inspect any\n\
9297 thread's state, all threads stop.\n\
9299 In non-stop mode, when one thread stops, other threads can continue\n\
9300 to run freely. You'll be able to step each thread independently,\n\
9301 leave it stopped or free to run as needed."),
9307 for (size_t i
= 0; i
< GDB_SIGNAL_LAST
; i
++)
9310 signal_print
[i
] = 1;
9311 signal_program
[i
] = 1;
9312 signal_catch
[i
] = 0;
9315 /* Signals caused by debugger's own actions should not be given to
9316 the program afterwards.
9318 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9319 explicitly specifies that it should be delivered to the target
9320 program. Typically, that would occur when a user is debugging a
9321 target monitor on a simulator: the target monitor sets a
9322 breakpoint; the simulator encounters this breakpoint and halts
9323 the simulation handing control to GDB; GDB, noting that the stop
9324 address doesn't map to any known breakpoint, returns control back
9325 to the simulator; the simulator then delivers the hardware
9326 equivalent of a GDB_SIGNAL_TRAP to the program being
9328 signal_program
[GDB_SIGNAL_TRAP
] = 0;
9329 signal_program
[GDB_SIGNAL_INT
] = 0;
9331 /* Signals that are not errors should not normally enter the debugger. */
9332 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
9333 signal_print
[GDB_SIGNAL_ALRM
] = 0;
9334 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
9335 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
9336 signal_stop
[GDB_SIGNAL_PROF
] = 0;
9337 signal_print
[GDB_SIGNAL_PROF
] = 0;
9338 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
9339 signal_print
[GDB_SIGNAL_CHLD
] = 0;
9340 signal_stop
[GDB_SIGNAL_IO
] = 0;
9341 signal_print
[GDB_SIGNAL_IO
] = 0;
9342 signal_stop
[GDB_SIGNAL_POLL
] = 0;
9343 signal_print
[GDB_SIGNAL_POLL
] = 0;
9344 signal_stop
[GDB_SIGNAL_URG
] = 0;
9345 signal_print
[GDB_SIGNAL_URG
] = 0;
9346 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
9347 signal_print
[GDB_SIGNAL_WINCH
] = 0;
9348 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
9349 signal_print
[GDB_SIGNAL_PRIO
] = 0;
9351 /* These signals are used internally by user-level thread
9352 implementations. (See signal(5) on Solaris.) Like the above
9353 signals, a healthy program receives and handles them as part of
9354 its normal operation. */
9355 signal_stop
[GDB_SIGNAL_LWP
] = 0;
9356 signal_print
[GDB_SIGNAL_LWP
] = 0;
9357 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
9358 signal_print
[GDB_SIGNAL_WAITING
] = 0;
9359 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
9360 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
9361 signal_stop
[GDB_SIGNAL_LIBRT
] = 0;
9362 signal_print
[GDB_SIGNAL_LIBRT
] = 0;
9364 /* Update cached state. */
9365 signal_cache_update (-1);
9367 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
9368 &stop_on_solib_events
, _("\
9369 Set stopping for shared library events."), _("\
9370 Show stopping for shared library events."), _("\
9371 If nonzero, gdb will give control to the user when the dynamic linker\n\
9372 notifies gdb of shared library events. The most common event of interest\n\
9373 to the user would be loading/unloading of a new library."),
9374 set_stop_on_solib_events
,
9375 show_stop_on_solib_events
,
9376 &setlist
, &showlist
);
9378 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
9379 follow_fork_mode_kind_names
,
9380 &follow_fork_mode_string
, _("\
9381 Set debugger response to a program call of fork or vfork."), _("\
9382 Show debugger response to a program call of fork or vfork."), _("\
9383 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9384 parent - the original process is debugged after a fork\n\
9385 child - the new process is debugged after a fork\n\
9386 The unfollowed process will continue to run.\n\
9387 By default, the debugger will follow the parent process."),
9389 show_follow_fork_mode_string
,
9390 &setlist
, &showlist
);
9392 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
9393 follow_exec_mode_names
,
9394 &follow_exec_mode_string
, _("\
9395 Set debugger response to a program call of exec."), _("\
9396 Show debugger response to a program call of exec."), _("\
9397 An exec call replaces the program image of a process.\n\
9399 follow-exec-mode can be:\n\
9401 new - the debugger creates a new inferior and rebinds the process\n\
9402 to this new inferior. The program the process was running before\n\
9403 the exec call can be restarted afterwards by restarting the original\n\
9406 same - the debugger keeps the process bound to the same inferior.\n\
9407 The new executable image replaces the previous executable loaded in\n\
9408 the inferior. Restarting the inferior after the exec call restarts\n\
9409 the executable the process was running after the exec call.\n\
9411 By default, the debugger will use the same inferior."),
9413 show_follow_exec_mode_string
,
9414 &setlist
, &showlist
);
9416 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9417 scheduler_enums
, &scheduler_mode
, _("\
9418 Set mode for locking scheduler during execution."), _("\
9419 Show mode for locking scheduler during execution."), _("\
9420 off == no locking (threads may preempt at any time)\n\
9421 on == full locking (no thread except the current thread may run)\n\
9422 This applies to both normal execution and replay mode.\n\
9423 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9424 In this mode, other threads may run during other commands.\n\
9425 This applies to both normal execution and replay mode.\n\
9426 replay == scheduler locked in replay mode and unlocked during normal execution."),
9427 set_schedlock_func
, /* traps on target vector */
9428 show_scheduler_mode
,
9429 &setlist
, &showlist
);
9431 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9432 Set mode for resuming threads of all processes."), _("\
9433 Show mode for resuming threads of all processes."), _("\
9434 When on, execution commands (such as 'continue' or 'next') resume all\n\
9435 threads of all processes. When off (which is the default), execution\n\
9436 commands only resume the threads of the current process. The set of\n\
9437 threads that are resumed is further refined by the scheduler-locking\n\
9438 mode (see help set scheduler-locking)."),
9440 show_schedule_multiple
,
9441 &setlist
, &showlist
);
9443 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9444 Set mode of the step operation."), _("\
9445 Show mode of the step operation."), _("\
9446 When set, doing a step over a function without debug line information\n\
9447 will stop at the first instruction of that function. Otherwise, the\n\
9448 function is skipped and the step command stops at a different source line."),
9450 show_step_stop_if_no_debug
,
9451 &setlist
, &showlist
);
9453 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9454 &can_use_displaced_stepping
, _("\
9455 Set debugger's willingness to use displaced stepping."), _("\
9456 Show debugger's willingness to use displaced stepping."), _("\
9457 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9458 supported by the target architecture. If off, gdb will not use displaced\n\
9459 stepping to step over breakpoints, even if such is supported by the target\n\
9460 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9461 if the target architecture supports it and non-stop mode is active, but will not\n\
9462 use it in all-stop mode (see help set non-stop)."),
9464 show_can_use_displaced_stepping
,
9465 &setlist
, &showlist
);
9467 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9468 &exec_direction
, _("Set direction of execution.\n\
9469 Options are 'forward' or 'reverse'."),
9470 _("Show direction of execution (forward/reverse)."),
9471 _("Tells gdb whether to execute forward or backward."),
9472 set_exec_direction_func
, show_exec_direction_func
,
9473 &setlist
, &showlist
);
9475 /* Set/show detach-on-fork: user-settable mode. */
9477 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9478 Set whether gdb will detach the child of a fork."), _("\
9479 Show whether gdb will detach the child of a fork."), _("\
9480 Tells gdb whether to detach the child of a fork."),
9481 NULL
, NULL
, &setlist
, &showlist
);
9483 /* Set/show disable address space randomization mode. */
9485 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9486 &disable_randomization
, _("\
9487 Set disabling of debuggee's virtual address space randomization."), _("\
9488 Show disabling of debuggee's virtual address space randomization."), _("\
9489 When this mode is on (which is the default), randomization of the virtual\n\
9490 address space is disabled. Standalone programs run with the randomization\n\
9491 enabled by default on some platforms."),
9492 &set_disable_randomization
,
9493 &show_disable_randomization
,
9494 &setlist
, &showlist
);
9496 /* ptid initializations */
9497 inferior_ptid
= null_ptid
;
9498 target_last_wait_ptid
= minus_one_ptid
;
9500 gdb::observers::thread_ptid_changed
.attach (infrun_thread_ptid_changed
);
9501 gdb::observers::thread_stop_requested
.attach (infrun_thread_stop_requested
);
9502 gdb::observers::thread_exit
.attach (infrun_thread_thread_exit
);
9503 gdb::observers::inferior_exit
.attach (infrun_inferior_exit
);
9504 gdb::observers::inferior_execd
.attach (infrun_inferior_execd
);
9506 /* Explicitly create without lookup, since that tries to create a
9507 value with a void typed value, and when we get here, gdbarch
9508 isn't initialized yet. At this point, we're quite sure there
9509 isn't another convenience variable of the same name. */
9510 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9512 add_setshow_boolean_cmd ("observer", no_class
,
9513 &observer_mode_1
, _("\
9514 Set whether gdb controls the inferior in observer mode."), _("\
9515 Show whether gdb controls the inferior in observer mode."), _("\
9516 In observer mode, GDB can get data from the inferior, but not\n\
9517 affect its execution. Registers and memory may not be changed,\n\
9518 breakpoints may not be set, and the program cannot be interrupted\n\
9526 selftests::register_test ("infrun_thread_ptid_changed",
9527 selftests::infrun_thread_ptid_changed
);