1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2021 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "displaced-stepping.h"
28 #include "breakpoint.h"
32 #include "target-connection.h"
33 #include "gdbthread.h"
40 #include "observable.h"
45 #include "mi/mi-common.h"
46 #include "event-top.h"
48 #include "record-full.h"
49 #include "inline-frame.h"
51 #include "tracepoint.h"
55 #include "completer.h"
56 #include "target-descriptions.h"
57 #include "target-dcache.h"
60 #include "gdbsupport/event-loop.h"
61 #include "thread-fsm.h"
62 #include "gdbsupport/enum-flags.h"
63 #include "progspace-and-thread.h"
64 #include "gdbsupport/gdb_optional.h"
65 #include "arch-utils.h"
66 #include "gdbsupport/scope-exit.h"
67 #include "gdbsupport/forward-scope-exit.h"
68 #include "gdbsupport/gdb_select.h"
69 #include <unordered_map>
70 #include "async-event.h"
71 #include "gdbsupport/selftest.h"
72 #include "scoped-mock-context.h"
73 #include "test-target.h"
74 #include "gdbsupport/common-debug.h"
76 /* Prototypes for local functions */
78 static void sig_print_info (enum gdb_signal
);
80 static void sig_print_header (void);
82 static void follow_inferior_reset_breakpoints (void);
84 static bool currently_stepping (struct thread_info
*tp
);
86 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
88 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
90 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
92 static bool maybe_software_singlestep (struct gdbarch
*gdbarch
);
94 static void resume (gdb_signal sig
);
96 static void wait_for_inferior (inferior
*inf
);
98 /* Asynchronous signal handler registered as event loop source for
99 when we have pending events ready to be passed to the core. */
100 static struct async_event_handler
*infrun_async_inferior_event_token
;
102 /* Stores whether infrun_async was previously enabled or disabled.
103 Starts off as -1, indicating "never enabled/disabled". */
104 static int infrun_is_async
= -1;
109 infrun_async (int enable
)
111 if (infrun_is_async
!= enable
)
113 infrun_is_async
= enable
;
115 infrun_debug_printf ("enable=%d", enable
);
118 mark_async_event_handler (infrun_async_inferior_event_token
);
120 clear_async_event_handler (infrun_async_inferior_event_token
);
127 mark_infrun_async_event_handler (void)
129 mark_async_event_handler (infrun_async_inferior_event_token
);
132 /* When set, stop the 'step' command if we enter a function which has
133 no line number information. The normal behavior is that we step
134 over such function. */
135 bool step_stop_if_no_debug
= false;
137 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
138 struct cmd_list_element
*c
, const char *value
)
140 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
143 /* proceed and normal_stop use this to notify the user when the
144 inferior stopped in a different thread than it had been running
147 static ptid_t previous_inferior_ptid
;
149 /* If set (default for legacy reasons), when following a fork, GDB
150 will detach from one of the fork branches, child or parent.
151 Exactly which branch is detached depends on 'set follow-fork-mode'
154 static bool detach_fork
= true;
156 bool debug_infrun
= false;
158 show_debug_infrun (struct ui_file
*file
, int from_tty
,
159 struct cmd_list_element
*c
, const char *value
)
161 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
164 /* Support for disabling address space randomization. */
166 bool disable_randomization
= true;
169 show_disable_randomization (struct ui_file
*file
, int from_tty
,
170 struct cmd_list_element
*c
, const char *value
)
172 if (target_supports_disable_randomization ())
173 fprintf_filtered (file
,
174 _("Disabling randomization of debuggee's "
175 "virtual address space is %s.\n"),
178 fputs_filtered (_("Disabling randomization of debuggee's "
179 "virtual address space is unsupported on\n"
180 "this platform.\n"), file
);
184 set_disable_randomization (const char *args
, int from_tty
,
185 struct cmd_list_element
*c
)
187 if (!target_supports_disable_randomization ())
188 error (_("Disabling randomization of debuggee's "
189 "virtual address space is unsupported on\n"
193 /* User interface for non-stop mode. */
195 bool non_stop
= false;
196 static bool non_stop_1
= false;
199 set_non_stop (const char *args
, int from_tty
,
200 struct cmd_list_element
*c
)
202 if (target_has_execution ())
204 non_stop_1
= non_stop
;
205 error (_("Cannot change this setting while the inferior is running."));
208 non_stop
= non_stop_1
;
212 show_non_stop (struct ui_file
*file
, int from_tty
,
213 struct cmd_list_element
*c
, const char *value
)
215 fprintf_filtered (file
,
216 _("Controlling the inferior in non-stop mode is %s.\n"),
220 /* "Observer mode" is somewhat like a more extreme version of
221 non-stop, in which all GDB operations that might affect the
222 target's execution have been disabled. */
224 static bool observer_mode
= false;
225 static bool observer_mode_1
= false;
228 set_observer_mode (const char *args
, int from_tty
,
229 struct cmd_list_element
*c
)
231 if (target_has_execution ())
233 observer_mode_1
= observer_mode
;
234 error (_("Cannot change this setting while the inferior is running."));
237 observer_mode
= observer_mode_1
;
239 may_write_registers
= !observer_mode
;
240 may_write_memory
= !observer_mode
;
241 may_insert_breakpoints
= !observer_mode
;
242 may_insert_tracepoints
= !observer_mode
;
243 /* We can insert fast tracepoints in or out of observer mode,
244 but enable them if we're going into this mode. */
246 may_insert_fast_tracepoints
= true;
247 may_stop
= !observer_mode
;
248 update_target_permissions ();
250 /* Going *into* observer mode we must force non-stop, then
251 going out we leave it that way. */
254 pagination_enabled
= 0;
255 non_stop
= non_stop_1
= true;
259 printf_filtered (_("Observer mode is now %s.\n"),
260 (observer_mode
? "on" : "off"));
264 show_observer_mode (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
, const char *value
)
267 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
270 /* This updates the value of observer mode based on changes in
271 permissions. Note that we are deliberately ignoring the values of
272 may-write-registers and may-write-memory, since the user may have
273 reason to enable these during a session, for instance to turn on a
274 debugging-related global. */
277 update_observer_mode (void)
279 bool newval
= (!may_insert_breakpoints
280 && !may_insert_tracepoints
281 && may_insert_fast_tracepoints
285 /* Let the user know if things change. */
286 if (newval
!= observer_mode
)
287 printf_filtered (_("Observer mode is now %s.\n"),
288 (newval
? "on" : "off"));
290 observer_mode
= observer_mode_1
= newval
;
293 /* Tables of how to react to signals; the user sets them. */
295 static unsigned char signal_stop
[GDB_SIGNAL_LAST
];
296 static unsigned char signal_print
[GDB_SIGNAL_LAST
];
297 static unsigned char signal_program
[GDB_SIGNAL_LAST
];
299 /* Table of signals that are registered with "catch signal". A
300 non-zero entry indicates that the signal is caught by some "catch
302 static unsigned char signal_catch
[GDB_SIGNAL_LAST
];
304 /* Table of signals that the target may silently handle.
305 This is automatically determined from the flags above,
306 and simply cached here. */
307 static unsigned char signal_pass
[GDB_SIGNAL_LAST
];
309 #define SET_SIGS(nsigs,sigs,flags) \
311 int signum = (nsigs); \
312 while (signum-- > 0) \
313 if ((sigs)[signum]) \
314 (flags)[signum] = 1; \
317 #define UNSET_SIGS(nsigs,sigs,flags) \
319 int signum = (nsigs); \
320 while (signum-- > 0) \
321 if ((sigs)[signum]) \
322 (flags)[signum] = 0; \
325 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
326 this function is to avoid exporting `signal_program'. */
329 update_signals_program_target (void)
331 target_program_signals (signal_program
);
334 /* Value to pass to target_resume() to cause all threads to resume. */
336 #define RESUME_ALL minus_one_ptid
338 /* Command list pointer for the "stop" placeholder. */
340 static struct cmd_list_element
*stop_command
;
342 /* Nonzero if we want to give control to the user when we're notified
343 of shared library events by the dynamic linker. */
344 int stop_on_solib_events
;
346 /* Enable or disable optional shared library event breakpoints
347 as appropriate when the above flag is changed. */
350 set_stop_on_solib_events (const char *args
,
351 int from_tty
, struct cmd_list_element
*c
)
353 update_solib_breakpoints ();
357 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
358 struct cmd_list_element
*c
, const char *value
)
360 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
364 /* True after stop if current stack frame should be printed. */
366 static bool stop_print_frame
;
368 /* This is a cached copy of the target/ptid/waitstatus of the last
369 event returned by target_wait()/deprecated_target_wait_hook().
370 This information is returned by get_last_target_status(). */
371 static process_stratum_target
*target_last_proc_target
;
372 static ptid_t target_last_wait_ptid
;
373 static struct target_waitstatus target_last_waitstatus
;
375 void init_thread_stepping_state (struct thread_info
*tss
);
377 static const char follow_fork_mode_child
[] = "child";
378 static const char follow_fork_mode_parent
[] = "parent";
380 static const char *const follow_fork_mode_kind_names
[] = {
381 follow_fork_mode_child
,
382 follow_fork_mode_parent
,
386 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
388 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
389 struct cmd_list_element
*c
, const char *value
)
391 fprintf_filtered (file
,
392 _("Debugger response to a program "
393 "call of fork or vfork is \"%s\".\n"),
398 /* Handle changes to the inferior list based on the type of fork,
399 which process is being followed, and whether the other process
400 should be detached. On entry inferior_ptid must be the ptid of
401 the fork parent. At return inferior_ptid is the ptid of the
402 followed inferior. */
405 follow_fork_inferior (bool follow_child
, bool detach_fork
)
407 target_waitkind fork_kind
= inferior_thread ()->pending_follow
.kind
;
408 gdb_assert (fork_kind
== TARGET_WAITKIND_FORKED
409 || fork_kind
== TARGET_WAITKIND_VFORKED
);
410 bool has_vforked
= fork_kind
== TARGET_WAITKIND_VFORKED
;
411 ptid_t parent_ptid
= inferior_ptid
;
412 ptid_t child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
415 && !non_stop
/* Non-stop always resumes both branches. */
416 && current_ui
->prompt_state
== PROMPT_BLOCKED
417 && !(follow_child
|| detach_fork
|| sched_multi
))
419 /* The parent stays blocked inside the vfork syscall until the
420 child execs or exits. If we don't let the child run, then
421 the parent stays blocked. If we're telling the parent to run
422 in the foreground, the user will not be able to ctrl-c to get
423 back the terminal, effectively hanging the debug session. */
424 fprintf_filtered (gdb_stderr
, _("\
425 Can not resume the parent process over vfork in the foreground while\n\
426 holding the child stopped. Try \"set detach-on-fork\" or \
427 \"set schedule-multiple\".\n"));
431 thread_info
*child_thr
= nullptr;
435 /* Detach new forked process? */
438 /* Before detaching from the child, remove all breakpoints
439 from it. If we forked, then this has already been taken
440 care of by infrun.c. If we vforked however, any
441 breakpoint inserted in the parent is visible in the
442 child, even those added while stopped in a vfork
443 catchpoint. This will remove the breakpoints from the
444 parent also, but they'll be reinserted below. */
447 /* Keep breakpoints list in sync. */
448 remove_breakpoints_inf (current_inferior ());
451 if (print_inferior_events
)
453 /* Ensure that we have a process ptid. */
454 ptid_t process_ptid
= ptid_t (child_ptid
.pid ());
456 target_terminal::ours_for_output ();
457 fprintf_filtered (gdb_stdlog
,
458 _("[Detaching after %s from child %s]\n"),
459 has_vforked
? "vfork" : "fork",
460 target_pid_to_str (process_ptid
).c_str ());
465 struct inferior
*parent_inf
, *child_inf
;
467 /* Add process to GDB's tables. */
468 child_inf
= add_inferior (child_ptid
.pid ());
470 parent_inf
= current_inferior ();
471 child_inf
->attach_flag
= parent_inf
->attach_flag
;
472 copy_terminal_info (child_inf
, parent_inf
);
473 child_inf
->gdbarch
= parent_inf
->gdbarch
;
474 copy_inferior_target_desc_info (child_inf
, parent_inf
);
476 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
478 set_current_inferior (child_inf
);
479 switch_to_no_thread ();
480 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
481 child_inf
->push_target (parent_inf
->process_target ());
482 child_thr
= add_thread_silent (child_inf
->process_target (),
485 /* If this is a vfork child, then the address-space is
486 shared with the parent. */
489 child_inf
->pspace
= parent_inf
->pspace
;
490 child_inf
->aspace
= parent_inf
->aspace
;
494 /* The parent will be frozen until the child is done
495 with the shared region. Keep track of the
497 child_inf
->vfork_parent
= parent_inf
;
498 child_inf
->pending_detach
= 0;
499 parent_inf
->vfork_child
= child_inf
;
500 parent_inf
->pending_detach
= 0;
502 /* Now that the inferiors and program spaces are all
503 wired up, we can switch to the child thread (which
504 switches inferior and program space too). */
505 switch_to_thread (child_thr
);
509 child_inf
->aspace
= new_address_space ();
510 child_inf
->pspace
= new program_space (child_inf
->aspace
);
511 child_inf
->removable
= 1;
512 set_current_program_space (child_inf
->pspace
);
513 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
515 /* solib_create_inferior_hook relies on the current
517 switch_to_thread (child_thr
);
523 struct inferior
*parent_inf
;
525 parent_inf
= current_inferior ();
527 /* If we detached from the child, then we have to be careful
528 to not insert breakpoints in the parent until the child
529 is done with the shared memory region. However, if we're
530 staying attached to the child, then we can and should
531 insert breakpoints, so that we can debug it. A
532 subsequent child exec or exit is enough to know when does
533 the child stops using the parent's address space. */
534 parent_inf
->waiting_for_vfork_done
= detach_fork
;
535 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
540 /* Follow the child. */
541 struct inferior
*parent_inf
, *child_inf
;
542 struct program_space
*parent_pspace
;
544 if (print_inferior_events
)
546 std::string parent_pid
= target_pid_to_str (parent_ptid
);
547 std::string child_pid
= target_pid_to_str (child_ptid
);
549 target_terminal::ours_for_output ();
550 fprintf_filtered (gdb_stdlog
,
551 _("[Attaching after %s %s to child %s]\n"),
553 has_vforked
? "vfork" : "fork",
557 /* Add the new inferior first, so that the target_detach below
558 doesn't unpush the target. */
560 child_inf
= add_inferior (child_ptid
.pid ());
562 parent_inf
= current_inferior ();
563 child_inf
->attach_flag
= parent_inf
->attach_flag
;
564 copy_terminal_info (child_inf
, parent_inf
);
565 child_inf
->gdbarch
= parent_inf
->gdbarch
;
566 copy_inferior_target_desc_info (child_inf
, parent_inf
);
568 parent_pspace
= parent_inf
->pspace
;
570 process_stratum_target
*target
= parent_inf
->process_target ();
573 /* Hold a strong reference to the target while (maybe)
574 detaching the parent. Otherwise detaching could close the
576 auto target_ref
= target_ops_ref::new_reference (target
);
578 /* If we're vforking, we want to hold on to the parent until
579 the child exits or execs. At child exec or exit time we
580 can remove the old breakpoints from the parent and detach
581 or resume debugging it. Otherwise, detach the parent now;
582 we'll want to reuse it's program/address spaces, but we
583 can't set them to the child before removing breakpoints
584 from the parent, otherwise, the breakpoints module could
585 decide to remove breakpoints from the wrong process (since
586 they'd be assigned to the same address space). */
590 gdb_assert (child_inf
->vfork_parent
== NULL
);
591 gdb_assert (parent_inf
->vfork_child
== NULL
);
592 child_inf
->vfork_parent
= parent_inf
;
593 child_inf
->pending_detach
= 0;
594 parent_inf
->vfork_child
= child_inf
;
595 parent_inf
->pending_detach
= detach_fork
;
596 parent_inf
->waiting_for_vfork_done
= 0;
598 else if (detach_fork
)
600 if (print_inferior_events
)
602 /* Ensure that we have a process ptid. */
603 ptid_t process_ptid
= ptid_t (parent_ptid
.pid ());
605 target_terminal::ours_for_output ();
606 fprintf_filtered (gdb_stdlog
,
607 _("[Detaching after fork from "
609 target_pid_to_str (process_ptid
).c_str ());
612 target_detach (parent_inf
, 0);
616 /* Note that the detach above makes PARENT_INF dangling. */
618 /* Add the child thread to the appropriate lists, and switch
619 to this new thread, before cloning the program space, and
620 informing the solib layer about this new process. */
622 set_current_inferior (child_inf
);
623 child_inf
->push_target (target
);
626 child_thr
= add_thread_silent (target
, child_ptid
);
628 /* If this is a vfork child, then the address-space is shared
629 with the parent. If we detached from the parent, then we can
630 reuse the parent's program/address spaces. */
631 if (has_vforked
|| detach_fork
)
633 child_inf
->pspace
= parent_pspace
;
634 child_inf
->aspace
= child_inf
->pspace
->aspace
;
640 child_inf
->aspace
= new_address_space ();
641 child_inf
->pspace
= new program_space (child_inf
->aspace
);
642 child_inf
->removable
= 1;
643 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
644 set_current_program_space (child_inf
->pspace
);
645 clone_program_space (child_inf
->pspace
, parent_pspace
);
648 switch_to_thread (child_thr
);
651 target_follow_fork (child_ptid
, fork_kind
, follow_child
, detach_fork
);
653 /* If we ended up creating a new inferior, call post_create_inferior to inform
654 the various subcomponents. */
655 if (child_thr
!= nullptr)
657 scoped_restore_current_thread restore
;
658 switch_to_thread (child_thr
);
660 post_create_inferior (0);
666 /* Tell the target to follow the fork we're stopped at. Returns true
667 if the inferior should be resumed; false, if the target for some
668 reason decided it's best not to resume. */
673 bool follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
674 bool should_resume
= true;
675 struct thread_info
*tp
;
677 /* Copy user stepping state to the new inferior thread. FIXME: the
678 followed fork child thread should have a copy of most of the
679 parent thread structure's run control related fields, not just these.
680 Initialized to avoid "may be used uninitialized" warnings from gcc. */
681 struct breakpoint
*step_resume_breakpoint
= NULL
;
682 struct breakpoint
*exception_resume_breakpoint
= NULL
;
683 CORE_ADDR step_range_start
= 0;
684 CORE_ADDR step_range_end
= 0;
685 int current_line
= 0;
686 symtab
*current_symtab
= NULL
;
687 struct frame_id step_frame_id
= { 0 };
688 struct thread_fsm
*thread_fsm
= NULL
;
692 process_stratum_target
*wait_target
;
694 struct target_waitstatus wait_status
;
696 /* Get the last target status returned by target_wait(). */
697 get_last_target_status (&wait_target
, &wait_ptid
, &wait_status
);
699 /* If not stopped at a fork event, then there's nothing else to
701 if (wait_status
.kind
!= TARGET_WAITKIND_FORKED
702 && wait_status
.kind
!= TARGET_WAITKIND_VFORKED
)
705 /* Check if we switched over from WAIT_PTID, since the event was
707 if (wait_ptid
!= minus_one_ptid
708 && (current_inferior ()->process_target () != wait_target
709 || inferior_ptid
!= wait_ptid
))
711 /* We did. Switch back to WAIT_PTID thread, to tell the
712 target to follow it (in either direction). We'll
713 afterwards refuse to resume, and inform the user what
715 thread_info
*wait_thread
= find_thread_ptid (wait_target
, wait_ptid
);
716 switch_to_thread (wait_thread
);
717 should_resume
= false;
721 tp
= inferior_thread ();
723 /* If there were any forks/vforks that were caught and are now to be
724 followed, then do so now. */
725 switch (tp
->pending_follow
.kind
)
727 case TARGET_WAITKIND_FORKED
:
728 case TARGET_WAITKIND_VFORKED
:
730 ptid_t parent
, child
;
732 /* If the user did a next/step, etc, over a fork call,
733 preserve the stepping state in the fork child. */
734 if (follow_child
&& should_resume
)
736 step_resume_breakpoint
= clone_momentary_breakpoint
737 (tp
->control
.step_resume_breakpoint
);
738 step_range_start
= tp
->control
.step_range_start
;
739 step_range_end
= tp
->control
.step_range_end
;
740 current_line
= tp
->current_line
;
741 current_symtab
= tp
->current_symtab
;
742 step_frame_id
= tp
->control
.step_frame_id
;
743 exception_resume_breakpoint
744 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
745 thread_fsm
= tp
->thread_fsm
;
747 /* For now, delete the parent's sr breakpoint, otherwise,
748 parent/child sr breakpoints are considered duplicates,
749 and the child version will not be installed. Remove
750 this when the breakpoints module becomes aware of
751 inferiors and address spaces. */
752 delete_step_resume_breakpoint (tp
);
753 tp
->control
.step_range_start
= 0;
754 tp
->control
.step_range_end
= 0;
755 tp
->control
.step_frame_id
= null_frame_id
;
756 delete_exception_resume_breakpoint (tp
);
757 tp
->thread_fsm
= NULL
;
760 parent
= inferior_ptid
;
761 child
= tp
->pending_follow
.value
.related_pid
;
763 process_stratum_target
*parent_targ
= tp
->inf
->process_target ();
764 /* Set up inferior(s) as specified by the caller, and tell the
765 target to do whatever is necessary to follow either parent
767 if (follow_fork_inferior (follow_child
, detach_fork
))
769 /* Target refused to follow, or there's some other reason
770 we shouldn't resume. */
775 /* This pending follow fork event is now handled, one way
776 or another. The previous selected thread may be gone
777 from the lists by now, but if it is still around, need
778 to clear the pending follow request. */
779 tp
= find_thread_ptid (parent_targ
, parent
);
781 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
783 /* This makes sure we don't try to apply the "Switched
784 over from WAIT_PID" logic above. */
785 nullify_last_target_wait_ptid ();
787 /* If we followed the child, switch to it... */
790 thread_info
*child_thr
= find_thread_ptid (parent_targ
, child
);
791 switch_to_thread (child_thr
);
793 /* ... and preserve the stepping state, in case the
794 user was stepping over the fork call. */
797 tp
= inferior_thread ();
798 tp
->control
.step_resume_breakpoint
799 = step_resume_breakpoint
;
800 tp
->control
.step_range_start
= step_range_start
;
801 tp
->control
.step_range_end
= step_range_end
;
802 tp
->current_line
= current_line
;
803 tp
->current_symtab
= current_symtab
;
804 tp
->control
.step_frame_id
= step_frame_id
;
805 tp
->control
.exception_resume_breakpoint
806 = exception_resume_breakpoint
;
807 tp
->thread_fsm
= thread_fsm
;
811 /* If we get here, it was because we're trying to
812 resume from a fork catchpoint, but, the user
813 has switched threads away from the thread that
814 forked. In that case, the resume command
815 issued is most likely not applicable to the
816 child, so just warn, and refuse to resume. */
817 warning (_("Not resuming: switched threads "
818 "before following fork child."));
821 /* Reset breakpoints in the child as appropriate. */
822 follow_inferior_reset_breakpoints ();
827 case TARGET_WAITKIND_SPURIOUS
:
828 /* Nothing to follow. */
831 internal_error (__FILE__
, __LINE__
,
832 "Unexpected pending_follow.kind %d\n",
833 tp
->pending_follow
.kind
);
837 return should_resume
;
841 follow_inferior_reset_breakpoints (void)
843 struct thread_info
*tp
= inferior_thread ();
845 /* Was there a step_resume breakpoint? (There was if the user
846 did a "next" at the fork() call.) If so, explicitly reset its
847 thread number. Cloned step_resume breakpoints are disabled on
848 creation, so enable it here now that it is associated with the
851 step_resumes are a form of bp that are made to be per-thread.
852 Since we created the step_resume bp when the parent process
853 was being debugged, and now are switching to the child process,
854 from the breakpoint package's viewpoint, that's a switch of
855 "threads". We must update the bp's notion of which thread
856 it is for, or it'll be ignored when it triggers. */
858 if (tp
->control
.step_resume_breakpoint
)
860 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
861 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
864 /* Treat exception_resume breakpoints like step_resume breakpoints. */
865 if (tp
->control
.exception_resume_breakpoint
)
867 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
868 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
871 /* Reinsert all breakpoints in the child. The user may have set
872 breakpoints after catching the fork, in which case those
873 were never set in the child, but only in the parent. This makes
874 sure the inserted breakpoints match the breakpoint list. */
876 breakpoint_re_set ();
877 insert_breakpoints ();
880 /* The child has exited or execed: resume threads of the parent the
881 user wanted to be executing. */
884 proceed_after_vfork_done (struct thread_info
*thread
,
887 int pid
= * (int *) arg
;
889 if (thread
->ptid
.pid () == pid
890 && thread
->state
== THREAD_RUNNING
891 && !thread
->executing
892 && !thread
->stop_requested
893 && thread
->stop_signal () == GDB_SIGNAL_0
)
895 infrun_debug_printf ("resuming vfork parent thread %s",
896 target_pid_to_str (thread
->ptid
).c_str ());
898 switch_to_thread (thread
);
899 clear_proceed_status (0);
900 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
906 /* Called whenever we notice an exec or exit event, to handle
907 detaching or resuming a vfork parent. */
910 handle_vfork_child_exec_or_exit (int exec
)
912 struct inferior
*inf
= current_inferior ();
914 if (inf
->vfork_parent
)
916 int resume_parent
= -1;
918 /* This exec or exit marks the end of the shared memory region
919 between the parent and the child. Break the bonds. */
920 inferior
*vfork_parent
= inf
->vfork_parent
;
921 inf
->vfork_parent
->vfork_child
= NULL
;
922 inf
->vfork_parent
= NULL
;
924 /* If the user wanted to detach from the parent, now is the
926 if (vfork_parent
->pending_detach
)
928 struct program_space
*pspace
;
929 struct address_space
*aspace
;
931 /* follow-fork child, detach-on-fork on. */
933 vfork_parent
->pending_detach
= 0;
935 scoped_restore_current_pspace_and_thread restore_thread
;
937 /* We're letting loose of the parent. */
938 thread_info
*tp
= any_live_thread_of_inferior (vfork_parent
);
939 switch_to_thread (tp
);
941 /* We're about to detach from the parent, which implicitly
942 removes breakpoints from its address space. There's a
943 catch here: we want to reuse the spaces for the child,
944 but, parent/child are still sharing the pspace at this
945 point, although the exec in reality makes the kernel give
946 the child a fresh set of new pages. The problem here is
947 that the breakpoints module being unaware of this, would
948 likely chose the child process to write to the parent
949 address space. Swapping the child temporarily away from
950 the spaces has the desired effect. Yes, this is "sort
953 pspace
= inf
->pspace
;
954 aspace
= inf
->aspace
;
958 if (print_inferior_events
)
961 = target_pid_to_str (ptid_t (vfork_parent
->pid
));
963 target_terminal::ours_for_output ();
967 fprintf_filtered (gdb_stdlog
,
968 _("[Detaching vfork parent %s "
969 "after child exec]\n"), pidstr
.c_str ());
973 fprintf_filtered (gdb_stdlog
,
974 _("[Detaching vfork parent %s "
975 "after child exit]\n"), pidstr
.c_str ());
979 target_detach (vfork_parent
, 0);
982 inf
->pspace
= pspace
;
983 inf
->aspace
= aspace
;
987 /* We're staying attached to the parent, so, really give the
988 child a new address space. */
989 inf
->pspace
= new program_space (maybe_new_address_space ());
990 inf
->aspace
= inf
->pspace
->aspace
;
992 set_current_program_space (inf
->pspace
);
994 resume_parent
= vfork_parent
->pid
;
998 /* If this is a vfork child exiting, then the pspace and
999 aspaces were shared with the parent. Since we're
1000 reporting the process exit, we'll be mourning all that is
1001 found in the address space, and switching to null_ptid,
1002 preparing to start a new inferior. But, since we don't
1003 want to clobber the parent's address/program spaces, we
1004 go ahead and create a new one for this exiting
1007 /* Switch to no-thread while running clone_program_space, so
1008 that clone_program_space doesn't want to read the
1009 selected frame of a dead process. */
1010 scoped_restore_current_thread restore_thread
;
1011 switch_to_no_thread ();
1013 inf
->pspace
= new program_space (maybe_new_address_space ());
1014 inf
->aspace
= inf
->pspace
->aspace
;
1015 set_current_program_space (inf
->pspace
);
1017 inf
->symfile_flags
= SYMFILE_NO_READ
;
1018 clone_program_space (inf
->pspace
, vfork_parent
->pspace
);
1020 resume_parent
= vfork_parent
->pid
;
1023 gdb_assert (current_program_space
== inf
->pspace
);
1025 if (non_stop
&& resume_parent
!= -1)
1027 /* If the user wanted the parent to be running, let it go
1029 scoped_restore_current_thread restore_thread
;
1031 infrun_debug_printf ("resuming vfork parent process %d",
1034 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1039 /* Enum strings for "set|show follow-exec-mode". */
1041 static const char follow_exec_mode_new
[] = "new";
1042 static const char follow_exec_mode_same
[] = "same";
1043 static const char *const follow_exec_mode_names
[] =
1045 follow_exec_mode_new
,
1046 follow_exec_mode_same
,
1050 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1052 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1053 struct cmd_list_element
*c
, const char *value
)
1055 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1058 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1061 follow_exec (ptid_t ptid
, const char *exec_file_target
)
1063 int pid
= ptid
.pid ();
1064 ptid_t process_ptid
;
1066 /* Switch terminal for any messages produced e.g. by
1067 breakpoint_re_set. */
1068 target_terminal::ours_for_output ();
1070 /* This is an exec event that we actually wish to pay attention to.
1071 Refresh our symbol table to the newly exec'd program, remove any
1072 momentary bp's, etc.
1074 If there are breakpoints, they aren't really inserted now,
1075 since the exec() transformed our inferior into a fresh set
1078 We want to preserve symbolic breakpoints on the list, since
1079 we have hopes that they can be reset after the new a.out's
1080 symbol table is read.
1082 However, any "raw" breakpoints must be removed from the list
1083 (e.g., the solib bp's), since their address is probably invalid
1086 And, we DON'T want to call delete_breakpoints() here, since
1087 that may write the bp's "shadow contents" (the instruction
1088 value that was overwritten with a TRAP instruction). Since
1089 we now have a new a.out, those shadow contents aren't valid. */
1091 mark_breakpoints_out ();
1093 /* The target reports the exec event to the main thread, even if
1094 some other thread does the exec, and even if the main thread was
1095 stopped or already gone. We may still have non-leader threads of
1096 the process on our list. E.g., on targets that don't have thread
1097 exit events (like remote); or on native Linux in non-stop mode if
1098 there were only two threads in the inferior and the non-leader
1099 one is the one that execs (and nothing forces an update of the
1100 thread list up to here). When debugging remotely, it's best to
1101 avoid extra traffic, when possible, so avoid syncing the thread
1102 list with the target, and instead go ahead and delete all threads
1103 of the process but one that reported the event. Note this must
1104 be done before calling update_breakpoints_after_exec, as
1105 otherwise clearing the threads' resources would reference stale
1106 thread breakpoints -- it may have been one of these threads that
1107 stepped across the exec. We could just clear their stepping
1108 states, but as long as we're iterating, might as well delete
1109 them. Deleting them now rather than at the next user-visible
1110 stop provides a nicer sequence of events for user and MI
1112 for (thread_info
*th
: all_threads_safe ())
1113 if (th
->ptid
.pid () == pid
&& th
->ptid
!= ptid
)
1116 /* We also need to clear any left over stale state for the
1117 leader/event thread. E.g., if there was any step-resume
1118 breakpoint or similar, it's gone now. We cannot truly
1119 step-to-next statement through an exec(). */
1120 thread_info
*th
= inferior_thread ();
1121 th
->control
.step_resume_breakpoint
= NULL
;
1122 th
->control
.exception_resume_breakpoint
= NULL
;
1123 th
->control
.single_step_breakpoints
= NULL
;
1124 th
->control
.step_range_start
= 0;
1125 th
->control
.step_range_end
= 0;
1127 /* The user may have had the main thread held stopped in the
1128 previous image (e.g., schedlock on, or non-stop). Release
1130 th
->stop_requested
= 0;
1132 update_breakpoints_after_exec ();
1134 /* What is this a.out's name? */
1135 process_ptid
= ptid_t (pid
);
1136 printf_unfiltered (_("%s is executing new program: %s\n"),
1137 target_pid_to_str (process_ptid
).c_str (),
1140 /* We've followed the inferior through an exec. Therefore, the
1141 inferior has essentially been killed & reborn. */
1143 breakpoint_init_inferior (inf_execd
);
1145 gdb::unique_xmalloc_ptr
<char> exec_file_host
1146 = exec_file_find (exec_file_target
, NULL
);
1148 /* If we were unable to map the executable target pathname onto a host
1149 pathname, tell the user that. Otherwise GDB's subsequent behavior
1150 is confusing. Maybe it would even be better to stop at this point
1151 so that the user can specify a file manually before continuing. */
1152 if (exec_file_host
== NULL
)
1153 warning (_("Could not load symbols for executable %s.\n"
1154 "Do you need \"set sysroot\"?"),
1157 /* Reset the shared library package. This ensures that we get a
1158 shlib event when the child reaches "_start", at which point the
1159 dld will have had a chance to initialize the child. */
1160 /* Also, loading a symbol file below may trigger symbol lookups, and
1161 we don't want those to be satisfied by the libraries of the
1162 previous incarnation of this process. */
1163 no_shared_libraries (NULL
, 0);
1165 struct inferior
*inf
= current_inferior ();
1167 if (follow_exec_mode_string
== follow_exec_mode_new
)
1169 /* The user wants to keep the old inferior and program spaces
1170 around. Create a new fresh one, and switch to it. */
1172 /* Do exit processing for the original inferior before setting the new
1173 inferior's pid. Having two inferiors with the same pid would confuse
1174 find_inferior_p(t)id. Transfer the terminal state and info from the
1175 old to the new inferior. */
1176 inferior
*new_inferior
= add_inferior_with_spaces ();
1178 swap_terminal_info (new_inferior
, inf
);
1179 exit_inferior_silent (inf
);
1181 new_inferior
->pid
= pid
;
1182 target_follow_exec (new_inferior
, ptid
, exec_file_target
);
1184 /* We continue with the new inferior. */
1189 /* The old description may no longer be fit for the new image.
1190 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1191 old description; we'll read a new one below. No need to do
1192 this on "follow-exec-mode new", as the old inferior stays
1193 around (its description is later cleared/refetched on
1195 target_clear_description ();
1196 target_follow_exec (inf
, ptid
, exec_file_target
);
1199 gdb_assert (current_inferior () == inf
);
1200 gdb_assert (current_program_space
== inf
->pspace
);
1202 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1203 because the proper displacement for a PIE (Position Independent
1204 Executable) main symbol file will only be computed by
1205 solib_create_inferior_hook below. breakpoint_re_set would fail
1206 to insert the breakpoints with the zero displacement. */
1207 try_open_exec_file (exec_file_host
.get (), inf
, SYMFILE_DEFER_BP_RESET
);
1209 /* If the target can specify a description, read it. Must do this
1210 after flipping to the new executable (because the target supplied
1211 description must be compatible with the executable's
1212 architecture, and the old executable may e.g., be 32-bit, while
1213 the new one 64-bit), and before anything involving memory or
1215 target_find_description ();
1217 gdb::observers::inferior_execd
.notify (inf
);
1219 breakpoint_re_set ();
1221 /* Reinsert all breakpoints. (Those which were symbolic have
1222 been reset to the proper address in the new a.out, thanks
1223 to symbol_file_command...). */
1224 insert_breakpoints ();
1226 /* The next resume of this inferior should bring it to the shlib
1227 startup breakpoints. (If the user had also set bp's on
1228 "main" from the old (parent) process, then they'll auto-
1229 matically get reset there in the new process.). */
1232 /* The chain of threads that need to do a step-over operation to get
1233 past e.g., a breakpoint. What technique is used to step over the
1234 breakpoint/watchpoint does not matter -- all threads end up in the
1235 same queue, to maintain rough temporal order of execution, in order
1236 to avoid starvation, otherwise, we could e.g., find ourselves
1237 constantly stepping the same couple threads past their breakpoints
1238 over and over, if the single-step finish fast enough. */
1239 thread_step_over_list global_thread_step_over_list
;
1241 /* Bit flags indicating what the thread needs to step over. */
1243 enum step_over_what_flag
1245 /* Step over a breakpoint. */
1246 STEP_OVER_BREAKPOINT
= 1,
1248 /* Step past a non-continuable watchpoint, in order to let the
1249 instruction execute so we can evaluate the watchpoint
1251 STEP_OVER_WATCHPOINT
= 2
1253 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag
, step_over_what
);
1255 /* Info about an instruction that is being stepped over. */
1257 struct step_over_info
1259 /* If we're stepping past a breakpoint, this is the address space
1260 and address of the instruction the breakpoint is set at. We'll
1261 skip inserting all breakpoints here. Valid iff ASPACE is
1263 const address_space
*aspace
= nullptr;
1264 CORE_ADDR address
= 0;
1266 /* The instruction being stepped over triggers a nonsteppable
1267 watchpoint. If true, we'll skip inserting watchpoints. */
1268 int nonsteppable_watchpoint_p
= 0;
1270 /* The thread's global number. */
1274 /* The step-over info of the location that is being stepped over.
1276 Note that with async/breakpoint always-inserted mode, a user might
1277 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1278 being stepped over. As setting a new breakpoint inserts all
1279 breakpoints, we need to make sure the breakpoint being stepped over
1280 isn't inserted then. We do that by only clearing the step-over
1281 info when the step-over is actually finished (or aborted).
1283 Presently GDB can only step over one breakpoint at any given time.
1284 Given threads that can't run code in the same address space as the
1285 breakpoint's can't really miss the breakpoint, GDB could be taught
1286 to step-over at most one breakpoint per address space (so this info
1287 could move to the address space object if/when GDB is extended).
1288 The set of breakpoints being stepped over will normally be much
1289 smaller than the set of all breakpoints, so a flag in the
1290 breakpoint location structure would be wasteful. A separate list
1291 also saves complexity and run-time, as otherwise we'd have to go
1292 through all breakpoint locations clearing their flag whenever we
1293 start a new sequence. Similar considerations weigh against storing
1294 this info in the thread object. Plus, not all step overs actually
1295 have breakpoint locations -- e.g., stepping past a single-step
1296 breakpoint, or stepping to complete a non-continuable
1298 static struct step_over_info step_over_info
;
1300 /* Record the address of the breakpoint/instruction we're currently
1302 N.B. We record the aspace and address now, instead of say just the thread,
1303 because when we need the info later the thread may be running. */
1306 set_step_over_info (const address_space
*aspace
, CORE_ADDR address
,
1307 int nonsteppable_watchpoint_p
,
1310 step_over_info
.aspace
= aspace
;
1311 step_over_info
.address
= address
;
1312 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1313 step_over_info
.thread
= thread
;
1316 /* Called when we're not longer stepping over a breakpoint / an
1317 instruction, so all breakpoints are free to be (re)inserted. */
1320 clear_step_over_info (void)
1322 infrun_debug_printf ("clearing step over info");
1323 step_over_info
.aspace
= NULL
;
1324 step_over_info
.address
= 0;
1325 step_over_info
.nonsteppable_watchpoint_p
= 0;
1326 step_over_info
.thread
= -1;
1332 stepping_past_instruction_at (struct address_space
*aspace
,
1335 return (step_over_info
.aspace
!= NULL
1336 && breakpoint_address_match (aspace
, address
,
1337 step_over_info
.aspace
,
1338 step_over_info
.address
));
1344 thread_is_stepping_over_breakpoint (int thread
)
1346 return (step_over_info
.thread
!= -1
1347 && thread
== step_over_info
.thread
);
1353 stepping_past_nonsteppable_watchpoint (void)
1355 return step_over_info
.nonsteppable_watchpoint_p
;
1358 /* Returns true if step-over info is valid. */
1361 step_over_info_valid_p (void)
1363 return (step_over_info
.aspace
!= NULL
1364 || stepping_past_nonsteppable_watchpoint ());
1368 /* Displaced stepping. */
1370 /* In non-stop debugging mode, we must take special care to manage
1371 breakpoints properly; in particular, the traditional strategy for
1372 stepping a thread past a breakpoint it has hit is unsuitable.
1373 'Displaced stepping' is a tactic for stepping one thread past a
1374 breakpoint it has hit while ensuring that other threads running
1375 concurrently will hit the breakpoint as they should.
1377 The traditional way to step a thread T off a breakpoint in a
1378 multi-threaded program in all-stop mode is as follows:
1380 a0) Initially, all threads are stopped, and breakpoints are not
1382 a1) We single-step T, leaving breakpoints uninserted.
1383 a2) We insert breakpoints, and resume all threads.
1385 In non-stop debugging, however, this strategy is unsuitable: we
1386 don't want to have to stop all threads in the system in order to
1387 continue or step T past a breakpoint. Instead, we use displaced
1390 n0) Initially, T is stopped, other threads are running, and
1391 breakpoints are inserted.
1392 n1) We copy the instruction "under" the breakpoint to a separate
1393 location, outside the main code stream, making any adjustments
1394 to the instruction, register, and memory state as directed by
1396 n2) We single-step T over the instruction at its new location.
1397 n3) We adjust the resulting register and memory state as directed
1398 by T's architecture. This includes resetting T's PC to point
1399 back into the main instruction stream.
1402 This approach depends on the following gdbarch methods:
1404 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1405 indicate where to copy the instruction, and how much space must
1406 be reserved there. We use these in step n1.
1408 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1409 address, and makes any necessary adjustments to the instruction,
1410 register contents, and memory. We use this in step n1.
1412 - gdbarch_displaced_step_fixup adjusts registers and memory after
1413 we have successfully single-stepped the instruction, to yield the
1414 same effect the instruction would have had if we had executed it
1415 at its original address. We use this in step n3.
1417 The gdbarch_displaced_step_copy_insn and
1418 gdbarch_displaced_step_fixup functions must be written so that
1419 copying an instruction with gdbarch_displaced_step_copy_insn,
1420 single-stepping across the copied instruction, and then applying
1421 gdbarch_displaced_insn_fixup should have the same effects on the
1422 thread's memory and registers as stepping the instruction in place
1423 would have. Exactly which responsibilities fall to the copy and
1424 which fall to the fixup is up to the author of those functions.
1426 See the comments in gdbarch.sh for details.
1428 Note that displaced stepping and software single-step cannot
1429 currently be used in combination, although with some care I think
1430 they could be made to. Software single-step works by placing
1431 breakpoints on all possible subsequent instructions; if the
1432 displaced instruction is a PC-relative jump, those breakpoints
1433 could fall in very strange places --- on pages that aren't
1434 executable, or at addresses that are not proper instruction
1435 boundaries. (We do generally let other threads run while we wait
1436 to hit the software single-step breakpoint, and they might
1437 encounter such a corrupted instruction.) One way to work around
1438 this would be to have gdbarch_displaced_step_copy_insn fully
1439 simulate the effect of PC-relative instructions (and return NULL)
1440 on architectures that use software single-stepping.
1442 In non-stop mode, we can have independent and simultaneous step
1443 requests, so more than one thread may need to simultaneously step
1444 over a breakpoint. The current implementation assumes there is
1445 only one scratch space per process. In this case, we have to
1446 serialize access to the scratch space. If thread A wants to step
1447 over a breakpoint, but we are currently waiting for some other
1448 thread to complete a displaced step, we leave thread A stopped and
1449 place it in the displaced_step_request_queue. Whenever a displaced
1450 step finishes, we pick the next thread in the queue and start a new
1451 displaced step operation on it. See displaced_step_prepare and
1452 displaced_step_finish for details. */
1454 /* Return true if THREAD is doing a displaced step. */
1457 displaced_step_in_progress_thread (thread_info
*thread
)
1459 gdb_assert (thread
!= NULL
);
1461 return thread
->displaced_step_state
.in_progress ();
1464 /* Return true if INF has a thread doing a displaced step. */
1467 displaced_step_in_progress (inferior
*inf
)
1469 return inf
->displaced_step_state
.in_progress_count
> 0;
1472 /* Return true if any thread is doing a displaced step. */
1475 displaced_step_in_progress_any_thread ()
1477 for (inferior
*inf
: all_non_exited_inferiors ())
1479 if (displaced_step_in_progress (inf
))
1487 infrun_inferior_exit (struct inferior
*inf
)
1489 inf
->displaced_step_state
.reset ();
1493 infrun_inferior_execd (inferior
*inf
)
1495 /* If some threads where was doing a displaced step in this inferior at the
1496 moment of the exec, they no longer exist. Even if the exec'ing thread
1497 doing a displaced step, we don't want to to any fixup nor restore displaced
1498 stepping buffer bytes. */
1499 inf
->displaced_step_state
.reset ();
1501 for (thread_info
*thread
: inf
->threads ())
1502 thread
->displaced_step_state
.reset ();
1504 /* Since an in-line step is done with everything else stopped, if there was
1505 one in progress at the time of the exec, it must have been the exec'ing
1507 clear_step_over_info ();
1510 /* If ON, and the architecture supports it, GDB will use displaced
1511 stepping to step over breakpoints. If OFF, or if the architecture
1512 doesn't support it, GDB will instead use the traditional
1513 hold-and-step approach. If AUTO (which is the default), GDB will
1514 decide which technique to use to step over breakpoints depending on
1515 whether the target works in a non-stop way (see use_displaced_stepping). */
1517 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1520 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1521 struct cmd_list_element
*c
,
1524 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1525 fprintf_filtered (file
,
1526 _("Debugger's willingness to use displaced stepping "
1527 "to step over breakpoints is %s (currently %s).\n"),
1528 value
, target_is_non_stop_p () ? "on" : "off");
1530 fprintf_filtered (file
,
1531 _("Debugger's willingness to use displaced stepping "
1532 "to step over breakpoints is %s.\n"), value
);
1535 /* Return true if the gdbarch implements the required methods to use
1536 displaced stepping. */
1539 gdbarch_supports_displaced_stepping (gdbarch
*arch
)
1541 /* Only check for the presence of `prepare`. The gdbarch verification ensures
1542 that if `prepare` is provided, so is `finish`. */
1543 return gdbarch_displaced_step_prepare_p (arch
);
1546 /* Return non-zero if displaced stepping can/should be used to step
1547 over breakpoints of thread TP. */
1550 use_displaced_stepping (thread_info
*tp
)
1552 /* If the user disabled it explicitly, don't use displaced stepping. */
1553 if (can_use_displaced_stepping
== AUTO_BOOLEAN_FALSE
)
1556 /* If "auto", only use displaced stepping if the target operates in a non-stop
1558 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1559 && !target_is_non_stop_p ())
1562 gdbarch
*gdbarch
= get_thread_regcache (tp
)->arch ();
1564 /* If the architecture doesn't implement displaced stepping, don't use
1566 if (!gdbarch_supports_displaced_stepping (gdbarch
))
1569 /* If recording, don't use displaced stepping. */
1570 if (find_record_target () != nullptr)
1573 /* If displaced stepping failed before for this inferior, don't bother trying
1575 if (tp
->inf
->displaced_step_state
.failed_before
)
1581 /* Simple function wrapper around displaced_step_thread_state::reset. */
1584 displaced_step_reset (displaced_step_thread_state
*displaced
)
1586 displaced
->reset ();
1589 /* A cleanup that wraps displaced_step_reset. We use this instead of, say,
1590 SCOPE_EXIT, because it needs to be discardable with "cleanup.release ()". */
1592 using displaced_step_reset_cleanup
= FORWARD_SCOPE_EXIT (displaced_step_reset
);
1597 displaced_step_dump_bytes (const gdb_byte
*buf
, size_t len
)
1601 for (size_t i
= 0; i
< len
; i
++)
1604 ret
+= string_printf ("%02x", buf
[i
]);
1606 ret
+= string_printf (" %02x", buf
[i
]);
1612 /* Prepare to single-step, using displaced stepping.
1614 Note that we cannot use displaced stepping when we have a signal to
1615 deliver. If we have a signal to deliver and an instruction to step
1616 over, then after the step, there will be no indication from the
1617 target whether the thread entered a signal handler or ignored the
1618 signal and stepped over the instruction successfully --- both cases
1619 result in a simple SIGTRAP. In the first case we mustn't do a
1620 fixup, and in the second case we must --- but we can't tell which.
1621 Comments in the code for 'random signals' in handle_inferior_event
1622 explain how we handle this case instead.
1624 Returns DISPLACED_STEP_PREPARE_STATUS_OK if preparing was successful -- this
1625 thread is going to be stepped now; DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
1626 if displaced stepping this thread got queued; or
1627 DISPLACED_STEP_PREPARE_STATUS_CANT if this instruction can't be displaced
1630 static displaced_step_prepare_status
1631 displaced_step_prepare_throw (thread_info
*tp
)
1633 regcache
*regcache
= get_thread_regcache (tp
);
1634 struct gdbarch
*gdbarch
= regcache
->arch ();
1635 displaced_step_thread_state
&disp_step_thread_state
1636 = tp
->displaced_step_state
;
1638 /* We should never reach this function if the architecture does not
1639 support displaced stepping. */
1640 gdb_assert (gdbarch_supports_displaced_stepping (gdbarch
));
1642 /* Nor if the thread isn't meant to step over a breakpoint. */
1643 gdb_assert (tp
->control
.trap_expected
);
1645 /* Disable range stepping while executing in the scratch pad. We
1646 want a single-step even if executing the displaced instruction in
1647 the scratch buffer lands within the stepping range (e.g., a
1649 tp
->control
.may_range_step
= 0;
1651 /* We are about to start a displaced step for this thread. If one is already
1652 in progress, something's wrong. */
1653 gdb_assert (!disp_step_thread_state
.in_progress ());
1655 if (tp
->inf
->displaced_step_state
.unavailable
)
1657 /* The gdbarch tells us it's not worth asking to try a prepare because
1658 it is likely that it will return unavailable, so don't bother asking. */
1660 displaced_debug_printf ("deferring step of %s",
1661 target_pid_to_str (tp
->ptid
).c_str ());
1663 global_thread_step_over_chain_enqueue (tp
);
1664 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1667 displaced_debug_printf ("displaced-stepping %s now",
1668 target_pid_to_str (tp
->ptid
).c_str ());
1670 scoped_restore_current_thread restore_thread
;
1672 switch_to_thread (tp
);
1674 CORE_ADDR original_pc
= regcache_read_pc (regcache
);
1675 CORE_ADDR displaced_pc
;
1677 displaced_step_prepare_status status
1678 = gdbarch_displaced_step_prepare (gdbarch
, tp
, displaced_pc
);
1680 if (status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
1682 displaced_debug_printf ("failed to prepare (%s)",
1683 target_pid_to_str (tp
->ptid
).c_str ());
1685 return DISPLACED_STEP_PREPARE_STATUS_CANT
;
1687 else if (status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
1689 /* Not enough displaced stepping resources available, defer this
1690 request by placing it the queue. */
1692 displaced_debug_printf ("not enough resources available, "
1693 "deferring step of %s",
1694 target_pid_to_str (tp
->ptid
).c_str ());
1696 global_thread_step_over_chain_enqueue (tp
);
1698 return DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
;
1701 gdb_assert (status
== DISPLACED_STEP_PREPARE_STATUS_OK
);
1703 /* Save the information we need to fix things up if the step
1705 disp_step_thread_state
.set (gdbarch
);
1707 tp
->inf
->displaced_step_state
.in_progress_count
++;
1709 displaced_debug_printf ("prepared successfully thread=%s, "
1710 "original_pc=%s, displaced_pc=%s",
1711 target_pid_to_str (tp
->ptid
).c_str (),
1712 paddress (gdbarch
, original_pc
),
1713 paddress (gdbarch
, displaced_pc
));
1715 return DISPLACED_STEP_PREPARE_STATUS_OK
;
1718 /* Wrapper for displaced_step_prepare_throw that disabled further
1719 attempts at displaced stepping if we get a memory error. */
1721 static displaced_step_prepare_status
1722 displaced_step_prepare (thread_info
*thread
)
1724 displaced_step_prepare_status status
1725 = DISPLACED_STEP_PREPARE_STATUS_CANT
;
1729 status
= displaced_step_prepare_throw (thread
);
1731 catch (const gdb_exception_error
&ex
)
1733 if (ex
.error
!= MEMORY_ERROR
1734 && ex
.error
!= NOT_SUPPORTED_ERROR
)
1737 infrun_debug_printf ("caught exception, disabling displaced stepping: %s",
1740 /* Be verbose if "set displaced-stepping" is "on", silent if
1742 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1744 warning (_("disabling displaced stepping: %s"),
1748 /* Disable further displaced stepping attempts. */
1749 thread
->inf
->displaced_step_state
.failed_before
= 1;
1755 /* If we displaced stepped an instruction successfully, adjust registers and
1756 memory to yield the same effect the instruction would have had if we had
1757 executed it at its original address, and return
1758 DISPLACED_STEP_FINISH_STATUS_OK. If the instruction didn't complete,
1759 relocate the PC and return DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED.
1761 If the thread wasn't displaced stepping, return
1762 DISPLACED_STEP_FINISH_STATUS_OK as well. */
1764 static displaced_step_finish_status
1765 displaced_step_finish (thread_info
*event_thread
, enum gdb_signal signal
)
1767 displaced_step_thread_state
*displaced
= &event_thread
->displaced_step_state
;
1769 /* Was this thread performing a displaced step? */
1770 if (!displaced
->in_progress ())
1771 return DISPLACED_STEP_FINISH_STATUS_OK
;
1773 gdb_assert (event_thread
->inf
->displaced_step_state
.in_progress_count
> 0);
1774 event_thread
->inf
->displaced_step_state
.in_progress_count
--;
1776 /* Fixup may need to read memory/registers. Switch to the thread
1777 that we're fixing up. Also, target_stopped_by_watchpoint checks
1778 the current thread, and displaced_step_restore performs ptid-dependent
1779 memory accesses using current_inferior(). */
1780 switch_to_thread (event_thread
);
1782 displaced_step_reset_cleanup
cleanup (displaced
);
1784 /* Do the fixup, and release the resources acquired to do the displaced
1786 return gdbarch_displaced_step_finish (displaced
->get_original_gdbarch (),
1787 event_thread
, signal
);
1790 /* Data to be passed around while handling an event. This data is
1791 discarded between events. */
1792 struct execution_control_state
1794 process_stratum_target
*target
;
1796 /* The thread that got the event, if this was a thread event; NULL
1798 struct thread_info
*event_thread
;
1800 struct target_waitstatus ws
;
1801 int stop_func_filled_in
;
1802 CORE_ADDR stop_func_start
;
1803 CORE_ADDR stop_func_end
;
1804 const char *stop_func_name
;
1807 /* True if the event thread hit the single-step breakpoint of
1808 another thread. Thus the event doesn't cause a stop, the thread
1809 needs to be single-stepped past the single-step breakpoint before
1810 we can switch back to the original stepping thread. */
1811 int hit_singlestep_breakpoint
;
1814 /* Clear ECS and set it to point at TP. */
1817 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
1819 memset (ecs
, 0, sizeof (*ecs
));
1820 ecs
->event_thread
= tp
;
1821 ecs
->ptid
= tp
->ptid
;
1824 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
1825 static void prepare_to_wait (struct execution_control_state
*ecs
);
1826 static bool keep_going_stepped_thread (struct thread_info
*tp
);
1827 static step_over_what
thread_still_needs_step_over (struct thread_info
*tp
);
1829 /* Are there any pending step-over requests? If so, run all we can
1830 now and return true. Otherwise, return false. */
1833 start_step_over (void)
1835 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
1837 /* Don't start a new step-over if we already have an in-line
1838 step-over operation ongoing. */
1839 if (step_over_info_valid_p ())
1842 /* Steal the global thread step over chain. As we try to initiate displaced
1843 steps, threads will be enqueued in the global chain if no buffers are
1844 available. If we iterated on the global chain directly, we might iterate
1846 thread_step_over_list threads_to_step
1847 = std::move (global_thread_step_over_list
);
1849 infrun_debug_printf ("stealing global queue of threads to step, length = %d",
1850 thread_step_over_chain_length (threads_to_step
));
1852 bool started
= false;
1854 /* On scope exit (whatever the reason, return or exception), if there are
1855 threads left in the THREADS_TO_STEP chain, put back these threads in the
1859 if (threads_to_step
.empty ())
1860 infrun_debug_printf ("step-over queue now empty");
1863 infrun_debug_printf ("putting back %d threads to step in global queue",
1864 thread_step_over_chain_length (threads_to_step
));
1866 global_thread_step_over_chain_enqueue_chain
1867 (std::move (threads_to_step
));
1871 thread_step_over_list_safe_range range
1872 = make_thread_step_over_list_safe_range (threads_to_step
);
1874 for (thread_info
*tp
: range
)
1876 struct execution_control_state ecss
;
1877 struct execution_control_state
*ecs
= &ecss
;
1878 step_over_what step_what
;
1879 int must_be_in_line
;
1881 gdb_assert (!tp
->stop_requested
);
1883 if (tp
->inf
->displaced_step_state
.unavailable
)
1885 /* The arch told us to not even try preparing another displaced step
1886 for this inferior. Just leave the thread in THREADS_TO_STEP, it
1887 will get moved to the global chain on scope exit. */
1891 /* Remove thread from the THREADS_TO_STEP chain. If anything goes wrong
1892 while we try to prepare the displaced step, we don't add it back to
1893 the global step over chain. This is to avoid a thread staying in the
1894 step over chain indefinitely if something goes wrong when resuming it
1895 If the error is intermittent and it still needs a step over, it will
1896 get enqueued again when we try to resume it normally. */
1897 threads_to_step
.erase (threads_to_step
.iterator_to (*tp
));
1899 step_what
= thread_still_needs_step_over (tp
);
1900 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
1901 || ((step_what
& STEP_OVER_BREAKPOINT
)
1902 && !use_displaced_stepping (tp
)));
1904 /* We currently stop all threads of all processes to step-over
1905 in-line. If we need to start a new in-line step-over, let
1906 any pending displaced steps finish first. */
1907 if (must_be_in_line
&& displaced_step_in_progress_any_thread ())
1909 global_thread_step_over_chain_enqueue (tp
);
1913 if (tp
->control
.trap_expected
1917 internal_error (__FILE__
, __LINE__
,
1918 "[%s] has inconsistent state: "
1919 "trap_expected=%d, resumed=%d, executing=%d\n",
1920 target_pid_to_str (tp
->ptid
).c_str (),
1921 tp
->control
.trap_expected
,
1926 infrun_debug_printf ("resuming [%s] for step-over",
1927 target_pid_to_str (tp
->ptid
).c_str ());
1929 /* keep_going_pass_signal skips the step-over if the breakpoint
1930 is no longer inserted. In all-stop, we want to keep looking
1931 for a thread that needs a step-over instead of resuming TP,
1932 because we wouldn't be able to resume anything else until the
1933 target stops again. In non-stop, the resume always resumes
1934 only TP, so it's OK to let the thread resume freely. */
1935 if (!target_is_non_stop_p () && !step_what
)
1938 switch_to_thread (tp
);
1939 reset_ecs (ecs
, tp
);
1940 keep_going_pass_signal (ecs
);
1942 if (!ecs
->wait_some_more
)
1943 error (_("Command aborted."));
1945 /* If the thread's step over could not be initiated because no buffers
1946 were available, it was re-added to the global step over chain. */
1949 infrun_debug_printf ("[%s] was resumed.",
1950 target_pid_to_str (tp
->ptid
).c_str ());
1951 gdb_assert (!thread_is_in_step_over_chain (tp
));
1955 infrun_debug_printf ("[%s] was NOT resumed.",
1956 target_pid_to_str (tp
->ptid
).c_str ());
1957 gdb_assert (thread_is_in_step_over_chain (tp
));
1960 /* If we started a new in-line step-over, we're done. */
1961 if (step_over_info_valid_p ())
1963 gdb_assert (tp
->control
.trap_expected
);
1968 if (!target_is_non_stop_p ())
1970 /* On all-stop, shouldn't have resumed unless we needed a
1972 gdb_assert (tp
->control
.trap_expected
1973 || tp
->step_after_step_resume_breakpoint
);
1975 /* With remote targets (at least), in all-stop, we can't
1976 issue any further remote commands until the program stops
1982 /* Either the thread no longer needed a step-over, or a new
1983 displaced stepping sequence started. Even in the latter
1984 case, continue looking. Maybe we can also start another
1985 displaced step on a thread of other process. */
1991 /* Update global variables holding ptids to hold NEW_PTID if they were
1992 holding OLD_PTID. */
1994 infrun_thread_ptid_changed (process_stratum_target
*target
,
1995 ptid_t old_ptid
, ptid_t new_ptid
)
1997 if (inferior_ptid
== old_ptid
1998 && current_inferior ()->process_target () == target
)
1999 inferior_ptid
= new_ptid
;
2004 static const char schedlock_off
[] = "off";
2005 static const char schedlock_on
[] = "on";
2006 static const char schedlock_step
[] = "step";
2007 static const char schedlock_replay
[] = "replay";
2008 static const char *const scheduler_enums
[] = {
2015 static const char *scheduler_mode
= schedlock_replay
;
2017 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2018 struct cmd_list_element
*c
, const char *value
)
2020 fprintf_filtered (file
,
2021 _("Mode for locking scheduler "
2022 "during execution is \"%s\".\n"),
2027 set_schedlock_func (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2029 if (!target_can_lock_scheduler ())
2031 scheduler_mode
= schedlock_off
;
2032 error (_("Target '%s' cannot support this command."),
2033 target_shortname ());
2037 /* True if execution commands resume all threads of all processes by
2038 default; otherwise, resume only threads of the current inferior
2040 bool sched_multi
= false;
2042 /* Try to setup for software single stepping. Return true if target_resume()
2043 should use hardware single step.
2045 GDBARCH the current gdbarch. */
2048 maybe_software_singlestep (struct gdbarch
*gdbarch
)
2050 bool hw_step
= true;
2052 if (execution_direction
== EXEC_FORWARD
2053 && gdbarch_software_single_step_p (gdbarch
))
2054 hw_step
= !insert_single_step_breakpoints (gdbarch
);
2062 user_visible_resume_ptid (int step
)
2068 /* With non-stop mode on, threads are always handled
2070 resume_ptid
= inferior_ptid
;
2072 else if ((scheduler_mode
== schedlock_on
)
2073 || (scheduler_mode
== schedlock_step
&& step
))
2075 /* User-settable 'scheduler' mode requires solo thread
2077 resume_ptid
= inferior_ptid
;
2079 else if ((scheduler_mode
== schedlock_replay
)
2080 && target_record_will_replay (minus_one_ptid
, execution_direction
))
2082 /* User-settable 'scheduler' mode requires solo thread resume in replay
2084 resume_ptid
= inferior_ptid
;
2086 else if (!sched_multi
&& target_supports_multi_process ())
2088 /* Resume all threads of the current process (and none of other
2090 resume_ptid
= ptid_t (inferior_ptid
.pid ());
2094 /* Resume all threads of all processes. */
2095 resume_ptid
= RESUME_ALL
;
2103 process_stratum_target
*
2104 user_visible_resume_target (ptid_t resume_ptid
)
2106 return (resume_ptid
== minus_one_ptid
&& sched_multi
2108 : current_inferior ()->process_target ());
2111 /* Return a ptid representing the set of threads that we will resume,
2112 in the perspective of the target, assuming run control handling
2113 does not require leaving some threads stopped (e.g., stepping past
2114 breakpoint). USER_STEP indicates whether we're about to start the
2115 target for a stepping command. */
2118 internal_resume_ptid (int user_step
)
2120 /* In non-stop, we always control threads individually. Note that
2121 the target may always work in non-stop mode even with "set
2122 non-stop off", in which case user_visible_resume_ptid could
2123 return a wildcard ptid. */
2124 if (target_is_non_stop_p ())
2125 return inferior_ptid
;
2127 return user_visible_resume_ptid (user_step
);
2130 /* Wrapper for target_resume, that handles infrun-specific
2134 do_target_resume (ptid_t resume_ptid
, bool step
, enum gdb_signal sig
)
2136 struct thread_info
*tp
= inferior_thread ();
2138 gdb_assert (!tp
->stop_requested
);
2140 /* Install inferior's terminal modes. */
2141 target_terminal::inferior ();
2143 /* Avoid confusing the next resume, if the next stop/resume
2144 happens to apply to another thread. */
2145 tp
->set_stop_signal (GDB_SIGNAL_0
);
2147 /* Advise target which signals may be handled silently.
2149 If we have removed breakpoints because we are stepping over one
2150 in-line (in any thread), we need to receive all signals to avoid
2151 accidentally skipping a breakpoint during execution of a signal
2154 Likewise if we're displaced stepping, otherwise a trap for a
2155 breakpoint in a signal handler might be confused with the
2156 displaced step finishing. We don't make the displaced_step_finish
2157 step distinguish the cases instead, because:
2159 - a backtrace while stopped in the signal handler would show the
2160 scratch pad as frame older than the signal handler, instead of
2161 the real mainline code.
2163 - when the thread is later resumed, the signal handler would
2164 return to the scratch pad area, which would no longer be
2166 if (step_over_info_valid_p ()
2167 || displaced_step_in_progress (tp
->inf
))
2168 target_pass_signals ({});
2170 target_pass_signals (signal_pass
);
2172 target_resume (resume_ptid
, step
, sig
);
2174 if (target_can_async_p ())
2178 /* Resume the inferior. SIG is the signal to give the inferior
2179 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2180 call 'resume', which handles exceptions. */
2183 resume_1 (enum gdb_signal sig
)
2185 struct regcache
*regcache
= get_current_regcache ();
2186 struct gdbarch
*gdbarch
= regcache
->arch ();
2187 struct thread_info
*tp
= inferior_thread ();
2188 const address_space
*aspace
= regcache
->aspace ();
2190 /* This represents the user's step vs continue request. When
2191 deciding whether "set scheduler-locking step" applies, it's the
2192 user's intention that counts. */
2193 const int user_step
= tp
->control
.stepping_command
;
2194 /* This represents what we'll actually request the target to do.
2195 This can decay from a step to a continue, if e.g., we need to
2196 implement single-stepping with breakpoints (software
2200 gdb_assert (!tp
->stop_requested
);
2201 gdb_assert (!thread_is_in_step_over_chain (tp
));
2203 if (tp
->has_pending_waitstatus ())
2206 ("thread %s has pending wait "
2207 "status %s (currently_stepping=%d).",
2208 target_pid_to_str (tp
->ptid
).c_str (),
2209 target_waitstatus_to_string (&tp
->pending_waitstatus ()).c_str (),
2210 currently_stepping (tp
));
2212 tp
->inf
->process_target ()->threads_executing
= true;
2213 tp
->set_resumed (true);
2215 /* FIXME: What should we do if we are supposed to resume this
2216 thread with a signal? Maybe we should maintain a queue of
2217 pending signals to deliver. */
2218 if (sig
!= GDB_SIGNAL_0
)
2220 warning (_("Couldn't deliver signal %s to %s."),
2221 gdb_signal_to_name (sig
),
2222 target_pid_to_str (tp
->ptid
).c_str ());
2225 tp
->set_stop_signal (GDB_SIGNAL_0
);
2227 if (target_can_async_p ())
2230 /* Tell the event loop we have an event to process. */
2231 mark_async_event_handler (infrun_async_inferior_event_token
);
2236 tp
->stepped_breakpoint
= 0;
2238 /* Depends on stepped_breakpoint. */
2239 step
= currently_stepping (tp
);
2241 if (current_inferior ()->waiting_for_vfork_done
)
2243 /* Don't try to single-step a vfork parent that is waiting for
2244 the child to get out of the shared memory region (by exec'ing
2245 or exiting). This is particularly important on software
2246 single-step archs, as the child process would trip on the
2247 software single step breakpoint inserted for the parent
2248 process. Since the parent will not actually execute any
2249 instruction until the child is out of the shared region (such
2250 are vfork's semantics), it is safe to simply continue it.
2251 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2252 the parent, and tell it to `keep_going', which automatically
2253 re-sets it stepping. */
2254 infrun_debug_printf ("resume : clear step");
2258 CORE_ADDR pc
= regcache_read_pc (regcache
);
2260 infrun_debug_printf ("step=%d, signal=%s, trap_expected=%d, "
2261 "current thread [%s] at %s",
2262 step
, gdb_signal_to_symbol_string (sig
),
2263 tp
->control
.trap_expected
,
2264 target_pid_to_str (inferior_ptid
).c_str (),
2265 paddress (gdbarch
, pc
));
2267 /* Normally, by the time we reach `resume', the breakpoints are either
2268 removed or inserted, as appropriate. The exception is if we're sitting
2269 at a permanent breakpoint; we need to step over it, but permanent
2270 breakpoints can't be removed. So we have to test for it here. */
2271 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2273 if (sig
!= GDB_SIGNAL_0
)
2275 /* We have a signal to pass to the inferior. The resume
2276 may, or may not take us to the signal handler. If this
2277 is a step, we'll need to stop in the signal handler, if
2278 there's one, (if the target supports stepping into
2279 handlers), or in the next mainline instruction, if
2280 there's no handler. If this is a continue, we need to be
2281 sure to run the handler with all breakpoints inserted.
2282 In all cases, set a breakpoint at the current address
2283 (where the handler returns to), and once that breakpoint
2284 is hit, resume skipping the permanent breakpoint. If
2285 that breakpoint isn't hit, then we've stepped into the
2286 signal handler (or hit some other event). We'll delete
2287 the step-resume breakpoint then. */
2289 infrun_debug_printf ("resume: skipping permanent breakpoint, "
2290 "deliver signal first");
2292 clear_step_over_info ();
2293 tp
->control
.trap_expected
= 0;
2295 if (tp
->control
.step_resume_breakpoint
== NULL
)
2297 /* Set a "high-priority" step-resume, as we don't want
2298 user breakpoints at PC to trigger (again) when this
2300 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2301 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2303 tp
->step_after_step_resume_breakpoint
= step
;
2306 insert_breakpoints ();
2310 /* There's no signal to pass, we can go ahead and skip the
2311 permanent breakpoint manually. */
2312 infrun_debug_printf ("skipping permanent breakpoint");
2313 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2314 /* Update pc to reflect the new address from which we will
2315 execute instructions. */
2316 pc
= regcache_read_pc (regcache
);
2320 /* We've already advanced the PC, so the stepping part
2321 is done. Now we need to arrange for a trap to be
2322 reported to handle_inferior_event. Set a breakpoint
2323 at the current PC, and run to it. Don't update
2324 prev_pc, because if we end in
2325 switch_back_to_stepped_thread, we want the "expected
2326 thread advanced also" branch to be taken. IOW, we
2327 don't want this thread to step further from PC
2329 gdb_assert (!step_over_info_valid_p ());
2330 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2331 insert_breakpoints ();
2333 resume_ptid
= internal_resume_ptid (user_step
);
2334 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
2335 tp
->set_resumed (true);
2341 /* If we have a breakpoint to step over, make sure to do a single
2342 step only. Same if we have software watchpoints. */
2343 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2344 tp
->control
.may_range_step
= 0;
2346 /* If displaced stepping is enabled, step over breakpoints by executing a
2347 copy of the instruction at a different address.
2349 We can't use displaced stepping when we have a signal to deliver;
2350 the comments for displaced_step_prepare explain why. The
2351 comments in the handle_inferior event for dealing with 'random
2352 signals' explain what we do instead.
2354 We can't use displaced stepping when we are waiting for vfork_done
2355 event, displaced stepping breaks the vfork child similarly as single
2356 step software breakpoint. */
2357 if (tp
->control
.trap_expected
2358 && use_displaced_stepping (tp
)
2359 && !step_over_info_valid_p ()
2360 && sig
== GDB_SIGNAL_0
2361 && !current_inferior ()->waiting_for_vfork_done
)
2363 displaced_step_prepare_status prepare_status
2364 = displaced_step_prepare (tp
);
2366 if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
)
2368 infrun_debug_printf ("Got placed in step-over queue");
2370 tp
->control
.trap_expected
= 0;
2373 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_CANT
)
2375 /* Fallback to stepping over the breakpoint in-line. */
2377 if (target_is_non_stop_p ())
2378 stop_all_threads ();
2380 set_step_over_info (regcache
->aspace (),
2381 regcache_read_pc (regcache
), 0, tp
->global_num
);
2383 step
= maybe_software_singlestep (gdbarch
);
2385 insert_breakpoints ();
2387 else if (prepare_status
== DISPLACED_STEP_PREPARE_STATUS_OK
)
2389 /* Update pc to reflect the new address from which we will
2390 execute instructions due to displaced stepping. */
2391 pc
= regcache_read_pc (get_thread_regcache (tp
));
2393 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
);
2396 gdb_assert_not_reached (_("Invalid displaced_step_prepare_status "
2400 /* Do we need to do it the hard way, w/temp breakpoints? */
2402 step
= maybe_software_singlestep (gdbarch
);
2404 /* Currently, our software single-step implementation leads to different
2405 results than hardware single-stepping in one situation: when stepping
2406 into delivering a signal which has an associated signal handler,
2407 hardware single-step will stop at the first instruction of the handler,
2408 while software single-step will simply skip execution of the handler.
2410 For now, this difference in behavior is accepted since there is no
2411 easy way to actually implement single-stepping into a signal handler
2412 without kernel support.
2414 However, there is one scenario where this difference leads to follow-on
2415 problems: if we're stepping off a breakpoint by removing all breakpoints
2416 and then single-stepping. In this case, the software single-step
2417 behavior means that even if there is a *breakpoint* in the signal
2418 handler, GDB still would not stop.
2420 Fortunately, we can at least fix this particular issue. We detect
2421 here the case where we are about to deliver a signal while software
2422 single-stepping with breakpoints removed. In this situation, we
2423 revert the decisions to remove all breakpoints and insert single-
2424 step breakpoints, and instead we install a step-resume breakpoint
2425 at the current address, deliver the signal without stepping, and
2426 once we arrive back at the step-resume breakpoint, actually step
2427 over the breakpoint we originally wanted to step over. */
2428 if (thread_has_single_step_breakpoints_set (tp
)
2429 && sig
!= GDB_SIGNAL_0
2430 && step_over_info_valid_p ())
2432 /* If we have nested signals or a pending signal is delivered
2433 immediately after a handler returns, might already have
2434 a step-resume breakpoint set on the earlier handler. We cannot
2435 set another step-resume breakpoint; just continue on until the
2436 original breakpoint is hit. */
2437 if (tp
->control
.step_resume_breakpoint
== NULL
)
2439 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2440 tp
->step_after_step_resume_breakpoint
= 1;
2443 delete_single_step_breakpoints (tp
);
2445 clear_step_over_info ();
2446 tp
->control
.trap_expected
= 0;
2448 insert_breakpoints ();
2451 /* If STEP is set, it's a request to use hardware stepping
2452 facilities. But in that case, we should never
2453 use singlestep breakpoint. */
2454 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2456 /* Decide the set of threads to ask the target to resume. */
2457 if (tp
->control
.trap_expected
)
2459 /* We're allowing a thread to run past a breakpoint it has
2460 hit, either by single-stepping the thread with the breakpoint
2461 removed, or by displaced stepping, with the breakpoint inserted.
2462 In the former case, we need to single-step only this thread,
2463 and keep others stopped, as they can miss this breakpoint if
2464 allowed to run. That's not really a problem for displaced
2465 stepping, but, we still keep other threads stopped, in case
2466 another thread is also stopped for a breakpoint waiting for
2467 its turn in the displaced stepping queue. */
2468 resume_ptid
= inferior_ptid
;
2471 resume_ptid
= internal_resume_ptid (user_step
);
2473 if (execution_direction
!= EXEC_REVERSE
2474 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2476 /* There are two cases where we currently need to step a
2477 breakpoint instruction when we have a signal to deliver:
2479 - See handle_signal_stop where we handle random signals that
2480 could take out us out of the stepping range. Normally, in
2481 that case we end up continuing (instead of stepping) over the
2482 signal handler with a breakpoint at PC, but there are cases
2483 where we should _always_ single-step, even if we have a
2484 step-resume breakpoint, like when a software watchpoint is
2485 set. Assuming single-stepping and delivering a signal at the
2486 same time would takes us to the signal handler, then we could
2487 have removed the breakpoint at PC to step over it. However,
2488 some hardware step targets (like e.g., Mac OS) can't step
2489 into signal handlers, and for those, we need to leave the
2490 breakpoint at PC inserted, as otherwise if the handler
2491 recurses and executes PC again, it'll miss the breakpoint.
2492 So we leave the breakpoint inserted anyway, but we need to
2493 record that we tried to step a breakpoint instruction, so
2494 that adjust_pc_after_break doesn't end up confused.
2496 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2497 in one thread after another thread that was stepping had been
2498 momentarily paused for a step-over. When we re-resume the
2499 stepping thread, it may be resumed from that address with a
2500 breakpoint that hasn't trapped yet. Seen with
2501 gdb.threads/non-stop-fair-events.exp, on targets that don't
2502 do displaced stepping. */
2504 infrun_debug_printf ("resume: [%s] stepped breakpoint",
2505 target_pid_to_str (tp
->ptid
).c_str ());
2507 tp
->stepped_breakpoint
= 1;
2509 /* Most targets can step a breakpoint instruction, thus
2510 executing it normally. But if this one cannot, just
2511 continue and we will hit it anyway. */
2512 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2517 && tp
->control
.trap_expected
2518 && use_displaced_stepping (tp
)
2519 && !step_over_info_valid_p ())
2521 struct regcache
*resume_regcache
= get_thread_regcache (tp
);
2522 struct gdbarch
*resume_gdbarch
= resume_regcache
->arch ();
2523 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2526 read_memory (actual_pc
, buf
, sizeof (buf
));
2527 displaced_debug_printf ("run %s: %s",
2528 paddress (resume_gdbarch
, actual_pc
),
2529 displaced_step_dump_bytes
2530 (buf
, sizeof (buf
)).c_str ());
2533 if (tp
->control
.may_range_step
)
2535 /* If we're resuming a thread with the PC out of the step
2536 range, then we're doing some nested/finer run control
2537 operation, like stepping the thread out of the dynamic
2538 linker or the displaced stepping scratch pad. We
2539 shouldn't have allowed a range step then. */
2540 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2543 do_target_resume (resume_ptid
, step
, sig
);
2544 tp
->set_resumed (true);
2547 /* Resume the inferior. SIG is the signal to give the inferior
2548 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2549 rolls back state on error. */
2552 resume (gdb_signal sig
)
2558 catch (const gdb_exception
&ex
)
2560 /* If resuming is being aborted for any reason, delete any
2561 single-step breakpoint resume_1 may have created, to avoid
2562 confusing the following resumption, and to avoid leaving
2563 single-step breakpoints perturbing other threads, in case
2564 we're running in non-stop mode. */
2565 if (inferior_ptid
!= null_ptid
)
2566 delete_single_step_breakpoints (inferior_thread ());
2576 /* Counter that tracks number of user visible stops. This can be used
2577 to tell whether a command has proceeded the inferior past the
2578 current location. This allows e.g., inferior function calls in
2579 breakpoint commands to not interrupt the command list. When the
2580 call finishes successfully, the inferior is standing at the same
2581 breakpoint as if nothing happened (and so we don't call
2583 static ULONGEST current_stop_id
;
2590 return current_stop_id
;
2593 /* Called when we report a user visible stop. */
2601 /* Clear out all variables saying what to do when inferior is continued.
2602 First do this, then set the ones you want, then call `proceed'. */
2605 clear_proceed_status_thread (struct thread_info
*tp
)
2607 infrun_debug_printf ("%s", target_pid_to_str (tp
->ptid
).c_str ());
2609 /* If we're starting a new sequence, then the previous finished
2610 single-step is no longer relevant. */
2611 if (tp
->has_pending_waitstatus ())
2613 if (tp
->stop_reason () == TARGET_STOPPED_BY_SINGLE_STEP
)
2615 infrun_debug_printf ("pending event of %s was a finished step. "
2617 target_pid_to_str (tp
->ptid
).c_str ());
2619 tp
->clear_pending_waitstatus ();
2620 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
2625 ("thread %s has pending wait status %s (currently_stepping=%d).",
2626 target_pid_to_str (tp
->ptid
).c_str (),
2627 target_waitstatus_to_string (&tp
->pending_waitstatus ()).c_str (),
2628 currently_stepping (tp
));
2632 /* If this signal should not be seen by program, give it zero.
2633 Used for debugging signals. */
2634 if (!signal_pass_state (tp
->stop_signal ()))
2635 tp
->set_stop_signal (GDB_SIGNAL_0
);
2637 delete tp
->thread_fsm
;
2638 tp
->thread_fsm
= NULL
;
2640 tp
->control
.trap_expected
= 0;
2641 tp
->control
.step_range_start
= 0;
2642 tp
->control
.step_range_end
= 0;
2643 tp
->control
.may_range_step
= 0;
2644 tp
->control
.step_frame_id
= null_frame_id
;
2645 tp
->control
.step_stack_frame_id
= null_frame_id
;
2646 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2647 tp
->control
.step_start_function
= NULL
;
2648 tp
->stop_requested
= 0;
2650 tp
->control
.stop_step
= 0;
2652 tp
->control
.proceed_to_finish
= 0;
2654 tp
->control
.stepping_command
= 0;
2656 /* Discard any remaining commands or status from previous stop. */
2657 bpstat_clear (&tp
->control
.stop_bpstat
);
2661 clear_proceed_status (int step
)
2663 /* With scheduler-locking replay, stop replaying other threads if we're
2664 not replaying the user-visible resume ptid.
2666 This is a convenience feature to not require the user to explicitly
2667 stop replaying the other threads. We're assuming that the user's
2668 intent is to resume tracing the recorded process. */
2669 if (!non_stop
&& scheduler_mode
== schedlock_replay
2670 && target_record_is_replaying (minus_one_ptid
)
2671 && !target_record_will_replay (user_visible_resume_ptid (step
),
2672 execution_direction
))
2673 target_record_stop_replaying ();
2675 if (!non_stop
&& inferior_ptid
!= null_ptid
)
2677 ptid_t resume_ptid
= user_visible_resume_ptid (step
);
2678 process_stratum_target
*resume_target
2679 = user_visible_resume_target (resume_ptid
);
2681 /* In all-stop mode, delete the per-thread status of all threads
2682 we're about to resume, implicitly and explicitly. */
2683 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
2684 clear_proceed_status_thread (tp
);
2687 if (inferior_ptid
!= null_ptid
)
2689 struct inferior
*inferior
;
2693 /* If in non-stop mode, only delete the per-thread status of
2694 the current thread. */
2695 clear_proceed_status_thread (inferior_thread ());
2698 inferior
= current_inferior ();
2699 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2702 gdb::observers::about_to_proceed
.notify ();
2705 /* Returns true if TP is still stopped at a breakpoint that needs
2706 stepping-over in order to make progress. If the breakpoint is gone
2707 meanwhile, we can skip the whole step-over dance. */
2710 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2712 if (tp
->stepping_over_breakpoint
)
2714 struct regcache
*regcache
= get_thread_regcache (tp
);
2716 if (breakpoint_here_p (regcache
->aspace (),
2717 regcache_read_pc (regcache
))
2718 == ordinary_breakpoint_here
)
2721 tp
->stepping_over_breakpoint
= 0;
2727 /* Check whether thread TP still needs to start a step-over in order
2728 to make progress when resumed. Returns an bitwise or of enum
2729 step_over_what bits, indicating what needs to be stepped over. */
2731 static step_over_what
2732 thread_still_needs_step_over (struct thread_info
*tp
)
2734 step_over_what what
= 0;
2736 if (thread_still_needs_step_over_bp (tp
))
2737 what
|= STEP_OVER_BREAKPOINT
;
2739 if (tp
->stepping_over_watchpoint
2740 && !target_have_steppable_watchpoint ())
2741 what
|= STEP_OVER_WATCHPOINT
;
2746 /* Returns true if scheduler locking applies. STEP indicates whether
2747 we're about to do a step/next-like command to a thread. */
2750 schedlock_applies (struct thread_info
*tp
)
2752 return (scheduler_mode
== schedlock_on
2753 || (scheduler_mode
== schedlock_step
2754 && tp
->control
.stepping_command
)
2755 || (scheduler_mode
== schedlock_replay
2756 && target_record_will_replay (minus_one_ptid
,
2757 execution_direction
)));
2760 /* Set process_stratum_target::COMMIT_RESUMED_STATE in all target
2761 stacks that have threads executing and don't have threads with
2765 maybe_set_commit_resumed_all_targets ()
2767 scoped_restore_current_thread restore_thread
;
2769 for (inferior
*inf
: all_non_exited_inferiors ())
2771 process_stratum_target
*proc_target
= inf
->process_target ();
2773 if (proc_target
->commit_resumed_state
)
2775 /* We already set this in a previous iteration, via another
2776 inferior sharing the process_stratum target. */
2780 /* If the target has no resumed threads, it would be useless to
2781 ask it to commit the resumed threads. */
2782 if (!proc_target
->threads_executing
)
2784 infrun_debug_printf ("not requesting commit-resumed for target "
2785 "%s, no resumed threads",
2786 proc_target
->shortname ());
2790 /* As an optimization, if a thread from this target has some
2791 status to report, handle it before requiring the target to
2792 commit its resumed threads: handling the status might lead to
2793 resuming more threads. */
2794 if (proc_target
->has_resumed_with_pending_wait_status ())
2796 infrun_debug_printf ("not requesting commit-resumed for target %s, a"
2797 " thread has a pending waitstatus",
2798 proc_target
->shortname ());
2802 switch_to_inferior_no_thread (inf
);
2804 if (target_has_pending_events ())
2806 infrun_debug_printf ("not requesting commit-resumed for target %s, "
2807 "target has pending events",
2808 proc_target
->shortname ());
2812 infrun_debug_printf ("enabling commit-resumed for target %s",
2813 proc_target
->shortname ());
2815 proc_target
->commit_resumed_state
= true;
2822 maybe_call_commit_resumed_all_targets ()
2824 scoped_restore_current_thread restore_thread
;
2826 for (inferior
*inf
: all_non_exited_inferiors ())
2828 process_stratum_target
*proc_target
= inf
->process_target ();
2830 if (!proc_target
->commit_resumed_state
)
2833 switch_to_inferior_no_thread (inf
);
2835 infrun_debug_printf ("calling commit_resumed for target %s",
2836 proc_target
->shortname());
2838 target_commit_resumed ();
2842 /* To track nesting of scoped_disable_commit_resumed objects, ensuring
2843 that only the outermost one attempts to re-enable
2845 static bool enable_commit_resumed
= true;
2849 scoped_disable_commit_resumed::scoped_disable_commit_resumed
2850 (const char *reason
)
2851 : m_reason (reason
),
2852 m_prev_enable_commit_resumed (enable_commit_resumed
)
2854 infrun_debug_printf ("reason=%s", m_reason
);
2856 enable_commit_resumed
= false;
2858 for (inferior
*inf
: all_non_exited_inferiors ())
2860 process_stratum_target
*proc_target
= inf
->process_target ();
2862 if (m_prev_enable_commit_resumed
)
2864 /* This is the outermost instance: force all
2865 COMMIT_RESUMED_STATE to false. */
2866 proc_target
->commit_resumed_state
= false;
2870 /* This is not the outermost instance, we expect
2871 COMMIT_RESUMED_STATE to have been cleared by the
2872 outermost instance. */
2873 gdb_assert (!proc_target
->commit_resumed_state
);
2881 scoped_disable_commit_resumed::reset ()
2887 infrun_debug_printf ("reason=%s", m_reason
);
2889 gdb_assert (!enable_commit_resumed
);
2891 enable_commit_resumed
= m_prev_enable_commit_resumed
;
2893 if (m_prev_enable_commit_resumed
)
2895 /* This is the outermost instance, re-enable
2896 COMMIT_RESUMED_STATE on the targets where it's possible. */
2897 maybe_set_commit_resumed_all_targets ();
2901 /* This is not the outermost instance, we expect
2902 COMMIT_RESUMED_STATE to still be false. */
2903 for (inferior
*inf
: all_non_exited_inferiors ())
2905 process_stratum_target
*proc_target
= inf
->process_target ();
2906 gdb_assert (!proc_target
->commit_resumed_state
);
2913 scoped_disable_commit_resumed::~scoped_disable_commit_resumed ()
2921 scoped_disable_commit_resumed::reset_and_commit ()
2924 maybe_call_commit_resumed_all_targets ();
2929 scoped_enable_commit_resumed::scoped_enable_commit_resumed
2930 (const char *reason
)
2931 : m_reason (reason
),
2932 m_prev_enable_commit_resumed (enable_commit_resumed
)
2934 infrun_debug_printf ("reason=%s", m_reason
);
2936 if (!enable_commit_resumed
)
2938 enable_commit_resumed
= true;
2940 /* Re-enable COMMIT_RESUMED_STATE on the targets where it's
2942 maybe_set_commit_resumed_all_targets ();
2944 maybe_call_commit_resumed_all_targets ();
2950 scoped_enable_commit_resumed::~scoped_enable_commit_resumed ()
2952 infrun_debug_printf ("reason=%s", m_reason
);
2954 gdb_assert (enable_commit_resumed
);
2956 enable_commit_resumed
= m_prev_enable_commit_resumed
;
2958 if (!enable_commit_resumed
)
2960 /* Force all COMMIT_RESUMED_STATE back to false. */
2961 for (inferior
*inf
: all_non_exited_inferiors ())
2963 process_stratum_target
*proc_target
= inf
->process_target ();
2964 proc_target
->commit_resumed_state
= false;
2969 /* Check that all the targets we're about to resume are in non-stop
2970 mode. Ideally, we'd only care whether all targets support
2971 target-async, but we're not there yet. E.g., stop_all_threads
2972 doesn't know how to handle all-stop targets. Also, the remote
2973 protocol in all-stop mode is synchronous, irrespective of
2974 target-async, which means that things like a breakpoint re-set
2975 triggered by one target would try to read memory from all targets
2979 check_multi_target_resumption (process_stratum_target
*resume_target
)
2981 if (!non_stop
&& resume_target
== nullptr)
2983 scoped_restore_current_thread restore_thread
;
2985 /* This is used to track whether we're resuming more than one
2987 process_stratum_target
*first_connection
= nullptr;
2989 /* The first inferior we see with a target that does not work in
2990 always-non-stop mode. */
2991 inferior
*first_not_non_stop
= nullptr;
2993 for (inferior
*inf
: all_non_exited_inferiors ())
2995 switch_to_inferior_no_thread (inf
);
2997 if (!target_has_execution ())
3000 process_stratum_target
*proc_target
3001 = current_inferior ()->process_target();
3003 if (!target_is_non_stop_p ())
3004 first_not_non_stop
= inf
;
3006 if (first_connection
== nullptr)
3007 first_connection
= proc_target
;
3008 else if (first_connection
!= proc_target
3009 && first_not_non_stop
!= nullptr)
3011 switch_to_inferior_no_thread (first_not_non_stop
);
3013 proc_target
= current_inferior ()->process_target();
3015 error (_("Connection %d (%s) does not support "
3016 "multi-target resumption."),
3017 proc_target
->connection_number
,
3018 make_target_connection_string (proc_target
).c_str ());
3024 /* Basic routine for continuing the program in various fashions.
3026 ADDR is the address to resume at, or -1 for resume where stopped.
3027 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
3028 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
3030 You should call clear_proceed_status before calling proceed. */
3033 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
3035 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
3037 struct regcache
*regcache
;
3038 struct gdbarch
*gdbarch
;
3040 struct execution_control_state ecss
;
3041 struct execution_control_state
*ecs
= &ecss
;
3044 /* If we're stopped at a fork/vfork, follow the branch set by the
3045 "set follow-fork-mode" command; otherwise, we'll just proceed
3046 resuming the current thread. */
3047 if (!follow_fork ())
3049 /* The target for some reason decided not to resume. */
3051 if (target_can_async_p ())
3052 inferior_event_handler (INF_EXEC_COMPLETE
);
3056 /* We'll update this if & when we switch to a new thread. */
3057 previous_inferior_ptid
= inferior_ptid
;
3059 regcache
= get_current_regcache ();
3060 gdbarch
= regcache
->arch ();
3061 const address_space
*aspace
= regcache
->aspace ();
3063 pc
= regcache_read_pc_protected (regcache
);
3065 thread_info
*cur_thr
= inferior_thread ();
3067 /* Fill in with reasonable starting values. */
3068 init_thread_stepping_state (cur_thr
);
3070 gdb_assert (!thread_is_in_step_over_chain (cur_thr
));
3073 = user_visible_resume_ptid (cur_thr
->control
.stepping_command
);
3074 process_stratum_target
*resume_target
3075 = user_visible_resume_target (resume_ptid
);
3077 check_multi_target_resumption (resume_target
);
3079 if (addr
== (CORE_ADDR
) -1)
3081 if (pc
== cur_thr
->stop_pc ()
3082 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
3083 && execution_direction
!= EXEC_REVERSE
)
3084 /* There is a breakpoint at the address we will resume at,
3085 step one instruction before inserting breakpoints so that
3086 we do not stop right away (and report a second hit at this
3089 Note, we don't do this in reverse, because we won't
3090 actually be executing the breakpoint insn anyway.
3091 We'll be (un-)executing the previous instruction. */
3092 cur_thr
->stepping_over_breakpoint
= 1;
3093 else if (gdbarch_single_step_through_delay_p (gdbarch
)
3094 && gdbarch_single_step_through_delay (gdbarch
,
3095 get_current_frame ()))
3096 /* We stepped onto an instruction that needs to be stepped
3097 again before re-inserting the breakpoint, do so. */
3098 cur_thr
->stepping_over_breakpoint
= 1;
3102 regcache_write_pc (regcache
, addr
);
3105 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
3106 cur_thr
->set_stop_signal (siggnal
);
3108 /* If an exception is thrown from this point on, make sure to
3109 propagate GDB's knowledge of the executing state to the
3110 frontend/user running state. */
3111 scoped_finish_thread_state
finish_state (resume_target
, resume_ptid
);
3113 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3114 threads (e.g., we might need to set threads stepping over
3115 breakpoints first), from the user/frontend's point of view, all
3116 threads in RESUME_PTID are now running. Unless we're calling an
3117 inferior function, as in that case we pretend the inferior
3118 doesn't run at all. */
3119 if (!cur_thr
->control
.in_infcall
)
3120 set_running (resume_target
, resume_ptid
, true);
3122 infrun_debug_printf ("addr=%s, signal=%s", paddress (gdbarch
, addr
),
3123 gdb_signal_to_symbol_string (siggnal
));
3125 annotate_starting ();
3127 /* Make sure that output from GDB appears before output from the
3129 gdb_flush (gdb_stdout
);
3131 /* Since we've marked the inferior running, give it the terminal. A
3132 QUIT/Ctrl-C from here on is forwarded to the target (which can
3133 still detect attempts to unblock a stuck connection with repeated
3134 Ctrl-C from within target_pass_ctrlc). */
3135 target_terminal::inferior ();
3137 /* In a multi-threaded task we may select another thread and
3138 then continue or step.
3140 But if a thread that we're resuming had stopped at a breakpoint,
3141 it will immediately cause another breakpoint stop without any
3142 execution (i.e. it will report a breakpoint hit incorrectly). So
3143 we must step over it first.
3145 Look for threads other than the current (TP) that reported a
3146 breakpoint hit and haven't been resumed yet since. */
3148 /* If scheduler locking applies, we can avoid iterating over all
3150 if (!non_stop
&& !schedlock_applies (cur_thr
))
3152 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3155 switch_to_thread_no_regs (tp
);
3157 /* Ignore the current thread here. It's handled
3162 if (!thread_still_needs_step_over (tp
))
3165 gdb_assert (!thread_is_in_step_over_chain (tp
));
3167 infrun_debug_printf ("need to step-over [%s] first",
3168 target_pid_to_str (tp
->ptid
).c_str ());
3170 global_thread_step_over_chain_enqueue (tp
);
3173 switch_to_thread (cur_thr
);
3176 /* Enqueue the current thread last, so that we move all other
3177 threads over their breakpoints first. */
3178 if (cur_thr
->stepping_over_breakpoint
)
3179 global_thread_step_over_chain_enqueue (cur_thr
);
3181 /* If the thread isn't started, we'll still need to set its prev_pc,
3182 so that switch_back_to_stepped_thread knows the thread hasn't
3183 advanced. Must do this before resuming any thread, as in
3184 all-stop/remote, once we resume we can't send any other packet
3185 until the target stops again. */
3186 cur_thr
->prev_pc
= regcache_read_pc_protected (regcache
);
3189 scoped_disable_commit_resumed
disable_commit_resumed ("proceeding");
3191 started
= start_step_over ();
3193 if (step_over_info_valid_p ())
3195 /* Either this thread started a new in-line step over, or some
3196 other thread was already doing one. In either case, don't
3197 resume anything else until the step-over is finished. */
3199 else if (started
&& !target_is_non_stop_p ())
3201 /* A new displaced stepping sequence was started. In all-stop,
3202 we can't talk to the target anymore until it next stops. */
3204 else if (!non_stop
&& target_is_non_stop_p ())
3206 INFRUN_SCOPED_DEBUG_START_END
3207 ("resuming threads, all-stop-on-top-of-non-stop");
3209 /* In all-stop, but the target is always in non-stop mode.
3210 Start all other threads that are implicitly resumed too. */
3211 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3214 switch_to_thread_no_regs (tp
);
3216 if (!tp
->inf
->has_execution ())
3218 infrun_debug_printf ("[%s] target has no execution",
3219 target_pid_to_str (tp
->ptid
).c_str ());
3225 infrun_debug_printf ("[%s] resumed",
3226 target_pid_to_str (tp
->ptid
).c_str ());
3227 gdb_assert (tp
->executing
|| tp
->has_pending_waitstatus ());
3231 if (thread_is_in_step_over_chain (tp
))
3233 infrun_debug_printf ("[%s] needs step-over",
3234 target_pid_to_str (tp
->ptid
).c_str ());
3238 infrun_debug_printf ("resuming %s",
3239 target_pid_to_str (tp
->ptid
).c_str ());
3241 reset_ecs (ecs
, tp
);
3242 switch_to_thread (tp
);
3243 keep_going_pass_signal (ecs
);
3244 if (!ecs
->wait_some_more
)
3245 error (_("Command aborted."));
3248 else if (!cur_thr
->resumed () && !thread_is_in_step_over_chain (cur_thr
))
3250 /* The thread wasn't started, and isn't queued, run it now. */
3251 reset_ecs (ecs
, cur_thr
);
3252 switch_to_thread (cur_thr
);
3253 keep_going_pass_signal (ecs
);
3254 if (!ecs
->wait_some_more
)
3255 error (_("Command aborted."));
3258 disable_commit_resumed
.reset_and_commit ();
3261 finish_state
.release ();
3263 /* If we've switched threads above, switch back to the previously
3264 current thread. We don't want the user to see a different
3266 switch_to_thread (cur_thr
);
3268 /* Tell the event loop to wait for it to stop. If the target
3269 supports asynchronous execution, it'll do this from within
3271 if (!target_can_async_p ())
3272 mark_async_event_handler (infrun_async_inferior_event_token
);
3276 /* Start remote-debugging of a machine over a serial link. */
3279 start_remote (int from_tty
)
3281 inferior
*inf
= current_inferior ();
3282 inf
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3284 /* Always go on waiting for the target, regardless of the mode. */
3285 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3286 indicate to wait_for_inferior that a target should timeout if
3287 nothing is returned (instead of just blocking). Because of this,
3288 targets expecting an immediate response need to, internally, set
3289 things up so that the target_wait() is forced to eventually
3291 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3292 differentiate to its caller what the state of the target is after
3293 the initial open has been performed. Here we're assuming that
3294 the target has stopped. It should be possible to eventually have
3295 target_open() return to the caller an indication that the target
3296 is currently running and GDB state should be set to the same as
3297 for an async run. */
3298 wait_for_inferior (inf
);
3300 /* Now that the inferior has stopped, do any bookkeeping like
3301 loading shared libraries. We want to do this before normal_stop,
3302 so that the displayed frame is up to date. */
3303 post_create_inferior (from_tty
);
3308 /* Initialize static vars when a new inferior begins. */
3311 init_wait_for_inferior (void)
3313 /* These are meaningless until the first time through wait_for_inferior. */
3315 breakpoint_init_inferior (inf_starting
);
3317 clear_proceed_status (0);
3319 nullify_last_target_wait_ptid ();
3321 previous_inferior_ptid
= inferior_ptid
;
3326 static void handle_inferior_event (struct execution_control_state
*ecs
);
3328 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3329 struct execution_control_state
*ecs
);
3330 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3331 struct execution_control_state
*ecs
);
3332 static void handle_signal_stop (struct execution_control_state
*ecs
);
3333 static void check_exception_resume (struct execution_control_state
*,
3334 struct frame_info
*);
3336 static void end_stepping_range (struct execution_control_state
*ecs
);
3337 static void stop_waiting (struct execution_control_state
*ecs
);
3338 static void keep_going (struct execution_control_state
*ecs
);
3339 static void process_event_stop_test (struct execution_control_state
*ecs
);
3340 static bool switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3342 /* This function is attached as a "thread_stop_requested" observer.
3343 Cleanup local state that assumed the PTID was to be resumed, and
3344 report the stop to the frontend. */
3347 infrun_thread_stop_requested (ptid_t ptid
)
3349 process_stratum_target
*curr_target
= current_inferior ()->process_target ();
3351 /* PTID was requested to stop. If the thread was already stopped,
3352 but the user/frontend doesn't know about that yet (e.g., the
3353 thread had been temporarily paused for some step-over), set up
3354 for reporting the stop now. */
3355 for (thread_info
*tp
: all_threads (curr_target
, ptid
))
3357 if (tp
->state
!= THREAD_RUNNING
)
3362 /* Remove matching threads from the step-over queue, so
3363 start_step_over doesn't try to resume them
3365 if (thread_is_in_step_over_chain (tp
))
3366 global_thread_step_over_chain_remove (tp
);
3368 /* If the thread is stopped, but the user/frontend doesn't
3369 know about that yet, queue a pending event, as if the
3370 thread had just stopped now. Unless the thread already had
3372 if (!tp
->has_pending_waitstatus ())
3374 target_waitstatus ws
;
3375 ws
.kind
= TARGET_WAITKIND_STOPPED
;
3376 ws
.value
.sig
= GDB_SIGNAL_0
;
3377 tp
->set_pending_waitstatus (ws
);
3380 /* Clear the inline-frame state, since we're re-processing the
3382 clear_inline_frame_state (tp
);
3384 /* If this thread was paused because some other thread was
3385 doing an inline-step over, let that finish first. Once
3386 that happens, we'll restart all threads and consume pending
3387 stop events then. */
3388 if (step_over_info_valid_p ())
3391 /* Otherwise we can process the (new) pending event now. Set
3392 it so this pending event is considered by
3394 tp
->set_resumed (true);
3399 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3401 if (target_last_proc_target
== tp
->inf
->process_target ()
3402 && target_last_wait_ptid
== tp
->ptid
)
3403 nullify_last_target_wait_ptid ();
3406 /* Delete the step resume, single-step and longjmp/exception resume
3407 breakpoints of TP. */
3410 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3412 delete_step_resume_breakpoint (tp
);
3413 delete_exception_resume_breakpoint (tp
);
3414 delete_single_step_breakpoints (tp
);
3417 /* If the target still has execution, call FUNC for each thread that
3418 just stopped. In all-stop, that's all the non-exited threads; in
3419 non-stop, that's the current thread, only. */
3421 typedef void (*for_each_just_stopped_thread_callback_func
)
3422 (struct thread_info
*tp
);
3425 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3427 if (!target_has_execution () || inferior_ptid
== null_ptid
)
3430 if (target_is_non_stop_p ())
3432 /* If in non-stop mode, only the current thread stopped. */
3433 func (inferior_thread ());
3437 /* In all-stop mode, all threads have stopped. */
3438 for (thread_info
*tp
: all_non_exited_threads ())
3443 /* Delete the step resume and longjmp/exception resume breakpoints of
3444 the threads that just stopped. */
3447 delete_just_stopped_threads_infrun_breakpoints (void)
3449 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3452 /* Delete the single-step breakpoints of the threads that just
3456 delete_just_stopped_threads_single_step_breakpoints (void)
3458 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3464 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3465 const struct target_waitstatus
*ws
)
3467 infrun_debug_printf ("target_wait (%d.%ld.%ld [%s], status) =",
3471 target_pid_to_str (waiton_ptid
).c_str ());
3472 infrun_debug_printf (" %d.%ld.%ld [%s],",
3476 target_pid_to_str (result_ptid
).c_str ());
3477 infrun_debug_printf (" %s", target_waitstatus_to_string (ws
).c_str ());
3480 /* Select a thread at random, out of those which are resumed and have
3483 static struct thread_info
*
3484 random_pending_event_thread (inferior
*inf
, ptid_t waiton_ptid
)
3486 process_stratum_target
*proc_target
= inf
->process_target ();
3488 = proc_target
->random_resumed_with_pending_wait_status (inf
, waiton_ptid
);
3490 if (thread
== nullptr)
3492 infrun_debug_printf ("None found.");
3496 infrun_debug_printf ("Found %s.", target_pid_to_str (thread
->ptid
).c_str ());
3497 gdb_assert (thread
->resumed ());
3498 gdb_assert (thread
->has_pending_waitstatus ());
3503 /* Wrapper for target_wait that first checks whether threads have
3504 pending statuses to report before actually asking the target for
3505 more events. INF is the inferior we're using to call target_wait
3509 do_target_wait_1 (inferior
*inf
, ptid_t ptid
,
3510 target_waitstatus
*status
, target_wait_flags options
)
3513 struct thread_info
*tp
;
3515 /* We know that we are looking for an event in the target of inferior
3516 INF, but we don't know which thread the event might come from. As
3517 such we want to make sure that INFERIOR_PTID is reset so that none of
3518 the wait code relies on it - doing so is always a mistake. */
3519 switch_to_inferior_no_thread (inf
);
3521 /* First check if there is a resumed thread with a wait status
3523 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
3525 tp
= random_pending_event_thread (inf
, ptid
);
3529 infrun_debug_printf ("Waiting for specific thread %s.",
3530 target_pid_to_str (ptid
).c_str ());
3532 /* We have a specific thread to check. */
3533 tp
= find_thread_ptid (inf
, ptid
);
3534 gdb_assert (tp
!= NULL
);
3535 if (!tp
->has_pending_waitstatus ())
3540 && (tp
->stop_reason () == TARGET_STOPPED_BY_SW_BREAKPOINT
3541 || tp
->stop_reason () == TARGET_STOPPED_BY_HW_BREAKPOINT
))
3543 struct regcache
*regcache
= get_thread_regcache (tp
);
3544 struct gdbarch
*gdbarch
= regcache
->arch ();
3548 pc
= regcache_read_pc (regcache
);
3550 if (pc
!= tp
->stop_pc ())
3552 infrun_debug_printf ("PC of %s changed. was=%s, now=%s",
3553 target_pid_to_str (tp
->ptid
).c_str (),
3554 paddress (gdbarch
, tp
->stop_pc ()),
3555 paddress (gdbarch
, pc
));
3558 else if (!breakpoint_inserted_here_p (regcache
->aspace (), pc
))
3560 infrun_debug_printf ("previous breakpoint of %s, at %s gone",
3561 target_pid_to_str (tp
->ptid
).c_str (),
3562 paddress (gdbarch
, pc
));
3569 infrun_debug_printf ("pending event of %s cancelled.",
3570 target_pid_to_str (tp
->ptid
).c_str ());
3572 tp
->clear_pending_waitstatus ();
3573 target_waitstatus ws
;
3574 ws
.kind
= TARGET_WAITKIND_SPURIOUS
;
3575 tp
->set_pending_waitstatus (ws
);
3576 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
3582 infrun_debug_printf ("Using pending wait status %s for %s.",
3583 target_waitstatus_to_string
3584 (&tp
->pending_waitstatus ()).c_str (),
3585 target_pid_to_str (tp
->ptid
).c_str ());
3587 /* Now that we've selected our final event LWP, un-adjust its PC
3588 if it was a software breakpoint (and the target doesn't
3589 always adjust the PC itself). */
3590 if (tp
->stop_reason () == TARGET_STOPPED_BY_SW_BREAKPOINT
3591 && !target_supports_stopped_by_sw_breakpoint ())
3593 struct regcache
*regcache
;
3594 struct gdbarch
*gdbarch
;
3597 regcache
= get_thread_regcache (tp
);
3598 gdbarch
= regcache
->arch ();
3600 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3605 pc
= regcache_read_pc (regcache
);
3606 regcache_write_pc (regcache
, pc
+ decr_pc
);
3610 tp
->set_stop_reason (TARGET_STOPPED_BY_NO_REASON
);
3611 *status
= tp
->pending_waitstatus ();
3612 tp
->clear_pending_waitstatus ();
3614 /* Wake up the event loop again, until all pending events are
3616 if (target_is_async_p ())
3617 mark_async_event_handler (infrun_async_inferior_event_token
);
3621 /* But if we don't find one, we'll have to wait. */
3623 /* We can't ask a non-async target to do a non-blocking wait, so this will be
3625 if (!target_can_async_p ())
3626 options
&= ~TARGET_WNOHANG
;
3628 if (deprecated_target_wait_hook
)
3629 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3631 event_ptid
= target_wait (ptid
, status
, options
);
3636 /* Wrapper for target_wait that first checks whether threads have
3637 pending statuses to report before actually asking the target for
3638 more events. Polls for events from all inferiors/targets. */
3641 do_target_wait (execution_control_state
*ecs
, target_wait_flags options
)
3643 int num_inferiors
= 0;
3644 int random_selector
;
3646 /* For fairness, we pick the first inferior/target to poll at random
3647 out of all inferiors that may report events, and then continue
3648 polling the rest of the inferior list starting from that one in a
3649 circular fashion until the whole list is polled once. */
3651 auto inferior_matches
= [] (inferior
*inf
)
3653 return inf
->process_target () != nullptr;
3656 /* First see how many matching inferiors we have. */
3657 for (inferior
*inf
: all_inferiors ())
3658 if (inferior_matches (inf
))
3661 if (num_inferiors
== 0)
3663 ecs
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
3667 /* Now randomly pick an inferior out of those that matched. */
3668 random_selector
= (int)
3669 ((num_inferiors
* (double) rand ()) / (RAND_MAX
+ 1.0));
3671 if (num_inferiors
> 1)
3672 infrun_debug_printf ("Found %d inferiors, starting at #%d",
3673 num_inferiors
, random_selector
);
3675 /* Select the Nth inferior that matched. */
3677 inferior
*selected
= nullptr;
3679 for (inferior
*inf
: all_inferiors ())
3680 if (inferior_matches (inf
))
3681 if (random_selector
-- == 0)
3687 /* Now poll for events out of each of the matching inferior's
3688 targets, starting from the selected one. */
3690 auto do_wait
= [&] (inferior
*inf
)
3692 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, options
);
3693 ecs
->target
= inf
->process_target ();
3694 return (ecs
->ws
.kind
!= TARGET_WAITKIND_IGNORE
);
3697 /* Needed in 'all-stop + target-non-stop' mode, because we end up
3698 here spuriously after the target is all stopped and we've already
3699 reported the stop to the user, polling for events. */
3700 scoped_restore_current_thread restore_thread
;
3702 intrusive_list_iterator
<inferior
> start
3703 = inferior_list
.iterator_to (*selected
);
3705 for (intrusive_list_iterator
<inferior
> it
= start
;
3706 it
!= inferior_list
.end ();
3709 inferior
*inf
= &*it
;
3711 if (inferior_matches (inf
) && do_wait (inf
))
3715 for (intrusive_list_iterator
<inferior
> it
= inferior_list
.begin ();
3719 inferior
*inf
= &*it
;
3721 if (inferior_matches (inf
) && do_wait (inf
))
3725 ecs
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
3729 /* An event reported by wait_one. */
3731 struct wait_one_event
3733 /* The target the event came out of. */
3734 process_stratum_target
*target
;
3736 /* The PTID the event was for. */
3739 /* The waitstatus. */
3740 target_waitstatus ws
;
3743 static bool handle_one (const wait_one_event
&event
);
3744 static void restart_threads (struct thread_info
*event_thread
);
3746 /* Prepare and stabilize the inferior for detaching it. E.g.,
3747 detaching while a thread is displaced stepping is a recipe for
3748 crashing it, as nothing would readjust the PC out of the scratch
3752 prepare_for_detach (void)
3754 struct inferior
*inf
= current_inferior ();
3755 ptid_t pid_ptid
= ptid_t (inf
->pid
);
3756 scoped_restore_current_thread restore_thread
;
3758 scoped_restore restore_detaching
= make_scoped_restore (&inf
->detaching
, true);
3760 /* Remove all threads of INF from the global step-over chain. We
3761 want to stop any ongoing step-over, not start any new one. */
3762 thread_step_over_list_safe_range range
3763 = make_thread_step_over_list_safe_range (global_thread_step_over_list
);
3765 for (thread_info
*tp
: range
)
3768 infrun_debug_printf ("removing thread %s from global step over chain",
3769 target_pid_to_str (tp
->ptid
).c_str ());
3770 global_thread_step_over_chain_remove (tp
);
3773 /* If we were already in the middle of an inline step-over, and the
3774 thread stepping belongs to the inferior we're detaching, we need
3775 to restart the threads of other inferiors. */
3776 if (step_over_info
.thread
!= -1)
3778 infrun_debug_printf ("inline step-over in-process while detaching");
3780 thread_info
*thr
= find_thread_global_id (step_over_info
.thread
);
3781 if (thr
->inf
== inf
)
3783 /* Since we removed threads of INF from the step-over chain,
3784 we know this won't start a step-over for INF. */
3785 clear_step_over_info ();
3787 if (target_is_non_stop_p ())
3789 /* Start a new step-over in another thread if there's
3790 one that needs it. */
3793 /* Restart all other threads (except the
3794 previously-stepping thread, since that one is still
3796 if (!step_over_info_valid_p ())
3797 restart_threads (thr
);
3802 if (displaced_step_in_progress (inf
))
3804 infrun_debug_printf ("displaced-stepping in-process while detaching");
3806 /* Stop threads currently displaced stepping, aborting it. */
3808 for (thread_info
*thr
: inf
->non_exited_threads ())
3810 if (thr
->displaced_step_state
.in_progress ())
3814 if (!thr
->stop_requested
)
3816 target_stop (thr
->ptid
);
3817 thr
->stop_requested
= true;
3821 thr
->set_resumed (false);
3825 while (displaced_step_in_progress (inf
))
3827 wait_one_event event
;
3829 event
.target
= inf
->process_target ();
3830 event
.ptid
= do_target_wait_1 (inf
, pid_ptid
, &event
.ws
, 0);
3833 print_target_wait_results (pid_ptid
, event
.ptid
, &event
.ws
);
3838 /* It's OK to leave some of the threads of INF stopped, since
3839 they'll be detached shortly. */
3843 /* Wait for control to return from inferior to debugger.
3845 If inferior gets a signal, we may decide to start it up again
3846 instead of returning. That is why there is a loop in this function.
3847 When this function actually returns it means the inferior
3848 should be left stopped and GDB should read more commands. */
3851 wait_for_inferior (inferior
*inf
)
3853 infrun_debug_printf ("wait_for_inferior ()");
3855 SCOPE_EXIT
{ delete_just_stopped_threads_infrun_breakpoints (); };
3857 /* If an error happens while handling the event, propagate GDB's
3858 knowledge of the executing state to the frontend/user running
3860 scoped_finish_thread_state finish_state
3861 (inf
->process_target (), minus_one_ptid
);
3865 struct execution_control_state ecss
;
3866 struct execution_control_state
*ecs
= &ecss
;
3868 memset (ecs
, 0, sizeof (*ecs
));
3870 overlay_cache_invalid
= 1;
3872 /* Flush target cache before starting to handle each event.
3873 Target was running and cache could be stale. This is just a
3874 heuristic. Running threads may modify target memory, but we
3875 don't get any event. */
3876 target_dcache_invalidate ();
3878 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, 0);
3879 ecs
->target
= inf
->process_target ();
3882 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, &ecs
->ws
);
3884 /* Now figure out what to do with the result of the result. */
3885 handle_inferior_event (ecs
);
3887 if (!ecs
->wait_some_more
)
3891 /* No error, don't finish the state yet. */
3892 finish_state
.release ();
3895 /* Cleanup that reinstalls the readline callback handler, if the
3896 target is running in the background. If while handling the target
3897 event something triggered a secondary prompt, like e.g., a
3898 pagination prompt, we'll have removed the callback handler (see
3899 gdb_readline_wrapper_line). Need to do this as we go back to the
3900 event loop, ready to process further input. Note this has no
3901 effect if the handler hasn't actually been removed, because calling
3902 rl_callback_handler_install resets the line buffer, thus losing
3906 reinstall_readline_callback_handler_cleanup ()
3908 struct ui
*ui
= current_ui
;
3912 /* We're not going back to the top level event loop yet. Don't
3913 install the readline callback, as it'd prep the terminal,
3914 readline-style (raw, noecho) (e.g., --batch). We'll install
3915 it the next time the prompt is displayed, when we're ready
3920 if (ui
->command_editing
&& ui
->prompt_state
!= PROMPT_BLOCKED
)
3921 gdb_rl_callback_handler_reinstall ();
3924 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3925 that's just the event thread. In all-stop, that's all threads. */
3928 clean_up_just_stopped_threads_fsms (struct execution_control_state
*ecs
)
3930 if (ecs
->event_thread
!= NULL
3931 && ecs
->event_thread
->thread_fsm
!= NULL
)
3932 ecs
->event_thread
->thread_fsm
->clean_up (ecs
->event_thread
);
3936 for (thread_info
*thr
: all_non_exited_threads ())
3938 if (thr
->thread_fsm
== NULL
)
3940 if (thr
== ecs
->event_thread
)
3943 switch_to_thread (thr
);
3944 thr
->thread_fsm
->clean_up (thr
);
3947 if (ecs
->event_thread
!= NULL
)
3948 switch_to_thread (ecs
->event_thread
);
3952 /* Helper for all_uis_check_sync_execution_done that works on the
3956 check_curr_ui_sync_execution_done (void)
3958 struct ui
*ui
= current_ui
;
3960 if (ui
->prompt_state
== PROMPT_NEEDED
3962 && !gdb_in_secondary_prompt_p (ui
))
3964 target_terminal::ours ();
3965 gdb::observers::sync_execution_done
.notify ();
3966 ui_register_input_event_handler (ui
);
3973 all_uis_check_sync_execution_done (void)
3975 SWITCH_THRU_ALL_UIS ()
3977 check_curr_ui_sync_execution_done ();
3984 all_uis_on_sync_execution_starting (void)
3986 SWITCH_THRU_ALL_UIS ()
3988 if (current_ui
->prompt_state
== PROMPT_NEEDED
)
3989 async_disable_stdin ();
3993 /* Asynchronous version of wait_for_inferior. It is called by the
3994 event loop whenever a change of state is detected on the file
3995 descriptor corresponding to the target. It can be called more than
3996 once to complete a single execution command. In such cases we need
3997 to keep the state in a global variable ECSS. If it is the last time
3998 that this function is called for a single execution command, then
3999 report to the user that the inferior has stopped, and do the
4000 necessary cleanups. */
4003 fetch_inferior_event ()
4005 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
4007 struct execution_control_state ecss
;
4008 struct execution_control_state
*ecs
= &ecss
;
4011 memset (ecs
, 0, sizeof (*ecs
));
4013 /* Events are always processed with the main UI as current UI. This
4014 way, warnings, debug output, etc. are always consistently sent to
4015 the main console. */
4016 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, main_ui
);
4018 /* Temporarily disable pagination. Otherwise, the user would be
4019 given an option to press 'q' to quit, which would cause an early
4020 exit and could leave GDB in a half-baked state. */
4021 scoped_restore save_pagination
4022 = make_scoped_restore (&pagination_enabled
, false);
4024 /* End up with readline processing input, if necessary. */
4026 SCOPE_EXIT
{ reinstall_readline_callback_handler_cleanup (); };
4028 /* We're handling a live event, so make sure we're doing live
4029 debugging. If we're looking at traceframes while the target is
4030 running, we're going to need to get back to that mode after
4031 handling the event. */
4032 gdb::optional
<scoped_restore_current_traceframe
> maybe_restore_traceframe
;
4035 maybe_restore_traceframe
.emplace ();
4036 set_current_traceframe (-1);
4039 /* The user/frontend should not notice a thread switch due to
4040 internal events. Make sure we revert to the user selected
4041 thread and frame after handling the event and running any
4042 breakpoint commands. */
4043 scoped_restore_current_thread restore_thread
;
4045 overlay_cache_invalid
= 1;
4046 /* Flush target cache before starting to handle each event. Target
4047 was running and cache could be stale. This is just a heuristic.
4048 Running threads may modify target memory, but we don't get any
4050 target_dcache_invalidate ();
4052 scoped_restore save_exec_dir
4053 = make_scoped_restore (&execution_direction
,
4054 target_execution_direction ());
4056 /* Allow targets to pause their resumed threads while we handle
4058 scoped_disable_commit_resumed
disable_commit_resumed ("handling event");
4060 if (!do_target_wait (ecs
, TARGET_WNOHANG
))
4062 infrun_debug_printf ("do_target_wait returned no event");
4063 disable_commit_resumed
.reset_and_commit ();
4067 gdb_assert (ecs
->ws
.kind
!= TARGET_WAITKIND_IGNORE
);
4069 /* Switch to the target that generated the event, so we can do
4071 switch_to_target_no_thread (ecs
->target
);
4074 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, &ecs
->ws
);
4076 /* If an error happens while handling the event, propagate GDB's
4077 knowledge of the executing state to the frontend/user running
4079 ptid_t finish_ptid
= !target_is_non_stop_p () ? minus_one_ptid
: ecs
->ptid
;
4080 scoped_finish_thread_state
finish_state (ecs
->target
, finish_ptid
);
4082 /* Get executed before scoped_restore_current_thread above to apply
4083 still for the thread which has thrown the exception. */
4084 auto defer_bpstat_clear
4085 = make_scope_exit (bpstat_clear_actions
);
4086 auto defer_delete_threads
4087 = make_scope_exit (delete_just_stopped_threads_infrun_breakpoints
);
4089 /* Now figure out what to do with the result of the result. */
4090 handle_inferior_event (ecs
);
4092 if (!ecs
->wait_some_more
)
4094 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4095 bool should_stop
= true;
4096 struct thread_info
*thr
= ecs
->event_thread
;
4098 delete_just_stopped_threads_infrun_breakpoints ();
4102 struct thread_fsm
*thread_fsm
= thr
->thread_fsm
;
4104 if (thread_fsm
!= NULL
)
4105 should_stop
= thread_fsm
->should_stop (thr
);
4114 bool should_notify_stop
= true;
4117 clean_up_just_stopped_threads_fsms (ecs
);
4119 if (thr
!= NULL
&& thr
->thread_fsm
!= NULL
)
4120 should_notify_stop
= thr
->thread_fsm
->should_notify_stop ();
4122 if (should_notify_stop
)
4124 /* We may not find an inferior if this was a process exit. */
4125 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
4126 proceeded
= normal_stop ();
4131 inferior_event_handler (INF_EXEC_COMPLETE
);
4135 /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
4136 previously selected thread is gone. We have two
4137 choices - switch to no thread selected, or restore the
4138 previously selected thread (now exited). We chose the
4139 later, just because that's what GDB used to do. After
4140 this, "info threads" says "The current thread <Thread
4141 ID 2> has terminated." instead of "No thread
4145 && ecs
->ws
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
4146 restore_thread
.dont_restore ();
4150 defer_delete_threads
.release ();
4151 defer_bpstat_clear
.release ();
4153 /* No error, don't finish the thread states yet. */
4154 finish_state
.release ();
4156 disable_commit_resumed
.reset_and_commit ();
4158 /* This scope is used to ensure that readline callbacks are
4159 reinstalled here. */
4162 /* If a UI was in sync execution mode, and now isn't, restore its
4163 prompt (a synchronous execution command has finished, and we're
4164 ready for input). */
4165 all_uis_check_sync_execution_done ();
4168 && exec_done_display_p
4169 && (inferior_ptid
== null_ptid
4170 || inferior_thread ()->state
!= THREAD_RUNNING
))
4171 printf_unfiltered (_("completed.\n"));
4177 set_step_info (thread_info
*tp
, struct frame_info
*frame
,
4178 struct symtab_and_line sal
)
4180 /* This can be removed once this function no longer implicitly relies on the
4181 inferior_ptid value. */
4182 gdb_assert (inferior_ptid
== tp
->ptid
);
4184 tp
->control
.step_frame_id
= get_frame_id (frame
);
4185 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
4187 tp
->current_symtab
= sal
.symtab
;
4188 tp
->current_line
= sal
.line
;
4191 /* Clear context switchable stepping state. */
4194 init_thread_stepping_state (struct thread_info
*tss
)
4196 tss
->stepped_breakpoint
= 0;
4197 tss
->stepping_over_breakpoint
= 0;
4198 tss
->stepping_over_watchpoint
= 0;
4199 tss
->step_after_step_resume_breakpoint
= 0;
4205 set_last_target_status (process_stratum_target
*target
, ptid_t ptid
,
4206 target_waitstatus status
)
4208 target_last_proc_target
= target
;
4209 target_last_wait_ptid
= ptid
;
4210 target_last_waitstatus
= status
;
4216 get_last_target_status (process_stratum_target
**target
, ptid_t
*ptid
,
4217 target_waitstatus
*status
)
4219 if (target
!= nullptr)
4220 *target
= target_last_proc_target
;
4221 if (ptid
!= nullptr)
4222 *ptid
= target_last_wait_ptid
;
4223 if (status
!= nullptr)
4224 *status
= target_last_waitstatus
;
4230 nullify_last_target_wait_ptid (void)
4232 target_last_proc_target
= nullptr;
4233 target_last_wait_ptid
= minus_one_ptid
;
4234 target_last_waitstatus
= {};
4237 /* Switch thread contexts. */
4240 context_switch (execution_control_state
*ecs
)
4242 if (ecs
->ptid
!= inferior_ptid
4243 && (inferior_ptid
== null_ptid
4244 || ecs
->event_thread
!= inferior_thread ()))
4246 infrun_debug_printf ("Switching context from %s to %s",
4247 target_pid_to_str (inferior_ptid
).c_str (),
4248 target_pid_to_str (ecs
->ptid
).c_str ());
4251 switch_to_thread (ecs
->event_thread
);
4254 /* If the target can't tell whether we've hit breakpoints
4255 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4256 check whether that could have been caused by a breakpoint. If so,
4257 adjust the PC, per gdbarch_decr_pc_after_break. */
4260 adjust_pc_after_break (struct thread_info
*thread
,
4261 const target_waitstatus
*ws
)
4263 struct regcache
*regcache
;
4264 struct gdbarch
*gdbarch
;
4265 CORE_ADDR breakpoint_pc
, decr_pc
;
4267 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4268 we aren't, just return.
4270 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4271 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4272 implemented by software breakpoints should be handled through the normal
4275 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4276 different signals (SIGILL or SIGEMT for instance), but it is less
4277 clear where the PC is pointing afterwards. It may not match
4278 gdbarch_decr_pc_after_break. I don't know any specific target that
4279 generates these signals at breakpoints (the code has been in GDB since at
4280 least 1992) so I can not guess how to handle them here.
4282 In earlier versions of GDB, a target with
4283 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4284 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4285 target with both of these set in GDB history, and it seems unlikely to be
4286 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4288 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
4291 if (ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
4294 /* In reverse execution, when a breakpoint is hit, the instruction
4295 under it has already been de-executed. The reported PC always
4296 points at the breakpoint address, so adjusting it further would
4297 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4300 B1 0x08000000 : INSN1
4301 B2 0x08000001 : INSN2
4303 PC -> 0x08000003 : INSN4
4305 Say you're stopped at 0x08000003 as above. Reverse continuing
4306 from that point should hit B2 as below. Reading the PC when the
4307 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4308 been de-executed already.
4310 B1 0x08000000 : INSN1
4311 B2 PC -> 0x08000001 : INSN2
4315 We can't apply the same logic as for forward execution, because
4316 we would wrongly adjust the PC to 0x08000000, since there's a
4317 breakpoint at PC - 1. We'd then report a hit on B1, although
4318 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4320 if (execution_direction
== EXEC_REVERSE
)
4323 /* If the target can tell whether the thread hit a SW breakpoint,
4324 trust it. Targets that can tell also adjust the PC
4326 if (target_supports_stopped_by_sw_breakpoint ())
4329 /* Note that relying on whether a breakpoint is planted in memory to
4330 determine this can fail. E.g,. the breakpoint could have been
4331 removed since. Or the thread could have been told to step an
4332 instruction the size of a breakpoint instruction, and only
4333 _after_ was a breakpoint inserted at its address. */
4335 /* If this target does not decrement the PC after breakpoints, then
4336 we have nothing to do. */
4337 regcache
= get_thread_regcache (thread
);
4338 gdbarch
= regcache
->arch ();
4340 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4344 const address_space
*aspace
= regcache
->aspace ();
4346 /* Find the location where (if we've hit a breakpoint) the
4347 breakpoint would be. */
4348 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4350 /* If the target can't tell whether a software breakpoint triggered,
4351 fallback to figuring it out based on breakpoints we think were
4352 inserted in the target, and on whether the thread was stepped or
4355 /* Check whether there actually is a software breakpoint inserted at
4358 If in non-stop mode, a race condition is possible where we've
4359 removed a breakpoint, but stop events for that breakpoint were
4360 already queued and arrive later. To suppress those spurious
4361 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4362 and retire them after a number of stop events are reported. Note
4363 this is an heuristic and can thus get confused. The real fix is
4364 to get the "stopped by SW BP and needs adjustment" info out of
4365 the target/kernel (and thus never reach here; see above). */
4366 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4367 || (target_is_non_stop_p ()
4368 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4370 gdb::optional
<scoped_restore_tmpl
<int>> restore_operation_disable
;
4372 if (record_full_is_used ())
4373 restore_operation_disable
.emplace
4374 (record_full_gdb_operation_disable_set ());
4376 /* When using hardware single-step, a SIGTRAP is reported for both
4377 a completed single-step and a software breakpoint. Need to
4378 differentiate between the two, as the latter needs adjusting
4379 but the former does not.
4381 The SIGTRAP can be due to a completed hardware single-step only if
4382 - we didn't insert software single-step breakpoints
4383 - this thread is currently being stepped
4385 If any of these events did not occur, we must have stopped due
4386 to hitting a software breakpoint, and have to back up to the
4389 As a special case, we could have hardware single-stepped a
4390 software breakpoint. In this case (prev_pc == breakpoint_pc),
4391 we also need to back up to the breakpoint address. */
4393 if (thread_has_single_step_breakpoints_set (thread
)
4394 || !currently_stepping (thread
)
4395 || (thread
->stepped_breakpoint
4396 && thread
->prev_pc
== breakpoint_pc
))
4397 regcache_write_pc (regcache
, breakpoint_pc
);
4402 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4404 for (frame
= get_prev_frame (frame
);
4406 frame
= get_prev_frame (frame
))
4408 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4411 if (get_frame_type (frame
) != INLINE_FRAME
)
4418 /* Look for an inline frame that is marked for skip.
4419 If PREV_FRAME is TRUE start at the previous frame,
4420 otherwise start at the current frame. Stop at the
4421 first non-inline frame, or at the frame where the
4425 inline_frame_is_marked_for_skip (bool prev_frame
, struct thread_info
*tp
)
4427 struct frame_info
*frame
= get_current_frame ();
4430 frame
= get_prev_frame (frame
);
4432 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
4434 const char *fn
= NULL
;
4435 symtab_and_line sal
;
4438 if (frame_id_eq (get_frame_id (frame
), tp
->control
.step_frame_id
))
4440 if (get_frame_type (frame
) != INLINE_FRAME
)
4443 sal
= find_frame_sal (frame
);
4444 sym
= get_frame_function (frame
);
4447 fn
= sym
->print_name ();
4450 && function_name_is_marked_for_skip (fn
, sal
))
4457 /* If the event thread has the stop requested flag set, pretend it
4458 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4462 handle_stop_requested (struct execution_control_state
*ecs
)
4464 if (ecs
->event_thread
->stop_requested
)
4466 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
4467 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
4468 handle_signal_stop (ecs
);
4474 /* Auxiliary function that handles syscall entry/return events.
4475 It returns true if the inferior should keep going (and GDB
4476 should ignore the event), or false if the event deserves to be
4480 handle_syscall_event (struct execution_control_state
*ecs
)
4482 struct regcache
*regcache
;
4485 context_switch (ecs
);
4487 regcache
= get_thread_regcache (ecs
->event_thread
);
4488 syscall_number
= ecs
->ws
.value
.syscall_number
;
4489 ecs
->event_thread
->set_stop_pc (regcache_read_pc (regcache
));
4491 if (catch_syscall_enabled () > 0
4492 && catching_syscall_number (syscall_number
) > 0)
4494 infrun_debug_printf ("syscall number=%d", syscall_number
);
4496 ecs
->event_thread
->control
.stop_bpstat
4497 = bpstat_stop_status (regcache
->aspace (),
4498 ecs
->event_thread
->stop_pc (),
4499 ecs
->event_thread
, &ecs
->ws
);
4501 if (handle_stop_requested (ecs
))
4504 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4506 /* Catchpoint hit. */
4511 if (handle_stop_requested (ecs
))
4514 /* If no catchpoint triggered for this, then keep going. */
4520 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4523 fill_in_stop_func (struct gdbarch
*gdbarch
,
4524 struct execution_control_state
*ecs
)
4526 if (!ecs
->stop_func_filled_in
)
4529 const general_symbol_info
*gsi
;
4531 /* Don't care about return value; stop_func_start and stop_func_name
4532 will both be 0 if it doesn't work. */
4533 find_pc_partial_function_sym (ecs
->event_thread
->stop_pc (),
4535 &ecs
->stop_func_start
,
4536 &ecs
->stop_func_end
,
4538 ecs
->stop_func_name
= gsi
== nullptr ? nullptr : gsi
->print_name ();
4540 /* The call to find_pc_partial_function, above, will set
4541 stop_func_start and stop_func_end to the start and end
4542 of the range containing the stop pc. If this range
4543 contains the entry pc for the block (which is always the
4544 case for contiguous blocks), advance stop_func_start past
4545 the function's start offset and entrypoint. Note that
4546 stop_func_start is NOT advanced when in a range of a
4547 non-contiguous block that does not contain the entry pc. */
4548 if (block
!= nullptr
4549 && ecs
->stop_func_start
<= BLOCK_ENTRY_PC (block
)
4550 && BLOCK_ENTRY_PC (block
) < ecs
->stop_func_end
)
4552 ecs
->stop_func_start
4553 += gdbarch_deprecated_function_start_offset (gdbarch
);
4555 if (gdbarch_skip_entrypoint_p (gdbarch
))
4556 ecs
->stop_func_start
4557 = gdbarch_skip_entrypoint (gdbarch
, ecs
->stop_func_start
);
4560 ecs
->stop_func_filled_in
= 1;
4565 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
4567 static enum stop_kind
4568 get_inferior_stop_soon (execution_control_state
*ecs
)
4570 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4572 gdb_assert (inf
!= NULL
);
4573 return inf
->control
.stop_soon
;
4576 /* Poll for one event out of the current target. Store the resulting
4577 waitstatus in WS, and return the event ptid. Does not block. */
4580 poll_one_curr_target (struct target_waitstatus
*ws
)
4584 overlay_cache_invalid
= 1;
4586 /* Flush target cache before starting to handle each event.
4587 Target was running and cache could be stale. This is just a
4588 heuristic. Running threads may modify target memory, but we
4589 don't get any event. */
4590 target_dcache_invalidate ();
4592 if (deprecated_target_wait_hook
)
4593 event_ptid
= deprecated_target_wait_hook (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4595 event_ptid
= target_wait (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4598 print_target_wait_results (minus_one_ptid
, event_ptid
, ws
);
4603 /* Wait for one event out of any target. */
4605 static wait_one_event
4610 for (inferior
*inf
: all_inferiors ())
4612 process_stratum_target
*target
= inf
->process_target ();
4614 || !target
->is_async_p ()
4615 || !target
->threads_executing
)
4618 switch_to_inferior_no_thread (inf
);
4620 wait_one_event event
;
4621 event
.target
= target
;
4622 event
.ptid
= poll_one_curr_target (&event
.ws
);
4624 if (event
.ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4626 /* If nothing is resumed, remove the target from the
4630 else if (event
.ws
.kind
!= TARGET_WAITKIND_IGNORE
)
4634 /* Block waiting for some event. */
4641 for (inferior
*inf
: all_inferiors ())
4643 process_stratum_target
*target
= inf
->process_target ();
4645 || !target
->is_async_p ()
4646 || !target
->threads_executing
)
4649 int fd
= target
->async_wait_fd ();
4650 FD_SET (fd
, &readfds
);
4657 /* No waitable targets left. All must be stopped. */
4658 return {NULL
, minus_one_ptid
, {TARGET_WAITKIND_NO_RESUMED
}};
4663 int numfds
= interruptible_select (nfds
, &readfds
, 0, NULL
, 0);
4669 perror_with_name ("interruptible_select");
4674 /* Save the thread's event and stop reason to process it later. */
4677 save_waitstatus (struct thread_info
*tp
, const target_waitstatus
*ws
)
4679 infrun_debug_printf ("saving status %s for %d.%ld.%ld",
4680 target_waitstatus_to_string (ws
).c_str (),
4685 /* Record for later. */
4686 tp
->set_pending_waitstatus (*ws
);
4688 if (ws
->kind
== TARGET_WAITKIND_STOPPED
4689 && ws
->value
.sig
== GDB_SIGNAL_TRAP
)
4691 struct regcache
*regcache
= get_thread_regcache (tp
);
4692 const address_space
*aspace
= regcache
->aspace ();
4693 CORE_ADDR pc
= regcache_read_pc (regcache
);
4695 adjust_pc_after_break (tp
, &tp
->pending_waitstatus ());
4697 scoped_restore_current_thread restore_thread
;
4698 switch_to_thread (tp
);
4700 if (target_stopped_by_watchpoint ())
4701 tp
->set_stop_reason (TARGET_STOPPED_BY_WATCHPOINT
);
4702 else if (target_supports_stopped_by_sw_breakpoint ()
4703 && target_stopped_by_sw_breakpoint ())
4704 tp
->set_stop_reason (TARGET_STOPPED_BY_SW_BREAKPOINT
);
4705 else if (target_supports_stopped_by_hw_breakpoint ()
4706 && target_stopped_by_hw_breakpoint ())
4707 tp
->set_stop_reason (TARGET_STOPPED_BY_HW_BREAKPOINT
);
4708 else if (!target_supports_stopped_by_hw_breakpoint ()
4709 && hardware_breakpoint_inserted_here_p (aspace
, pc
))
4710 tp
->set_stop_reason (TARGET_STOPPED_BY_HW_BREAKPOINT
);
4711 else if (!target_supports_stopped_by_sw_breakpoint ()
4712 && software_breakpoint_inserted_here_p (aspace
, pc
))
4713 tp
->set_stop_reason (TARGET_STOPPED_BY_SW_BREAKPOINT
);
4714 else if (!thread_has_single_step_breakpoints_set (tp
)
4715 && currently_stepping (tp
))
4716 tp
->set_stop_reason (TARGET_STOPPED_BY_SINGLE_STEP
);
4720 /* Mark the non-executing threads accordingly. In all-stop, all
4721 threads of all processes are stopped when we get any event
4722 reported. In non-stop mode, only the event thread stops. */
4725 mark_non_executing_threads (process_stratum_target
*target
,
4727 struct target_waitstatus ws
)
4731 if (!target_is_non_stop_p ())
4732 mark_ptid
= minus_one_ptid
;
4733 else if (ws
.kind
== TARGET_WAITKIND_SIGNALLED
4734 || ws
.kind
== TARGET_WAITKIND_EXITED
)
4736 /* If we're handling a process exit in non-stop mode, even
4737 though threads haven't been deleted yet, one would think
4738 that there is nothing to do, as threads of the dead process
4739 will be soon deleted, and threads of any other process were
4740 left running. However, on some targets, threads survive a
4741 process exit event. E.g., for the "checkpoint" command,
4742 when the current checkpoint/fork exits, linux-fork.c
4743 automatically switches to another fork from within
4744 target_mourn_inferior, by associating the same
4745 inferior/thread to another fork. We haven't mourned yet at
4746 this point, but we must mark any threads left in the
4747 process as not-executing so that finish_thread_state marks
4748 them stopped (in the user's perspective) if/when we present
4749 the stop to the user. */
4750 mark_ptid
= ptid_t (event_ptid
.pid ());
4753 mark_ptid
= event_ptid
;
4755 set_executing (target
, mark_ptid
, false);
4757 /* Likewise the resumed flag. */
4758 set_resumed (target
, mark_ptid
, false);
4761 /* Handle one event after stopping threads. If the eventing thread
4762 reports back any interesting event, we leave it pending. If the
4763 eventing thread was in the middle of a displaced step, we
4764 cancel/finish it, and unless the thread's inferior is being
4765 detached, put the thread back in the step-over chain. Returns true
4766 if there are no resumed threads left in the target (thus there's no
4767 point in waiting further), false otherwise. */
4770 handle_one (const wait_one_event
&event
)
4773 ("%s %s", target_waitstatus_to_string (&event
.ws
).c_str (),
4774 target_pid_to_str (event
.ptid
).c_str ());
4776 if (event
.ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4778 /* All resumed threads exited. */
4781 else if (event
.ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
4782 || event
.ws
.kind
== TARGET_WAITKIND_EXITED
4783 || event
.ws
.kind
== TARGET_WAITKIND_SIGNALLED
)
4785 /* One thread/process exited/signalled. */
4787 thread_info
*t
= nullptr;
4789 /* The target may have reported just a pid. If so, try
4790 the first non-exited thread. */
4791 if (event
.ptid
.is_pid ())
4793 int pid
= event
.ptid
.pid ();
4794 inferior
*inf
= find_inferior_pid (event
.target
, pid
);
4795 for (thread_info
*tp
: inf
->non_exited_threads ())
4801 /* If there is no available thread, the event would
4802 have to be appended to a per-inferior event list,
4803 which does not exist (and if it did, we'd have
4804 to adjust run control command to be able to
4805 resume such an inferior). We assert here instead
4806 of going into an infinite loop. */
4807 gdb_assert (t
!= nullptr);
4810 ("using %s", target_pid_to_str (t
->ptid
).c_str ());
4814 t
= find_thread_ptid (event
.target
, event
.ptid
);
4815 /* Check if this is the first time we see this thread.
4816 Don't bother adding if it individually exited. */
4818 && event
.ws
.kind
!= TARGET_WAITKIND_THREAD_EXITED
)
4819 t
= add_thread (event
.target
, event
.ptid
);
4824 /* Set the threads as non-executing to avoid
4825 another stop attempt on them. */
4826 switch_to_thread_no_regs (t
);
4827 mark_non_executing_threads (event
.target
, event
.ptid
,
4829 save_waitstatus (t
, &event
.ws
);
4830 t
->stop_requested
= false;
4835 thread_info
*t
= find_thread_ptid (event
.target
, event
.ptid
);
4837 t
= add_thread (event
.target
, event
.ptid
);
4839 t
->stop_requested
= 0;
4841 t
->set_resumed (false);
4842 t
->control
.may_range_step
= 0;
4844 /* This may be the first time we see the inferior report
4846 inferior
*inf
= find_inferior_ptid (event
.target
, event
.ptid
);
4847 if (inf
->needs_setup
)
4849 switch_to_thread_no_regs (t
);
4853 if (event
.ws
.kind
== TARGET_WAITKIND_STOPPED
4854 && event
.ws
.value
.sig
== GDB_SIGNAL_0
)
4856 /* We caught the event that we intended to catch, so
4857 there's no event to save as pending. */
4859 if (displaced_step_finish (t
, GDB_SIGNAL_0
)
4860 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
4862 /* Add it back to the step-over queue. */
4864 ("displaced-step of %s canceled",
4865 target_pid_to_str (t
->ptid
).c_str ());
4867 t
->control
.trap_expected
= 0;
4868 if (!t
->inf
->detaching
)
4869 global_thread_step_over_chain_enqueue (t
);
4874 enum gdb_signal sig
;
4875 struct regcache
*regcache
;
4878 ("target_wait %s, saving status for %d.%ld.%ld",
4879 target_waitstatus_to_string (&event
.ws
).c_str (),
4880 t
->ptid
.pid (), t
->ptid
.lwp (), t
->ptid
.tid ());
4882 /* Record for later. */
4883 save_waitstatus (t
, &event
.ws
);
4885 sig
= (event
.ws
.kind
== TARGET_WAITKIND_STOPPED
4886 ? event
.ws
.value
.sig
: GDB_SIGNAL_0
);
4888 if (displaced_step_finish (t
, sig
)
4889 == DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED
)
4891 /* Add it back to the step-over queue. */
4892 t
->control
.trap_expected
= 0;
4893 if (!t
->inf
->detaching
)
4894 global_thread_step_over_chain_enqueue (t
);
4897 regcache
= get_thread_regcache (t
);
4898 t
->set_stop_pc (regcache_read_pc (regcache
));
4900 infrun_debug_printf ("saved stop_pc=%s for %s "
4901 "(currently_stepping=%d)",
4902 paddress (target_gdbarch (), t
->stop_pc ()),
4903 target_pid_to_str (t
->ptid
).c_str (),
4904 currently_stepping (t
));
4914 stop_all_threads (void)
4916 /* We may need multiple passes to discover all threads. */
4920 gdb_assert (exists_non_stop_target ());
4922 infrun_debug_printf ("starting");
4924 scoped_restore_current_thread restore_thread
;
4926 /* Enable thread events of all targets. */
4927 for (auto *target
: all_non_exited_process_targets ())
4929 switch_to_target_no_thread (target
);
4930 target_thread_events (true);
4935 /* Disable thread events of all targets. */
4936 for (auto *target
: all_non_exited_process_targets ())
4938 switch_to_target_no_thread (target
);
4939 target_thread_events (false);
4942 /* Use debug_prefixed_printf directly to get a meaningful function
4945 debug_prefixed_printf ("infrun", "stop_all_threads", "done");
4948 /* Request threads to stop, and then wait for the stops. Because
4949 threads we already know about can spawn more threads while we're
4950 trying to stop them, and we only learn about new threads when we
4951 update the thread list, do this in a loop, and keep iterating
4952 until two passes find no threads that need to be stopped. */
4953 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4955 infrun_debug_printf ("pass=%d, iterations=%d", pass
, iterations
);
4958 int waits_needed
= 0;
4960 for (auto *target
: all_non_exited_process_targets ())
4962 switch_to_target_no_thread (target
);
4963 update_thread_list ();
4966 /* Go through all threads looking for threads that we need
4967 to tell the target to stop. */
4968 for (thread_info
*t
: all_non_exited_threads ())
4970 /* For a single-target setting with an all-stop target,
4971 we would not even arrive here. For a multi-target
4972 setting, until GDB is able to handle a mixture of
4973 all-stop and non-stop targets, simply skip all-stop
4974 targets' threads. This should be fine due to the
4975 protection of 'check_multi_target_resumption'. */
4977 switch_to_thread_no_regs (t
);
4978 if (!target_is_non_stop_p ())
4983 /* If already stopping, don't request a stop again.
4984 We just haven't seen the notification yet. */
4985 if (!t
->stop_requested
)
4987 infrun_debug_printf (" %s executing, need stop",
4988 target_pid_to_str (t
->ptid
).c_str ());
4989 target_stop (t
->ptid
);
4990 t
->stop_requested
= 1;
4994 infrun_debug_printf (" %s executing, already stopping",
4995 target_pid_to_str (t
->ptid
).c_str ());
4998 if (t
->stop_requested
)
5003 infrun_debug_printf (" %s not executing",
5004 target_pid_to_str (t
->ptid
).c_str ());
5006 /* The thread may be not executing, but still be
5007 resumed with a pending status to process. */
5008 t
->set_resumed (false);
5012 if (waits_needed
== 0)
5015 /* If we find new threads on the second iteration, restart
5016 over. We want to see two iterations in a row with all
5021 for (int i
= 0; i
< waits_needed
; i
++)
5023 wait_one_event event
= wait_one ();
5024 if (handle_one (event
))
5031 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
5034 handle_no_resumed (struct execution_control_state
*ecs
)
5036 if (target_can_async_p ())
5038 bool any_sync
= false;
5040 for (ui
*ui
: all_uis ())
5042 if (ui
->prompt_state
== PROMPT_BLOCKED
)
5050 /* There were no unwaited-for children left in the target, but,
5051 we're not synchronously waiting for events either. Just
5054 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED (ignoring: bg)");
5055 prepare_to_wait (ecs
);
5060 /* Otherwise, if we were running a synchronous execution command, we
5061 may need to cancel it and give the user back the terminal.
5063 In non-stop mode, the target can't tell whether we've already
5064 consumed previous stop events, so it can end up sending us a
5065 no-resumed event like so:
5067 #0 - thread 1 is left stopped
5069 #1 - thread 2 is resumed and hits breakpoint
5070 -> TARGET_WAITKIND_STOPPED
5072 #2 - thread 3 is resumed and exits
5073 this is the last resumed thread, so
5074 -> TARGET_WAITKIND_NO_RESUMED
5076 #3 - gdb processes stop for thread 2 and decides to re-resume
5079 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
5080 thread 2 is now resumed, so the event should be ignored.
5082 IOW, if the stop for thread 2 doesn't end a foreground command,
5083 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
5084 event. But it could be that the event meant that thread 2 itself
5085 (or whatever other thread was the last resumed thread) exited.
5087 To address this we refresh the thread list and check whether we
5088 have resumed threads _now_. In the example above, this removes
5089 thread 3 from the thread list. If thread 2 was re-resumed, we
5090 ignore this event. If we find no thread resumed, then we cancel
5091 the synchronous command and show "no unwaited-for " to the
5094 inferior
*curr_inf
= current_inferior ();
5096 scoped_restore_current_thread restore_thread
;
5098 for (auto *target
: all_non_exited_process_targets ())
5100 switch_to_target_no_thread (target
);
5101 update_thread_list ();
5106 - the current target has no thread executing, and
5107 - the current inferior is native, and
5108 - the current inferior is the one which has the terminal, and
5111 then a Ctrl-C from this point on would remain stuck in the
5112 kernel, until a thread resumes and dequeues it. That would
5113 result in the GDB CLI not reacting to Ctrl-C, not able to
5114 interrupt the program. To address this, if the current inferior
5115 no longer has any thread executing, we give the terminal to some
5116 other inferior that has at least one thread executing. */
5117 bool swap_terminal
= true;
5119 /* Whether to ignore this TARGET_WAITKIND_NO_RESUMED event, or
5120 whether to report it to the user. */
5121 bool ignore_event
= false;
5123 for (thread_info
*thread
: all_non_exited_threads ())
5125 if (swap_terminal
&& thread
->executing
)
5127 if (thread
->inf
!= curr_inf
)
5129 target_terminal::ours ();
5131 switch_to_thread (thread
);
5132 target_terminal::inferior ();
5134 swap_terminal
= false;
5138 && (thread
->executing
|| thread
->has_pending_waitstatus ()))
5140 /* Either there were no unwaited-for children left in the
5141 target at some point, but there are now, or some target
5142 other than the eventing one has unwaited-for children
5143 left. Just ignore. */
5144 infrun_debug_printf ("TARGET_WAITKIND_NO_RESUMED "
5145 "(ignoring: found resumed)");
5147 ignore_event
= true;
5150 if (ignore_event
&& !swap_terminal
)
5156 switch_to_inferior_no_thread (curr_inf
);
5157 prepare_to_wait (ecs
);
5161 /* Go ahead and report the event. */
5165 /* Given an execution control state that has been freshly filled in by
5166 an event from the inferior, figure out what it means and take
5169 The alternatives are:
5171 1) stop_waiting and return; to really stop and return to the
5174 2) keep_going and return; to wait for the next event (set
5175 ecs->event_thread->stepping_over_breakpoint to 1 to single step
5179 handle_inferior_event (struct execution_control_state
*ecs
)
5181 /* Make sure that all temporary struct value objects that were
5182 created during the handling of the event get deleted at the
5184 scoped_value_mark free_values
;
5186 infrun_debug_printf ("%s", target_waitstatus_to_string (&ecs
->ws
).c_str ());
5188 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
5190 /* We had an event in the inferior, but we are not interested in
5191 handling it at this level. The lower layers have already
5192 done what needs to be done, if anything.
5194 One of the possible circumstances for this is when the
5195 inferior produces output for the console. The inferior has
5196 not stopped, and we are ignoring the event. Another possible
5197 circumstance is any event which the lower level knows will be
5198 reported multiple times without an intervening resume. */
5199 prepare_to_wait (ecs
);
5203 if (ecs
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
5205 prepare_to_wait (ecs
);
5209 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
5210 && handle_no_resumed (ecs
))
5213 /* Cache the last target/ptid/waitstatus. */
5214 set_last_target_status (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5216 /* Always clear state belonging to the previous time we stopped. */
5217 stop_stack_dummy
= STOP_NONE
;
5219 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
5221 /* No unwaited-for children left. IOW, all resumed children
5223 stop_print_frame
= false;
5228 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
5229 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
5231 ecs
->event_thread
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5232 /* If it's a new thread, add it to the thread database. */
5233 if (ecs
->event_thread
== NULL
)
5234 ecs
->event_thread
= add_thread (ecs
->target
, ecs
->ptid
);
5236 /* Disable range stepping. If the next step request could use a
5237 range, this will be end up re-enabled then. */
5238 ecs
->event_thread
->control
.may_range_step
= 0;
5241 /* Dependent on valid ECS->EVENT_THREAD. */
5242 adjust_pc_after_break (ecs
->event_thread
, &ecs
->ws
);
5244 /* Dependent on the current PC value modified by adjust_pc_after_break. */
5245 reinit_frame_cache ();
5247 breakpoint_retire_moribund ();
5249 /* First, distinguish signals caused by the debugger from signals
5250 that have to do with the program's own actions. Note that
5251 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
5252 on the operating system version. Here we detect when a SIGILL or
5253 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
5254 something similar for SIGSEGV, since a SIGSEGV will be generated
5255 when we're trying to execute a breakpoint instruction on a
5256 non-executable stack. This happens for call dummy breakpoints
5257 for architectures like SPARC that place call dummies on the
5259 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
5260 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
5261 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
5262 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
5264 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5266 if (breakpoint_inserted_here_p (regcache
->aspace (),
5267 regcache_read_pc (regcache
)))
5269 infrun_debug_printf ("Treating signal as SIGTRAP");
5270 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
5274 mark_non_executing_threads (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5276 switch (ecs
->ws
.kind
)
5278 case TARGET_WAITKIND_LOADED
:
5280 context_switch (ecs
);
5281 /* Ignore gracefully during startup of the inferior, as it might
5282 be the shell which has just loaded some objects, otherwise
5283 add the symbols for the newly loaded objects. Also ignore at
5284 the beginning of an attach or remote session; we will query
5285 the full list of libraries once the connection is
5288 stop_kind stop_soon
= get_inferior_stop_soon (ecs
);
5289 if (stop_soon
== NO_STOP_QUIETLY
)
5291 struct regcache
*regcache
;
5293 regcache
= get_thread_regcache (ecs
->event_thread
);
5295 handle_solib_event ();
5297 ecs
->event_thread
->control
.stop_bpstat
5298 = bpstat_stop_status (regcache
->aspace (),
5299 ecs
->event_thread
->stop_pc (),
5300 ecs
->event_thread
, &ecs
->ws
);
5302 if (handle_stop_requested (ecs
))
5305 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5307 /* A catchpoint triggered. */
5308 process_event_stop_test (ecs
);
5312 /* If requested, stop when the dynamic linker notifies
5313 gdb of events. This allows the user to get control
5314 and place breakpoints in initializer routines for
5315 dynamically loaded objects (among other things). */
5316 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5317 if (stop_on_solib_events
)
5319 /* Make sure we print "Stopped due to solib-event" in
5321 stop_print_frame
= true;
5328 /* If we are skipping through a shell, or through shared library
5329 loading that we aren't interested in, resume the program. If
5330 we're running the program normally, also resume. */
5331 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
5333 /* Loading of shared libraries might have changed breakpoint
5334 addresses. Make sure new breakpoints are inserted. */
5335 if (stop_soon
== NO_STOP_QUIETLY
)
5336 insert_breakpoints ();
5337 resume (GDB_SIGNAL_0
);
5338 prepare_to_wait (ecs
);
5342 /* But stop if we're attaching or setting up a remote
5344 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5345 || stop_soon
== STOP_QUIETLY_REMOTE
)
5347 infrun_debug_printf ("quietly stopped");
5352 internal_error (__FILE__
, __LINE__
,
5353 _("unhandled stop_soon: %d"), (int) stop_soon
);
5356 case TARGET_WAITKIND_SPURIOUS
:
5357 if (handle_stop_requested (ecs
))
5359 context_switch (ecs
);
5360 resume (GDB_SIGNAL_0
);
5361 prepare_to_wait (ecs
);
5364 case TARGET_WAITKIND_THREAD_CREATED
:
5365 if (handle_stop_requested (ecs
))
5367 context_switch (ecs
);
5368 if (!switch_back_to_stepped_thread (ecs
))
5372 case TARGET_WAITKIND_EXITED
:
5373 case TARGET_WAITKIND_SIGNALLED
:
5375 /* Depending on the system, ecs->ptid may point to a thread or
5376 to a process. On some targets, target_mourn_inferior may
5377 need to have access to the just-exited thread. That is the
5378 case of GNU/Linux's "checkpoint" support, for example.
5379 Call the switch_to_xxx routine as appropriate. */
5380 thread_info
*thr
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5382 switch_to_thread (thr
);
5385 inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5386 switch_to_inferior_no_thread (inf
);
5389 handle_vfork_child_exec_or_exit (0);
5390 target_terminal::ours (); /* Must do this before mourn anyway. */
5392 /* Clearing any previous state of convenience variables. */
5393 clear_exit_convenience_vars ();
5395 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
5397 /* Record the exit code in the convenience variable $_exitcode, so
5398 that the user can inspect this again later. */
5399 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5400 (LONGEST
) ecs
->ws
.value
.integer
);
5402 /* Also record this in the inferior itself. */
5403 current_inferior ()->has_exit_code
= 1;
5404 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
5406 /* Support the --return-child-result option. */
5407 return_child_result_value
= ecs
->ws
.value
.integer
;
5409 gdb::observers::exited
.notify (ecs
->ws
.value
.integer
);
5413 struct gdbarch
*gdbarch
= current_inferior ()->gdbarch
;
5415 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
5417 /* Set the value of the internal variable $_exitsignal,
5418 which holds the signal uncaught by the inferior. */
5419 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5420 gdbarch_gdb_signal_to_target (gdbarch
,
5421 ecs
->ws
.value
.sig
));
5425 /* We don't have access to the target's method used for
5426 converting between signal numbers (GDB's internal
5427 representation <-> target's representation).
5428 Therefore, we cannot do a good job at displaying this
5429 information to the user. It's better to just warn
5430 her about it (if infrun debugging is enabled), and
5432 infrun_debug_printf ("Cannot fill $_exitsignal with the correct "
5436 gdb::observers::signal_exited
.notify (ecs
->ws
.value
.sig
);
5439 gdb_flush (gdb_stdout
);
5440 target_mourn_inferior (inferior_ptid
);
5441 stop_print_frame
= false;
5445 case TARGET_WAITKIND_FORKED
:
5446 case TARGET_WAITKIND_VFORKED
:
5447 /* Check whether the inferior is displaced stepping. */
5449 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5450 struct gdbarch
*gdbarch
= regcache
->arch ();
5451 inferior
*parent_inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5453 /* If this is a fork (child gets its own address space copy)
5454 and some displaced step buffers were in use at the time of
5455 the fork, restore the displaced step buffer bytes in the
5458 Architectures which support displaced stepping and fork
5459 events must supply an implementation of
5460 gdbarch_displaced_step_restore_all_in_ptid. This is not
5461 enforced during gdbarch validation to support architectures
5462 which support displaced stepping but not forks. */
5463 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
5464 && gdbarch_supports_displaced_stepping (gdbarch
))
5465 gdbarch_displaced_step_restore_all_in_ptid
5466 (gdbarch
, parent_inf
, ecs
->ws
.value
.related_pid
);
5468 /* If displaced stepping is supported, and thread ecs->ptid is
5469 displaced stepping. */
5470 if (displaced_step_in_progress_thread (ecs
->event_thread
))
5472 struct regcache
*child_regcache
;
5473 CORE_ADDR parent_pc
;
5475 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5476 indicating that the displaced stepping of syscall instruction
5477 has been done. Perform cleanup for parent process here. Note
5478 that this operation also cleans up the child process for vfork,
5479 because their pages are shared. */
5480 displaced_step_finish (ecs
->event_thread
, GDB_SIGNAL_TRAP
);
5481 /* Start a new step-over in another thread if there's one
5485 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5486 the child's PC is also within the scratchpad. Set the child's PC
5487 to the parent's PC value, which has already been fixed up.
5488 FIXME: we use the parent's aspace here, although we're touching
5489 the child, because the child hasn't been added to the inferior
5490 list yet at this point. */
5493 = get_thread_arch_aspace_regcache (parent_inf
->process_target (),
5494 ecs
->ws
.value
.related_pid
,
5496 parent_inf
->aspace
);
5497 /* Read PC value of parent process. */
5498 parent_pc
= regcache_read_pc (regcache
);
5500 displaced_debug_printf ("write child pc from %s to %s",
5502 regcache_read_pc (child_regcache
)),
5503 paddress (gdbarch
, parent_pc
));
5505 regcache_write_pc (child_regcache
, parent_pc
);
5509 context_switch (ecs
);
5511 /* Immediately detach breakpoints from the child before there's
5512 any chance of letting the user delete breakpoints from the
5513 breakpoint lists. If we don't do this early, it's easy to
5514 leave left over traps in the child, vis: "break foo; catch
5515 fork; c; <fork>; del; c; <child calls foo>". We only follow
5516 the fork on the last `continue', and by that time the
5517 breakpoint at "foo" is long gone from the breakpoint table.
5518 If we vforked, then we don't need to unpatch here, since both
5519 parent and child are sharing the same memory pages; we'll
5520 need to unpatch at follow/detach time instead to be certain
5521 that new breakpoints added between catchpoint hit time and
5522 vfork follow are detached. */
5523 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
5525 /* This won't actually modify the breakpoint list, but will
5526 physically remove the breakpoints from the child. */
5527 detach_breakpoints (ecs
->ws
.value
.related_pid
);
5530 delete_just_stopped_threads_single_step_breakpoints ();
5532 /* In case the event is caught by a catchpoint, remember that
5533 the event is to be followed at the next resume of the thread,
5534 and not immediately. */
5535 ecs
->event_thread
->pending_follow
= ecs
->ws
;
5537 ecs
->event_thread
->set_stop_pc
5538 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
5540 ecs
->event_thread
->control
.stop_bpstat
5541 = bpstat_stop_status (get_current_regcache ()->aspace (),
5542 ecs
->event_thread
->stop_pc (),
5543 ecs
->event_thread
, &ecs
->ws
);
5545 if (handle_stop_requested (ecs
))
5548 /* If no catchpoint triggered for this, then keep going. Note
5549 that we're interested in knowing the bpstat actually causes a
5550 stop, not just if it may explain the signal. Software
5551 watchpoints, for example, always appear in the bpstat. */
5552 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5555 = (follow_fork_mode_string
== follow_fork_mode_child
);
5557 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5559 process_stratum_target
*targ
5560 = ecs
->event_thread
->inf
->process_target ();
5562 bool should_resume
= follow_fork ();
5564 /* Note that one of these may be an invalid pointer,
5565 depending on detach_fork. */
5566 thread_info
*parent
= ecs
->event_thread
;
5568 = find_thread_ptid (targ
, ecs
->ws
.value
.related_pid
);
5570 /* At this point, the parent is marked running, and the
5571 child is marked stopped. */
5573 /* If not resuming the parent, mark it stopped. */
5574 if (follow_child
&& !detach_fork
&& !non_stop
&& !sched_multi
)
5575 parent
->set_running (false);
5577 /* If resuming the child, mark it running. */
5578 if (follow_child
|| (!detach_fork
&& (non_stop
|| sched_multi
)))
5579 child
->set_running (true);
5581 /* In non-stop mode, also resume the other branch. */
5582 if (!detach_fork
&& (non_stop
5583 || (sched_multi
&& target_is_non_stop_p ())))
5586 switch_to_thread (parent
);
5588 switch_to_thread (child
);
5590 ecs
->event_thread
= inferior_thread ();
5591 ecs
->ptid
= inferior_ptid
;
5596 switch_to_thread (child
);
5598 switch_to_thread (parent
);
5600 ecs
->event_thread
= inferior_thread ();
5601 ecs
->ptid
= inferior_ptid
;
5609 process_event_stop_test (ecs
);
5612 case TARGET_WAITKIND_VFORK_DONE
:
5613 /* Done with the shared memory region. Re-insert breakpoints in
5614 the parent, and keep going. */
5616 context_switch (ecs
);
5618 current_inferior ()->waiting_for_vfork_done
= 0;
5619 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
5621 if (handle_stop_requested (ecs
))
5624 /* This also takes care of reinserting breakpoints in the
5625 previously locked inferior. */
5629 case TARGET_WAITKIND_EXECD
:
5631 /* Note we can't read registers yet (the stop_pc), because we
5632 don't yet know the inferior's post-exec architecture.
5633 'stop_pc' is explicitly read below instead. */
5634 switch_to_thread_no_regs (ecs
->event_thread
);
5636 /* Do whatever is necessary to the parent branch of the vfork. */
5637 handle_vfork_child_exec_or_exit (1);
5639 /* This causes the eventpoints and symbol table to be reset.
5640 Must do this now, before trying to determine whether to
5642 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
5644 /* In follow_exec we may have deleted the original thread and
5645 created a new one. Make sure that the event thread is the
5646 execd thread for that case (this is a nop otherwise). */
5647 ecs
->event_thread
= inferior_thread ();
5649 ecs
->event_thread
->set_stop_pc
5650 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
5652 ecs
->event_thread
->control
.stop_bpstat
5653 = bpstat_stop_status (get_current_regcache ()->aspace (),
5654 ecs
->event_thread
->stop_pc (),
5655 ecs
->event_thread
, &ecs
->ws
);
5657 /* Note that this may be referenced from inside
5658 bpstat_stop_status above, through inferior_has_execd. */
5659 xfree (ecs
->ws
.value
.execd_pathname
);
5660 ecs
->ws
.value
.execd_pathname
= NULL
;
5662 if (handle_stop_requested (ecs
))
5665 /* If no catchpoint triggered for this, then keep going. */
5666 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5668 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5672 process_event_stop_test (ecs
);
5675 /* Be careful not to try to gather much state about a thread
5676 that's in a syscall. It's frequently a losing proposition. */
5677 case TARGET_WAITKIND_SYSCALL_ENTRY
:
5678 /* Getting the current syscall number. */
5679 if (handle_syscall_event (ecs
) == 0)
5680 process_event_stop_test (ecs
);
5683 /* Before examining the threads further, step this thread to
5684 get it entirely out of the syscall. (We get notice of the
5685 event when the thread is just on the verge of exiting a
5686 syscall. Stepping one instruction seems to get it back
5688 case TARGET_WAITKIND_SYSCALL_RETURN
:
5689 if (handle_syscall_event (ecs
) == 0)
5690 process_event_stop_test (ecs
);
5693 case TARGET_WAITKIND_STOPPED
:
5694 handle_signal_stop (ecs
);
5697 case TARGET_WAITKIND_NO_HISTORY
:
5698 /* Reverse execution: target ran out of history info. */
5700 /* Switch to the stopped thread. */
5701 context_switch (ecs
);
5702 infrun_debug_printf ("stopped");
5704 delete_just_stopped_threads_single_step_breakpoints ();
5705 ecs
->event_thread
->set_stop_pc
5706 (regcache_read_pc (get_thread_regcache (inferior_thread ())));
5708 if (handle_stop_requested (ecs
))
5711 gdb::observers::no_history
.notify ();
5717 /* Restart threads back to what they were trying to do back when we
5718 paused them for an in-line step-over. The EVENT_THREAD thread is
5722 restart_threads (struct thread_info
*event_thread
)
5724 /* In case the instruction just stepped spawned a new thread. */
5725 update_thread_list ();
5727 for (thread_info
*tp
: all_non_exited_threads ())
5729 if (tp
->inf
->detaching
)
5731 infrun_debug_printf ("restart threads: [%s] inferior detaching",
5732 target_pid_to_str (tp
->ptid
).c_str ());
5736 switch_to_thread_no_regs (tp
);
5738 if (tp
== event_thread
)
5740 infrun_debug_printf ("restart threads: [%s] is event thread",
5741 target_pid_to_str (tp
->ptid
).c_str ());
5745 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5747 infrun_debug_printf ("restart threads: [%s] not meant to be running",
5748 target_pid_to_str (tp
->ptid
).c_str ());
5754 infrun_debug_printf ("restart threads: [%s] resumed",
5755 target_pid_to_str (tp
->ptid
).c_str ());
5756 gdb_assert (tp
->executing
|| tp
->has_pending_waitstatus ());
5760 if (thread_is_in_step_over_chain (tp
))
5762 infrun_debug_printf ("restart threads: [%s] needs step-over",
5763 target_pid_to_str (tp
->ptid
).c_str ());
5764 gdb_assert (!tp
->resumed ());
5769 if (tp
->has_pending_waitstatus ())
5771 infrun_debug_printf ("restart threads: [%s] has pending status",
5772 target_pid_to_str (tp
->ptid
).c_str ());
5773 tp
->set_resumed (true);
5777 gdb_assert (!tp
->stop_requested
);
5779 /* If some thread needs to start a step-over at this point, it
5780 should still be in the step-over queue, and thus skipped
5782 if (thread_still_needs_step_over (tp
))
5784 internal_error (__FILE__
, __LINE__
,
5785 "thread [%s] needs a step-over, but not in "
5786 "step-over queue\n",
5787 target_pid_to_str (tp
->ptid
).c_str ());
5790 if (currently_stepping (tp
))
5792 infrun_debug_printf ("restart threads: [%s] was stepping",
5793 target_pid_to_str (tp
->ptid
).c_str ());
5794 keep_going_stepped_thread (tp
);
5798 struct execution_control_state ecss
;
5799 struct execution_control_state
*ecs
= &ecss
;
5801 infrun_debug_printf ("restart threads: [%s] continuing",
5802 target_pid_to_str (tp
->ptid
).c_str ());
5803 reset_ecs (ecs
, tp
);
5804 switch_to_thread (tp
);
5805 keep_going_pass_signal (ecs
);
5810 /* Callback for iterate_over_threads. Find a resumed thread that has
5811 a pending waitstatus. */
5814 resumed_thread_with_pending_status (struct thread_info
*tp
,
5817 return tp
->resumed () && tp
->has_pending_waitstatus ();
5820 /* Called when we get an event that may finish an in-line or
5821 out-of-line (displaced stepping) step-over started previously.
5822 Return true if the event is processed and we should go back to the
5823 event loop; false if the caller should continue processing the
5827 finish_step_over (struct execution_control_state
*ecs
)
5829 displaced_step_finish (ecs
->event_thread
, ecs
->event_thread
->stop_signal ());
5831 bool had_step_over_info
= step_over_info_valid_p ();
5833 if (had_step_over_info
)
5835 /* If we're stepping over a breakpoint with all threads locked,
5836 then only the thread that was stepped should be reporting
5838 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5840 clear_step_over_info ();
5843 if (!target_is_non_stop_p ())
5846 /* Start a new step-over in another thread if there's one that
5850 /* If we were stepping over a breakpoint before, and haven't started
5851 a new in-line step-over sequence, then restart all other threads
5852 (except the event thread). We can't do this in all-stop, as then
5853 e.g., we wouldn't be able to issue any other remote packet until
5854 these other threads stop. */
5855 if (had_step_over_info
&& !step_over_info_valid_p ())
5857 struct thread_info
*pending
;
5859 /* If we only have threads with pending statuses, the restart
5860 below won't restart any thread and so nothing re-inserts the
5861 breakpoint we just stepped over. But we need it inserted
5862 when we later process the pending events, otherwise if
5863 another thread has a pending event for this breakpoint too,
5864 we'd discard its event (because the breakpoint that
5865 originally caused the event was no longer inserted). */
5866 context_switch (ecs
);
5867 insert_breakpoints ();
5869 restart_threads (ecs
->event_thread
);
5871 /* If we have events pending, go through handle_inferior_event
5872 again, picking up a pending event at random. This avoids
5873 thread starvation. */
5875 /* But not if we just stepped over a watchpoint in order to let
5876 the instruction execute so we can evaluate its expression.
5877 The set of watchpoints that triggered is recorded in the
5878 breakpoint objects themselves (see bp->watchpoint_triggered).
5879 If we processed another event first, that other event could
5880 clobber this info. */
5881 if (ecs
->event_thread
->stepping_over_watchpoint
)
5884 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5886 if (pending
!= NULL
)
5888 struct thread_info
*tp
= ecs
->event_thread
;
5889 struct regcache
*regcache
;
5891 infrun_debug_printf ("found resumed threads with "
5892 "pending events, saving status");
5894 gdb_assert (pending
!= tp
);
5896 /* Record the event thread's event for later. */
5897 save_waitstatus (tp
, &ecs
->ws
);
5898 /* This was cleared early, by handle_inferior_event. Set it
5899 so this pending event is considered by
5901 tp
->set_resumed (true);
5903 gdb_assert (!tp
->executing
);
5905 regcache
= get_thread_regcache (tp
);
5906 tp
->set_stop_pc (regcache_read_pc (regcache
));
5908 infrun_debug_printf ("saved stop_pc=%s for %s "
5909 "(currently_stepping=%d)",
5910 paddress (target_gdbarch (), tp
->stop_pc ()),
5911 target_pid_to_str (tp
->ptid
).c_str (),
5912 currently_stepping (tp
));
5914 /* This in-line step-over finished; clear this so we won't
5915 start a new one. This is what handle_signal_stop would
5916 do, if we returned false. */
5917 tp
->stepping_over_breakpoint
= 0;
5919 /* Wake up the event loop again. */
5920 mark_async_event_handler (infrun_async_inferior_event_token
);
5922 prepare_to_wait (ecs
);
5930 /* Come here when the program has stopped with a signal. */
5933 handle_signal_stop (struct execution_control_state
*ecs
)
5935 struct frame_info
*frame
;
5936 struct gdbarch
*gdbarch
;
5937 int stopped_by_watchpoint
;
5938 enum stop_kind stop_soon
;
5941 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5943 ecs
->event_thread
->set_stop_signal (ecs
->ws
.value
.sig
);
5945 /* Do we need to clean up the state of a thread that has
5946 completed a displaced single-step? (Doing so usually affects
5947 the PC, so do it here, before we set stop_pc.) */
5948 if (finish_step_over (ecs
))
5951 /* If we either finished a single-step or hit a breakpoint, but
5952 the user wanted this thread to be stopped, pretend we got a
5953 SIG0 (generic unsignaled stop). */
5954 if (ecs
->event_thread
->stop_requested
5955 && ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
5956 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
5958 ecs
->event_thread
->set_stop_pc
5959 (regcache_read_pc (get_thread_regcache (ecs
->event_thread
)));
5961 context_switch (ecs
);
5963 if (deprecated_context_hook
)
5964 deprecated_context_hook (ecs
->event_thread
->global_num
);
5968 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5969 struct gdbarch
*reg_gdbarch
= regcache
->arch ();
5972 ("stop_pc=%s", paddress (reg_gdbarch
, ecs
->event_thread
->stop_pc ()));
5973 if (target_stopped_by_watchpoint ())
5977 infrun_debug_printf ("stopped by watchpoint");
5979 if (target_stopped_data_address (current_inferior ()->top_target (),
5981 infrun_debug_printf ("stopped data address=%s",
5982 paddress (reg_gdbarch
, addr
));
5984 infrun_debug_printf ("(no data address available)");
5988 /* This is originated from start_remote(), start_inferior() and
5989 shared libraries hook functions. */
5990 stop_soon
= get_inferior_stop_soon (ecs
);
5991 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5993 infrun_debug_printf ("quietly stopped");
5994 stop_print_frame
= true;
5999 /* This originates from attach_command(). We need to overwrite
6000 the stop_signal here, because some kernels don't ignore a
6001 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
6002 See more comments in inferior.h. On the other hand, if we
6003 get a non-SIGSTOP, report it to the user - assume the backend
6004 will handle the SIGSTOP if it should show up later.
6006 Also consider that the attach is complete when we see a
6007 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
6008 target extended-remote report it instead of a SIGSTOP
6009 (e.g. gdbserver). We already rely on SIGTRAP being our
6010 signal, so this is no exception.
6012 Also consider that the attach is complete when we see a
6013 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
6014 the target to stop all threads of the inferior, in case the
6015 low level attach operation doesn't stop them implicitly. If
6016 they weren't stopped implicitly, then the stub will report a
6017 GDB_SIGNAL_0, meaning: stopped for no particular reason
6018 other than GDB's request. */
6019 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
6020 && (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_STOP
6021 || ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6022 || ecs
->event_thread
->stop_signal () == GDB_SIGNAL_0
))
6024 stop_print_frame
= true;
6026 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6030 /* At this point, get hold of the now-current thread's frame. */
6031 frame
= get_current_frame ();
6032 gdbarch
= get_frame_arch (frame
);
6034 /* Pull the single step breakpoints out of the target. */
6035 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
6037 struct regcache
*regcache
;
6040 regcache
= get_thread_regcache (ecs
->event_thread
);
6041 const address_space
*aspace
= regcache
->aspace ();
6043 pc
= regcache_read_pc (regcache
);
6045 /* However, before doing so, if this single-step breakpoint was
6046 actually for another thread, set this thread up for moving
6048 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
6051 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
6053 infrun_debug_printf ("[%s] hit another thread's single-step "
6055 target_pid_to_str (ecs
->ptid
).c_str ());
6056 ecs
->hit_singlestep_breakpoint
= 1;
6061 infrun_debug_printf ("[%s] hit its single-step breakpoint",
6062 target_pid_to_str (ecs
->ptid
).c_str ());
6065 delete_just_stopped_threads_single_step_breakpoints ();
6067 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6068 && ecs
->event_thread
->control
.trap_expected
6069 && ecs
->event_thread
->stepping_over_watchpoint
)
6070 stopped_by_watchpoint
= 0;
6072 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
6074 /* If necessary, step over this watchpoint. We'll be back to display
6076 if (stopped_by_watchpoint
6077 && (target_have_steppable_watchpoint ()
6078 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
6080 /* At this point, we are stopped at an instruction which has
6081 attempted to write to a piece of memory under control of
6082 a watchpoint. The instruction hasn't actually executed
6083 yet. If we were to evaluate the watchpoint expression
6084 now, we would get the old value, and therefore no change
6085 would seem to have occurred.
6087 In order to make watchpoints work `right', we really need
6088 to complete the memory write, and then evaluate the
6089 watchpoint expression. We do this by single-stepping the
6092 It may not be necessary to disable the watchpoint to step over
6093 it. For example, the PA can (with some kernel cooperation)
6094 single step over a watchpoint without disabling the watchpoint.
6096 It is far more common to need to disable a watchpoint to step
6097 the inferior over it. If we have non-steppable watchpoints,
6098 we must disable the current watchpoint; it's simplest to
6099 disable all watchpoints.
6101 Any breakpoint at PC must also be stepped over -- if there's
6102 one, it will have already triggered before the watchpoint
6103 triggered, and we either already reported it to the user, or
6104 it didn't cause a stop and we called keep_going. In either
6105 case, if there was a breakpoint at PC, we must be trying to
6107 ecs
->event_thread
->stepping_over_watchpoint
= 1;
6112 ecs
->event_thread
->stepping_over_breakpoint
= 0;
6113 ecs
->event_thread
->stepping_over_watchpoint
= 0;
6114 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
6115 ecs
->event_thread
->control
.stop_step
= 0;
6116 stop_print_frame
= true;
6117 stopped_by_random_signal
= 0;
6118 bpstat stop_chain
= NULL
;
6120 /* Hide inlined functions starting here, unless we just performed stepi or
6121 nexti. After stepi and nexti, always show the innermost frame (not any
6122 inline function call sites). */
6123 if (ecs
->event_thread
->control
.step_range_end
!= 1)
6125 const address_space
*aspace
6126 = get_thread_regcache (ecs
->event_thread
)->aspace ();
6128 /* skip_inline_frames is expensive, so we avoid it if we can
6129 determine that the address is one where functions cannot have
6130 been inlined. This improves performance with inferiors that
6131 load a lot of shared libraries, because the solib event
6132 breakpoint is defined as the address of a function (i.e. not
6133 inline). Note that we have to check the previous PC as well
6134 as the current one to catch cases when we have just
6135 single-stepped off a breakpoint prior to reinstating it.
6136 Note that we're assuming that the code we single-step to is
6137 not inline, but that's not definitive: there's nothing
6138 preventing the event breakpoint function from containing
6139 inlined code, and the single-step ending up there. If the
6140 user had set a breakpoint on that inlined code, the missing
6141 skip_inline_frames call would break things. Fortunately
6142 that's an extremely unlikely scenario. */
6143 if (!pc_at_non_inline_function (aspace
,
6144 ecs
->event_thread
->stop_pc (),
6146 && !(ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6147 && ecs
->event_thread
->control
.trap_expected
6148 && pc_at_non_inline_function (aspace
,
6149 ecs
->event_thread
->prev_pc
,
6152 stop_chain
= build_bpstat_chain (aspace
,
6153 ecs
->event_thread
->stop_pc (),
6155 skip_inline_frames (ecs
->event_thread
, stop_chain
);
6157 /* Re-fetch current thread's frame in case that invalidated
6159 frame
= get_current_frame ();
6160 gdbarch
= get_frame_arch (frame
);
6164 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6165 && ecs
->event_thread
->control
.trap_expected
6166 && gdbarch_single_step_through_delay_p (gdbarch
)
6167 && currently_stepping (ecs
->event_thread
))
6169 /* We're trying to step off a breakpoint. Turns out that we're
6170 also on an instruction that needs to be stepped multiple
6171 times before it's been fully executing. E.g., architectures
6172 with a delay slot. It needs to be stepped twice, once for
6173 the instruction and once for the delay slot. */
6174 int step_through_delay
6175 = gdbarch_single_step_through_delay (gdbarch
, frame
);
6177 if (step_through_delay
)
6178 infrun_debug_printf ("step through delay");
6180 if (ecs
->event_thread
->control
.step_range_end
== 0
6181 && step_through_delay
)
6183 /* The user issued a continue when stopped at a breakpoint.
6184 Set up for another trap and get out of here. */
6185 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6189 else if (step_through_delay
)
6191 /* The user issued a step when stopped at a breakpoint.
6192 Maybe we should stop, maybe we should not - the delay
6193 slot *might* correspond to a line of source. In any
6194 case, don't decide that here, just set
6195 ecs->stepping_over_breakpoint, making sure we
6196 single-step again before breakpoints are re-inserted. */
6197 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6201 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
6202 handles this event. */
6203 ecs
->event_thread
->control
.stop_bpstat
6204 = bpstat_stop_status (get_current_regcache ()->aspace (),
6205 ecs
->event_thread
->stop_pc (),
6206 ecs
->event_thread
, &ecs
->ws
, stop_chain
);
6208 /* Following in case break condition called a
6210 stop_print_frame
= true;
6212 /* This is where we handle "moribund" watchpoints. Unlike
6213 software breakpoints traps, hardware watchpoint traps are
6214 always distinguishable from random traps. If no high-level
6215 watchpoint is associated with the reported stop data address
6216 anymore, then the bpstat does not explain the signal ---
6217 simply make sure to ignore it if `stopped_by_watchpoint' is
6220 if (ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6221 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6223 && stopped_by_watchpoint
)
6225 infrun_debug_printf ("no user watchpoint explains watchpoint SIGTRAP, "
6229 /* NOTE: cagney/2003-03-29: These checks for a random signal
6230 at one stage in the past included checks for an inferior
6231 function call's call dummy's return breakpoint. The original
6232 comment, that went with the test, read:
6234 ``End of a stack dummy. Some systems (e.g. Sony news) give
6235 another signal besides SIGTRAP, so check here as well as
6238 If someone ever tries to get call dummys on a
6239 non-executable stack to work (where the target would stop
6240 with something like a SIGSEGV), then those tests might need
6241 to be re-instated. Given, however, that the tests were only
6242 enabled when momentary breakpoints were not being used, I
6243 suspect that it won't be the case.
6245 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
6246 be necessary for call dummies on a non-executable stack on
6249 /* See if the breakpoints module can explain the signal. */
6251 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6252 ecs
->event_thread
->stop_signal ());
6254 /* Maybe this was a trap for a software breakpoint that has since
6256 if (random_signal
&& target_stopped_by_sw_breakpoint ())
6258 if (gdbarch_program_breakpoint_here_p (gdbarch
,
6259 ecs
->event_thread
->stop_pc ()))
6261 struct regcache
*regcache
;
6264 /* Re-adjust PC to what the program would see if GDB was not
6266 regcache
= get_thread_regcache (ecs
->event_thread
);
6267 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
6270 gdb::optional
<scoped_restore_tmpl
<int>>
6271 restore_operation_disable
;
6273 if (record_full_is_used ())
6274 restore_operation_disable
.emplace
6275 (record_full_gdb_operation_disable_set ());
6277 regcache_write_pc (regcache
,
6278 ecs
->event_thread
->stop_pc () + decr_pc
);
6283 /* A delayed software breakpoint event. Ignore the trap. */
6284 infrun_debug_printf ("delayed software breakpoint trap, ignoring");
6289 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6290 has since been removed. */
6291 if (random_signal
&& target_stopped_by_hw_breakpoint ())
6293 /* A delayed hardware breakpoint event. Ignore the trap. */
6294 infrun_debug_printf ("delayed hardware breakpoint/watchpoint "
6299 /* If not, perhaps stepping/nexting can. */
6301 random_signal
= !(ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
6302 && currently_stepping (ecs
->event_thread
));
6304 /* Perhaps the thread hit a single-step breakpoint of _another_
6305 thread. Single-step breakpoints are transparent to the
6306 breakpoints module. */
6308 random_signal
= !ecs
->hit_singlestep_breakpoint
;
6310 /* No? Perhaps we got a moribund watchpoint. */
6312 random_signal
= !stopped_by_watchpoint
;
6314 /* Always stop if the user explicitly requested this thread to
6316 if (ecs
->event_thread
->stop_requested
)
6319 infrun_debug_printf ("user-requested stop");
6322 /* For the program's own signals, act according to
6323 the signal handling tables. */
6327 /* Signal not for debugging purposes. */
6328 enum gdb_signal stop_signal
= ecs
->event_thread
->stop_signal ();
6330 infrun_debug_printf ("random signal (%s)",
6331 gdb_signal_to_symbol_string (stop_signal
));
6333 stopped_by_random_signal
= 1;
6335 /* Always stop on signals if we're either just gaining control
6336 of the program, or the user explicitly requested this thread
6337 to remain stopped. */
6338 if (stop_soon
!= NO_STOP_QUIETLY
6339 || ecs
->event_thread
->stop_requested
6340 || signal_stop_state (ecs
->event_thread
->stop_signal ()))
6346 /* Notify observers the signal has "handle print" set. Note we
6347 returned early above if stopping; normal_stop handles the
6348 printing in that case. */
6349 if (signal_print
[ecs
->event_thread
->stop_signal ()])
6351 /* The signal table tells us to print about this signal. */
6352 target_terminal::ours_for_output ();
6353 gdb::observers::signal_received
.notify (ecs
->event_thread
->stop_signal ());
6354 target_terminal::inferior ();
6357 /* Clear the signal if it should not be passed. */
6358 if (signal_program
[ecs
->event_thread
->stop_signal ()] == 0)
6359 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
6361 if (ecs
->event_thread
->prev_pc
== ecs
->event_thread
->stop_pc ()
6362 && ecs
->event_thread
->control
.trap_expected
6363 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6365 /* We were just starting a new sequence, attempting to
6366 single-step off of a breakpoint and expecting a SIGTRAP.
6367 Instead this signal arrives. This signal will take us out
6368 of the stepping range so GDB needs to remember to, when
6369 the signal handler returns, resume stepping off that
6371 /* To simplify things, "continue" is forced to use the same
6372 code paths as single-step - set a breakpoint at the
6373 signal return address and then, once hit, step off that
6375 infrun_debug_printf ("signal arrived while stepping over breakpoint");
6377 insert_hp_step_resume_breakpoint_at_frame (frame
);
6378 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6379 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6380 ecs
->event_thread
->control
.trap_expected
= 0;
6382 /* If we were nexting/stepping some other thread, switch to
6383 it, so that we don't continue it, losing control. */
6384 if (!switch_back_to_stepped_thread (ecs
))
6389 if (ecs
->event_thread
->stop_signal () != GDB_SIGNAL_0
6390 && (pc_in_thread_step_range (ecs
->event_thread
->stop_pc (),
6392 || ecs
->event_thread
->control
.step_range_end
== 1)
6393 && frame_id_eq (get_stack_frame_id (frame
),
6394 ecs
->event_thread
->control
.step_stack_frame_id
)
6395 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6397 /* The inferior is about to take a signal that will take it
6398 out of the single step range. Set a breakpoint at the
6399 current PC (which is presumably where the signal handler
6400 will eventually return) and then allow the inferior to
6403 Note that this is only needed for a signal delivered
6404 while in the single-step range. Nested signals aren't a
6405 problem as they eventually all return. */
6406 infrun_debug_printf ("signal may take us out of single-step range");
6408 clear_step_over_info ();
6409 insert_hp_step_resume_breakpoint_at_frame (frame
);
6410 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6411 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6412 ecs
->event_thread
->control
.trap_expected
= 0;
6417 /* Note: step_resume_breakpoint may be non-NULL. This occurs
6418 when either there's a nested signal, or when there's a
6419 pending signal enabled just as the signal handler returns
6420 (leaving the inferior at the step-resume-breakpoint without
6421 actually executing it). Either way continue until the
6422 breakpoint is really hit. */
6424 if (!switch_back_to_stepped_thread (ecs
))
6426 infrun_debug_printf ("random signal, keep going");
6433 process_event_stop_test (ecs
);
6436 /* Come here when we've got some debug event / signal we can explain
6437 (IOW, not a random signal), and test whether it should cause a
6438 stop, or whether we should resume the inferior (transparently).
6439 E.g., could be a breakpoint whose condition evaluates false; we
6440 could be still stepping within the line; etc. */
6443 process_event_stop_test (struct execution_control_state
*ecs
)
6445 struct symtab_and_line stop_pc_sal
;
6446 struct frame_info
*frame
;
6447 struct gdbarch
*gdbarch
;
6448 CORE_ADDR jmp_buf_pc
;
6449 struct bpstat_what what
;
6451 /* Handle cases caused by hitting a breakpoint. */
6453 frame
= get_current_frame ();
6454 gdbarch
= get_frame_arch (frame
);
6456 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
6458 if (what
.call_dummy
)
6460 stop_stack_dummy
= what
.call_dummy
;
6463 /* A few breakpoint types have callbacks associated (e.g.,
6464 bp_jit_event). Run them now. */
6465 bpstat_run_callbacks (ecs
->event_thread
->control
.stop_bpstat
);
6467 /* If we hit an internal event that triggers symbol changes, the
6468 current frame will be invalidated within bpstat_what (e.g., if we
6469 hit an internal solib event). Re-fetch it. */
6470 frame
= get_current_frame ();
6471 gdbarch
= get_frame_arch (frame
);
6473 switch (what
.main_action
)
6475 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
6476 /* If we hit the breakpoint at longjmp while stepping, we
6477 install a momentary breakpoint at the target of the
6480 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME");
6482 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6484 if (what
.is_longjmp
)
6486 struct value
*arg_value
;
6488 /* If we set the longjmp breakpoint via a SystemTap probe,
6489 then use it to extract the arguments. The destination PC
6490 is the third argument to the probe. */
6491 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
6494 jmp_buf_pc
= value_as_address (arg_value
);
6495 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
6497 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
6498 || !gdbarch_get_longjmp_target (gdbarch
,
6499 frame
, &jmp_buf_pc
))
6501 infrun_debug_printf ("BPSTAT_WHAT_SET_LONGJMP_RESUME "
6502 "(!gdbarch_get_longjmp_target)");
6507 /* Insert a breakpoint at resume address. */
6508 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
6511 check_exception_resume (ecs
, frame
);
6515 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
6517 struct frame_info
*init_frame
;
6519 /* There are several cases to consider.
6521 1. The initiating frame no longer exists. In this case we
6522 must stop, because the exception or longjmp has gone too
6525 2. The initiating frame exists, and is the same as the
6526 current frame. We stop, because the exception or longjmp
6529 3. The initiating frame exists and is different from the
6530 current frame. This means the exception or longjmp has
6531 been caught beneath the initiating frame, so keep going.
6533 4. longjmp breakpoint has been placed just to protect
6534 against stale dummy frames and user is not interested in
6535 stopping around longjmps. */
6537 infrun_debug_printf ("BPSTAT_WHAT_CLEAR_LONGJMP_RESUME");
6539 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
6541 delete_exception_resume_breakpoint (ecs
->event_thread
);
6543 if (what
.is_longjmp
)
6545 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
6547 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
6555 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
6559 struct frame_id current_id
6560 = get_frame_id (get_current_frame ());
6561 if (frame_id_eq (current_id
,
6562 ecs
->event_thread
->initiating_frame
))
6564 /* Case 2. Fall through. */
6574 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6576 delete_step_resume_breakpoint (ecs
->event_thread
);
6578 end_stepping_range (ecs
);
6582 case BPSTAT_WHAT_SINGLE
:
6583 infrun_debug_printf ("BPSTAT_WHAT_SINGLE");
6584 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6585 /* Still need to check other stuff, at least the case where we
6586 are stepping and step out of the right range. */
6589 case BPSTAT_WHAT_STEP_RESUME
:
6590 infrun_debug_printf ("BPSTAT_WHAT_STEP_RESUME");
6592 delete_step_resume_breakpoint (ecs
->event_thread
);
6593 if (ecs
->event_thread
->control
.proceed_to_finish
6594 && execution_direction
== EXEC_REVERSE
)
6596 struct thread_info
*tp
= ecs
->event_thread
;
6598 /* We are finishing a function in reverse, and just hit the
6599 step-resume breakpoint at the start address of the
6600 function, and we're almost there -- just need to back up
6601 by one more single-step, which should take us back to the
6603 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6607 fill_in_stop_func (gdbarch
, ecs
);
6608 if (ecs
->event_thread
->stop_pc () == ecs
->stop_func_start
6609 && execution_direction
== EXEC_REVERSE
)
6611 /* We are stepping over a function call in reverse, and just
6612 hit the step-resume breakpoint at the start address of
6613 the function. Go back to single-stepping, which should
6614 take us back to the function call. */
6615 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6621 case BPSTAT_WHAT_STOP_NOISY
:
6622 infrun_debug_printf ("BPSTAT_WHAT_STOP_NOISY");
6623 stop_print_frame
= true;
6625 /* Assume the thread stopped for a breakpoint. We'll still check
6626 whether a/the breakpoint is there when the thread is next
6628 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6633 case BPSTAT_WHAT_STOP_SILENT
:
6634 infrun_debug_printf ("BPSTAT_WHAT_STOP_SILENT");
6635 stop_print_frame
= false;
6637 /* Assume the thread stopped for a breakpoint. We'll still check
6638 whether a/the breakpoint is there when the thread is next
6640 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6644 case BPSTAT_WHAT_HP_STEP_RESUME
:
6645 infrun_debug_printf ("BPSTAT_WHAT_HP_STEP_RESUME");
6647 delete_step_resume_breakpoint (ecs
->event_thread
);
6648 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6650 /* Back when the step-resume breakpoint was inserted, we
6651 were trying to single-step off a breakpoint. Go back to
6653 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6654 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6660 case BPSTAT_WHAT_KEEP_CHECKING
:
6664 /* If we stepped a permanent breakpoint and we had a high priority
6665 step-resume breakpoint for the address we stepped, but we didn't
6666 hit it, then we must have stepped into the signal handler. The
6667 step-resume was only necessary to catch the case of _not_
6668 stepping into the handler, so delete it, and fall through to
6669 checking whether the step finished. */
6670 if (ecs
->event_thread
->stepped_breakpoint
)
6672 struct breakpoint
*sr_bp
6673 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6676 && sr_bp
->loc
->permanent
6677 && sr_bp
->type
== bp_hp_step_resume
6678 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6680 infrun_debug_printf ("stepped permanent breakpoint, stopped in handler");
6681 delete_step_resume_breakpoint (ecs
->event_thread
);
6682 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6686 /* We come here if we hit a breakpoint but should not stop for it.
6687 Possibly we also were stepping and should stop for that. So fall
6688 through and test for stepping. But, if not stepping, do not
6691 /* In all-stop mode, if we're currently stepping but have stopped in
6692 some other thread, we need to switch back to the stepped thread. */
6693 if (switch_back_to_stepped_thread (ecs
))
6696 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6698 infrun_debug_printf ("step-resume breakpoint is inserted");
6700 /* Having a step-resume breakpoint overrides anything
6701 else having to do with stepping commands until
6702 that breakpoint is reached. */
6707 if (ecs
->event_thread
->control
.step_range_end
== 0)
6709 infrun_debug_printf ("no stepping, continue");
6710 /* Likewise if we aren't even stepping. */
6715 /* Re-fetch current thread's frame in case the code above caused
6716 the frame cache to be re-initialized, making our FRAME variable
6717 a dangling pointer. */
6718 frame
= get_current_frame ();
6719 gdbarch
= get_frame_arch (frame
);
6720 fill_in_stop_func (gdbarch
, ecs
);
6722 /* If stepping through a line, keep going if still within it.
6724 Note that step_range_end is the address of the first instruction
6725 beyond the step range, and NOT the address of the last instruction
6728 Note also that during reverse execution, we may be stepping
6729 through a function epilogue and therefore must detect when
6730 the current-frame changes in the middle of a line. */
6732 if (pc_in_thread_step_range (ecs
->event_thread
->stop_pc (),
6734 && (execution_direction
!= EXEC_REVERSE
6735 || frame_id_eq (get_frame_id (frame
),
6736 ecs
->event_thread
->control
.step_frame_id
)))
6739 ("stepping inside range [%s-%s]",
6740 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6741 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6743 /* Tentatively re-enable range stepping; `resume' disables it if
6744 necessary (e.g., if we're stepping over a breakpoint or we
6745 have software watchpoints). */
6746 ecs
->event_thread
->control
.may_range_step
= 1;
6748 /* When stepping backward, stop at beginning of line range
6749 (unless it's the function entry point, in which case
6750 keep going back to the call point). */
6751 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
6752 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6753 && stop_pc
!= ecs
->stop_func_start
6754 && execution_direction
== EXEC_REVERSE
)
6755 end_stepping_range (ecs
);
6762 /* We stepped out of the stepping range. */
6764 /* If we are stepping at the source level and entered the runtime
6765 loader dynamic symbol resolution code...
6767 EXEC_FORWARD: we keep on single stepping until we exit the run
6768 time loader code and reach the callee's address.
6770 EXEC_REVERSE: we've already executed the callee (backward), and
6771 the runtime loader code is handled just like any other
6772 undebuggable function call. Now we need only keep stepping
6773 backward through the trampoline code, and that's handled further
6774 down, so there is nothing for us to do here. */
6776 if (execution_direction
!= EXEC_REVERSE
6777 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6778 && in_solib_dynsym_resolve_code (ecs
->event_thread
->stop_pc ()))
6780 CORE_ADDR pc_after_resolver
=
6781 gdbarch_skip_solib_resolver (gdbarch
, ecs
->event_thread
->stop_pc ());
6783 infrun_debug_printf ("stepped into dynsym resolve code");
6785 if (pc_after_resolver
)
6787 /* Set up a step-resume breakpoint at the address
6788 indicated by SKIP_SOLIB_RESOLVER. */
6789 symtab_and_line sr_sal
;
6790 sr_sal
.pc
= pc_after_resolver
;
6791 sr_sal
.pspace
= get_frame_program_space (frame
);
6793 insert_step_resume_breakpoint_at_sal (gdbarch
,
6794 sr_sal
, null_frame_id
);
6801 /* Step through an indirect branch thunk. */
6802 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6803 && gdbarch_in_indirect_branch_thunk (gdbarch
,
6804 ecs
->event_thread
->stop_pc ()))
6806 infrun_debug_printf ("stepped into indirect branch thunk");
6811 if (ecs
->event_thread
->control
.step_range_end
!= 1
6812 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6813 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6814 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6816 infrun_debug_printf ("stepped into signal trampoline");
6817 /* The inferior, while doing a "step" or "next", has ended up in
6818 a signal trampoline (either by a signal being delivered or by
6819 the signal handler returning). Just single-step until the
6820 inferior leaves the trampoline (either by calling the handler
6826 /* If we're in the return path from a shared library trampoline,
6827 we want to proceed through the trampoline when stepping. */
6828 /* macro/2012-04-25: This needs to come before the subroutine
6829 call check below as on some targets return trampolines look
6830 like subroutine calls (MIPS16 return thunks). */
6831 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6832 ecs
->event_thread
->stop_pc (),
6833 ecs
->stop_func_name
)
6834 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6836 /* Determine where this trampoline returns. */
6837 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
6838 CORE_ADDR real_stop_pc
6839 = gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6841 infrun_debug_printf ("stepped into solib return tramp");
6843 /* Only proceed through if we know where it's going. */
6846 /* And put the step-breakpoint there and go until there. */
6847 symtab_and_line sr_sal
;
6848 sr_sal
.pc
= real_stop_pc
;
6849 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6850 sr_sal
.pspace
= get_frame_program_space (frame
);
6852 /* Do not specify what the fp should be when we stop since
6853 on some machines the prologue is where the new fp value
6855 insert_step_resume_breakpoint_at_sal (gdbarch
,
6856 sr_sal
, null_frame_id
);
6858 /* Restart without fiddling with the step ranges or
6865 /* Check for subroutine calls. The check for the current frame
6866 equalling the step ID is not necessary - the check of the
6867 previous frame's ID is sufficient - but it is a common case and
6868 cheaper than checking the previous frame's ID.
6870 NOTE: frame_id_eq will never report two invalid frame IDs as
6871 being equal, so to get into this block, both the current and
6872 previous frame must have valid frame IDs. */
6873 /* The outer_frame_id check is a heuristic to detect stepping
6874 through startup code. If we step over an instruction which
6875 sets the stack pointer from an invalid value to a valid value,
6876 we may detect that as a subroutine call from the mythical
6877 "outermost" function. This could be fixed by marking
6878 outermost frames as !stack_p,code_p,special_p. Then the
6879 initial outermost frame, before sp was valid, would
6880 have code_addr == &_start. See the comment in frame_id_eq
6882 if (!frame_id_eq (get_stack_frame_id (frame
),
6883 ecs
->event_thread
->control
.step_stack_frame_id
)
6884 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6885 ecs
->event_thread
->control
.step_stack_frame_id
)
6886 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6888 || (ecs
->event_thread
->control
.step_start_function
6889 != find_pc_function (ecs
->event_thread
->stop_pc ())))))
6891 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
6892 CORE_ADDR real_stop_pc
;
6894 infrun_debug_printf ("stepped into subroutine");
6896 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6898 /* I presume that step_over_calls is only 0 when we're
6899 supposed to be stepping at the assembly language level
6900 ("stepi"). Just stop. */
6901 /* And this works the same backward as frontward. MVS */
6902 end_stepping_range (ecs
);
6906 /* Reverse stepping through solib trampolines. */
6908 if (execution_direction
== EXEC_REVERSE
6909 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6910 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6911 || (ecs
->stop_func_start
== 0
6912 && in_solib_dynsym_resolve_code (stop_pc
))))
6914 /* Any solib trampoline code can be handled in reverse
6915 by simply continuing to single-step. We have already
6916 executed the solib function (backwards), and a few
6917 steps will take us back through the trampoline to the
6923 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6925 /* We're doing a "next".
6927 Normal (forward) execution: set a breakpoint at the
6928 callee's return address (the address at which the caller
6931 Reverse (backward) execution. set the step-resume
6932 breakpoint at the start of the function that we just
6933 stepped into (backwards), and continue to there. When we
6934 get there, we'll need to single-step back to the caller. */
6936 if (execution_direction
== EXEC_REVERSE
)
6938 /* If we're already at the start of the function, we've either
6939 just stepped backward into a single instruction function,
6940 or stepped back out of a signal handler to the first instruction
6941 of the function. Just keep going, which will single-step back
6943 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6945 /* Normal function call return (static or dynamic). */
6946 symtab_and_line sr_sal
;
6947 sr_sal
.pc
= ecs
->stop_func_start
;
6948 sr_sal
.pspace
= get_frame_program_space (frame
);
6949 insert_step_resume_breakpoint_at_sal (gdbarch
,
6950 sr_sal
, null_frame_id
);
6954 insert_step_resume_breakpoint_at_caller (frame
);
6960 /* If we are in a function call trampoline (a stub between the
6961 calling routine and the real function), locate the real
6962 function. That's what tells us (a) whether we want to step
6963 into it at all, and (b) what prologue we want to run to the
6964 end of, if we do step into it. */
6965 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6966 if (real_stop_pc
== 0)
6967 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6968 if (real_stop_pc
!= 0)
6969 ecs
->stop_func_start
= real_stop_pc
;
6971 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6973 symtab_and_line sr_sal
;
6974 sr_sal
.pc
= ecs
->stop_func_start
;
6975 sr_sal
.pspace
= get_frame_program_space (frame
);
6977 insert_step_resume_breakpoint_at_sal (gdbarch
,
6978 sr_sal
, null_frame_id
);
6983 /* If we have line number information for the function we are
6984 thinking of stepping into and the function isn't on the skip
6987 If there are several symtabs at that PC (e.g. with include
6988 files), just want to know whether *any* of them have line
6989 numbers. find_pc_line handles this. */
6991 struct symtab_and_line tmp_sal
;
6993 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6994 if (tmp_sal
.line
!= 0
6995 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6997 && !inline_frame_is_marked_for_skip (true, ecs
->event_thread
))
6999 if (execution_direction
== EXEC_REVERSE
)
7000 handle_step_into_function_backward (gdbarch
, ecs
);
7002 handle_step_into_function (gdbarch
, ecs
);
7007 /* If we have no line number and the step-stop-if-no-debug is
7008 set, we stop the step so that the user has a chance to switch
7009 in assembly mode. */
7010 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7011 && step_stop_if_no_debug
)
7013 end_stepping_range (ecs
);
7017 if (execution_direction
== EXEC_REVERSE
)
7019 /* If we're already at the start of the function, we've either just
7020 stepped backward into a single instruction function without line
7021 number info, or stepped back out of a signal handler to the first
7022 instruction of the function without line number info. Just keep
7023 going, which will single-step back to the caller. */
7024 if (ecs
->stop_func_start
!= stop_pc
)
7026 /* Set a breakpoint at callee's start address.
7027 From there we can step once and be back in the caller. */
7028 symtab_and_line sr_sal
;
7029 sr_sal
.pc
= ecs
->stop_func_start
;
7030 sr_sal
.pspace
= get_frame_program_space (frame
);
7031 insert_step_resume_breakpoint_at_sal (gdbarch
,
7032 sr_sal
, null_frame_id
);
7036 /* Set a breakpoint at callee's return address (the address
7037 at which the caller will resume). */
7038 insert_step_resume_breakpoint_at_caller (frame
);
7044 /* Reverse stepping through solib trampolines. */
7046 if (execution_direction
== EXEC_REVERSE
7047 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
7049 CORE_ADDR stop_pc
= ecs
->event_thread
->stop_pc ();
7051 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
7052 || (ecs
->stop_func_start
== 0
7053 && in_solib_dynsym_resolve_code (stop_pc
)))
7055 /* Any solib trampoline code can be handled in reverse
7056 by simply continuing to single-step. We have already
7057 executed the solib function (backwards), and a few
7058 steps will take us back through the trampoline to the
7063 else if (in_solib_dynsym_resolve_code (stop_pc
))
7065 /* Stepped backward into the solib dynsym resolver.
7066 Set a breakpoint at its start and continue, then
7067 one more step will take us out. */
7068 symtab_and_line sr_sal
;
7069 sr_sal
.pc
= ecs
->stop_func_start
;
7070 sr_sal
.pspace
= get_frame_program_space (frame
);
7071 insert_step_resume_breakpoint_at_sal (gdbarch
,
7072 sr_sal
, null_frame_id
);
7078 /* This always returns the sal for the inner-most frame when we are in a
7079 stack of inlined frames, even if GDB actually believes that it is in a
7080 more outer frame. This is checked for below by calls to
7081 inline_skipped_frames. */
7082 stop_pc_sal
= find_pc_line (ecs
->event_thread
->stop_pc (), 0);
7084 /* NOTE: tausq/2004-05-24: This if block used to be done before all
7085 the trampoline processing logic, however, there are some trampolines
7086 that have no names, so we should do trampoline handling first. */
7087 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7088 && ecs
->stop_func_name
== NULL
7089 && stop_pc_sal
.line
== 0)
7091 infrun_debug_printf ("stepped into undebuggable function");
7093 /* The inferior just stepped into, or returned to, an
7094 undebuggable function (where there is no debugging information
7095 and no line number corresponding to the address where the
7096 inferior stopped). Since we want to skip this kind of code,
7097 we keep going until the inferior returns from this
7098 function - unless the user has asked us not to (via
7099 set step-mode) or we no longer know how to get back
7100 to the call site. */
7101 if (step_stop_if_no_debug
7102 || !frame_id_p (frame_unwind_caller_id (frame
)))
7104 /* If we have no line number and the step-stop-if-no-debug
7105 is set, we stop the step so that the user has a chance to
7106 switch in assembly mode. */
7107 end_stepping_range (ecs
);
7112 /* Set a breakpoint at callee's return address (the address
7113 at which the caller will resume). */
7114 insert_step_resume_breakpoint_at_caller (frame
);
7120 if (ecs
->event_thread
->control
.step_range_end
== 1)
7122 /* It is stepi or nexti. We always want to stop stepping after
7124 infrun_debug_printf ("stepi/nexti");
7125 end_stepping_range (ecs
);
7129 if (stop_pc_sal
.line
== 0)
7131 /* We have no line number information. That means to stop
7132 stepping (does this always happen right after one instruction,
7133 when we do "s" in a function with no line numbers,
7134 or can this happen as a result of a return or longjmp?). */
7135 infrun_debug_printf ("line number info");
7136 end_stepping_range (ecs
);
7140 /* Look for "calls" to inlined functions, part one. If the inline
7141 frame machinery detected some skipped call sites, we have entered
7142 a new inline function. */
7144 if (frame_id_eq (get_frame_id (get_current_frame ()),
7145 ecs
->event_thread
->control
.step_frame_id
)
7146 && inline_skipped_frames (ecs
->event_thread
))
7148 infrun_debug_printf ("stepped into inlined function");
7150 symtab_and_line call_sal
= find_frame_sal (get_current_frame ());
7152 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
7154 /* For "step", we're going to stop. But if the call site
7155 for this inlined function is on the same source line as
7156 we were previously stepping, go down into the function
7157 first. Otherwise stop at the call site. */
7159 if (call_sal
.line
== ecs
->event_thread
->current_line
7160 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7162 step_into_inline_frame (ecs
->event_thread
);
7163 if (inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7170 end_stepping_range (ecs
);
7175 /* For "next", we should stop at the call site if it is on a
7176 different source line. Otherwise continue through the
7177 inlined function. */
7178 if (call_sal
.line
== ecs
->event_thread
->current_line
7179 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7182 end_stepping_range (ecs
);
7187 /* Look for "calls" to inlined functions, part two. If we are still
7188 in the same real function we were stepping through, but we have
7189 to go further up to find the exact frame ID, we are stepping
7190 through a more inlined call beyond its call site. */
7192 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
7193 && !frame_id_eq (get_frame_id (get_current_frame ()),
7194 ecs
->event_thread
->control
.step_frame_id
)
7195 && stepped_in_from (get_current_frame (),
7196 ecs
->event_thread
->control
.step_frame_id
))
7198 infrun_debug_printf ("stepping through inlined function");
7200 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
7201 || inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7204 end_stepping_range (ecs
);
7208 bool refresh_step_info
= true;
7209 if ((ecs
->event_thread
->stop_pc () == stop_pc_sal
.pc
)
7210 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
7211 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
7213 /* We are at a different line. */
7215 if (stop_pc_sal
.is_stmt
)
7217 /* We are at the start of a statement.
7219 So stop. Note that we don't stop if we step into the middle of a
7220 statement. That is said to make things like for (;;) statements
7222 infrun_debug_printf ("stepped to a different line");
7223 end_stepping_range (ecs
);
7226 else if (frame_id_eq (get_frame_id (get_current_frame ()),
7227 ecs
->event_thread
->control
.step_frame_id
))
7229 /* We are not at the start of a statement, and we have not changed
7232 We ignore this line table entry, and continue stepping forward,
7233 looking for a better place to stop. */
7234 refresh_step_info
= false;
7235 infrun_debug_printf ("stepped to a different line, but "
7236 "it's not the start of a statement");
7240 /* We are not the start of a statement, and we have changed frame.
7242 We ignore this line table entry, and continue stepping forward,
7243 looking for a better place to stop. Keep refresh_step_info at
7244 true to note that the frame has changed, but ignore the line
7245 number to make sure we don't ignore a subsequent entry with the
7246 same line number. */
7247 stop_pc_sal
.line
= 0;
7248 infrun_debug_printf ("stepped to a different frame, but "
7249 "it's not the start of a statement");
7253 /* We aren't done stepping.
7255 Optimize by setting the stepping range to the line.
7256 (We might not be in the original line, but if we entered a
7257 new line in mid-statement, we continue stepping. This makes
7258 things like for(;;) statements work better.)
7260 If we entered a SAL that indicates a non-statement line table entry,
7261 then we update the stepping range, but we don't update the step info,
7262 which includes things like the line number we are stepping away from.
7263 This means we will stop when we find a line table entry that is marked
7264 as is-statement, even if it matches the non-statement one we just
7267 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
7268 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
7269 ecs
->event_thread
->control
.may_range_step
= 1;
7270 if (refresh_step_info
)
7271 set_step_info (ecs
->event_thread
, frame
, stop_pc_sal
);
7273 infrun_debug_printf ("keep going");
7277 static bool restart_stepped_thread (process_stratum_target
*resume_target
,
7278 ptid_t resume_ptid
);
7280 /* In all-stop mode, if we're currently stepping but have stopped in
7281 some other thread, we may need to switch back to the stepped
7282 thread. Returns true we set the inferior running, false if we left
7283 it stopped (and the event needs further processing). */
7286 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
7288 if (!target_is_non_stop_p ())
7290 /* If any thread is blocked on some internal breakpoint, and we
7291 simply need to step over that breakpoint to get it going
7292 again, do that first. */
7294 /* However, if we see an event for the stepping thread, then we
7295 know all other threads have been moved past their breakpoints
7296 already. Let the caller check whether the step is finished,
7297 etc., before deciding to move it past a breakpoint. */
7298 if (ecs
->event_thread
->control
.step_range_end
!= 0)
7301 /* Check if the current thread is blocked on an incomplete
7302 step-over, interrupted by a random signal. */
7303 if (ecs
->event_thread
->control
.trap_expected
7304 && ecs
->event_thread
->stop_signal () != GDB_SIGNAL_TRAP
)
7307 ("need to finish step-over of [%s]",
7308 target_pid_to_str (ecs
->event_thread
->ptid
).c_str ());
7313 /* Check if the current thread is blocked by a single-step
7314 breakpoint of another thread. */
7315 if (ecs
->hit_singlestep_breakpoint
)
7317 infrun_debug_printf ("need to step [%s] over single-step breakpoint",
7318 target_pid_to_str (ecs
->ptid
).c_str ());
7323 /* If this thread needs yet another step-over (e.g., stepping
7324 through a delay slot), do it first before moving on to
7326 if (thread_still_needs_step_over (ecs
->event_thread
))
7329 ("thread [%s] still needs step-over",
7330 target_pid_to_str (ecs
->event_thread
->ptid
).c_str ());
7335 /* If scheduler locking applies even if not stepping, there's no
7336 need to walk over threads. Above we've checked whether the
7337 current thread is stepping. If some other thread not the
7338 event thread is stepping, then it must be that scheduler
7339 locking is not in effect. */
7340 if (schedlock_applies (ecs
->event_thread
))
7343 /* Otherwise, we no longer expect a trap in the current thread.
7344 Clear the trap_expected flag before switching back -- this is
7345 what keep_going does as well, if we call it. */
7346 ecs
->event_thread
->control
.trap_expected
= 0;
7348 /* Likewise, clear the signal if it should not be passed. */
7349 if (!signal_program
[ecs
->event_thread
->stop_signal ()])
7350 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
7352 if (restart_stepped_thread (ecs
->target
, ecs
->ptid
))
7354 prepare_to_wait (ecs
);
7358 switch_to_thread (ecs
->event_thread
);
7364 /* Look for the thread that was stepping, and resume it.
7365 RESUME_TARGET / RESUME_PTID indicate the set of threads the caller
7366 is resuming. Return true if a thread was started, false
7370 restart_stepped_thread (process_stratum_target
*resume_target
,
7373 /* Do all pending step-overs before actually proceeding with
7375 if (start_step_over ())
7378 for (thread_info
*tp
: all_threads_safe ())
7380 if (tp
->state
== THREAD_EXITED
)
7383 if (tp
->has_pending_waitstatus ())
7386 /* Ignore threads of processes the caller is not
7389 && (tp
->inf
->process_target () != resume_target
7390 || tp
->inf
->pid
!= resume_ptid
.pid ()))
7393 if (tp
->control
.trap_expected
)
7395 infrun_debug_printf ("switching back to stepped thread (step-over)");
7397 if (keep_going_stepped_thread (tp
))
7402 for (thread_info
*tp
: all_threads_safe ())
7404 if (tp
->state
== THREAD_EXITED
)
7407 if (tp
->has_pending_waitstatus ())
7410 /* Ignore threads of processes the caller is not
7413 && (tp
->inf
->process_target () != resume_target
7414 || tp
->inf
->pid
!= resume_ptid
.pid ()))
7417 /* Did we find the stepping thread? */
7418 if (tp
->control
.step_range_end
)
7420 infrun_debug_printf ("switching back to stepped thread (stepping)");
7422 if (keep_going_stepped_thread (tp
))
7433 restart_after_all_stop_detach (process_stratum_target
*proc_target
)
7435 /* Note we don't check target_is_non_stop_p() here, because the
7436 current inferior may no longer have a process_stratum target
7437 pushed, as we just detached. */
7439 /* See if we have a THREAD_RUNNING thread that need to be
7440 re-resumed. If we have any thread that is already executing,
7441 then we don't need to resume the target -- it is already been
7442 resumed. With the remote target (in all-stop), it's even
7443 impossible to issue another resumption if the target is already
7444 resumed, until the target reports a stop. */
7445 for (thread_info
*thr
: all_threads (proc_target
))
7447 if (thr
->state
!= THREAD_RUNNING
)
7450 /* If we have any thread that is already executing, then we
7451 don't need to resume the target -- it is already been
7456 /* If we have a pending event to process, skip resuming the
7457 target and go straight to processing it. */
7458 if (thr
->resumed () && thr
->has_pending_waitstatus ())
7462 /* Alright, we need to re-resume the target. If a thread was
7463 stepping, we need to restart it stepping. */
7464 if (restart_stepped_thread (proc_target
, minus_one_ptid
))
7467 /* Otherwise, find the first THREAD_RUNNING thread and resume
7469 for (thread_info
*thr
: all_threads (proc_target
))
7471 if (thr
->state
!= THREAD_RUNNING
)
7474 execution_control_state ecs
;
7475 reset_ecs (&ecs
, thr
);
7476 switch_to_thread (thr
);
7482 /* Set a previously stepped thread back to stepping. Returns true on
7483 success, false if the resume is not possible (e.g., the thread
7487 keep_going_stepped_thread (struct thread_info
*tp
)
7489 struct frame_info
*frame
;
7490 struct execution_control_state ecss
;
7491 struct execution_control_state
*ecs
= &ecss
;
7493 /* If the stepping thread exited, then don't try to switch back and
7494 resume it, which could fail in several different ways depending
7495 on the target. Instead, just keep going.
7497 We can find a stepping dead thread in the thread list in two
7500 - The target supports thread exit events, and when the target
7501 tries to delete the thread from the thread list, inferior_ptid
7502 pointed at the exiting thread. In such case, calling
7503 delete_thread does not really remove the thread from the list;
7504 instead, the thread is left listed, with 'exited' state.
7506 - The target's debug interface does not support thread exit
7507 events, and so we have no idea whatsoever if the previously
7508 stepping thread is still alive. For that reason, we need to
7509 synchronously query the target now. */
7511 if (tp
->state
== THREAD_EXITED
|| !target_thread_alive (tp
->ptid
))
7513 infrun_debug_printf ("not resuming previously stepped thread, it has "
7520 infrun_debug_printf ("resuming previously stepped thread");
7522 reset_ecs (ecs
, tp
);
7523 switch_to_thread (tp
);
7525 tp
->set_stop_pc (regcache_read_pc (get_thread_regcache (tp
)));
7526 frame
= get_current_frame ();
7528 /* If the PC of the thread we were trying to single-step has
7529 changed, then that thread has trapped or been signaled, but the
7530 event has not been reported to GDB yet. Re-poll the target
7531 looking for this particular thread's event (i.e. temporarily
7532 enable schedlock) by:
7534 - setting a break at the current PC
7535 - resuming that particular thread, only (by setting trap
7538 This prevents us continuously moving the single-step breakpoint
7539 forward, one instruction at a time, overstepping. */
7541 if (tp
->stop_pc () != tp
->prev_pc
)
7545 infrun_debug_printf ("expected thread advanced also (%s -> %s)",
7546 paddress (target_gdbarch (), tp
->prev_pc
),
7547 paddress (target_gdbarch (), tp
->stop_pc ()));
7549 /* Clear the info of the previous step-over, as it's no longer
7550 valid (if the thread was trying to step over a breakpoint, it
7551 has already succeeded). It's what keep_going would do too,
7552 if we called it. Do this before trying to insert the sss
7553 breakpoint, otherwise if we were previously trying to step
7554 over this exact address in another thread, the breakpoint is
7556 clear_step_over_info ();
7557 tp
->control
.trap_expected
= 0;
7559 insert_single_step_breakpoint (get_frame_arch (frame
),
7560 get_frame_address_space (frame
),
7563 tp
->set_resumed (true);
7564 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
7565 do_target_resume (resume_ptid
, false, GDB_SIGNAL_0
);
7569 infrun_debug_printf ("expected thread still hasn't advanced");
7571 keep_going_pass_signal (ecs
);
7577 /* Is thread TP in the middle of (software or hardware)
7578 single-stepping? (Note the result of this function must never be
7579 passed directly as target_resume's STEP parameter.) */
7582 currently_stepping (struct thread_info
*tp
)
7584 return ((tp
->control
.step_range_end
7585 && tp
->control
.step_resume_breakpoint
== NULL
)
7586 || tp
->control
.trap_expected
7587 || tp
->stepped_breakpoint
7588 || bpstat_should_step ());
7591 /* Inferior has stepped into a subroutine call with source code that
7592 we should not step over. Do step to the first line of code in
7596 handle_step_into_function (struct gdbarch
*gdbarch
,
7597 struct execution_control_state
*ecs
)
7599 fill_in_stop_func (gdbarch
, ecs
);
7601 compunit_symtab
*cust
7602 = find_pc_compunit_symtab (ecs
->event_thread
->stop_pc ());
7603 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7604 ecs
->stop_func_start
7605 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7607 symtab_and_line stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
7608 /* Use the step_resume_break to step until the end of the prologue,
7609 even if that involves jumps (as it seems to on the vax under
7611 /* If the prologue ends in the middle of a source line, continue to
7612 the end of that source line (if it is still within the function).
7613 Otherwise, just go to end of prologue. */
7614 if (stop_func_sal
.end
7615 && stop_func_sal
.pc
!= ecs
->stop_func_start
7616 && stop_func_sal
.end
< ecs
->stop_func_end
)
7617 ecs
->stop_func_start
= stop_func_sal
.end
;
7619 /* Architectures which require breakpoint adjustment might not be able
7620 to place a breakpoint at the computed address. If so, the test
7621 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7622 ecs->stop_func_start to an address at which a breakpoint may be
7623 legitimately placed.
7625 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7626 made, GDB will enter an infinite loop when stepping through
7627 optimized code consisting of VLIW instructions which contain
7628 subinstructions corresponding to different source lines. On
7629 FR-V, it's not permitted to place a breakpoint on any but the
7630 first subinstruction of a VLIW instruction. When a breakpoint is
7631 set, GDB will adjust the breakpoint address to the beginning of
7632 the VLIW instruction. Thus, we need to make the corresponding
7633 adjustment here when computing the stop address. */
7635 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7637 ecs
->stop_func_start
7638 = gdbarch_adjust_breakpoint_address (gdbarch
,
7639 ecs
->stop_func_start
);
7642 if (ecs
->stop_func_start
== ecs
->event_thread
->stop_pc ())
7644 /* We are already there: stop now. */
7645 end_stepping_range (ecs
);
7650 /* Put the step-breakpoint there and go until there. */
7651 symtab_and_line sr_sal
;
7652 sr_sal
.pc
= ecs
->stop_func_start
;
7653 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7654 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7656 /* Do not specify what the fp should be when we stop since on
7657 some machines the prologue is where the new fp value is
7659 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7661 /* And make sure stepping stops right away then. */
7662 ecs
->event_thread
->control
.step_range_end
7663 = ecs
->event_thread
->control
.step_range_start
;
7668 /* Inferior has stepped backward into a subroutine call with source
7669 code that we should not step over. Do step to the beginning of the
7670 last line of code in it. */
7673 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7674 struct execution_control_state
*ecs
)
7676 struct compunit_symtab
*cust
;
7677 struct symtab_and_line stop_func_sal
;
7679 fill_in_stop_func (gdbarch
, ecs
);
7681 cust
= find_pc_compunit_symtab (ecs
->event_thread
->stop_pc ());
7682 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7683 ecs
->stop_func_start
7684 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7686 stop_func_sal
= find_pc_line (ecs
->event_thread
->stop_pc (), 0);
7688 /* OK, we're just going to keep stepping here. */
7689 if (stop_func_sal
.pc
== ecs
->event_thread
->stop_pc ())
7691 /* We're there already. Just stop stepping now. */
7692 end_stepping_range (ecs
);
7696 /* Else just reset the step range and keep going.
7697 No step-resume breakpoint, they don't work for
7698 epilogues, which can have multiple entry paths. */
7699 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7700 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7706 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7707 This is used to both functions and to skip over code. */
7710 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7711 struct symtab_and_line sr_sal
,
7712 struct frame_id sr_id
,
7713 enum bptype sr_type
)
7715 /* There should never be more than one step-resume or longjmp-resume
7716 breakpoint per thread, so we should never be setting a new
7717 step_resume_breakpoint when one is already active. */
7718 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7719 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7721 infrun_debug_printf ("inserting step-resume breakpoint at %s",
7722 paddress (gdbarch
, sr_sal
.pc
));
7724 inferior_thread ()->control
.step_resume_breakpoint
7725 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
).release ();
7729 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7730 struct symtab_and_line sr_sal
,
7731 struct frame_id sr_id
)
7733 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7738 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7739 This is used to skip a potential signal handler.
7741 This is called with the interrupted function's frame. The signal
7742 handler, when it returns, will resume the interrupted function at
7746 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7748 gdb_assert (return_frame
!= NULL
);
7750 struct gdbarch
*gdbarch
= get_frame_arch (return_frame
);
7752 symtab_and_line sr_sal
;
7753 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7754 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7755 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7757 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7758 get_stack_frame_id (return_frame
),
7762 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7763 is used to skip a function after stepping into it (for "next" or if
7764 the called function has no debugging information).
7766 The current function has almost always been reached by single
7767 stepping a call or return instruction. NEXT_FRAME belongs to the
7768 current function, and the breakpoint will be set at the caller's
7771 This is a separate function rather than reusing
7772 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7773 get_prev_frame, which may stop prematurely (see the implementation
7774 of frame_unwind_caller_id for an example). */
7777 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7779 /* We shouldn't have gotten here if we don't know where the call site
7781 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7783 struct gdbarch
*gdbarch
= frame_unwind_caller_arch (next_frame
);
7785 symtab_and_line sr_sal
;
7786 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7787 frame_unwind_caller_pc (next_frame
));
7788 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7789 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7791 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7792 frame_unwind_caller_id (next_frame
));
7795 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7796 new breakpoint at the target of a jmp_buf. The handling of
7797 longjmp-resume uses the same mechanisms used for handling
7798 "step-resume" breakpoints. */
7801 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7803 /* There should never be more than one longjmp-resume breakpoint per
7804 thread, so we should never be setting a new
7805 longjmp_resume_breakpoint when one is already active. */
7806 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7808 infrun_debug_printf ("inserting longjmp-resume breakpoint at %s",
7809 paddress (gdbarch
, pc
));
7811 inferior_thread ()->control
.exception_resume_breakpoint
=
7812 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
).release ();
7815 /* Insert an exception resume breakpoint. TP is the thread throwing
7816 the exception. The block B is the block of the unwinder debug hook
7817 function. FRAME is the frame corresponding to the call to this
7818 function. SYM is the symbol of the function argument holding the
7819 target PC of the exception. */
7822 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7823 const struct block
*b
,
7824 struct frame_info
*frame
,
7829 struct block_symbol vsym
;
7830 struct value
*value
;
7832 struct breakpoint
*bp
;
7834 vsym
= lookup_symbol_search_name (sym
->search_name (),
7836 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
7837 /* If the value was optimized out, revert to the old behavior. */
7838 if (! value_optimized_out (value
))
7840 handler
= value_as_address (value
);
7842 infrun_debug_printf ("exception resume at %lx",
7843 (unsigned long) handler
);
7845 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7847 bp_exception_resume
).release ();
7849 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7852 bp
->thread
= tp
->global_num
;
7853 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7856 catch (const gdb_exception_error
&e
)
7858 /* We want to ignore errors here. */
7862 /* A helper for check_exception_resume that sets an
7863 exception-breakpoint based on a SystemTap probe. */
7866 insert_exception_resume_from_probe (struct thread_info
*tp
,
7867 const struct bound_probe
*probe
,
7868 struct frame_info
*frame
)
7870 struct value
*arg_value
;
7872 struct breakpoint
*bp
;
7874 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7878 handler
= value_as_address (arg_value
);
7880 infrun_debug_printf ("exception resume at %s",
7881 paddress (probe
->objfile
->arch (), handler
));
7883 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7884 handler
, bp_exception_resume
).release ();
7885 bp
->thread
= tp
->global_num
;
7886 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7889 /* This is called when an exception has been intercepted. Check to
7890 see whether the exception's destination is of interest, and if so,
7891 set an exception resume breakpoint there. */
7894 check_exception_resume (struct execution_control_state
*ecs
,
7895 struct frame_info
*frame
)
7897 struct bound_probe probe
;
7898 struct symbol
*func
;
7900 /* First see if this exception unwinding breakpoint was set via a
7901 SystemTap probe point. If so, the probe has two arguments: the
7902 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7903 set a breakpoint there. */
7904 probe
= find_probe_by_pc (get_frame_pc (frame
));
7907 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7911 func
= get_frame_function (frame
);
7917 const struct block
*b
;
7918 struct block_iterator iter
;
7922 /* The exception breakpoint is a thread-specific breakpoint on
7923 the unwinder's debug hook, declared as:
7925 void _Unwind_DebugHook (void *cfa, void *handler);
7927 The CFA argument indicates the frame to which control is
7928 about to be transferred. HANDLER is the destination PC.
7930 We ignore the CFA and set a temporary breakpoint at HANDLER.
7931 This is not extremely efficient but it avoids issues in gdb
7932 with computing the DWARF CFA, and it also works even in weird
7933 cases such as throwing an exception from inside a signal
7936 b
= SYMBOL_BLOCK_VALUE (func
);
7937 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7939 if (!SYMBOL_IS_ARGUMENT (sym
))
7946 insert_exception_resume_breakpoint (ecs
->event_thread
,
7952 catch (const gdb_exception_error
&e
)
7958 stop_waiting (struct execution_control_state
*ecs
)
7960 infrun_debug_printf ("stop_waiting");
7962 /* Let callers know we don't want to wait for the inferior anymore. */
7963 ecs
->wait_some_more
= 0;
7965 /* If all-stop, but there exists a non-stop target, stop all
7966 threads now that we're presenting the stop to the user. */
7967 if (!non_stop
&& exists_non_stop_target ())
7968 stop_all_threads ();
7971 /* Like keep_going, but passes the signal to the inferior, even if the
7972 signal is set to nopass. */
7975 keep_going_pass_signal (struct execution_control_state
*ecs
)
7977 gdb_assert (ecs
->event_thread
->ptid
== inferior_ptid
);
7978 gdb_assert (!ecs
->event_thread
->resumed ());
7980 /* Save the pc before execution, to compare with pc after stop. */
7981 ecs
->event_thread
->prev_pc
7982 = regcache_read_pc_protected (get_thread_regcache (ecs
->event_thread
));
7984 if (ecs
->event_thread
->control
.trap_expected
)
7986 struct thread_info
*tp
= ecs
->event_thread
;
7988 infrun_debug_printf ("%s has trap_expected set, "
7989 "resuming to collect trap",
7990 target_pid_to_str (tp
->ptid
).c_str ());
7992 /* We haven't yet gotten our trap, and either: intercepted a
7993 non-signal event (e.g., a fork); or took a signal which we
7994 are supposed to pass through to the inferior. Simply
7996 resume (ecs
->event_thread
->stop_signal ());
7998 else if (step_over_info_valid_p ())
8000 /* Another thread is stepping over a breakpoint in-line. If
8001 this thread needs a step-over too, queue the request. In
8002 either case, this resume must be deferred for later. */
8003 struct thread_info
*tp
= ecs
->event_thread
;
8005 if (ecs
->hit_singlestep_breakpoint
8006 || thread_still_needs_step_over (tp
))
8008 infrun_debug_printf ("step-over already in progress: "
8009 "step-over for %s deferred",
8010 target_pid_to_str (tp
->ptid
).c_str ());
8011 global_thread_step_over_chain_enqueue (tp
);
8015 infrun_debug_printf ("step-over in progress: resume of %s deferred",
8016 target_pid_to_str (tp
->ptid
).c_str ());
8021 struct regcache
*regcache
= get_current_regcache ();
8024 step_over_what step_what
;
8026 /* Either the trap was not expected, but we are continuing
8027 anyway (if we got a signal, the user asked it be passed to
8030 We got our expected trap, but decided we should resume from
8033 We're going to run this baby now!
8035 Note that insert_breakpoints won't try to re-insert
8036 already inserted breakpoints. Therefore, we don't
8037 care if breakpoints were already inserted, or not. */
8039 /* If we need to step over a breakpoint, and we're not using
8040 displaced stepping to do so, insert all breakpoints
8041 (watchpoints, etc.) but the one we're stepping over, step one
8042 instruction, and then re-insert the breakpoint when that step
8045 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
8047 remove_bp
= (ecs
->hit_singlestep_breakpoint
8048 || (step_what
& STEP_OVER_BREAKPOINT
));
8049 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
8051 /* We can't use displaced stepping if we need to step past a
8052 watchpoint. The instruction copied to the scratch pad would
8053 still trigger the watchpoint. */
8055 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
8057 set_step_over_info (regcache
->aspace (),
8058 regcache_read_pc (regcache
), remove_wps
,
8059 ecs
->event_thread
->global_num
);
8061 else if (remove_wps
)
8062 set_step_over_info (NULL
, 0, remove_wps
, -1);
8064 /* If we now need to do an in-line step-over, we need to stop
8065 all other threads. Note this must be done before
8066 insert_breakpoints below, because that removes the breakpoint
8067 we're about to step over, otherwise other threads could miss
8069 if (step_over_info_valid_p () && target_is_non_stop_p ())
8070 stop_all_threads ();
8072 /* Stop stepping if inserting breakpoints fails. */
8075 insert_breakpoints ();
8077 catch (const gdb_exception_error
&e
)
8079 exception_print (gdb_stderr
, e
);
8081 clear_step_over_info ();
8085 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
8087 resume (ecs
->event_thread
->stop_signal ());
8090 prepare_to_wait (ecs
);
8093 /* Called when we should continue running the inferior, because the
8094 current event doesn't cause a user visible stop. This does the
8095 resuming part; waiting for the next event is done elsewhere. */
8098 keep_going (struct execution_control_state
*ecs
)
8100 if (ecs
->event_thread
->control
.trap_expected
8101 && ecs
->event_thread
->stop_signal () == GDB_SIGNAL_TRAP
)
8102 ecs
->event_thread
->control
.trap_expected
= 0;
8104 if (!signal_program
[ecs
->event_thread
->stop_signal ()])
8105 ecs
->event_thread
->set_stop_signal (GDB_SIGNAL_0
);
8106 keep_going_pass_signal (ecs
);
8109 /* This function normally comes after a resume, before
8110 handle_inferior_event exits. It takes care of any last bits of
8111 housekeeping, and sets the all-important wait_some_more flag. */
8114 prepare_to_wait (struct execution_control_state
*ecs
)
8116 infrun_debug_printf ("prepare_to_wait");
8118 ecs
->wait_some_more
= 1;
8120 /* If the target can't async, emulate it by marking the infrun event
8121 handler such that as soon as we get back to the event-loop, we
8122 immediately end up in fetch_inferior_event again calling
8124 if (!target_can_async_p ())
8125 mark_infrun_async_event_handler ();
8128 /* We are done with the step range of a step/next/si/ni command.
8129 Called once for each n of a "step n" operation. */
8132 end_stepping_range (struct execution_control_state
*ecs
)
8134 ecs
->event_thread
->control
.stop_step
= 1;
8138 /* Several print_*_reason functions to print why the inferior has stopped.
8139 We always print something when the inferior exits, or receives a signal.
8140 The rest of the cases are dealt with later on in normal_stop and
8141 print_it_typical. Ideally there should be a call to one of these
8142 print_*_reason functions functions from handle_inferior_event each time
8143 stop_waiting is called.
8145 Note that we don't call these directly, instead we delegate that to
8146 the interpreters, through observers. Interpreters then call these
8147 with whatever uiout is right. */
8150 print_end_stepping_range_reason (struct ui_out
*uiout
)
8152 /* For CLI-like interpreters, print nothing. */
8154 if (uiout
->is_mi_like_p ())
8156 uiout
->field_string ("reason",
8157 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
8162 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
8164 annotate_signalled ();
8165 if (uiout
->is_mi_like_p ())
8167 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
8168 uiout
->text ("\nProgram terminated with signal ");
8169 annotate_signal_name ();
8170 uiout
->field_string ("signal-name",
8171 gdb_signal_to_name (siggnal
));
8172 annotate_signal_name_end ();
8174 annotate_signal_string ();
8175 uiout
->field_string ("signal-meaning",
8176 gdb_signal_to_string (siggnal
));
8177 annotate_signal_string_end ();
8178 uiout
->text (".\n");
8179 uiout
->text ("The program no longer exists.\n");
8183 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
8185 struct inferior
*inf
= current_inferior ();
8186 std::string pidstr
= target_pid_to_str (ptid_t (inf
->pid
));
8188 annotate_exited (exitstatus
);
8191 if (uiout
->is_mi_like_p ())
8192 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED
));
8193 std::string exit_code_str
8194 = string_printf ("0%o", (unsigned int) exitstatus
);
8195 uiout
->message ("[Inferior %s (%s) exited with code %pF]\n",
8196 plongest (inf
->num
), pidstr
.c_str (),
8197 string_field ("exit-code", exit_code_str
.c_str ()));
8201 if (uiout
->is_mi_like_p ())
8203 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
8204 uiout
->message ("[Inferior %s (%s) exited normally]\n",
8205 plongest (inf
->num
), pidstr
.c_str ());
8210 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
8212 struct thread_info
*thr
= inferior_thread ();
8216 if (uiout
->is_mi_like_p ())
8218 else if (show_thread_that_caused_stop ())
8222 uiout
->text ("\nThread ");
8223 uiout
->field_string ("thread-id", print_thread_id (thr
));
8225 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
8228 uiout
->text (" \"");
8229 uiout
->field_string ("name", name
);
8234 uiout
->text ("\nProgram");
8236 if (siggnal
== GDB_SIGNAL_0
&& !uiout
->is_mi_like_p ())
8237 uiout
->text (" stopped");
8240 uiout
->text (" received signal ");
8241 annotate_signal_name ();
8242 if (uiout
->is_mi_like_p ())
8244 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
8245 uiout
->field_string ("signal-name", gdb_signal_to_name (siggnal
));
8246 annotate_signal_name_end ();
8248 annotate_signal_string ();
8249 uiout
->field_string ("signal-meaning", gdb_signal_to_string (siggnal
));
8251 struct regcache
*regcache
= get_current_regcache ();
8252 struct gdbarch
*gdbarch
= regcache
->arch ();
8253 if (gdbarch_report_signal_info_p (gdbarch
))
8254 gdbarch_report_signal_info (gdbarch
, uiout
, siggnal
);
8256 annotate_signal_string_end ();
8258 uiout
->text (".\n");
8262 print_no_history_reason (struct ui_out
*uiout
)
8264 uiout
->text ("\nNo more reverse-execution history.\n");
8267 /* Print current location without a level number, if we have changed
8268 functions or hit a breakpoint. Print source line if we have one.
8269 bpstat_print contains the logic deciding in detail what to print,
8270 based on the event(s) that just occurred. */
8273 print_stop_location (struct target_waitstatus
*ws
)
8276 enum print_what source_flag
;
8277 int do_frame_printing
= 1;
8278 struct thread_info
*tp
= inferior_thread ();
8280 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
8284 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8285 should) carry around the function and does (or should) use
8286 that when doing a frame comparison. */
8287 if (tp
->control
.stop_step
8288 && frame_id_eq (tp
->control
.step_frame_id
,
8289 get_frame_id (get_current_frame ()))
8290 && (tp
->control
.step_start_function
8291 == find_pc_function (tp
->stop_pc ())))
8293 /* Finished step, just print source line. */
8294 source_flag
= SRC_LINE
;
8298 /* Print location and source line. */
8299 source_flag
= SRC_AND_LOC
;
8302 case PRINT_SRC_AND_LOC
:
8303 /* Print location and source line. */
8304 source_flag
= SRC_AND_LOC
;
8306 case PRINT_SRC_ONLY
:
8307 source_flag
= SRC_LINE
;
8310 /* Something bogus. */
8311 source_flag
= SRC_LINE
;
8312 do_frame_printing
= 0;
8315 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
8318 /* The behavior of this routine with respect to the source
8320 SRC_LINE: Print only source line
8321 LOCATION: Print only location
8322 SRC_AND_LOC: Print location and source line. */
8323 if (do_frame_printing
)
8324 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
8330 print_stop_event (struct ui_out
*uiout
, bool displays
)
8332 struct target_waitstatus last
;
8333 struct thread_info
*tp
;
8335 get_last_target_status (nullptr, nullptr, &last
);
8338 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
8340 print_stop_location (&last
);
8342 /* Display the auto-display expressions. */
8347 tp
= inferior_thread ();
8348 if (tp
->thread_fsm
!= NULL
8349 && tp
->thread_fsm
->finished_p ())
8351 struct return_value_info
*rv
;
8353 rv
= tp
->thread_fsm
->return_value ();
8355 print_return_value (uiout
, rv
);
8362 maybe_remove_breakpoints (void)
8364 if (!breakpoints_should_be_inserted_now () && target_has_execution ())
8366 if (remove_breakpoints ())
8368 target_terminal::ours_for_output ();
8369 printf_filtered (_("Cannot remove breakpoints because "
8370 "program is no longer writable.\nFurther "
8371 "execution is probably impossible.\n"));
8376 /* The execution context that just caused a normal stop. */
8382 DISABLE_COPY_AND_ASSIGN (stop_context
);
8384 bool changed () const;
8389 /* The event PTID. */
8393 /* If stopp for a thread event, this is the thread that caused the
8395 thread_info_ref thread
;
8397 /* The inferior that caused the stop. */
8401 /* Initializes a new stop context. If stopped for a thread event, this
8402 takes a strong reference to the thread. */
8404 stop_context::stop_context ()
8406 stop_id
= get_stop_id ();
8407 ptid
= inferior_ptid
;
8408 inf_num
= current_inferior ()->num
;
8410 if (inferior_ptid
!= null_ptid
)
8412 /* Take a strong reference so that the thread can't be deleted
8414 thread
= thread_info_ref::new_reference (inferior_thread ());
8418 /* Return true if the current context no longer matches the saved stop
8422 stop_context::changed () const
8424 if (ptid
!= inferior_ptid
)
8426 if (inf_num
!= current_inferior ()->num
)
8428 if (thread
!= NULL
&& thread
->state
!= THREAD_STOPPED
)
8430 if (get_stop_id () != stop_id
)
8440 struct target_waitstatus last
;
8442 get_last_target_status (nullptr, nullptr, &last
);
8446 /* If an exception is thrown from this point on, make sure to
8447 propagate GDB's knowledge of the executing state to the
8448 frontend/user running state. A QUIT is an easy exception to see
8449 here, so do this before any filtered output. */
8451 ptid_t finish_ptid
= null_ptid
;
8454 finish_ptid
= minus_one_ptid
;
8455 else if (last
.kind
== TARGET_WAITKIND_SIGNALLED
8456 || last
.kind
== TARGET_WAITKIND_EXITED
)
8458 /* On some targets, we may still have live threads in the
8459 inferior when we get a process exit event. E.g., for
8460 "checkpoint", when the current checkpoint/fork exits,
8461 linux-fork.c automatically switches to another fork from
8462 within target_mourn_inferior. */
8463 if (inferior_ptid
!= null_ptid
)
8464 finish_ptid
= ptid_t (inferior_ptid
.pid ());
8466 else if (last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8467 finish_ptid
= inferior_ptid
;
8469 gdb::optional
<scoped_finish_thread_state
> maybe_finish_thread_state
;
8470 if (finish_ptid
!= null_ptid
)
8472 maybe_finish_thread_state
.emplace
8473 (user_visible_resume_target (finish_ptid
), finish_ptid
);
8476 /* As we're presenting a stop, and potentially removing breakpoints,
8477 update the thread list so we can tell whether there are threads
8478 running on the target. With target remote, for example, we can
8479 only learn about new threads when we explicitly update the thread
8480 list. Do this before notifying the interpreters about signal
8481 stops, end of stepping ranges, etc., so that the "new thread"
8482 output is emitted before e.g., "Program received signal FOO",
8483 instead of after. */
8484 update_thread_list ();
8486 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
8487 gdb::observers::signal_received
.notify (inferior_thread ()->stop_signal ());
8489 /* As with the notification of thread events, we want to delay
8490 notifying the user that we've switched thread context until
8491 the inferior actually stops.
8493 There's no point in saying anything if the inferior has exited.
8494 Note that SIGNALLED here means "exited with a signal", not
8495 "received a signal".
8497 Also skip saying anything in non-stop mode. In that mode, as we
8498 don't want GDB to switch threads behind the user's back, to avoid
8499 races where the user is typing a command to apply to thread x,
8500 but GDB switches to thread y before the user finishes entering
8501 the command, fetch_inferior_event installs a cleanup to restore
8502 the current thread back to the thread the user had selected right
8503 after this event is handled, so we're not really switching, only
8504 informing of a stop. */
8506 && previous_inferior_ptid
!= inferior_ptid
8507 && target_has_execution ()
8508 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
8509 && last
.kind
!= TARGET_WAITKIND_EXITED
8510 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8512 SWITCH_THRU_ALL_UIS ()
8514 target_terminal::ours_for_output ();
8515 printf_filtered (_("[Switching to %s]\n"),
8516 target_pid_to_str (inferior_ptid
).c_str ());
8517 annotate_thread_changed ();
8519 previous_inferior_ptid
= inferior_ptid
;
8522 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
8524 SWITCH_THRU_ALL_UIS ()
8525 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
8527 target_terminal::ours_for_output ();
8528 printf_filtered (_("No unwaited-for children left.\n"));
8532 /* Note: this depends on the update_thread_list call above. */
8533 maybe_remove_breakpoints ();
8535 /* If an auto-display called a function and that got a signal,
8536 delete that auto-display to avoid an infinite recursion. */
8538 if (stopped_by_random_signal
)
8539 disable_current_display ();
8541 SWITCH_THRU_ALL_UIS ()
8543 async_enable_stdin ();
8546 /* Let the user/frontend see the threads as stopped. */
8547 maybe_finish_thread_state
.reset ();
8549 /* Select innermost stack frame - i.e., current frame is frame 0,
8550 and current location is based on that. Handle the case where the
8551 dummy call is returning after being stopped. E.g. the dummy call
8552 previously hit a breakpoint. (If the dummy call returns
8553 normally, we won't reach here.) Do this before the stop hook is
8554 run, so that it doesn't get to see the temporary dummy frame,
8555 which is not where we'll present the stop. */
8556 if (has_stack_frames ())
8558 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
8560 /* Pop the empty frame that contains the stack dummy. This
8561 also restores inferior state prior to the call (struct
8562 infcall_suspend_state). */
8563 struct frame_info
*frame
= get_current_frame ();
8565 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
8567 /* frame_pop calls reinit_frame_cache as the last thing it
8568 does which means there's now no selected frame. */
8571 select_frame (get_current_frame ());
8573 /* Set the current source location. */
8574 set_current_sal_from_frame (get_current_frame ());
8577 /* Look up the hook_stop and run it (CLI internally handles problem
8578 of stop_command's pre-hook not existing). */
8579 if (stop_command
!= NULL
)
8581 stop_context saved_context
;
8585 execute_cmd_pre_hook (stop_command
);
8587 catch (const gdb_exception
&ex
)
8589 exception_fprintf (gdb_stderr
, ex
,
8590 "Error while running hook_stop:\n");
8593 /* If the stop hook resumes the target, then there's no point in
8594 trying to notify about the previous stop; its context is
8595 gone. Likewise if the command switches thread or inferior --
8596 the observers would print a stop for the wrong
8598 if (saved_context
.changed ())
8602 /* Notify observers about the stop. This is where the interpreters
8603 print the stop event. */
8604 if (inferior_ptid
!= null_ptid
)
8605 gdb::observers::normal_stop
.notify (inferior_thread ()->control
.stop_bpstat
,
8608 gdb::observers::normal_stop
.notify (NULL
, stop_print_frame
);
8610 annotate_stopped ();
8612 if (target_has_execution ())
8614 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
8615 && last
.kind
!= TARGET_WAITKIND_EXITED
8616 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8617 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8618 Delete any breakpoint that is to be deleted at the next stop. */
8619 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
8622 /* Try to get rid of automatically added inferiors that are no
8623 longer needed. Keeping those around slows down things linearly.
8624 Note that this never removes the current inferior. */
8631 signal_stop_state (int signo
)
8633 return signal_stop
[signo
];
8637 signal_print_state (int signo
)
8639 return signal_print
[signo
];
8643 signal_pass_state (int signo
)
8645 return signal_program
[signo
];
8649 signal_cache_update (int signo
)
8653 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
8654 signal_cache_update (signo
);
8659 signal_pass
[signo
] = (signal_stop
[signo
] == 0
8660 && signal_print
[signo
] == 0
8661 && signal_program
[signo
] == 1
8662 && signal_catch
[signo
] == 0);
8666 signal_stop_update (int signo
, int state
)
8668 int ret
= signal_stop
[signo
];
8670 signal_stop
[signo
] = state
;
8671 signal_cache_update (signo
);
8676 signal_print_update (int signo
, int state
)
8678 int ret
= signal_print
[signo
];
8680 signal_print
[signo
] = state
;
8681 signal_cache_update (signo
);
8686 signal_pass_update (int signo
, int state
)
8688 int ret
= signal_program
[signo
];
8690 signal_program
[signo
] = state
;
8691 signal_cache_update (signo
);
8695 /* Update the global 'signal_catch' from INFO and notify the
8699 signal_catch_update (const unsigned int *info
)
8703 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8704 signal_catch
[i
] = info
[i
] > 0;
8705 signal_cache_update (-1);
8706 target_pass_signals (signal_pass
);
8710 sig_print_header (void)
8712 printf_filtered (_("Signal Stop\tPrint\tPass "
8713 "to program\tDescription\n"));
8717 sig_print_info (enum gdb_signal oursig
)
8719 const char *name
= gdb_signal_to_name (oursig
);
8720 int name_padding
= 13 - strlen (name
);
8722 if (name_padding
<= 0)
8725 printf_filtered ("%s", name
);
8726 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8727 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8728 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8729 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8730 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8733 /* Specify how various signals in the inferior should be handled. */
8736 handle_command (const char *args
, int from_tty
)
8738 int digits
, wordlen
;
8739 int sigfirst
, siglast
;
8740 enum gdb_signal oursig
;
8745 error_no_arg (_("signal to handle"));
8748 /* Allocate and zero an array of flags for which signals to handle. */
8750 const size_t nsigs
= GDB_SIGNAL_LAST
;
8751 unsigned char sigs
[nsigs
] {};
8753 /* Break the command line up into args. */
8755 gdb_argv
built_argv (args
);
8757 /* Walk through the args, looking for signal oursigs, signal names, and
8758 actions. Signal numbers and signal names may be interspersed with
8759 actions, with the actions being performed for all signals cumulatively
8760 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8762 for (char *arg
: built_argv
)
8764 wordlen
= strlen (arg
);
8765 for (digits
= 0; isdigit (arg
[digits
]); digits
++)
8769 sigfirst
= siglast
= -1;
8771 if (wordlen
>= 1 && !strncmp (arg
, "all", wordlen
))
8773 /* Apply action to all signals except those used by the
8774 debugger. Silently skip those. */
8777 siglast
= nsigs
- 1;
8779 else if (wordlen
>= 1 && !strncmp (arg
, "stop", wordlen
))
8781 SET_SIGS (nsigs
, sigs
, signal_stop
);
8782 SET_SIGS (nsigs
, sigs
, signal_print
);
8784 else if (wordlen
>= 1 && !strncmp (arg
, "ignore", wordlen
))
8786 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8788 else if (wordlen
>= 2 && !strncmp (arg
, "print", wordlen
))
8790 SET_SIGS (nsigs
, sigs
, signal_print
);
8792 else if (wordlen
>= 2 && !strncmp (arg
, "pass", wordlen
))
8794 SET_SIGS (nsigs
, sigs
, signal_program
);
8796 else if (wordlen
>= 3 && !strncmp (arg
, "nostop", wordlen
))
8798 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8800 else if (wordlen
>= 3 && !strncmp (arg
, "noignore", wordlen
))
8802 SET_SIGS (nsigs
, sigs
, signal_program
);
8804 else if (wordlen
>= 4 && !strncmp (arg
, "noprint", wordlen
))
8806 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8807 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8809 else if (wordlen
>= 4 && !strncmp (arg
, "nopass", wordlen
))
8811 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8813 else if (digits
> 0)
8815 /* It is numeric. The numeric signal refers to our own
8816 internal signal numbering from target.h, not to host/target
8817 signal number. This is a feature; users really should be
8818 using symbolic names anyway, and the common ones like
8819 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8821 sigfirst
= siglast
= (int)
8822 gdb_signal_from_command (atoi (arg
));
8823 if (arg
[digits
] == '-')
8826 gdb_signal_from_command (atoi (arg
+ digits
+ 1));
8828 if (sigfirst
> siglast
)
8830 /* Bet he didn't figure we'd think of this case... */
8831 std::swap (sigfirst
, siglast
);
8836 oursig
= gdb_signal_from_name (arg
);
8837 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8839 sigfirst
= siglast
= (int) oursig
;
8843 /* Not a number and not a recognized flag word => complain. */
8844 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg
);
8848 /* If any signal numbers or symbol names were found, set flags for
8849 which signals to apply actions to. */
8851 for (int signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8853 switch ((enum gdb_signal
) signum
)
8855 case GDB_SIGNAL_TRAP
:
8856 case GDB_SIGNAL_INT
:
8857 if (!allsigs
&& !sigs
[signum
])
8859 if (query (_("%s is used by the debugger.\n\
8860 Are you sure you want to change it? "),
8861 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8866 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8870 case GDB_SIGNAL_DEFAULT
:
8871 case GDB_SIGNAL_UNKNOWN
:
8872 /* Make sure that "all" doesn't print these. */
8881 for (int signum
= 0; signum
< nsigs
; signum
++)
8884 signal_cache_update (-1);
8885 target_pass_signals (signal_pass
);
8886 target_program_signals (signal_program
);
8890 /* Show the results. */
8891 sig_print_header ();
8892 for (; signum
< nsigs
; signum
++)
8894 sig_print_info ((enum gdb_signal
) signum
);
8901 /* Complete the "handle" command. */
8904 handle_completer (struct cmd_list_element
*ignore
,
8905 completion_tracker
&tracker
,
8906 const char *text
, const char *word
)
8908 static const char * const keywords
[] =
8922 signal_completer (ignore
, tracker
, text
, word
);
8923 complete_on_enum (tracker
, keywords
, word
, word
);
8927 gdb_signal_from_command (int num
)
8929 if (num
>= 1 && num
<= 15)
8930 return (enum gdb_signal
) num
;
8931 error (_("Only signals 1-15 are valid as numeric signals.\n\
8932 Use \"info signals\" for a list of symbolic signals."));
8935 /* Print current contents of the tables set by the handle command.
8936 It is possible we should just be printing signals actually used
8937 by the current target (but for things to work right when switching
8938 targets, all signals should be in the signal tables). */
8941 info_signals_command (const char *signum_exp
, int from_tty
)
8943 enum gdb_signal oursig
;
8945 sig_print_header ();
8949 /* First see if this is a symbol name. */
8950 oursig
= gdb_signal_from_name (signum_exp
);
8951 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8953 /* No, try numeric. */
8955 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8957 sig_print_info (oursig
);
8961 printf_filtered ("\n");
8962 /* These ugly casts brought to you by the native VAX compiler. */
8963 for (oursig
= GDB_SIGNAL_FIRST
;
8964 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8965 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8969 if (oursig
!= GDB_SIGNAL_UNKNOWN
8970 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8971 sig_print_info (oursig
);
8974 printf_filtered (_("\nUse the \"handle\" command "
8975 "to change these tables.\n"));
8978 /* The $_siginfo convenience variable is a bit special. We don't know
8979 for sure the type of the value until we actually have a chance to
8980 fetch the data. The type can change depending on gdbarch, so it is
8981 also dependent on which thread you have selected.
8983 1. making $_siginfo be an internalvar that creates a new value on
8986 2. making the value of $_siginfo be an lval_computed value. */
8988 /* This function implements the lval_computed support for reading a
8992 siginfo_value_read (struct value
*v
)
8994 LONGEST transferred
;
8996 /* If we can access registers, so can we access $_siginfo. Likewise
8998 validate_registers_access ();
9001 target_read (current_inferior ()->top_target (),
9002 TARGET_OBJECT_SIGNAL_INFO
,
9004 value_contents_all_raw (v
),
9006 TYPE_LENGTH (value_type (v
)));
9008 if (transferred
!= TYPE_LENGTH (value_type (v
)))
9009 error (_("Unable to read siginfo"));
9012 /* This function implements the lval_computed support for writing a
9016 siginfo_value_write (struct value
*v
, struct value
*fromval
)
9018 LONGEST transferred
;
9020 /* If we can access registers, so can we access $_siginfo. Likewise
9022 validate_registers_access ();
9024 transferred
= target_write (current_inferior ()->top_target (),
9025 TARGET_OBJECT_SIGNAL_INFO
,
9027 value_contents_all_raw (fromval
),
9029 TYPE_LENGTH (value_type (fromval
)));
9031 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
9032 error (_("Unable to write siginfo"));
9035 static const struct lval_funcs siginfo_value_funcs
=
9041 /* Return a new value with the correct type for the siginfo object of
9042 the current thread using architecture GDBARCH. Return a void value
9043 if there's no object available. */
9045 static struct value
*
9046 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
9049 if (target_has_stack ()
9050 && inferior_ptid
!= null_ptid
9051 && gdbarch_get_siginfo_type_p (gdbarch
))
9053 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9055 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
9058 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
9062 /* infcall_suspend_state contains state about the program itself like its
9063 registers and any signal it received when it last stopped.
9064 This state must be restored regardless of how the inferior function call
9065 ends (either successfully, or after it hits a breakpoint or signal)
9066 if the program is to properly continue where it left off. */
9068 class infcall_suspend_state
9071 /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
9072 once the inferior function call has finished. */
9073 infcall_suspend_state (struct gdbarch
*gdbarch
,
9074 const struct thread_info
*tp
,
9075 struct regcache
*regcache
)
9076 : m_registers (new readonly_detached_regcache (*regcache
))
9078 tp
->save_suspend_to (m_thread_suspend
);
9080 gdb::unique_xmalloc_ptr
<gdb_byte
> siginfo_data
;
9082 if (gdbarch_get_siginfo_type_p (gdbarch
))
9084 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9085 size_t len
= TYPE_LENGTH (type
);
9087 siginfo_data
.reset ((gdb_byte
*) xmalloc (len
));
9089 if (target_read (current_inferior ()->top_target (),
9090 TARGET_OBJECT_SIGNAL_INFO
, NULL
,
9091 siginfo_data
.get (), 0, len
) != len
)
9093 /* Errors ignored. */
9094 siginfo_data
.reset (nullptr);
9100 m_siginfo_gdbarch
= gdbarch
;
9101 m_siginfo_data
= std::move (siginfo_data
);
9105 /* Return a pointer to the stored register state. */
9107 readonly_detached_regcache
*registers () const
9109 return m_registers
.get ();
9112 /* Restores the stored state into GDBARCH, TP, and REGCACHE. */
9114 void restore (struct gdbarch
*gdbarch
,
9115 struct thread_info
*tp
,
9116 struct regcache
*regcache
) const
9118 tp
->restore_suspend_from (m_thread_suspend
);
9120 if (m_siginfo_gdbarch
== gdbarch
)
9122 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9124 /* Errors ignored. */
9125 target_write (current_inferior ()->top_target (),
9126 TARGET_OBJECT_SIGNAL_INFO
, NULL
,
9127 m_siginfo_data
.get (), 0, TYPE_LENGTH (type
));
9130 /* The inferior can be gone if the user types "print exit(0)"
9131 (and perhaps other times). */
9132 if (target_has_execution ())
9133 /* NB: The register write goes through to the target. */
9134 regcache
->restore (registers ());
9138 /* How the current thread stopped before the inferior function call was
9140 struct thread_suspend_state m_thread_suspend
;
9142 /* The registers before the inferior function call was executed. */
9143 std::unique_ptr
<readonly_detached_regcache
> m_registers
;
9145 /* Format of SIGINFO_DATA or NULL if it is not present. */
9146 struct gdbarch
*m_siginfo_gdbarch
= nullptr;
9148 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
9149 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
9150 content would be invalid. */
9151 gdb::unique_xmalloc_ptr
<gdb_byte
> m_siginfo_data
;
9154 infcall_suspend_state_up
9155 save_infcall_suspend_state ()
9157 struct thread_info
*tp
= inferior_thread ();
9158 struct regcache
*regcache
= get_current_regcache ();
9159 struct gdbarch
*gdbarch
= regcache
->arch ();
9161 infcall_suspend_state_up inf_state
9162 (new struct infcall_suspend_state (gdbarch
, tp
, regcache
));
9164 /* Having saved the current state, adjust the thread state, discarding
9165 any stop signal information. The stop signal is not useful when
9166 starting an inferior function call, and run_inferior_call will not use
9167 the signal due to its `proceed' call with GDB_SIGNAL_0. */
9168 tp
->set_stop_signal (GDB_SIGNAL_0
);
9173 /* Restore inferior session state to INF_STATE. */
9176 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
9178 struct thread_info
*tp
= inferior_thread ();
9179 struct regcache
*regcache
= get_current_regcache ();
9180 struct gdbarch
*gdbarch
= regcache
->arch ();
9182 inf_state
->restore (gdbarch
, tp
, regcache
);
9183 discard_infcall_suspend_state (inf_state
);
9187 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
9192 readonly_detached_regcache
*
9193 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
9195 return inf_state
->registers ();
9198 /* infcall_control_state contains state regarding gdb's control of the
9199 inferior itself like stepping control. It also contains session state like
9200 the user's currently selected frame. */
9202 struct infcall_control_state
9204 struct thread_control_state thread_control
;
9205 struct inferior_control_state inferior_control
;
9208 enum stop_stack_kind stop_stack_dummy
= STOP_NONE
;
9209 int stopped_by_random_signal
= 0;
9211 /* ID and level of the selected frame when the inferior function
9213 struct frame_id selected_frame_id
{};
9214 int selected_frame_level
= -1;
9217 /* Save all of the information associated with the inferior<==>gdb
9220 infcall_control_state_up
9221 save_infcall_control_state ()
9223 infcall_control_state_up
inf_status (new struct infcall_control_state
);
9224 struct thread_info
*tp
= inferior_thread ();
9225 struct inferior
*inf
= current_inferior ();
9227 inf_status
->thread_control
= tp
->control
;
9228 inf_status
->inferior_control
= inf
->control
;
9230 tp
->control
.step_resume_breakpoint
= NULL
;
9231 tp
->control
.exception_resume_breakpoint
= NULL
;
9233 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
9234 chain. If caller's caller is walking the chain, they'll be happier if we
9235 hand them back the original chain when restore_infcall_control_state is
9237 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
9240 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
9241 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
9243 save_selected_frame (&inf_status
->selected_frame_id
,
9244 &inf_status
->selected_frame_level
);
9249 /* Restore inferior session state to INF_STATUS. */
9252 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
9254 struct thread_info
*tp
= inferior_thread ();
9255 struct inferior
*inf
= current_inferior ();
9257 if (tp
->control
.step_resume_breakpoint
)
9258 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
9260 if (tp
->control
.exception_resume_breakpoint
)
9261 tp
->control
.exception_resume_breakpoint
->disposition
9262 = disp_del_at_next_stop
;
9264 /* Handle the bpstat_copy of the chain. */
9265 bpstat_clear (&tp
->control
.stop_bpstat
);
9267 tp
->control
= inf_status
->thread_control
;
9268 inf
->control
= inf_status
->inferior_control
;
9271 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
9272 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
9274 if (target_has_stack ())
9276 restore_selected_frame (inf_status
->selected_frame_id
,
9277 inf_status
->selected_frame_level
);
9284 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
9286 if (inf_status
->thread_control
.step_resume_breakpoint
)
9287 inf_status
->thread_control
.step_resume_breakpoint
->disposition
9288 = disp_del_at_next_stop
;
9290 if (inf_status
->thread_control
.exception_resume_breakpoint
)
9291 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
9292 = disp_del_at_next_stop
;
9294 /* See save_infcall_control_state for info on stop_bpstat. */
9295 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
9303 clear_exit_convenience_vars (void)
9305 clear_internalvar (lookup_internalvar ("_exitsignal"));
9306 clear_internalvar (lookup_internalvar ("_exitcode"));
9310 /* User interface for reverse debugging:
9311 Set exec-direction / show exec-direction commands
9312 (returns error unless target implements to_set_exec_direction method). */
9314 enum exec_direction_kind execution_direction
= EXEC_FORWARD
;
9315 static const char exec_forward
[] = "forward";
9316 static const char exec_reverse
[] = "reverse";
9317 static const char *exec_direction
= exec_forward
;
9318 static const char *const exec_direction_names
[] = {
9325 set_exec_direction_func (const char *args
, int from_tty
,
9326 struct cmd_list_element
*cmd
)
9328 if (target_can_execute_reverse ())
9330 if (!strcmp (exec_direction
, exec_forward
))
9331 execution_direction
= EXEC_FORWARD
;
9332 else if (!strcmp (exec_direction
, exec_reverse
))
9333 execution_direction
= EXEC_REVERSE
;
9337 exec_direction
= exec_forward
;
9338 error (_("Target does not support this operation."));
9343 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
9344 struct cmd_list_element
*cmd
, const char *value
)
9346 switch (execution_direction
) {
9348 fprintf_filtered (out
, _("Forward.\n"));
9351 fprintf_filtered (out
, _("Reverse.\n"));
9354 internal_error (__FILE__
, __LINE__
,
9355 _("bogus execution_direction value: %d"),
9356 (int) execution_direction
);
9361 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
9362 struct cmd_list_element
*c
, const char *value
)
9364 fprintf_filtered (file
, _("Resuming the execution of threads "
9365 "of all processes is %s.\n"), value
);
9368 /* Implementation of `siginfo' variable. */
9370 static const struct internalvar_funcs siginfo_funcs
=
9377 /* Callback for infrun's target events source. This is marked when a
9378 thread has a pending status to process. */
9381 infrun_async_inferior_event_handler (gdb_client_data data
)
9383 clear_async_event_handler (infrun_async_inferior_event_token
);
9384 inferior_event_handler (INF_REG_EVENT
);
9391 /* Verify that when two threads with the same ptid exist (from two different
9392 targets) and one of them changes ptid, we only update inferior_ptid if
9393 it is appropriate. */
9396 infrun_thread_ptid_changed ()
9398 gdbarch
*arch
= current_inferior ()->gdbarch
;
9400 /* The thread which inferior_ptid represents changes ptid. */
9402 scoped_restore_current_pspace_and_thread restore
;
9404 scoped_mock_context
<test_target_ops
> target1 (arch
);
9405 scoped_mock_context
<test_target_ops
> target2 (arch
);
9407 ptid_t
old_ptid (111, 222);
9408 ptid_t
new_ptid (111, 333);
9410 target1
.mock_inferior
.pid
= old_ptid
.pid ();
9411 target1
.mock_thread
.ptid
= old_ptid
;
9412 target1
.mock_inferior
.ptid_thread_map
.clear ();
9413 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
9415 target2
.mock_inferior
.pid
= old_ptid
.pid ();
9416 target2
.mock_thread
.ptid
= old_ptid
;
9417 target2
.mock_inferior
.ptid_thread_map
.clear ();
9418 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
9420 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
9421 set_current_inferior (&target1
.mock_inferior
);
9423 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
9425 gdb_assert (inferior_ptid
== new_ptid
);
9428 /* A thread with the same ptid as inferior_ptid, but from another target,
9431 scoped_restore_current_pspace_and_thread restore
;
9433 scoped_mock_context
<test_target_ops
> target1 (arch
);
9434 scoped_mock_context
<test_target_ops
> target2 (arch
);
9436 ptid_t
old_ptid (111, 222);
9437 ptid_t
new_ptid (111, 333);
9439 target1
.mock_inferior
.pid
= old_ptid
.pid ();
9440 target1
.mock_thread
.ptid
= old_ptid
;
9441 target1
.mock_inferior
.ptid_thread_map
.clear ();
9442 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
9444 target2
.mock_inferior
.pid
= old_ptid
.pid ();
9445 target2
.mock_thread
.ptid
= old_ptid
;
9446 target2
.mock_inferior
.ptid_thread_map
.clear ();
9447 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
9449 auto restore_inferior_ptid
= make_scoped_restore (&inferior_ptid
, old_ptid
);
9450 set_current_inferior (&target2
.mock_inferior
);
9452 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
9454 gdb_assert (inferior_ptid
== old_ptid
);
9458 } /* namespace selftests */
9460 #endif /* GDB_SELF_TEST */
9462 void _initialize_infrun ();
9464 _initialize_infrun ()
9466 struct cmd_list_element
*c
;
9468 /* Register extra event sources in the event loop. */
9469 infrun_async_inferior_event_token
9470 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
,
9473 cmd_list_element
*info_signals_cmd
9474 = add_info ("signals", info_signals_command
, _("\
9475 What debugger does when program gets various signals.\n\
9476 Specify a signal as argument to print info on that signal only."));
9477 add_info_alias ("handle", info_signals_cmd
, 0);
9479 c
= add_com ("handle", class_run
, handle_command
, _("\
9480 Specify how to handle signals.\n\
9481 Usage: handle SIGNAL [ACTIONS]\n\
9482 Args are signals and actions to apply to those signals.\n\
9483 If no actions are specified, the current settings for the specified signals\n\
9484 will be displayed instead.\n\
9486 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9487 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9488 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9489 The special arg \"all\" is recognized to mean all signals except those\n\
9490 used by the debugger, typically SIGTRAP and SIGINT.\n\
9492 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9493 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9494 Stop means reenter debugger if this signal happens (implies print).\n\
9495 Print means print a message if this signal happens.\n\
9496 Pass means let program see this signal; otherwise program doesn't know.\n\
9497 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9498 Pass and Stop may be combined.\n\
9500 Multiple signals may be specified. Signal numbers and signal names\n\
9501 may be interspersed with actions, with the actions being performed for\n\
9502 all signals cumulatively specified."));
9503 set_cmd_completer (c
, handle_completer
);
9506 stop_command
= add_cmd ("stop", class_obscure
,
9507 not_just_help_class_command
, _("\
9508 There is no `stop' command, but you can set a hook on `stop'.\n\
9509 This allows you to set a list of commands to be run each time execution\n\
9510 of the program stops."), &cmdlist
);
9512 add_setshow_boolean_cmd
9513 ("infrun", class_maintenance
, &debug_infrun
,
9514 _("Set inferior debugging."),
9515 _("Show inferior debugging."),
9516 _("When non-zero, inferior specific debugging is enabled."),
9517 NULL
, show_debug_infrun
, &setdebuglist
, &showdebuglist
);
9519 add_setshow_boolean_cmd ("non-stop", no_class
,
9521 Set whether gdb controls the inferior in non-stop mode."), _("\
9522 Show whether gdb controls the inferior in non-stop mode."), _("\
9523 When debugging a multi-threaded program and this setting is\n\
9524 off (the default, also called all-stop mode), when one thread stops\n\
9525 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9526 all other threads in the program while you interact with the thread of\n\
9527 interest. When you continue or step a thread, you can allow the other\n\
9528 threads to run, or have them remain stopped, but while you inspect any\n\
9529 thread's state, all threads stop.\n\
9531 In non-stop mode, when one thread stops, other threads can continue\n\
9532 to run freely. You'll be able to step each thread independently,\n\
9533 leave it stopped or free to run as needed."),
9539 for (size_t i
= 0; i
< GDB_SIGNAL_LAST
; i
++)
9542 signal_print
[i
] = 1;
9543 signal_program
[i
] = 1;
9544 signal_catch
[i
] = 0;
9547 /* Signals caused by debugger's own actions should not be given to
9548 the program afterwards.
9550 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9551 explicitly specifies that it should be delivered to the target
9552 program. Typically, that would occur when a user is debugging a
9553 target monitor on a simulator: the target monitor sets a
9554 breakpoint; the simulator encounters this breakpoint and halts
9555 the simulation handing control to GDB; GDB, noting that the stop
9556 address doesn't map to any known breakpoint, returns control back
9557 to the simulator; the simulator then delivers the hardware
9558 equivalent of a GDB_SIGNAL_TRAP to the program being
9560 signal_program
[GDB_SIGNAL_TRAP
] = 0;
9561 signal_program
[GDB_SIGNAL_INT
] = 0;
9563 /* Signals that are not errors should not normally enter the debugger. */
9564 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
9565 signal_print
[GDB_SIGNAL_ALRM
] = 0;
9566 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
9567 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
9568 signal_stop
[GDB_SIGNAL_PROF
] = 0;
9569 signal_print
[GDB_SIGNAL_PROF
] = 0;
9570 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
9571 signal_print
[GDB_SIGNAL_CHLD
] = 0;
9572 signal_stop
[GDB_SIGNAL_IO
] = 0;
9573 signal_print
[GDB_SIGNAL_IO
] = 0;
9574 signal_stop
[GDB_SIGNAL_POLL
] = 0;
9575 signal_print
[GDB_SIGNAL_POLL
] = 0;
9576 signal_stop
[GDB_SIGNAL_URG
] = 0;
9577 signal_print
[GDB_SIGNAL_URG
] = 0;
9578 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
9579 signal_print
[GDB_SIGNAL_WINCH
] = 0;
9580 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
9581 signal_print
[GDB_SIGNAL_PRIO
] = 0;
9583 /* These signals are used internally by user-level thread
9584 implementations. (See signal(5) on Solaris.) Like the above
9585 signals, a healthy program receives and handles them as part of
9586 its normal operation. */
9587 signal_stop
[GDB_SIGNAL_LWP
] = 0;
9588 signal_print
[GDB_SIGNAL_LWP
] = 0;
9589 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
9590 signal_print
[GDB_SIGNAL_WAITING
] = 0;
9591 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
9592 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
9593 signal_stop
[GDB_SIGNAL_LIBRT
] = 0;
9594 signal_print
[GDB_SIGNAL_LIBRT
] = 0;
9596 /* Update cached state. */
9597 signal_cache_update (-1);
9599 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
9600 &stop_on_solib_events
, _("\
9601 Set stopping for shared library events."), _("\
9602 Show stopping for shared library events."), _("\
9603 If nonzero, gdb will give control to the user when the dynamic linker\n\
9604 notifies gdb of shared library events. The most common event of interest\n\
9605 to the user would be loading/unloading of a new library."),
9606 set_stop_on_solib_events
,
9607 show_stop_on_solib_events
,
9608 &setlist
, &showlist
);
9610 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
9611 follow_fork_mode_kind_names
,
9612 &follow_fork_mode_string
, _("\
9613 Set debugger response to a program call of fork or vfork."), _("\
9614 Show debugger response to a program call of fork or vfork."), _("\
9615 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9616 parent - the original process is debugged after a fork\n\
9617 child - the new process is debugged after a fork\n\
9618 The unfollowed process will continue to run.\n\
9619 By default, the debugger will follow the parent process."),
9621 show_follow_fork_mode_string
,
9622 &setlist
, &showlist
);
9624 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
9625 follow_exec_mode_names
,
9626 &follow_exec_mode_string
, _("\
9627 Set debugger response to a program call of exec."), _("\
9628 Show debugger response to a program call of exec."), _("\
9629 An exec call replaces the program image of a process.\n\
9631 follow-exec-mode can be:\n\
9633 new - the debugger creates a new inferior and rebinds the process\n\
9634 to this new inferior. The program the process was running before\n\
9635 the exec call can be restarted afterwards by restarting the original\n\
9638 same - the debugger keeps the process bound to the same inferior.\n\
9639 The new executable image replaces the previous executable loaded in\n\
9640 the inferior. Restarting the inferior after the exec call restarts\n\
9641 the executable the process was running after the exec call.\n\
9643 By default, the debugger will use the same inferior."),
9645 show_follow_exec_mode_string
,
9646 &setlist
, &showlist
);
9648 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9649 scheduler_enums
, &scheduler_mode
, _("\
9650 Set mode for locking scheduler during execution."), _("\
9651 Show mode for locking scheduler during execution."), _("\
9652 off == no locking (threads may preempt at any time)\n\
9653 on == full locking (no thread except the current thread may run)\n\
9654 This applies to both normal execution and replay mode.\n\
9655 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9656 In this mode, other threads may run during other commands.\n\
9657 This applies to both normal execution and replay mode.\n\
9658 replay == scheduler locked in replay mode and unlocked during normal execution."),
9659 set_schedlock_func
, /* traps on target vector */
9660 show_scheduler_mode
,
9661 &setlist
, &showlist
);
9663 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9664 Set mode for resuming threads of all processes."), _("\
9665 Show mode for resuming threads of all processes."), _("\
9666 When on, execution commands (such as 'continue' or 'next') resume all\n\
9667 threads of all processes. When off (which is the default), execution\n\
9668 commands only resume the threads of the current process. The set of\n\
9669 threads that are resumed is further refined by the scheduler-locking\n\
9670 mode (see help set scheduler-locking)."),
9672 show_schedule_multiple
,
9673 &setlist
, &showlist
);
9675 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9676 Set mode of the step operation."), _("\
9677 Show mode of the step operation."), _("\
9678 When set, doing a step over a function without debug line information\n\
9679 will stop at the first instruction of that function. Otherwise, the\n\
9680 function is skipped and the step command stops at a different source line."),
9682 show_step_stop_if_no_debug
,
9683 &setlist
, &showlist
);
9685 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9686 &can_use_displaced_stepping
, _("\
9687 Set debugger's willingness to use displaced stepping."), _("\
9688 Show debugger's willingness to use displaced stepping."), _("\
9689 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9690 supported by the target architecture. If off, gdb will not use displaced\n\
9691 stepping to step over breakpoints, even if such is supported by the target\n\
9692 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9693 if the target architecture supports it and non-stop mode is active, but will not\n\
9694 use it in all-stop mode (see help set non-stop)."),
9696 show_can_use_displaced_stepping
,
9697 &setlist
, &showlist
);
9699 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9700 &exec_direction
, _("Set direction of execution.\n\
9701 Options are 'forward' or 'reverse'."),
9702 _("Show direction of execution (forward/reverse)."),
9703 _("Tells gdb whether to execute forward or backward."),
9704 set_exec_direction_func
, show_exec_direction_func
,
9705 &setlist
, &showlist
);
9707 /* Set/show detach-on-fork: user-settable mode. */
9709 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9710 Set whether gdb will detach the child of a fork."), _("\
9711 Show whether gdb will detach the child of a fork."), _("\
9712 Tells gdb whether to detach the child of a fork."),
9713 NULL
, NULL
, &setlist
, &showlist
);
9715 /* Set/show disable address space randomization mode. */
9717 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9718 &disable_randomization
, _("\
9719 Set disabling of debuggee's virtual address space randomization."), _("\
9720 Show disabling of debuggee's virtual address space randomization."), _("\
9721 When this mode is on (which is the default), randomization of the virtual\n\
9722 address space is disabled. Standalone programs run with the randomization\n\
9723 enabled by default on some platforms."),
9724 &set_disable_randomization
,
9725 &show_disable_randomization
,
9726 &setlist
, &showlist
);
9728 /* ptid initializations */
9729 inferior_ptid
= null_ptid
;
9730 target_last_wait_ptid
= minus_one_ptid
;
9732 gdb::observers::thread_ptid_changed
.attach (infrun_thread_ptid_changed
,
9734 gdb::observers::thread_stop_requested
.attach (infrun_thread_stop_requested
,
9736 gdb::observers::thread_exit
.attach (infrun_thread_thread_exit
, "infrun");
9737 gdb::observers::inferior_exit
.attach (infrun_inferior_exit
, "infrun");
9738 gdb::observers::inferior_execd
.attach (infrun_inferior_execd
, "infrun");
9740 /* Explicitly create without lookup, since that tries to create a
9741 value with a void typed value, and when we get here, gdbarch
9742 isn't initialized yet. At this point, we're quite sure there
9743 isn't another convenience variable of the same name. */
9744 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9746 add_setshow_boolean_cmd ("observer", no_class
,
9747 &observer_mode_1
, _("\
9748 Set whether gdb controls the inferior in observer mode."), _("\
9749 Show whether gdb controls the inferior in observer mode."), _("\
9750 In observer mode, GDB can get data from the inferior, but not\n\
9751 affect its execution. Registers and memory may not be changed,\n\
9752 breakpoints may not be set, and the program cannot be interrupted\n\
9760 selftests::register_test ("infrun_thread_ptid_changed",
9761 selftests::infrun_thread_ptid_changed
);