1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2020 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
31 #include "target-connection.h"
32 #include "gdbthread.h"
39 #include "observable.h"
44 #include "mi/mi-common.h"
45 #include "event-top.h"
47 #include "record-full.h"
48 #include "inline-frame.h"
50 #include "tracepoint.h"
54 #include "completer.h"
55 #include "target-descriptions.h"
56 #include "target-dcache.h"
59 #include "event-loop.h"
60 #include "thread-fsm.h"
61 #include "gdbsupport/enum-flags.h"
62 #include "progspace-and-thread.h"
63 #include "gdbsupport/gdb_optional.h"
64 #include "arch-utils.h"
65 #include "gdbsupport/scope-exit.h"
66 #include "gdbsupport/forward-scope-exit.h"
67 #include "gdb_select.h"
68 #include <unordered_map>
70 /* Prototypes for local functions */
72 static void sig_print_info (enum gdb_signal
);
74 static void sig_print_header (void);
76 static int follow_fork (void);
78 static int follow_fork_inferior (int follow_child
, int detach_fork
);
80 static void follow_inferior_reset_breakpoints (void);
82 static int currently_stepping (struct thread_info
*tp
);
84 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
86 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
88 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
90 static int maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
);
92 static void resume (gdb_signal sig
);
94 static void wait_for_inferior (inferior
*inf
);
96 /* Asynchronous signal handler registered as event loop source for
97 when we have pending events ready to be passed to the core. */
98 static struct async_event_handler
*infrun_async_inferior_event_token
;
100 /* Stores whether infrun_async was previously enabled or disabled.
101 Starts off as -1, indicating "never enabled/disabled". */
102 static int infrun_is_async
= -1;
107 infrun_async (int enable
)
109 if (infrun_is_async
!= enable
)
111 infrun_is_async
= enable
;
114 fprintf_unfiltered (gdb_stdlog
,
115 "infrun: infrun_async(%d)\n",
119 mark_async_event_handler (infrun_async_inferior_event_token
);
121 clear_async_event_handler (infrun_async_inferior_event_token
);
128 mark_infrun_async_event_handler (void)
130 mark_async_event_handler (infrun_async_inferior_event_token
);
133 /* When set, stop the 'step' command if we enter a function which has
134 no line number information. The normal behavior is that we step
135 over such function. */
136 bool step_stop_if_no_debug
= false;
138 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
139 struct cmd_list_element
*c
, const char *value
)
141 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
144 /* proceed and normal_stop use this to notify the user when the
145 inferior stopped in a different thread than it had been running
148 static ptid_t previous_inferior_ptid
;
150 /* If set (default for legacy reasons), when following a fork, GDB
151 will detach from one of the fork branches, child or parent.
152 Exactly which branch is detached depends on 'set follow-fork-mode'
155 static bool detach_fork
= true;
157 bool debug_displaced
= false;
159 show_debug_displaced (struct ui_file
*file
, int from_tty
,
160 struct cmd_list_element
*c
, const char *value
)
162 fprintf_filtered (file
, _("Displace stepping debugging is %s.\n"), value
);
165 unsigned int debug_infrun
= 0;
167 show_debug_infrun (struct ui_file
*file
, int from_tty
,
168 struct cmd_list_element
*c
, const char *value
)
170 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
174 /* Support for disabling address space randomization. */
176 bool disable_randomization
= true;
179 show_disable_randomization (struct ui_file
*file
, int from_tty
,
180 struct cmd_list_element
*c
, const char *value
)
182 if (target_supports_disable_randomization ())
183 fprintf_filtered (file
,
184 _("Disabling randomization of debuggee's "
185 "virtual address space is %s.\n"),
188 fputs_filtered (_("Disabling randomization of debuggee's "
189 "virtual address space is unsupported on\n"
190 "this platform.\n"), file
);
194 set_disable_randomization (const char *args
, int from_tty
,
195 struct cmd_list_element
*c
)
197 if (!target_supports_disable_randomization ())
198 error (_("Disabling randomization of debuggee's "
199 "virtual address space is unsupported on\n"
203 /* User interface for non-stop mode. */
205 bool non_stop
= false;
206 static bool non_stop_1
= false;
209 set_non_stop (const char *args
, int from_tty
,
210 struct cmd_list_element
*c
)
212 if (target_has_execution
)
214 non_stop_1
= non_stop
;
215 error (_("Cannot change this setting while the inferior is running."));
218 non_stop
= non_stop_1
;
222 show_non_stop (struct ui_file
*file
, int from_tty
,
223 struct cmd_list_element
*c
, const char *value
)
225 fprintf_filtered (file
,
226 _("Controlling the inferior in non-stop mode is %s.\n"),
230 /* "Observer mode" is somewhat like a more extreme version of
231 non-stop, in which all GDB operations that might affect the
232 target's execution have been disabled. */
234 bool observer_mode
= false;
235 static bool observer_mode_1
= false;
238 set_observer_mode (const char *args
, int from_tty
,
239 struct cmd_list_element
*c
)
241 if (target_has_execution
)
243 observer_mode_1
= observer_mode
;
244 error (_("Cannot change this setting while the inferior is running."));
247 observer_mode
= observer_mode_1
;
249 may_write_registers
= !observer_mode
;
250 may_write_memory
= !observer_mode
;
251 may_insert_breakpoints
= !observer_mode
;
252 may_insert_tracepoints
= !observer_mode
;
253 /* We can insert fast tracepoints in or out of observer mode,
254 but enable them if we're going into this mode. */
256 may_insert_fast_tracepoints
= true;
257 may_stop
= !observer_mode
;
258 update_target_permissions ();
260 /* Going *into* observer mode we must force non-stop, then
261 going out we leave it that way. */
264 pagination_enabled
= 0;
265 non_stop
= non_stop_1
= true;
269 printf_filtered (_("Observer mode is now %s.\n"),
270 (observer_mode
? "on" : "off"));
274 show_observer_mode (struct ui_file
*file
, int from_tty
,
275 struct cmd_list_element
*c
, const char *value
)
277 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
280 /* This updates the value of observer mode based on changes in
281 permissions. Note that we are deliberately ignoring the values of
282 may-write-registers and may-write-memory, since the user may have
283 reason to enable these during a session, for instance to turn on a
284 debugging-related global. */
287 update_observer_mode (void)
289 bool newval
= (!may_insert_breakpoints
290 && !may_insert_tracepoints
291 && may_insert_fast_tracepoints
295 /* Let the user know if things change. */
296 if (newval
!= observer_mode
)
297 printf_filtered (_("Observer mode is now %s.\n"),
298 (newval
? "on" : "off"));
300 observer_mode
= observer_mode_1
= newval
;
303 /* Tables of how to react to signals; the user sets them. */
305 static unsigned char signal_stop
[GDB_SIGNAL_LAST
];
306 static unsigned char signal_print
[GDB_SIGNAL_LAST
];
307 static unsigned char signal_program
[GDB_SIGNAL_LAST
];
309 /* Table of signals that are registered with "catch signal". A
310 non-zero entry indicates that the signal is caught by some "catch
312 static unsigned char signal_catch
[GDB_SIGNAL_LAST
];
314 /* Table of signals that the target may silently handle.
315 This is automatically determined from the flags above,
316 and simply cached here. */
317 static unsigned char signal_pass
[GDB_SIGNAL_LAST
];
319 #define SET_SIGS(nsigs,sigs,flags) \
321 int signum = (nsigs); \
322 while (signum-- > 0) \
323 if ((sigs)[signum]) \
324 (flags)[signum] = 1; \
327 #define UNSET_SIGS(nsigs,sigs,flags) \
329 int signum = (nsigs); \
330 while (signum-- > 0) \
331 if ((sigs)[signum]) \
332 (flags)[signum] = 0; \
335 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
336 this function is to avoid exporting `signal_program'. */
339 update_signals_program_target (void)
341 target_program_signals (signal_program
);
344 /* Value to pass to target_resume() to cause all threads to resume. */
346 #define RESUME_ALL minus_one_ptid
348 /* Command list pointer for the "stop" placeholder. */
350 static struct cmd_list_element
*stop_command
;
352 /* Nonzero if we want to give control to the user when we're notified
353 of shared library events by the dynamic linker. */
354 int stop_on_solib_events
;
356 /* Enable or disable optional shared library event breakpoints
357 as appropriate when the above flag is changed. */
360 set_stop_on_solib_events (const char *args
,
361 int from_tty
, struct cmd_list_element
*c
)
363 update_solib_breakpoints ();
367 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
368 struct cmd_list_element
*c
, const char *value
)
370 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
374 /* Nonzero after stop if current stack frame should be printed. */
376 static int stop_print_frame
;
378 /* This is a cached copy of the target/ptid/waitstatus of the last
379 event returned by target_wait()/deprecated_target_wait_hook().
380 This information is returned by get_last_target_status(). */
381 static process_stratum_target
*target_last_proc_target
;
382 static ptid_t target_last_wait_ptid
;
383 static struct target_waitstatus target_last_waitstatus
;
385 void init_thread_stepping_state (struct thread_info
*tss
);
387 static const char follow_fork_mode_child
[] = "child";
388 static const char follow_fork_mode_parent
[] = "parent";
390 static const char *const follow_fork_mode_kind_names
[] = {
391 follow_fork_mode_child
,
392 follow_fork_mode_parent
,
396 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
398 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
399 struct cmd_list_element
*c
, const char *value
)
401 fprintf_filtered (file
,
402 _("Debugger response to a program "
403 "call of fork or vfork is \"%s\".\n"),
408 /* Handle changes to the inferior list based on the type of fork,
409 which process is being followed, and whether the other process
410 should be detached. On entry inferior_ptid must be the ptid of
411 the fork parent. At return inferior_ptid is the ptid of the
412 followed inferior. */
415 follow_fork_inferior (int follow_child
, int detach_fork
)
418 ptid_t parent_ptid
, child_ptid
;
420 has_vforked
= (inferior_thread ()->pending_follow
.kind
421 == TARGET_WAITKIND_VFORKED
);
422 parent_ptid
= inferior_ptid
;
423 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
426 && !non_stop
/* Non-stop always resumes both branches. */
427 && current_ui
->prompt_state
== PROMPT_BLOCKED
428 && !(follow_child
|| detach_fork
|| sched_multi
))
430 /* The parent stays blocked inside the vfork syscall until the
431 child execs or exits. If we don't let the child run, then
432 the parent stays blocked. If we're telling the parent to run
433 in the foreground, the user will not be able to ctrl-c to get
434 back the terminal, effectively hanging the debug session. */
435 fprintf_filtered (gdb_stderr
, _("\
436 Can not resume the parent process over vfork in the foreground while\n\
437 holding the child stopped. Try \"set detach-on-fork\" or \
438 \"set schedule-multiple\".\n"));
444 /* Detach new forked process? */
447 /* Before detaching from the child, remove all breakpoints
448 from it. If we forked, then this has already been taken
449 care of by infrun.c. If we vforked however, any
450 breakpoint inserted in the parent is visible in the
451 child, even those added while stopped in a vfork
452 catchpoint. This will remove the breakpoints from the
453 parent also, but they'll be reinserted below. */
456 /* Keep breakpoints list in sync. */
457 remove_breakpoints_inf (current_inferior ());
460 if (print_inferior_events
)
462 /* Ensure that we have a process ptid. */
463 ptid_t process_ptid
= ptid_t (child_ptid
.pid ());
465 target_terminal::ours_for_output ();
466 fprintf_filtered (gdb_stdlog
,
467 _("[Detaching after %s from child %s]\n"),
468 has_vforked
? "vfork" : "fork",
469 target_pid_to_str (process_ptid
).c_str ());
474 struct inferior
*parent_inf
, *child_inf
;
476 /* Add process to GDB's tables. */
477 child_inf
= add_inferior (child_ptid
.pid ());
479 parent_inf
= current_inferior ();
480 child_inf
->attach_flag
= parent_inf
->attach_flag
;
481 copy_terminal_info (child_inf
, parent_inf
);
482 child_inf
->gdbarch
= parent_inf
->gdbarch
;
483 copy_inferior_target_desc_info (child_inf
, parent_inf
);
485 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
487 set_current_inferior (child_inf
);
488 switch_to_no_thread ();
489 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
490 push_target (parent_inf
->process_target ());
491 add_thread_silent (child_inf
->process_target (), child_ptid
);
492 inferior_ptid
= child_ptid
;
494 /* If this is a vfork child, then the address-space is
495 shared with the parent. */
498 child_inf
->pspace
= parent_inf
->pspace
;
499 child_inf
->aspace
= parent_inf
->aspace
;
503 /* The parent will be frozen until the child is done
504 with the shared region. Keep track of the
506 child_inf
->vfork_parent
= parent_inf
;
507 child_inf
->pending_detach
= 0;
508 parent_inf
->vfork_child
= child_inf
;
509 parent_inf
->pending_detach
= 0;
513 child_inf
->aspace
= new_address_space ();
514 child_inf
->pspace
= new program_space (child_inf
->aspace
);
515 child_inf
->removable
= 1;
516 set_current_program_space (child_inf
->pspace
);
517 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
519 /* Let the shared library layer (e.g., solib-svr4) learn
520 about this new process, relocate the cloned exec, pull
521 in shared libraries, and install the solib event
522 breakpoint. If a "cloned-VM" event was propagated
523 better throughout the core, this wouldn't be
525 solib_create_inferior_hook (0);
531 struct inferior
*parent_inf
;
533 parent_inf
= current_inferior ();
535 /* If we detached from the child, then we have to be careful
536 to not insert breakpoints in the parent until the child
537 is done with the shared memory region. However, if we're
538 staying attached to the child, then we can and should
539 insert breakpoints, so that we can debug it. A
540 subsequent child exec or exit is enough to know when does
541 the child stops using the parent's address space. */
542 parent_inf
->waiting_for_vfork_done
= detach_fork
;
543 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
548 /* Follow the child. */
549 struct inferior
*parent_inf
, *child_inf
;
550 struct program_space
*parent_pspace
;
552 if (print_inferior_events
)
554 std::string parent_pid
= target_pid_to_str (parent_ptid
);
555 std::string child_pid
= target_pid_to_str (child_ptid
);
557 target_terminal::ours_for_output ();
558 fprintf_filtered (gdb_stdlog
,
559 _("[Attaching after %s %s to child %s]\n"),
561 has_vforked
? "vfork" : "fork",
565 /* Add the new inferior first, so that the target_detach below
566 doesn't unpush the target. */
568 child_inf
= add_inferior (child_ptid
.pid ());
570 parent_inf
= current_inferior ();
571 child_inf
->attach_flag
= parent_inf
->attach_flag
;
572 copy_terminal_info (child_inf
, parent_inf
);
573 child_inf
->gdbarch
= parent_inf
->gdbarch
;
574 copy_inferior_target_desc_info (child_inf
, parent_inf
);
576 parent_pspace
= parent_inf
->pspace
;
578 process_stratum_target
*target
= parent_inf
->process_target ();
581 /* Hold a strong reference to the target while (maybe)
582 detaching the parent. Otherwise detaching could close the
584 auto target_ref
= target_ops_ref::new_reference (target
);
586 /* If we're vforking, we want to hold on to the parent until
587 the child exits or execs. At child exec or exit time we
588 can remove the old breakpoints from the parent and detach
589 or resume debugging it. Otherwise, detach the parent now;
590 we'll want to reuse it's program/address spaces, but we
591 can't set them to the child before removing breakpoints
592 from the parent, otherwise, the breakpoints module could
593 decide to remove breakpoints from the wrong process (since
594 they'd be assigned to the same address space). */
598 gdb_assert (child_inf
->vfork_parent
== NULL
);
599 gdb_assert (parent_inf
->vfork_child
== NULL
);
600 child_inf
->vfork_parent
= parent_inf
;
601 child_inf
->pending_detach
= 0;
602 parent_inf
->vfork_child
= child_inf
;
603 parent_inf
->pending_detach
= detach_fork
;
604 parent_inf
->waiting_for_vfork_done
= 0;
606 else if (detach_fork
)
608 if (print_inferior_events
)
610 /* Ensure that we have a process ptid. */
611 ptid_t process_ptid
= ptid_t (parent_ptid
.pid ());
613 target_terminal::ours_for_output ();
614 fprintf_filtered (gdb_stdlog
,
615 _("[Detaching after fork from "
617 target_pid_to_str (process_ptid
).c_str ());
620 target_detach (parent_inf
, 0);
624 /* Note that the detach above makes PARENT_INF dangling. */
626 /* Add the child thread to the appropriate lists, and switch
627 to this new thread, before cloning the program space, and
628 informing the solib layer about this new process. */
630 set_current_inferior (child_inf
);
631 push_target (target
);
634 add_thread_silent (target
, child_ptid
);
635 inferior_ptid
= child_ptid
;
637 /* If this is a vfork child, then the address-space is shared
638 with the parent. If we detached from the parent, then we can
639 reuse the parent's program/address spaces. */
640 if (has_vforked
|| detach_fork
)
642 child_inf
->pspace
= parent_pspace
;
643 child_inf
->aspace
= child_inf
->pspace
->aspace
;
649 child_inf
->aspace
= new_address_space ();
650 child_inf
->pspace
= new program_space (child_inf
->aspace
);
651 child_inf
->removable
= 1;
652 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
653 set_current_program_space (child_inf
->pspace
);
654 clone_program_space (child_inf
->pspace
, parent_pspace
);
656 /* Let the shared library layer (e.g., solib-svr4) learn
657 about this new process, relocate the cloned exec, pull in
658 shared libraries, and install the solib event breakpoint.
659 If a "cloned-VM" event was propagated better throughout
660 the core, this wouldn't be required. */
661 solib_create_inferior_hook (0);
665 return target_follow_fork (follow_child
, detach_fork
);
668 /* Tell the target to follow the fork we're stopped at. Returns true
669 if the inferior should be resumed; false, if the target for some
670 reason decided it's best not to resume. */
675 int follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
676 int should_resume
= 1;
677 struct thread_info
*tp
;
679 /* Copy user stepping state to the new inferior thread. FIXME: the
680 followed fork child thread should have a copy of most of the
681 parent thread structure's run control related fields, not just these.
682 Initialized to avoid "may be used uninitialized" warnings from gcc. */
683 struct breakpoint
*step_resume_breakpoint
= NULL
;
684 struct breakpoint
*exception_resume_breakpoint
= NULL
;
685 CORE_ADDR step_range_start
= 0;
686 CORE_ADDR step_range_end
= 0;
687 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
);
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 step_frame_id
= tp
->control
.step_frame_id
;
741 exception_resume_breakpoint
742 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
743 thread_fsm
= tp
->thread_fsm
;
745 /* For now, delete the parent's sr breakpoint, otherwise,
746 parent/child sr breakpoints are considered duplicates,
747 and the child version will not be installed. Remove
748 this when the breakpoints module becomes aware of
749 inferiors and address spaces. */
750 delete_step_resume_breakpoint (tp
);
751 tp
->control
.step_range_start
= 0;
752 tp
->control
.step_range_end
= 0;
753 tp
->control
.step_frame_id
= null_frame_id
;
754 delete_exception_resume_breakpoint (tp
);
755 tp
->thread_fsm
= NULL
;
758 parent
= inferior_ptid
;
759 child
= tp
->pending_follow
.value
.related_pid
;
761 process_stratum_target
*parent_targ
= tp
->inf
->process_target ();
762 /* Set up inferior(s) as specified by the caller, and tell the
763 target to do whatever is necessary to follow either parent
765 if (follow_fork_inferior (follow_child
, detach_fork
))
767 /* Target refused to follow, or there's some other reason
768 we shouldn't resume. */
773 /* This pending follow fork event is now handled, one way
774 or another. The previous selected thread may be gone
775 from the lists by now, but if it is still around, need
776 to clear the pending follow request. */
777 tp
= find_thread_ptid (parent_targ
, parent
);
779 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
781 /* This makes sure we don't try to apply the "Switched
782 over from WAIT_PID" logic above. */
783 nullify_last_target_wait_ptid ();
785 /* If we followed the child, switch to it... */
788 thread_info
*child_thr
= find_thread_ptid (parent_targ
, child
);
789 switch_to_thread (child_thr
);
791 /* ... and preserve the stepping state, in case the
792 user was stepping over the fork call. */
795 tp
= inferior_thread ();
796 tp
->control
.step_resume_breakpoint
797 = step_resume_breakpoint
;
798 tp
->control
.step_range_start
= step_range_start
;
799 tp
->control
.step_range_end
= step_range_end
;
800 tp
->control
.step_frame_id
= step_frame_id
;
801 tp
->control
.exception_resume_breakpoint
802 = exception_resume_breakpoint
;
803 tp
->thread_fsm
= thread_fsm
;
807 /* If we get here, it was because we're trying to
808 resume from a fork catchpoint, but, the user
809 has switched threads away from the thread that
810 forked. In that case, the resume command
811 issued is most likely not applicable to the
812 child, so just warn, and refuse to resume. */
813 warning (_("Not resuming: switched threads "
814 "before following fork child."));
817 /* Reset breakpoints in the child as appropriate. */
818 follow_inferior_reset_breakpoints ();
823 case TARGET_WAITKIND_SPURIOUS
:
824 /* Nothing to follow. */
827 internal_error (__FILE__
, __LINE__
,
828 "Unexpected pending_follow.kind %d\n",
829 tp
->pending_follow
.kind
);
833 return should_resume
;
837 follow_inferior_reset_breakpoints (void)
839 struct thread_info
*tp
= inferior_thread ();
841 /* Was there a step_resume breakpoint? (There was if the user
842 did a "next" at the fork() call.) If so, explicitly reset its
843 thread number. Cloned step_resume breakpoints are disabled on
844 creation, so enable it here now that it is associated with the
847 step_resumes are a form of bp that are made to be per-thread.
848 Since we created the step_resume bp when the parent process
849 was being debugged, and now are switching to the child process,
850 from the breakpoint package's viewpoint, that's a switch of
851 "threads". We must update the bp's notion of which thread
852 it is for, or it'll be ignored when it triggers. */
854 if (tp
->control
.step_resume_breakpoint
)
856 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
857 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
860 /* Treat exception_resume breakpoints like step_resume breakpoints. */
861 if (tp
->control
.exception_resume_breakpoint
)
863 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
864 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
867 /* Reinsert all breakpoints in the child. The user may have set
868 breakpoints after catching the fork, in which case those
869 were never set in the child, but only in the parent. This makes
870 sure the inserted breakpoints match the breakpoint list. */
872 breakpoint_re_set ();
873 insert_breakpoints ();
876 /* The child has exited or execed: resume threads of the parent the
877 user wanted to be executing. */
880 proceed_after_vfork_done (struct thread_info
*thread
,
883 int pid
= * (int *) arg
;
885 if (thread
->ptid
.pid () == pid
886 && thread
->state
== THREAD_RUNNING
887 && !thread
->executing
888 && !thread
->stop_requested
889 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
892 fprintf_unfiltered (gdb_stdlog
,
893 "infrun: resuming vfork parent thread %s\n",
894 target_pid_to_str (thread
->ptid
).c_str ());
896 switch_to_thread (thread
);
897 clear_proceed_status (0);
898 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
904 /* Save/restore inferior_ptid, current program space and current
905 inferior. Only use this if the current context points at an exited
906 inferior (and therefore there's no current thread to save). */
907 class scoped_restore_exited_inferior
910 scoped_restore_exited_inferior ()
911 : m_saved_ptid (&inferior_ptid
)
915 scoped_restore_tmpl
<ptid_t
> m_saved_ptid
;
916 scoped_restore_current_program_space m_pspace
;
917 scoped_restore_current_inferior m_inferior
;
920 /* Called whenever we notice an exec or exit event, to handle
921 detaching or resuming a vfork parent. */
924 handle_vfork_child_exec_or_exit (int exec
)
926 struct inferior
*inf
= current_inferior ();
928 if (inf
->vfork_parent
)
930 int resume_parent
= -1;
932 /* This exec or exit marks the end of the shared memory region
933 between the parent and the child. Break the bonds. */
934 inferior
*vfork_parent
= inf
->vfork_parent
;
935 inf
->vfork_parent
->vfork_child
= NULL
;
936 inf
->vfork_parent
= NULL
;
938 /* If the user wanted to detach from the parent, now is the
940 if (vfork_parent
->pending_detach
)
942 struct thread_info
*tp
;
943 struct program_space
*pspace
;
944 struct address_space
*aspace
;
946 /* follow-fork child, detach-on-fork on. */
948 vfork_parent
->pending_detach
= 0;
950 gdb::optional
<scoped_restore_exited_inferior
>
951 maybe_restore_inferior
;
952 gdb::optional
<scoped_restore_current_pspace_and_thread
>
953 maybe_restore_thread
;
955 /* If we're handling a child exit, then inferior_ptid points
956 at the inferior's pid, not to a thread. */
958 maybe_restore_inferior
.emplace ();
960 maybe_restore_thread
.emplace ();
962 /* We're letting loose of the parent. */
963 tp
= any_live_thread_of_inferior (vfork_parent
);
964 switch_to_thread (tp
);
966 /* We're about to detach from the parent, which implicitly
967 removes breakpoints from its address space. There's a
968 catch here: we want to reuse the spaces for the child,
969 but, parent/child are still sharing the pspace at this
970 point, although the exec in reality makes the kernel give
971 the child a fresh set of new pages. The problem here is
972 that the breakpoints module being unaware of this, would
973 likely chose the child process to write to the parent
974 address space. Swapping the child temporarily away from
975 the spaces has the desired effect. Yes, this is "sort
978 pspace
= inf
->pspace
;
979 aspace
= inf
->aspace
;
983 if (print_inferior_events
)
986 = target_pid_to_str (ptid_t (vfork_parent
->pid
));
988 target_terminal::ours_for_output ();
992 fprintf_filtered (gdb_stdlog
,
993 _("[Detaching vfork parent %s "
994 "after child exec]\n"), pidstr
.c_str ());
998 fprintf_filtered (gdb_stdlog
,
999 _("[Detaching vfork parent %s "
1000 "after child exit]\n"), pidstr
.c_str ());
1004 target_detach (vfork_parent
, 0);
1007 inf
->pspace
= pspace
;
1008 inf
->aspace
= aspace
;
1012 /* We're staying attached to the parent, so, really give the
1013 child a new address space. */
1014 inf
->pspace
= new program_space (maybe_new_address_space ());
1015 inf
->aspace
= inf
->pspace
->aspace
;
1017 set_current_program_space (inf
->pspace
);
1019 resume_parent
= vfork_parent
->pid
;
1023 struct program_space
*pspace
;
1025 /* If this is a vfork child exiting, then the pspace and
1026 aspaces were shared with the parent. Since we're
1027 reporting the process exit, we'll be mourning all that is
1028 found in the address space, and switching to null_ptid,
1029 preparing to start a new inferior. But, since we don't
1030 want to clobber the parent's address/program spaces, we
1031 go ahead and create a new one for this exiting
1034 /* Switch to null_ptid while running clone_program_space, so
1035 that clone_program_space doesn't want to read the
1036 selected frame of a dead process. */
1037 scoped_restore restore_ptid
1038 = make_scoped_restore (&inferior_ptid
, null_ptid
);
1040 /* This inferior is dead, so avoid giving the breakpoints
1041 module the option to write through to it (cloning a
1042 program space resets breakpoints). */
1045 pspace
= new program_space (maybe_new_address_space ());
1046 set_current_program_space (pspace
);
1048 inf
->symfile_flags
= SYMFILE_NO_READ
;
1049 clone_program_space (pspace
, vfork_parent
->pspace
);
1050 inf
->pspace
= pspace
;
1051 inf
->aspace
= pspace
->aspace
;
1053 resume_parent
= vfork_parent
->pid
;
1056 gdb_assert (current_program_space
== inf
->pspace
);
1058 if (non_stop
&& resume_parent
!= -1)
1060 /* If the user wanted the parent to be running, let it go
1062 scoped_restore_current_thread restore_thread
;
1065 fprintf_unfiltered (gdb_stdlog
,
1066 "infrun: resuming vfork parent process %d\n",
1069 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1074 /* Enum strings for "set|show follow-exec-mode". */
1076 static const char follow_exec_mode_new
[] = "new";
1077 static const char follow_exec_mode_same
[] = "same";
1078 static const char *const follow_exec_mode_names
[] =
1080 follow_exec_mode_new
,
1081 follow_exec_mode_same
,
1085 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1087 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1088 struct cmd_list_element
*c
, const char *value
)
1090 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1093 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1096 follow_exec (ptid_t ptid
, const char *exec_file_target
)
1098 struct inferior
*inf
= current_inferior ();
1099 int pid
= ptid
.pid ();
1100 ptid_t process_ptid
;
1102 /* Switch terminal for any messages produced e.g. by
1103 breakpoint_re_set. */
1104 target_terminal::ours_for_output ();
1106 /* This is an exec event that we actually wish to pay attention to.
1107 Refresh our symbol table to the newly exec'd program, remove any
1108 momentary bp's, etc.
1110 If there are breakpoints, they aren't really inserted now,
1111 since the exec() transformed our inferior into a fresh set
1114 We want to preserve symbolic breakpoints on the list, since
1115 we have hopes that they can be reset after the new a.out's
1116 symbol table is read.
1118 However, any "raw" breakpoints must be removed from the list
1119 (e.g., the solib bp's), since their address is probably invalid
1122 And, we DON'T want to call delete_breakpoints() here, since
1123 that may write the bp's "shadow contents" (the instruction
1124 value that was overwritten with a TRAP instruction). Since
1125 we now have a new a.out, those shadow contents aren't valid. */
1127 mark_breakpoints_out ();
1129 /* The target reports the exec event to the main thread, even if
1130 some other thread does the exec, and even if the main thread was
1131 stopped or already gone. We may still have non-leader threads of
1132 the process on our list. E.g., on targets that don't have thread
1133 exit events (like remote); or on native Linux in non-stop mode if
1134 there were only two threads in the inferior and the non-leader
1135 one is the one that execs (and nothing forces an update of the
1136 thread list up to here). When debugging remotely, it's best to
1137 avoid extra traffic, when possible, so avoid syncing the thread
1138 list with the target, and instead go ahead and delete all threads
1139 of the process but one that reported the event. Note this must
1140 be done before calling update_breakpoints_after_exec, as
1141 otherwise clearing the threads' resources would reference stale
1142 thread breakpoints -- it may have been one of these threads that
1143 stepped across the exec. We could just clear their stepping
1144 states, but as long as we're iterating, might as well delete
1145 them. Deleting them now rather than at the next user-visible
1146 stop provides a nicer sequence of events for user and MI
1148 for (thread_info
*th
: all_threads_safe ())
1149 if (th
->ptid
.pid () == pid
&& th
->ptid
!= ptid
)
1152 /* We also need to clear any left over stale state for the
1153 leader/event thread. E.g., if there was any step-resume
1154 breakpoint or similar, it's gone now. We cannot truly
1155 step-to-next statement through an exec(). */
1156 thread_info
*th
= inferior_thread ();
1157 th
->control
.step_resume_breakpoint
= NULL
;
1158 th
->control
.exception_resume_breakpoint
= NULL
;
1159 th
->control
.single_step_breakpoints
= NULL
;
1160 th
->control
.step_range_start
= 0;
1161 th
->control
.step_range_end
= 0;
1163 /* The user may have had the main thread held stopped in the
1164 previous image (e.g., schedlock on, or non-stop). Release
1166 th
->stop_requested
= 0;
1168 update_breakpoints_after_exec ();
1170 /* What is this a.out's name? */
1171 process_ptid
= ptid_t (pid
);
1172 printf_unfiltered (_("%s is executing new program: %s\n"),
1173 target_pid_to_str (process_ptid
).c_str (),
1176 /* We've followed the inferior through an exec. Therefore, the
1177 inferior has essentially been killed & reborn. */
1179 breakpoint_init_inferior (inf_execd
);
1181 gdb::unique_xmalloc_ptr
<char> exec_file_host
1182 = exec_file_find (exec_file_target
, NULL
);
1184 /* If we were unable to map the executable target pathname onto a host
1185 pathname, tell the user that. Otherwise GDB's subsequent behavior
1186 is confusing. Maybe it would even be better to stop at this point
1187 so that the user can specify a file manually before continuing. */
1188 if (exec_file_host
== NULL
)
1189 warning (_("Could not load symbols for executable %s.\n"
1190 "Do you need \"set sysroot\"?"),
1193 /* Reset the shared library package. This ensures that we get a
1194 shlib event when the child reaches "_start", at which point the
1195 dld will have had a chance to initialize the child. */
1196 /* Also, loading a symbol file below may trigger symbol lookups, and
1197 we don't want those to be satisfied by the libraries of the
1198 previous incarnation of this process. */
1199 no_shared_libraries (NULL
, 0);
1201 if (follow_exec_mode_string
== follow_exec_mode_new
)
1203 /* The user wants to keep the old inferior and program spaces
1204 around. Create a new fresh one, and switch to it. */
1206 /* Do exit processing for the original inferior before setting the new
1207 inferior's pid. Having two inferiors with the same pid would confuse
1208 find_inferior_p(t)id. Transfer the terminal state and info from the
1209 old to the new inferior. */
1210 inf
= add_inferior_with_spaces ();
1211 swap_terminal_info (inf
, current_inferior ());
1212 exit_inferior_silent (current_inferior ());
1215 target_follow_exec (inf
, exec_file_target
);
1217 inferior
*org_inferior
= current_inferior ();
1218 switch_to_inferior_no_thread (inf
);
1219 push_target (org_inferior
->process_target ());
1220 thread_info
*thr
= add_thread (inf
->process_target (), ptid
);
1221 switch_to_thread (thr
);
1225 /* The old description may no longer be fit for the new image.
1226 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1227 old description; we'll read a new one below. No need to do
1228 this on "follow-exec-mode new", as the old inferior stays
1229 around (its description is later cleared/refetched on
1231 target_clear_description ();
1234 gdb_assert (current_program_space
== inf
->pspace
);
1236 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1237 because the proper displacement for a PIE (Position Independent
1238 Executable) main symbol file will only be computed by
1239 solib_create_inferior_hook below. breakpoint_re_set would fail
1240 to insert the breakpoints with the zero displacement. */
1241 try_open_exec_file (exec_file_host
.get (), inf
, SYMFILE_DEFER_BP_RESET
);
1243 /* If the target can specify a description, read it. Must do this
1244 after flipping to the new executable (because the target supplied
1245 description must be compatible with the executable's
1246 architecture, and the old executable may e.g., be 32-bit, while
1247 the new one 64-bit), and before anything involving memory or
1249 target_find_description ();
1251 solib_create_inferior_hook (0);
1253 jit_inferior_created_hook ();
1255 breakpoint_re_set ();
1257 /* Reinsert all breakpoints. (Those which were symbolic have
1258 been reset to the proper address in the new a.out, thanks
1259 to symbol_file_command...). */
1260 insert_breakpoints ();
1262 /* The next resume of this inferior should bring it to the shlib
1263 startup breakpoints. (If the user had also set bp's on
1264 "main" from the old (parent) process, then they'll auto-
1265 matically get reset there in the new process.). */
1268 /* The queue of threads that need to do a step-over operation to get
1269 past e.g., a breakpoint. What technique is used to step over the
1270 breakpoint/watchpoint does not matter -- all threads end up in the
1271 same queue, to maintain rough temporal order of execution, in order
1272 to avoid starvation, otherwise, we could e.g., find ourselves
1273 constantly stepping the same couple threads past their breakpoints
1274 over and over, if the single-step finish fast enough. */
1275 struct thread_info
*step_over_queue_head
;
1277 /* Bit flags indicating what the thread needs to step over. */
1279 enum step_over_what_flag
1281 /* Step over a breakpoint. */
1282 STEP_OVER_BREAKPOINT
= 1,
1284 /* Step past a non-continuable watchpoint, in order to let the
1285 instruction execute so we can evaluate the watchpoint
1287 STEP_OVER_WATCHPOINT
= 2
1289 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag
, step_over_what
);
1291 /* Info about an instruction that is being stepped over. */
1293 struct step_over_info
1295 /* If we're stepping past a breakpoint, this is the address space
1296 and address of the instruction the breakpoint is set at. We'll
1297 skip inserting all breakpoints here. Valid iff ASPACE is
1299 const address_space
*aspace
;
1302 /* The instruction being stepped over triggers a nonsteppable
1303 watchpoint. If true, we'll skip inserting watchpoints. */
1304 int nonsteppable_watchpoint_p
;
1306 /* The thread's global number. */
1310 /* The step-over info of the location that is being stepped over.
1312 Note that with async/breakpoint always-inserted mode, a user might
1313 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1314 being stepped over. As setting a new breakpoint inserts all
1315 breakpoints, we need to make sure the breakpoint being stepped over
1316 isn't inserted then. We do that by only clearing the step-over
1317 info when the step-over is actually finished (or aborted).
1319 Presently GDB can only step over one breakpoint at any given time.
1320 Given threads that can't run code in the same address space as the
1321 breakpoint's can't really miss the breakpoint, GDB could be taught
1322 to step-over at most one breakpoint per address space (so this info
1323 could move to the address space object if/when GDB is extended).
1324 The set of breakpoints being stepped over will normally be much
1325 smaller than the set of all breakpoints, so a flag in the
1326 breakpoint location structure would be wasteful. A separate list
1327 also saves complexity and run-time, as otherwise we'd have to go
1328 through all breakpoint locations clearing their flag whenever we
1329 start a new sequence. Similar considerations weigh against storing
1330 this info in the thread object. Plus, not all step overs actually
1331 have breakpoint locations -- e.g., stepping past a single-step
1332 breakpoint, or stepping to complete a non-continuable
1334 static struct step_over_info step_over_info
;
1336 /* Record the address of the breakpoint/instruction we're currently
1338 N.B. We record the aspace and address now, instead of say just the thread,
1339 because when we need the info later the thread may be running. */
1342 set_step_over_info (const address_space
*aspace
, CORE_ADDR address
,
1343 int nonsteppable_watchpoint_p
,
1346 step_over_info
.aspace
= aspace
;
1347 step_over_info
.address
= address
;
1348 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1349 step_over_info
.thread
= thread
;
1352 /* Called when we're not longer stepping over a breakpoint / an
1353 instruction, so all breakpoints are free to be (re)inserted. */
1356 clear_step_over_info (void)
1359 fprintf_unfiltered (gdb_stdlog
,
1360 "infrun: clear_step_over_info\n");
1361 step_over_info
.aspace
= NULL
;
1362 step_over_info
.address
= 0;
1363 step_over_info
.nonsteppable_watchpoint_p
= 0;
1364 step_over_info
.thread
= -1;
1370 stepping_past_instruction_at (struct address_space
*aspace
,
1373 return (step_over_info
.aspace
!= NULL
1374 && breakpoint_address_match (aspace
, address
,
1375 step_over_info
.aspace
,
1376 step_over_info
.address
));
1382 thread_is_stepping_over_breakpoint (int thread
)
1384 return (step_over_info
.thread
!= -1
1385 && thread
== step_over_info
.thread
);
1391 stepping_past_nonsteppable_watchpoint (void)
1393 return step_over_info
.nonsteppable_watchpoint_p
;
1396 /* Returns true if step-over info is valid. */
1399 step_over_info_valid_p (void)
1401 return (step_over_info
.aspace
!= NULL
1402 || stepping_past_nonsteppable_watchpoint ());
1406 /* Displaced stepping. */
1408 /* In non-stop debugging mode, we must take special care to manage
1409 breakpoints properly; in particular, the traditional strategy for
1410 stepping a thread past a breakpoint it has hit is unsuitable.
1411 'Displaced stepping' is a tactic for stepping one thread past a
1412 breakpoint it has hit while ensuring that other threads running
1413 concurrently will hit the breakpoint as they should.
1415 The traditional way to step a thread T off a breakpoint in a
1416 multi-threaded program in all-stop mode is as follows:
1418 a0) Initially, all threads are stopped, and breakpoints are not
1420 a1) We single-step T, leaving breakpoints uninserted.
1421 a2) We insert breakpoints, and resume all threads.
1423 In non-stop debugging, however, this strategy is unsuitable: we
1424 don't want to have to stop all threads in the system in order to
1425 continue or step T past a breakpoint. Instead, we use displaced
1428 n0) Initially, T is stopped, other threads are running, and
1429 breakpoints are inserted.
1430 n1) We copy the instruction "under" the breakpoint to a separate
1431 location, outside the main code stream, making any adjustments
1432 to the instruction, register, and memory state as directed by
1434 n2) We single-step T over the instruction at its new location.
1435 n3) We adjust the resulting register and memory state as directed
1436 by T's architecture. This includes resetting T's PC to point
1437 back into the main instruction stream.
1440 This approach depends on the following gdbarch methods:
1442 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1443 indicate where to copy the instruction, and how much space must
1444 be reserved there. We use these in step n1.
1446 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1447 address, and makes any necessary adjustments to the instruction,
1448 register contents, and memory. We use this in step n1.
1450 - gdbarch_displaced_step_fixup adjusts registers and memory after
1451 we have successfully single-stepped the instruction, to yield the
1452 same effect the instruction would have had if we had executed it
1453 at its original address. We use this in step n3.
1455 The gdbarch_displaced_step_copy_insn and
1456 gdbarch_displaced_step_fixup functions must be written so that
1457 copying an instruction with gdbarch_displaced_step_copy_insn,
1458 single-stepping across the copied instruction, and then applying
1459 gdbarch_displaced_insn_fixup should have the same effects on the
1460 thread's memory and registers as stepping the instruction in place
1461 would have. Exactly which responsibilities fall to the copy and
1462 which fall to the fixup is up to the author of those functions.
1464 See the comments in gdbarch.sh for details.
1466 Note that displaced stepping and software single-step cannot
1467 currently be used in combination, although with some care I think
1468 they could be made to. Software single-step works by placing
1469 breakpoints on all possible subsequent instructions; if the
1470 displaced instruction is a PC-relative jump, those breakpoints
1471 could fall in very strange places --- on pages that aren't
1472 executable, or at addresses that are not proper instruction
1473 boundaries. (We do generally let other threads run while we wait
1474 to hit the software single-step breakpoint, and they might
1475 encounter such a corrupted instruction.) One way to work around
1476 this would be to have gdbarch_displaced_step_copy_insn fully
1477 simulate the effect of PC-relative instructions (and return NULL)
1478 on architectures that use software single-stepping.
1480 In non-stop mode, we can have independent and simultaneous step
1481 requests, so more than one thread may need to simultaneously step
1482 over a breakpoint. The current implementation assumes there is
1483 only one scratch space per process. In this case, we have to
1484 serialize access to the scratch space. If thread A wants to step
1485 over a breakpoint, but we are currently waiting for some other
1486 thread to complete a displaced step, we leave thread A stopped and
1487 place it in the displaced_step_request_queue. Whenever a displaced
1488 step finishes, we pick the next thread in the queue and start a new
1489 displaced step operation on it. See displaced_step_prepare and
1490 displaced_step_fixup for details. */
1492 /* Default destructor for displaced_step_closure. */
1494 displaced_step_closure::~displaced_step_closure () = default;
1496 /* Get the displaced stepping state of process PID. */
1498 static displaced_step_inferior_state
*
1499 get_displaced_stepping_state (inferior
*inf
)
1501 return &inf
->displaced_step_state
;
1504 /* Returns true if any inferior has a thread doing a displaced
1508 displaced_step_in_progress_any_inferior ()
1510 for (inferior
*i
: all_inferiors ())
1512 if (i
->displaced_step_state
.step_thread
!= nullptr)
1519 /* Return true if thread represented by PTID is doing a displaced
1523 displaced_step_in_progress_thread (thread_info
*thread
)
1525 gdb_assert (thread
!= NULL
);
1527 return get_displaced_stepping_state (thread
->inf
)->step_thread
== thread
;
1530 /* Return true if process PID has a thread doing a displaced step. */
1533 displaced_step_in_progress (inferior
*inf
)
1535 return get_displaced_stepping_state (inf
)->step_thread
!= nullptr;
1538 /* If inferior is in displaced stepping, and ADDR equals to starting address
1539 of copy area, return corresponding displaced_step_closure. Otherwise,
1542 struct displaced_step_closure
*
1543 get_displaced_step_closure_by_addr (CORE_ADDR addr
)
1545 displaced_step_inferior_state
*displaced
1546 = get_displaced_stepping_state (current_inferior ());
1548 /* If checking the mode of displaced instruction in copy area. */
1549 if (displaced
->step_thread
!= nullptr
1550 && displaced
->step_copy
== addr
)
1551 return displaced
->step_closure
;
1557 infrun_inferior_exit (struct inferior
*inf
)
1559 inf
->displaced_step_state
.reset ();
1562 /* If ON, and the architecture supports it, GDB will use displaced
1563 stepping to step over breakpoints. If OFF, or if the architecture
1564 doesn't support it, GDB will instead use the traditional
1565 hold-and-step approach. If AUTO (which is the default), GDB will
1566 decide which technique to use to step over breakpoints depending on
1567 which of all-stop or non-stop mode is active --- displaced stepping
1568 in non-stop mode; hold-and-step in all-stop mode. */
1570 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1573 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1574 struct cmd_list_element
*c
,
1577 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1578 fprintf_filtered (file
,
1579 _("Debugger's willingness to use displaced stepping "
1580 "to step over breakpoints is %s (currently %s).\n"),
1581 value
, target_is_non_stop_p () ? "on" : "off");
1583 fprintf_filtered (file
,
1584 _("Debugger's willingness to use displaced stepping "
1585 "to step over breakpoints is %s.\n"), value
);
1588 /* Return non-zero if displaced stepping can/should be used to step
1589 over breakpoints of thread TP. */
1592 use_displaced_stepping (struct thread_info
*tp
)
1594 struct regcache
*regcache
= get_thread_regcache (tp
);
1595 struct gdbarch
*gdbarch
= regcache
->arch ();
1596 displaced_step_inferior_state
*displaced_state
1597 = get_displaced_stepping_state (tp
->inf
);
1599 return (((can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1600 && target_is_non_stop_p ())
1601 || can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1602 && gdbarch_displaced_step_copy_insn_p (gdbarch
)
1603 && find_record_target () == NULL
1604 && !displaced_state
->failed_before
);
1607 /* Clean out any stray displaced stepping state. */
1609 displaced_step_clear (struct displaced_step_inferior_state
*displaced
)
1611 /* Indicate that there is no cleanup pending. */
1612 displaced
->step_thread
= nullptr;
1614 delete displaced
->step_closure
;
1615 displaced
->step_closure
= NULL
;
1618 /* A cleanup that wraps displaced_step_clear. */
1619 using displaced_step_clear_cleanup
1620 = FORWARD_SCOPE_EXIT (displaced_step_clear
);
1622 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1624 displaced_step_dump_bytes (struct ui_file
*file
,
1625 const gdb_byte
*buf
,
1630 for (i
= 0; i
< len
; i
++)
1631 fprintf_unfiltered (file
, "%02x ", buf
[i
]);
1632 fputs_unfiltered ("\n", file
);
1635 /* Prepare to single-step, using displaced stepping.
1637 Note that we cannot use displaced stepping when we have a signal to
1638 deliver. If we have a signal to deliver and an instruction to step
1639 over, then after the step, there will be no indication from the
1640 target whether the thread entered a signal handler or ignored the
1641 signal and stepped over the instruction successfully --- both cases
1642 result in a simple SIGTRAP. In the first case we mustn't do a
1643 fixup, and in the second case we must --- but we can't tell which.
1644 Comments in the code for 'random signals' in handle_inferior_event
1645 explain how we handle this case instead.
1647 Returns 1 if preparing was successful -- this thread is going to be
1648 stepped now; 0 if displaced stepping this thread got queued; or -1
1649 if this instruction can't be displaced stepped. */
1652 displaced_step_prepare_throw (thread_info
*tp
)
1654 regcache
*regcache
= get_thread_regcache (tp
);
1655 struct gdbarch
*gdbarch
= regcache
->arch ();
1656 const address_space
*aspace
= regcache
->aspace ();
1657 CORE_ADDR original
, copy
;
1659 struct displaced_step_closure
*closure
;
1662 /* We should never reach this function if the architecture does not
1663 support displaced stepping. */
1664 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch
));
1666 /* Nor if the thread isn't meant to step over a breakpoint. */
1667 gdb_assert (tp
->control
.trap_expected
);
1669 /* Disable range stepping while executing in the scratch pad. We
1670 want a single-step even if executing the displaced instruction in
1671 the scratch buffer lands within the stepping range (e.g., a
1673 tp
->control
.may_range_step
= 0;
1675 /* We have to displaced step one thread at a time, as we only have
1676 access to a single scratch space per inferior. */
1678 displaced_step_inferior_state
*displaced
1679 = get_displaced_stepping_state (tp
->inf
);
1681 if (displaced
->step_thread
!= nullptr)
1683 /* Already waiting for a displaced step to finish. Defer this
1684 request and place in queue. */
1686 if (debug_displaced
)
1687 fprintf_unfiltered (gdb_stdlog
,
1688 "displaced: deferring step of %s\n",
1689 target_pid_to_str (tp
->ptid
).c_str ());
1691 thread_step_over_chain_enqueue (tp
);
1696 if (debug_displaced
)
1697 fprintf_unfiltered (gdb_stdlog
,
1698 "displaced: stepping %s now\n",
1699 target_pid_to_str (tp
->ptid
).c_str ());
1702 displaced_step_clear (displaced
);
1704 scoped_restore_current_thread restore_thread
;
1706 switch_to_thread (tp
);
1708 original
= regcache_read_pc (regcache
);
1710 copy
= gdbarch_displaced_step_location (gdbarch
);
1711 len
= gdbarch_max_insn_length (gdbarch
);
1713 if (breakpoint_in_range_p (aspace
, copy
, len
))
1715 /* There's a breakpoint set in the scratch pad location range
1716 (which is usually around the entry point). We'd either
1717 install it before resuming, which would overwrite/corrupt the
1718 scratch pad, or if it was already inserted, this displaced
1719 step would overwrite it. The latter is OK in the sense that
1720 we already assume that no thread is going to execute the code
1721 in the scratch pad range (after initial startup) anyway, but
1722 the former is unacceptable. Simply punt and fallback to
1723 stepping over this breakpoint in-line. */
1724 if (debug_displaced
)
1726 fprintf_unfiltered (gdb_stdlog
,
1727 "displaced: breakpoint set in scratch pad. "
1728 "Stepping over breakpoint in-line instead.\n");
1734 /* Save the original contents of the copy area. */
1735 displaced
->step_saved_copy
.resize (len
);
1736 status
= target_read_memory (copy
, displaced
->step_saved_copy
.data (), len
);
1738 throw_error (MEMORY_ERROR
,
1739 _("Error accessing memory address %s (%s) for "
1740 "displaced-stepping scratch space."),
1741 paddress (gdbarch
, copy
), safe_strerror (status
));
1742 if (debug_displaced
)
1744 fprintf_unfiltered (gdb_stdlog
, "displaced: saved %s: ",
1745 paddress (gdbarch
, copy
));
1746 displaced_step_dump_bytes (gdb_stdlog
,
1747 displaced
->step_saved_copy
.data (),
1751 closure
= gdbarch_displaced_step_copy_insn (gdbarch
,
1752 original
, copy
, regcache
);
1753 if (closure
== NULL
)
1755 /* The architecture doesn't know how or want to displaced step
1756 this instruction or instruction sequence. Fallback to
1757 stepping over the breakpoint in-line. */
1761 /* Save the information we need to fix things up if the step
1763 displaced
->step_thread
= tp
;
1764 displaced
->step_gdbarch
= gdbarch
;
1765 displaced
->step_closure
= closure
;
1766 displaced
->step_original
= original
;
1767 displaced
->step_copy
= copy
;
1770 displaced_step_clear_cleanup
cleanup (displaced
);
1772 /* Resume execution at the copy. */
1773 regcache_write_pc (regcache
, copy
);
1778 if (debug_displaced
)
1779 fprintf_unfiltered (gdb_stdlog
, "displaced: displaced pc to %s\n",
1780 paddress (gdbarch
, copy
));
1785 /* Wrapper for displaced_step_prepare_throw that disabled further
1786 attempts at displaced stepping if we get a memory error. */
1789 displaced_step_prepare (thread_info
*thread
)
1795 prepared
= displaced_step_prepare_throw (thread
);
1797 catch (const gdb_exception_error
&ex
)
1799 struct displaced_step_inferior_state
*displaced_state
;
1801 if (ex
.error
!= MEMORY_ERROR
1802 && ex
.error
!= NOT_SUPPORTED_ERROR
)
1807 fprintf_unfiltered (gdb_stdlog
,
1808 "infrun: disabling displaced stepping: %s\n",
1812 /* Be verbose if "set displaced-stepping" is "on", silent if
1814 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1816 warning (_("disabling displaced stepping: %s"),
1820 /* Disable further displaced stepping attempts. */
1822 = get_displaced_stepping_state (thread
->inf
);
1823 displaced_state
->failed_before
= 1;
1830 write_memory_ptid (ptid_t ptid
, CORE_ADDR memaddr
,
1831 const gdb_byte
*myaddr
, int len
)
1833 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1835 inferior_ptid
= ptid
;
1836 write_memory (memaddr
, myaddr
, len
);
1839 /* Restore the contents of the copy area for thread PTID. */
1842 displaced_step_restore (struct displaced_step_inferior_state
*displaced
,
1845 ULONGEST len
= gdbarch_max_insn_length (displaced
->step_gdbarch
);
1847 write_memory_ptid (ptid
, displaced
->step_copy
,
1848 displaced
->step_saved_copy
.data (), len
);
1849 if (debug_displaced
)
1850 fprintf_unfiltered (gdb_stdlog
, "displaced: restored %s %s\n",
1851 target_pid_to_str (ptid
).c_str (),
1852 paddress (displaced
->step_gdbarch
,
1853 displaced
->step_copy
));
1856 /* If we displaced stepped an instruction successfully, adjust
1857 registers and memory to yield the same effect the instruction would
1858 have had if we had executed it at its original address, and return
1859 1. If the instruction didn't complete, relocate the PC and return
1860 -1. If the thread wasn't displaced stepping, return 0. */
1863 displaced_step_fixup (thread_info
*event_thread
, enum gdb_signal signal
)
1865 struct displaced_step_inferior_state
*displaced
1866 = get_displaced_stepping_state (event_thread
->inf
);
1869 /* Was this event for the thread we displaced? */
1870 if (displaced
->step_thread
!= event_thread
)
1873 displaced_step_clear_cleanup
cleanup (displaced
);
1875 displaced_step_restore (displaced
, displaced
->step_thread
->ptid
);
1877 /* Fixup may need to read memory/registers. Switch to the thread
1878 that we're fixing up. Also, target_stopped_by_watchpoint checks
1879 the current thread. */
1880 switch_to_thread (event_thread
);
1882 /* Did the instruction complete successfully? */
1883 if (signal
== GDB_SIGNAL_TRAP
1884 && !(target_stopped_by_watchpoint ()
1885 && (gdbarch_have_nonsteppable_watchpoint (displaced
->step_gdbarch
)
1886 || target_have_steppable_watchpoint
)))
1888 /* Fix up the resulting state. */
1889 gdbarch_displaced_step_fixup (displaced
->step_gdbarch
,
1890 displaced
->step_closure
,
1891 displaced
->step_original
,
1892 displaced
->step_copy
,
1893 get_thread_regcache (displaced
->step_thread
));
1898 /* Since the instruction didn't complete, all we can do is
1900 struct regcache
*regcache
= get_thread_regcache (event_thread
);
1901 CORE_ADDR pc
= regcache_read_pc (regcache
);
1903 pc
= displaced
->step_original
+ (pc
- displaced
->step_copy
);
1904 regcache_write_pc (regcache
, pc
);
1911 /* Data to be passed around while handling an event. This data is
1912 discarded between events. */
1913 struct execution_control_state
1915 process_stratum_target
*target
;
1917 /* The thread that got the event, if this was a thread event; NULL
1919 struct thread_info
*event_thread
;
1921 struct target_waitstatus ws
;
1922 int stop_func_filled_in
;
1923 CORE_ADDR stop_func_start
;
1924 CORE_ADDR stop_func_end
;
1925 const char *stop_func_name
;
1928 /* True if the event thread hit the single-step breakpoint of
1929 another thread. Thus the event doesn't cause a stop, the thread
1930 needs to be single-stepped past the single-step breakpoint before
1931 we can switch back to the original stepping thread. */
1932 int hit_singlestep_breakpoint
;
1935 /* Clear ECS and set it to point at TP. */
1938 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
1940 memset (ecs
, 0, sizeof (*ecs
));
1941 ecs
->event_thread
= tp
;
1942 ecs
->ptid
= tp
->ptid
;
1945 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
1946 static void prepare_to_wait (struct execution_control_state
*ecs
);
1947 static int keep_going_stepped_thread (struct thread_info
*tp
);
1948 static step_over_what
thread_still_needs_step_over (struct thread_info
*tp
);
1950 /* Are there any pending step-over requests? If so, run all we can
1951 now and return true. Otherwise, return false. */
1954 start_step_over (void)
1956 struct thread_info
*tp
, *next
;
1958 /* Don't start a new step-over if we already have an in-line
1959 step-over operation ongoing. */
1960 if (step_over_info_valid_p ())
1963 for (tp
= step_over_queue_head
; tp
!= NULL
; tp
= next
)
1965 struct execution_control_state ecss
;
1966 struct execution_control_state
*ecs
= &ecss
;
1967 step_over_what step_what
;
1968 int must_be_in_line
;
1970 gdb_assert (!tp
->stop_requested
);
1972 next
= thread_step_over_chain_next (tp
);
1974 /* If this inferior already has a displaced step in process,
1975 don't start a new one. */
1976 if (displaced_step_in_progress (tp
->inf
))
1979 step_what
= thread_still_needs_step_over (tp
);
1980 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
1981 || ((step_what
& STEP_OVER_BREAKPOINT
)
1982 && !use_displaced_stepping (tp
)));
1984 /* We currently stop all threads of all processes to step-over
1985 in-line. If we need to start a new in-line step-over, let
1986 any pending displaced steps finish first. */
1987 if (must_be_in_line
&& displaced_step_in_progress_any_inferior ())
1990 thread_step_over_chain_remove (tp
);
1992 if (step_over_queue_head
== NULL
)
1995 fprintf_unfiltered (gdb_stdlog
,
1996 "infrun: step-over queue now empty\n");
1999 if (tp
->control
.trap_expected
2003 internal_error (__FILE__
, __LINE__
,
2004 "[%s] has inconsistent state: "
2005 "trap_expected=%d, resumed=%d, executing=%d\n",
2006 target_pid_to_str (tp
->ptid
).c_str (),
2007 tp
->control
.trap_expected
,
2013 fprintf_unfiltered (gdb_stdlog
,
2014 "infrun: resuming [%s] for step-over\n",
2015 target_pid_to_str (tp
->ptid
).c_str ());
2017 /* keep_going_pass_signal skips the step-over if the breakpoint
2018 is no longer inserted. In all-stop, we want to keep looking
2019 for a thread that needs a step-over instead of resuming TP,
2020 because we wouldn't be able to resume anything else until the
2021 target stops again. In non-stop, the resume always resumes
2022 only TP, so it's OK to let the thread resume freely. */
2023 if (!target_is_non_stop_p () && !step_what
)
2026 switch_to_thread (tp
);
2027 reset_ecs (ecs
, tp
);
2028 keep_going_pass_signal (ecs
);
2030 if (!ecs
->wait_some_more
)
2031 error (_("Command aborted."));
2033 gdb_assert (tp
->resumed
);
2035 /* If we started a new in-line step-over, we're done. */
2036 if (step_over_info_valid_p ())
2038 gdb_assert (tp
->control
.trap_expected
);
2042 if (!target_is_non_stop_p ())
2044 /* On all-stop, shouldn't have resumed unless we needed a
2046 gdb_assert (tp
->control
.trap_expected
2047 || tp
->step_after_step_resume_breakpoint
);
2049 /* With remote targets (at least), in all-stop, we can't
2050 issue any further remote commands until the program stops
2055 /* Either the thread no longer needed a step-over, or a new
2056 displaced stepping sequence started. Even in the latter
2057 case, continue looking. Maybe we can also start another
2058 displaced step on a thread of other process. */
2064 /* Update global variables holding ptids to hold NEW_PTID if they were
2065 holding OLD_PTID. */
2067 infrun_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
2069 if (inferior_ptid
== old_ptid
)
2070 inferior_ptid
= new_ptid
;
2075 static const char schedlock_off
[] = "off";
2076 static const char schedlock_on
[] = "on";
2077 static const char schedlock_step
[] = "step";
2078 static const char schedlock_replay
[] = "replay";
2079 static const char *const scheduler_enums
[] = {
2086 static const char *scheduler_mode
= schedlock_replay
;
2088 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2089 struct cmd_list_element
*c
, const char *value
)
2091 fprintf_filtered (file
,
2092 _("Mode for locking scheduler "
2093 "during execution is \"%s\".\n"),
2098 set_schedlock_func (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2100 if (!target_can_lock_scheduler
)
2102 scheduler_mode
= schedlock_off
;
2103 error (_("Target '%s' cannot support this command."), target_shortname
);
2107 /* True if execution commands resume all threads of all processes by
2108 default; otherwise, resume only threads of the current inferior
2110 bool sched_multi
= false;
2112 /* Try to setup for software single stepping over the specified location.
2113 Return 1 if target_resume() should use hardware single step.
2115 GDBARCH the current gdbarch.
2116 PC the location to step over. */
2119 maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2123 if (execution_direction
== EXEC_FORWARD
2124 && gdbarch_software_single_step_p (gdbarch
))
2125 hw_step
= !insert_single_step_breakpoints (gdbarch
);
2133 user_visible_resume_ptid (int step
)
2139 /* With non-stop mode on, threads are always handled
2141 resume_ptid
= inferior_ptid
;
2143 else if ((scheduler_mode
== schedlock_on
)
2144 || (scheduler_mode
== schedlock_step
&& step
))
2146 /* User-settable 'scheduler' mode requires solo thread
2148 resume_ptid
= inferior_ptid
;
2150 else if ((scheduler_mode
== schedlock_replay
)
2151 && target_record_will_replay (minus_one_ptid
, execution_direction
))
2153 /* User-settable 'scheduler' mode requires solo thread resume in replay
2155 resume_ptid
= inferior_ptid
;
2157 else if (!sched_multi
&& target_supports_multi_process ())
2159 /* Resume all threads of the current process (and none of other
2161 resume_ptid
= ptid_t (inferior_ptid
.pid ());
2165 /* Resume all threads of all processes. */
2166 resume_ptid
= RESUME_ALL
;
2174 process_stratum_target
*
2175 user_visible_resume_target (ptid_t resume_ptid
)
2177 return (resume_ptid
== minus_one_ptid
&& sched_multi
2179 : current_inferior ()->process_target ());
2182 /* Return a ptid representing the set of threads that we will resume,
2183 in the perspective of the target, assuming run control handling
2184 does not require leaving some threads stopped (e.g., stepping past
2185 breakpoint). USER_STEP indicates whether we're about to start the
2186 target for a stepping command. */
2189 internal_resume_ptid (int user_step
)
2191 /* In non-stop, we always control threads individually. Note that
2192 the target may always work in non-stop mode even with "set
2193 non-stop off", in which case user_visible_resume_ptid could
2194 return a wildcard ptid. */
2195 if (target_is_non_stop_p ())
2196 return inferior_ptid
;
2198 return user_visible_resume_ptid (user_step
);
2201 /* Wrapper for target_resume, that handles infrun-specific
2205 do_target_resume (ptid_t resume_ptid
, int step
, enum gdb_signal sig
)
2207 struct thread_info
*tp
= inferior_thread ();
2209 gdb_assert (!tp
->stop_requested
);
2211 /* Install inferior's terminal modes. */
2212 target_terminal::inferior ();
2214 /* Avoid confusing the next resume, if the next stop/resume
2215 happens to apply to another thread. */
2216 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2218 /* Advise target which signals may be handled silently.
2220 If we have removed breakpoints because we are stepping over one
2221 in-line (in any thread), we need to receive all signals to avoid
2222 accidentally skipping a breakpoint during execution of a signal
2225 Likewise if we're displaced stepping, otherwise a trap for a
2226 breakpoint in a signal handler might be confused with the
2227 displaced step finishing. We don't make the displaced_step_fixup
2228 step distinguish the cases instead, because:
2230 - a backtrace while stopped in the signal handler would show the
2231 scratch pad as frame older than the signal handler, instead of
2232 the real mainline code.
2234 - when the thread is later resumed, the signal handler would
2235 return to the scratch pad area, which would no longer be
2237 if (step_over_info_valid_p ()
2238 || displaced_step_in_progress (tp
->inf
))
2239 target_pass_signals ({});
2241 target_pass_signals (signal_pass
);
2243 target_resume (resume_ptid
, step
, sig
);
2245 target_commit_resume ();
2247 if (target_can_async_p ())
2251 /* Resume the inferior. SIG is the signal to give the inferior
2252 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2253 call 'resume', which handles exceptions. */
2256 resume_1 (enum gdb_signal sig
)
2258 struct regcache
*regcache
= get_current_regcache ();
2259 struct gdbarch
*gdbarch
= regcache
->arch ();
2260 struct thread_info
*tp
= inferior_thread ();
2261 CORE_ADDR pc
= regcache_read_pc (regcache
);
2262 const address_space
*aspace
= regcache
->aspace ();
2264 /* This represents the user's step vs continue request. When
2265 deciding whether "set scheduler-locking step" applies, it's the
2266 user's intention that counts. */
2267 const int user_step
= tp
->control
.stepping_command
;
2268 /* This represents what we'll actually request the target to do.
2269 This can decay from a step to a continue, if e.g., we need to
2270 implement single-stepping with breakpoints (software
2274 gdb_assert (!tp
->stop_requested
);
2275 gdb_assert (!thread_is_in_step_over_chain (tp
));
2277 if (tp
->suspend
.waitstatus_pending_p
)
2282 = target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2284 fprintf_unfiltered (gdb_stdlog
,
2285 "infrun: resume: thread %s has pending wait "
2286 "status %s (currently_stepping=%d).\n",
2287 target_pid_to_str (tp
->ptid
).c_str (),
2289 currently_stepping (tp
));
2292 tp
->inf
->process_target ()->threads_executing
= true;
2295 /* FIXME: What should we do if we are supposed to resume this
2296 thread with a signal? Maybe we should maintain a queue of
2297 pending signals to deliver. */
2298 if (sig
!= GDB_SIGNAL_0
)
2300 warning (_("Couldn't deliver signal %s to %s."),
2301 gdb_signal_to_name (sig
),
2302 target_pid_to_str (tp
->ptid
).c_str ());
2305 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2307 if (target_can_async_p ())
2310 /* Tell the event loop we have an event to process. */
2311 mark_async_event_handler (infrun_async_inferior_event_token
);
2316 tp
->stepped_breakpoint
= 0;
2318 /* Depends on stepped_breakpoint. */
2319 step
= currently_stepping (tp
);
2321 if (current_inferior ()->waiting_for_vfork_done
)
2323 /* Don't try to single-step a vfork parent that is waiting for
2324 the child to get out of the shared memory region (by exec'ing
2325 or exiting). This is particularly important on software
2326 single-step archs, as the child process would trip on the
2327 software single step breakpoint inserted for the parent
2328 process. Since the parent will not actually execute any
2329 instruction until the child is out of the shared region (such
2330 are vfork's semantics), it is safe to simply continue it.
2331 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2332 the parent, and tell it to `keep_going', which automatically
2333 re-sets it stepping. */
2335 fprintf_unfiltered (gdb_stdlog
,
2336 "infrun: resume : clear step\n");
2341 fprintf_unfiltered (gdb_stdlog
,
2342 "infrun: resume (step=%d, signal=%s), "
2343 "trap_expected=%d, current thread [%s] at %s\n",
2344 step
, gdb_signal_to_symbol_string (sig
),
2345 tp
->control
.trap_expected
,
2346 target_pid_to_str (inferior_ptid
).c_str (),
2347 paddress (gdbarch
, pc
));
2349 /* Normally, by the time we reach `resume', the breakpoints are either
2350 removed or inserted, as appropriate. The exception is if we're sitting
2351 at a permanent breakpoint; we need to step over it, but permanent
2352 breakpoints can't be removed. So we have to test for it here. */
2353 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2355 if (sig
!= GDB_SIGNAL_0
)
2357 /* We have a signal to pass to the inferior. The resume
2358 may, or may not take us to the signal handler. If this
2359 is a step, we'll need to stop in the signal handler, if
2360 there's one, (if the target supports stepping into
2361 handlers), or in the next mainline instruction, if
2362 there's no handler. If this is a continue, we need to be
2363 sure to run the handler with all breakpoints inserted.
2364 In all cases, set a breakpoint at the current address
2365 (where the handler returns to), and once that breakpoint
2366 is hit, resume skipping the permanent breakpoint. If
2367 that breakpoint isn't hit, then we've stepped into the
2368 signal handler (or hit some other event). We'll delete
2369 the step-resume breakpoint then. */
2372 fprintf_unfiltered (gdb_stdlog
,
2373 "infrun: resume: skipping permanent breakpoint, "
2374 "deliver signal first\n");
2376 clear_step_over_info ();
2377 tp
->control
.trap_expected
= 0;
2379 if (tp
->control
.step_resume_breakpoint
== NULL
)
2381 /* Set a "high-priority" step-resume, as we don't want
2382 user breakpoints at PC to trigger (again) when this
2384 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2385 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2387 tp
->step_after_step_resume_breakpoint
= step
;
2390 insert_breakpoints ();
2394 /* There's no signal to pass, we can go ahead and skip the
2395 permanent breakpoint manually. */
2397 fprintf_unfiltered (gdb_stdlog
,
2398 "infrun: resume: skipping permanent breakpoint\n");
2399 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2400 /* Update pc to reflect the new address from which we will
2401 execute instructions. */
2402 pc
= regcache_read_pc (regcache
);
2406 /* We've already advanced the PC, so the stepping part
2407 is done. Now we need to arrange for a trap to be
2408 reported to handle_inferior_event. Set a breakpoint
2409 at the current PC, and run to it. Don't update
2410 prev_pc, because if we end in
2411 switch_back_to_stepped_thread, we want the "expected
2412 thread advanced also" branch to be taken. IOW, we
2413 don't want this thread to step further from PC
2415 gdb_assert (!step_over_info_valid_p ());
2416 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2417 insert_breakpoints ();
2419 resume_ptid
= internal_resume_ptid (user_step
);
2420 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
2427 /* If we have a breakpoint to step over, make sure to do a single
2428 step only. Same if we have software watchpoints. */
2429 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2430 tp
->control
.may_range_step
= 0;
2432 /* If displaced stepping is enabled, step over breakpoints by executing a
2433 copy of the instruction at a different address.
2435 We can't use displaced stepping when we have a signal to deliver;
2436 the comments for displaced_step_prepare explain why. The
2437 comments in the handle_inferior event for dealing with 'random
2438 signals' explain what we do instead.
2440 We can't use displaced stepping when we are waiting for vfork_done
2441 event, displaced stepping breaks the vfork child similarly as single
2442 step software breakpoint. */
2443 if (tp
->control
.trap_expected
2444 && use_displaced_stepping (tp
)
2445 && !step_over_info_valid_p ()
2446 && sig
== GDB_SIGNAL_0
2447 && !current_inferior ()->waiting_for_vfork_done
)
2449 int prepared
= displaced_step_prepare (tp
);
2454 fprintf_unfiltered (gdb_stdlog
,
2455 "Got placed in step-over queue\n");
2457 tp
->control
.trap_expected
= 0;
2460 else if (prepared
< 0)
2462 /* Fallback to stepping over the breakpoint in-line. */
2464 if (target_is_non_stop_p ())
2465 stop_all_threads ();
2467 set_step_over_info (regcache
->aspace (),
2468 regcache_read_pc (regcache
), 0, tp
->global_num
);
2470 step
= maybe_software_singlestep (gdbarch
, pc
);
2472 insert_breakpoints ();
2474 else if (prepared
> 0)
2476 struct displaced_step_inferior_state
*displaced
;
2478 /* Update pc to reflect the new address from which we will
2479 execute instructions due to displaced stepping. */
2480 pc
= regcache_read_pc (get_thread_regcache (tp
));
2482 displaced
= get_displaced_stepping_state (tp
->inf
);
2483 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
,
2484 displaced
->step_closure
);
2488 /* Do we need to do it the hard way, w/temp breakpoints? */
2490 step
= maybe_software_singlestep (gdbarch
, pc
);
2492 /* Currently, our software single-step implementation leads to different
2493 results than hardware single-stepping in one situation: when stepping
2494 into delivering a signal which has an associated signal handler,
2495 hardware single-step will stop at the first instruction of the handler,
2496 while software single-step will simply skip execution of the handler.
2498 For now, this difference in behavior is accepted since there is no
2499 easy way to actually implement single-stepping into a signal handler
2500 without kernel support.
2502 However, there is one scenario where this difference leads to follow-on
2503 problems: if we're stepping off a breakpoint by removing all breakpoints
2504 and then single-stepping. In this case, the software single-step
2505 behavior means that even if there is a *breakpoint* in the signal
2506 handler, GDB still would not stop.
2508 Fortunately, we can at least fix this particular issue. We detect
2509 here the case where we are about to deliver a signal while software
2510 single-stepping with breakpoints removed. In this situation, we
2511 revert the decisions to remove all breakpoints and insert single-
2512 step breakpoints, and instead we install a step-resume breakpoint
2513 at the current address, deliver the signal without stepping, and
2514 once we arrive back at the step-resume breakpoint, actually step
2515 over the breakpoint we originally wanted to step over. */
2516 if (thread_has_single_step_breakpoints_set (tp
)
2517 && sig
!= GDB_SIGNAL_0
2518 && step_over_info_valid_p ())
2520 /* If we have nested signals or a pending signal is delivered
2521 immediately after a handler returns, might already have
2522 a step-resume breakpoint set on the earlier handler. We cannot
2523 set another step-resume breakpoint; just continue on until the
2524 original breakpoint is hit. */
2525 if (tp
->control
.step_resume_breakpoint
== NULL
)
2527 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2528 tp
->step_after_step_resume_breakpoint
= 1;
2531 delete_single_step_breakpoints (tp
);
2533 clear_step_over_info ();
2534 tp
->control
.trap_expected
= 0;
2536 insert_breakpoints ();
2539 /* If STEP is set, it's a request to use hardware stepping
2540 facilities. But in that case, we should never
2541 use singlestep breakpoint. */
2542 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2544 /* Decide the set of threads to ask the target to resume. */
2545 if (tp
->control
.trap_expected
)
2547 /* We're allowing a thread to run past a breakpoint it has
2548 hit, either by single-stepping the thread with the breakpoint
2549 removed, or by displaced stepping, with the breakpoint inserted.
2550 In the former case, we need to single-step only this thread,
2551 and keep others stopped, as they can miss this breakpoint if
2552 allowed to run. That's not really a problem for displaced
2553 stepping, but, we still keep other threads stopped, in case
2554 another thread is also stopped for a breakpoint waiting for
2555 its turn in the displaced stepping queue. */
2556 resume_ptid
= inferior_ptid
;
2559 resume_ptid
= internal_resume_ptid (user_step
);
2561 if (execution_direction
!= EXEC_REVERSE
2562 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2564 /* There are two cases where we currently need to step a
2565 breakpoint instruction when we have a signal to deliver:
2567 - See handle_signal_stop where we handle random signals that
2568 could take out us out of the stepping range. Normally, in
2569 that case we end up continuing (instead of stepping) over the
2570 signal handler with a breakpoint at PC, but there are cases
2571 where we should _always_ single-step, even if we have a
2572 step-resume breakpoint, like when a software watchpoint is
2573 set. Assuming single-stepping and delivering a signal at the
2574 same time would takes us to the signal handler, then we could
2575 have removed the breakpoint at PC to step over it. However,
2576 some hardware step targets (like e.g., Mac OS) can't step
2577 into signal handlers, and for those, we need to leave the
2578 breakpoint at PC inserted, as otherwise if the handler
2579 recurses and executes PC again, it'll miss the breakpoint.
2580 So we leave the breakpoint inserted anyway, but we need to
2581 record that we tried to step a breakpoint instruction, so
2582 that adjust_pc_after_break doesn't end up confused.
2584 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2585 in one thread after another thread that was stepping had been
2586 momentarily paused for a step-over. When we re-resume the
2587 stepping thread, it may be resumed from that address with a
2588 breakpoint that hasn't trapped yet. Seen with
2589 gdb.threads/non-stop-fair-events.exp, on targets that don't
2590 do displaced stepping. */
2593 fprintf_unfiltered (gdb_stdlog
,
2594 "infrun: resume: [%s] stepped breakpoint\n",
2595 target_pid_to_str (tp
->ptid
).c_str ());
2597 tp
->stepped_breakpoint
= 1;
2599 /* Most targets can step a breakpoint instruction, thus
2600 executing it normally. But if this one cannot, just
2601 continue and we will hit it anyway. */
2602 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2607 && tp
->control
.trap_expected
2608 && use_displaced_stepping (tp
)
2609 && !step_over_info_valid_p ())
2611 struct regcache
*resume_regcache
= get_thread_regcache (tp
);
2612 struct gdbarch
*resume_gdbarch
= resume_regcache
->arch ();
2613 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2616 fprintf_unfiltered (gdb_stdlog
, "displaced: run %s: ",
2617 paddress (resume_gdbarch
, actual_pc
));
2618 read_memory (actual_pc
, buf
, sizeof (buf
));
2619 displaced_step_dump_bytes (gdb_stdlog
, buf
, sizeof (buf
));
2622 if (tp
->control
.may_range_step
)
2624 /* If we're resuming a thread with the PC out of the step
2625 range, then we're doing some nested/finer run control
2626 operation, like stepping the thread out of the dynamic
2627 linker or the displaced stepping scratch pad. We
2628 shouldn't have allowed a range step then. */
2629 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2632 do_target_resume (resume_ptid
, step
, sig
);
2636 /* Resume the inferior. SIG is the signal to give the inferior
2637 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2638 rolls back state on error. */
2641 resume (gdb_signal sig
)
2647 catch (const gdb_exception
&ex
)
2649 /* If resuming is being aborted for any reason, delete any
2650 single-step breakpoint resume_1 may have created, to avoid
2651 confusing the following resumption, and to avoid leaving
2652 single-step breakpoints perturbing other threads, in case
2653 we're running in non-stop mode. */
2654 if (inferior_ptid
!= null_ptid
)
2655 delete_single_step_breakpoints (inferior_thread ());
2665 /* Counter that tracks number of user visible stops. This can be used
2666 to tell whether a command has proceeded the inferior past the
2667 current location. This allows e.g., inferior function calls in
2668 breakpoint commands to not interrupt the command list. When the
2669 call finishes successfully, the inferior is standing at the same
2670 breakpoint as if nothing happened (and so we don't call
2672 static ULONGEST current_stop_id
;
2679 return current_stop_id
;
2682 /* Called when we report a user visible stop. */
2690 /* Clear out all variables saying what to do when inferior is continued.
2691 First do this, then set the ones you want, then call `proceed'. */
2694 clear_proceed_status_thread (struct thread_info
*tp
)
2697 fprintf_unfiltered (gdb_stdlog
,
2698 "infrun: clear_proceed_status_thread (%s)\n",
2699 target_pid_to_str (tp
->ptid
).c_str ());
2701 /* If we're starting a new sequence, then the previous finished
2702 single-step is no longer relevant. */
2703 if (tp
->suspend
.waitstatus_pending_p
)
2705 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
2708 fprintf_unfiltered (gdb_stdlog
,
2709 "infrun: clear_proceed_status: pending "
2710 "event of %s was a finished step. "
2712 target_pid_to_str (tp
->ptid
).c_str ());
2714 tp
->suspend
.waitstatus_pending_p
= 0;
2715 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
2717 else if (debug_infrun
)
2720 = target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2722 fprintf_unfiltered (gdb_stdlog
,
2723 "infrun: clear_proceed_status_thread: thread %s "
2724 "has pending wait status %s "
2725 "(currently_stepping=%d).\n",
2726 target_pid_to_str (tp
->ptid
).c_str (),
2728 currently_stepping (tp
));
2732 /* If this signal should not be seen by program, give it zero.
2733 Used for debugging signals. */
2734 if (!signal_pass_state (tp
->suspend
.stop_signal
))
2735 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2737 delete tp
->thread_fsm
;
2738 tp
->thread_fsm
= NULL
;
2740 tp
->control
.trap_expected
= 0;
2741 tp
->control
.step_range_start
= 0;
2742 tp
->control
.step_range_end
= 0;
2743 tp
->control
.may_range_step
= 0;
2744 tp
->control
.step_frame_id
= null_frame_id
;
2745 tp
->control
.step_stack_frame_id
= null_frame_id
;
2746 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2747 tp
->control
.step_start_function
= NULL
;
2748 tp
->stop_requested
= 0;
2750 tp
->control
.stop_step
= 0;
2752 tp
->control
.proceed_to_finish
= 0;
2754 tp
->control
.stepping_command
= 0;
2756 /* Discard any remaining commands or status from previous stop. */
2757 bpstat_clear (&tp
->control
.stop_bpstat
);
2761 clear_proceed_status (int step
)
2763 /* With scheduler-locking replay, stop replaying other threads if we're
2764 not replaying the user-visible resume ptid.
2766 This is a convenience feature to not require the user to explicitly
2767 stop replaying the other threads. We're assuming that the user's
2768 intent is to resume tracing the recorded process. */
2769 if (!non_stop
&& scheduler_mode
== schedlock_replay
2770 && target_record_is_replaying (minus_one_ptid
)
2771 && !target_record_will_replay (user_visible_resume_ptid (step
),
2772 execution_direction
))
2773 target_record_stop_replaying ();
2775 if (!non_stop
&& inferior_ptid
!= null_ptid
)
2777 ptid_t resume_ptid
= user_visible_resume_ptid (step
);
2778 process_stratum_target
*resume_target
2779 = user_visible_resume_target (resume_ptid
);
2781 /* In all-stop mode, delete the per-thread status of all threads
2782 we're about to resume, implicitly and explicitly. */
2783 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
2784 clear_proceed_status_thread (tp
);
2787 if (inferior_ptid
!= null_ptid
)
2789 struct inferior
*inferior
;
2793 /* If in non-stop mode, only delete the per-thread status of
2794 the current thread. */
2795 clear_proceed_status_thread (inferior_thread ());
2798 inferior
= current_inferior ();
2799 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2802 gdb::observers::about_to_proceed
.notify ();
2805 /* Returns true if TP is still stopped at a breakpoint that needs
2806 stepping-over in order to make progress. If the breakpoint is gone
2807 meanwhile, we can skip the whole step-over dance. */
2810 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2812 if (tp
->stepping_over_breakpoint
)
2814 struct regcache
*regcache
= get_thread_regcache (tp
);
2816 if (breakpoint_here_p (regcache
->aspace (),
2817 regcache_read_pc (regcache
))
2818 == ordinary_breakpoint_here
)
2821 tp
->stepping_over_breakpoint
= 0;
2827 /* Check whether thread TP still needs to start a step-over in order
2828 to make progress when resumed. Returns an bitwise or of enum
2829 step_over_what bits, indicating what needs to be stepped over. */
2831 static step_over_what
2832 thread_still_needs_step_over (struct thread_info
*tp
)
2834 step_over_what what
= 0;
2836 if (thread_still_needs_step_over_bp (tp
))
2837 what
|= STEP_OVER_BREAKPOINT
;
2839 if (tp
->stepping_over_watchpoint
2840 && !target_have_steppable_watchpoint
)
2841 what
|= STEP_OVER_WATCHPOINT
;
2846 /* Returns true if scheduler locking applies. STEP indicates whether
2847 we're about to do a step/next-like command to a thread. */
2850 schedlock_applies (struct thread_info
*tp
)
2852 return (scheduler_mode
== schedlock_on
2853 || (scheduler_mode
== schedlock_step
2854 && tp
->control
.stepping_command
)
2855 || (scheduler_mode
== schedlock_replay
2856 && target_record_will_replay (minus_one_ptid
,
2857 execution_direction
)));
2860 /* Calls target_commit_resume on all targets. */
2863 commit_resume_all_targets ()
2865 scoped_restore_current_thread restore_thread
;
2867 /* Map between process_target and a representative inferior. This
2868 is to avoid committing a resume in the same target more than
2869 once. Resumptions must be idempotent, so this is an
2871 std::unordered_map
<process_stratum_target
*, inferior
*> conn_inf
;
2873 for (inferior
*inf
: all_non_exited_inferiors ())
2874 if (inf
->has_execution ())
2875 conn_inf
[inf
->process_target ()] = inf
;
2877 for (const auto &ci
: conn_inf
)
2879 inferior
*inf
= ci
.second
;
2880 switch_to_inferior_no_thread (inf
);
2881 target_commit_resume ();
2885 /* Check that all the targets we're about to resume are in non-stop
2886 mode. Ideally, we'd only care whether all targets support
2887 target-async, but we're not there yet. E.g., stop_all_threads
2888 doesn't know how to handle all-stop targets. Also, the remote
2889 protocol in all-stop mode is synchronous, irrespective of
2890 target-async, which means that things like a breakpoint re-set
2891 triggered by one target would try to read memory from all targets
2895 check_multi_target_resumption (process_stratum_target
*resume_target
)
2897 if (!non_stop
&& resume_target
== nullptr)
2899 scoped_restore_current_thread restore_thread
;
2901 /* This is used to track whether we're resuming more than one
2903 process_stratum_target
*first_connection
= nullptr;
2905 /* The first inferior we see with a target that does not work in
2906 always-non-stop mode. */
2907 inferior
*first_not_non_stop
= nullptr;
2909 for (inferior
*inf
: all_non_exited_inferiors (resume_target
))
2911 switch_to_inferior_no_thread (inf
);
2913 if (!target_has_execution
)
2916 process_stratum_target
*proc_target
2917 = current_inferior ()->process_target();
2919 if (!target_is_non_stop_p ())
2920 first_not_non_stop
= inf
;
2922 if (first_connection
== nullptr)
2923 first_connection
= proc_target
;
2924 else if (first_connection
!= proc_target
2925 && first_not_non_stop
!= nullptr)
2927 switch_to_inferior_no_thread (first_not_non_stop
);
2929 proc_target
= current_inferior ()->process_target();
2931 error (_("Connection %d (%s) does not support "
2932 "multi-target resumption."),
2933 proc_target
->connection_number
,
2934 make_target_connection_string (proc_target
).c_str ());
2940 /* Basic routine for continuing the program in various fashions.
2942 ADDR is the address to resume at, or -1 for resume where stopped.
2943 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
2944 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
2946 You should call clear_proceed_status before calling proceed. */
2949 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
2951 struct regcache
*regcache
;
2952 struct gdbarch
*gdbarch
;
2954 struct execution_control_state ecss
;
2955 struct execution_control_state
*ecs
= &ecss
;
2958 /* If we're stopped at a fork/vfork, follow the branch set by the
2959 "set follow-fork-mode" command; otherwise, we'll just proceed
2960 resuming the current thread. */
2961 if (!follow_fork ())
2963 /* The target for some reason decided not to resume. */
2965 if (target_can_async_p ())
2966 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
2970 /* We'll update this if & when we switch to a new thread. */
2971 previous_inferior_ptid
= inferior_ptid
;
2973 regcache
= get_current_regcache ();
2974 gdbarch
= regcache
->arch ();
2975 const address_space
*aspace
= regcache
->aspace ();
2977 pc
= regcache_read_pc (regcache
);
2978 thread_info
*cur_thr
= inferior_thread ();
2980 /* Fill in with reasonable starting values. */
2981 init_thread_stepping_state (cur_thr
);
2983 gdb_assert (!thread_is_in_step_over_chain (cur_thr
));
2986 = user_visible_resume_ptid (cur_thr
->control
.stepping_command
);
2987 process_stratum_target
*resume_target
2988 = user_visible_resume_target (resume_ptid
);
2990 check_multi_target_resumption (resume_target
);
2992 if (addr
== (CORE_ADDR
) -1)
2994 if (pc
== cur_thr
->suspend
.stop_pc
2995 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
2996 && execution_direction
!= EXEC_REVERSE
)
2997 /* There is a breakpoint at the address we will resume at,
2998 step one instruction before inserting breakpoints so that
2999 we do not stop right away (and report a second hit at this
3002 Note, we don't do this in reverse, because we won't
3003 actually be executing the breakpoint insn anyway.
3004 We'll be (un-)executing the previous instruction. */
3005 cur_thr
->stepping_over_breakpoint
= 1;
3006 else if (gdbarch_single_step_through_delay_p (gdbarch
)
3007 && gdbarch_single_step_through_delay (gdbarch
,
3008 get_current_frame ()))
3009 /* We stepped onto an instruction that needs to be stepped
3010 again before re-inserting the breakpoint, do so. */
3011 cur_thr
->stepping_over_breakpoint
= 1;
3015 regcache_write_pc (regcache
, addr
);
3018 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
3019 cur_thr
->suspend
.stop_signal
= siggnal
;
3021 /* If an exception is thrown from this point on, make sure to
3022 propagate GDB's knowledge of the executing state to the
3023 frontend/user running state. */
3024 scoped_finish_thread_state
finish_state (resume_target
, resume_ptid
);
3026 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3027 threads (e.g., we might need to set threads stepping over
3028 breakpoints first), from the user/frontend's point of view, all
3029 threads in RESUME_PTID are now running. Unless we're calling an
3030 inferior function, as in that case we pretend the inferior
3031 doesn't run at all. */
3032 if (!cur_thr
->control
.in_infcall
)
3033 set_running (resume_target
, resume_ptid
, 1);
3036 fprintf_unfiltered (gdb_stdlog
,
3037 "infrun: proceed (addr=%s, signal=%s)\n",
3038 paddress (gdbarch
, addr
),
3039 gdb_signal_to_symbol_string (siggnal
));
3041 annotate_starting ();
3043 /* Make sure that output from GDB appears before output from the
3045 gdb_flush (gdb_stdout
);
3047 /* Since we've marked the inferior running, give it the terminal. A
3048 QUIT/Ctrl-C from here on is forwarded to the target (which can
3049 still detect attempts to unblock a stuck connection with repeated
3050 Ctrl-C from within target_pass_ctrlc). */
3051 target_terminal::inferior ();
3053 /* In a multi-threaded task we may select another thread and
3054 then continue or step.
3056 But if a thread that we're resuming had stopped at a breakpoint,
3057 it will immediately cause another breakpoint stop without any
3058 execution (i.e. it will report a breakpoint hit incorrectly). So
3059 we must step over it first.
3061 Look for threads other than the current (TP) that reported a
3062 breakpoint hit and haven't been resumed yet since. */
3064 /* If scheduler locking applies, we can avoid iterating over all
3066 if (!non_stop
&& !schedlock_applies (cur_thr
))
3068 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3071 switch_to_thread_no_regs (tp
);
3073 /* Ignore the current thread here. It's handled
3078 if (!thread_still_needs_step_over (tp
))
3081 gdb_assert (!thread_is_in_step_over_chain (tp
));
3084 fprintf_unfiltered (gdb_stdlog
,
3085 "infrun: need to step-over [%s] first\n",
3086 target_pid_to_str (tp
->ptid
).c_str ());
3088 thread_step_over_chain_enqueue (tp
);
3091 switch_to_thread (cur_thr
);
3094 /* Enqueue the current thread last, so that we move all other
3095 threads over their breakpoints first. */
3096 if (cur_thr
->stepping_over_breakpoint
)
3097 thread_step_over_chain_enqueue (cur_thr
);
3099 /* If the thread isn't started, we'll still need to set its prev_pc,
3100 so that switch_back_to_stepped_thread knows the thread hasn't
3101 advanced. Must do this before resuming any thread, as in
3102 all-stop/remote, once we resume we can't send any other packet
3103 until the target stops again. */
3104 cur_thr
->prev_pc
= regcache_read_pc (regcache
);
3107 scoped_restore save_defer_tc
= make_scoped_defer_target_commit_resume ();
3109 started
= start_step_over ();
3111 if (step_over_info_valid_p ())
3113 /* Either this thread started a new in-line step over, or some
3114 other thread was already doing one. In either case, don't
3115 resume anything else until the step-over is finished. */
3117 else if (started
&& !target_is_non_stop_p ())
3119 /* A new displaced stepping sequence was started. In all-stop,
3120 we can't talk to the target anymore until it next stops. */
3122 else if (!non_stop
&& target_is_non_stop_p ())
3124 /* In all-stop, but the target is always in non-stop mode.
3125 Start all other threads that are implicitly resumed too. */
3126 for (thread_info
*tp
: all_non_exited_threads (resume_target
,
3129 switch_to_thread_no_regs (tp
);
3131 if (!tp
->inf
->has_execution ())
3134 fprintf_unfiltered (gdb_stdlog
,
3135 "infrun: proceed: [%s] target has "
3137 target_pid_to_str (tp
->ptid
).c_str ());
3144 fprintf_unfiltered (gdb_stdlog
,
3145 "infrun: proceed: [%s] resumed\n",
3146 target_pid_to_str (tp
->ptid
).c_str ());
3147 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
3151 if (thread_is_in_step_over_chain (tp
))
3154 fprintf_unfiltered (gdb_stdlog
,
3155 "infrun: proceed: [%s] needs step-over\n",
3156 target_pid_to_str (tp
->ptid
).c_str ());
3161 fprintf_unfiltered (gdb_stdlog
,
3162 "infrun: proceed: resuming %s\n",
3163 target_pid_to_str (tp
->ptid
).c_str ());
3165 reset_ecs (ecs
, tp
);
3166 switch_to_thread (tp
);
3167 keep_going_pass_signal (ecs
);
3168 if (!ecs
->wait_some_more
)
3169 error (_("Command aborted."));
3172 else if (!cur_thr
->resumed
&& !thread_is_in_step_over_chain (cur_thr
))
3174 /* The thread wasn't started, and isn't queued, run it now. */
3175 reset_ecs (ecs
, cur_thr
);
3176 switch_to_thread (cur_thr
);
3177 keep_going_pass_signal (ecs
);
3178 if (!ecs
->wait_some_more
)
3179 error (_("Command aborted."));
3183 commit_resume_all_targets ();
3185 finish_state
.release ();
3187 /* If we've switched threads above, switch back to the previously
3188 current thread. We don't want the user to see a different
3190 switch_to_thread (cur_thr
);
3192 /* Tell the event loop to wait for it to stop. If the target
3193 supports asynchronous execution, it'll do this from within
3195 if (!target_can_async_p ())
3196 mark_async_event_handler (infrun_async_inferior_event_token
);
3200 /* Start remote-debugging of a machine over a serial link. */
3203 start_remote (int from_tty
)
3205 inferior
*inf
= current_inferior ();
3206 inf
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3208 /* Always go on waiting for the target, regardless of the mode. */
3209 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3210 indicate to wait_for_inferior that a target should timeout if
3211 nothing is returned (instead of just blocking). Because of this,
3212 targets expecting an immediate response need to, internally, set
3213 things up so that the target_wait() is forced to eventually
3215 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3216 differentiate to its caller what the state of the target is after
3217 the initial open has been performed. Here we're assuming that
3218 the target has stopped. It should be possible to eventually have
3219 target_open() return to the caller an indication that the target
3220 is currently running and GDB state should be set to the same as
3221 for an async run. */
3222 wait_for_inferior (inf
);
3224 /* Now that the inferior has stopped, do any bookkeeping like
3225 loading shared libraries. We want to do this before normal_stop,
3226 so that the displayed frame is up to date. */
3227 post_create_inferior (current_top_target (), from_tty
);
3232 /* Initialize static vars when a new inferior begins. */
3235 init_wait_for_inferior (void)
3237 /* These are meaningless until the first time through wait_for_inferior. */
3239 breakpoint_init_inferior (inf_starting
);
3241 clear_proceed_status (0);
3243 nullify_last_target_wait_ptid ();
3245 previous_inferior_ptid
= inferior_ptid
;
3250 static void handle_inferior_event (struct execution_control_state
*ecs
);
3252 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3253 struct execution_control_state
*ecs
);
3254 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3255 struct execution_control_state
*ecs
);
3256 static void handle_signal_stop (struct execution_control_state
*ecs
);
3257 static void check_exception_resume (struct execution_control_state
*,
3258 struct frame_info
*);
3260 static void end_stepping_range (struct execution_control_state
*ecs
);
3261 static void stop_waiting (struct execution_control_state
*ecs
);
3262 static void keep_going (struct execution_control_state
*ecs
);
3263 static void process_event_stop_test (struct execution_control_state
*ecs
);
3264 static int switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3266 /* This function is attached as a "thread_stop_requested" observer.
3267 Cleanup local state that assumed the PTID was to be resumed, and
3268 report the stop to the frontend. */
3271 infrun_thread_stop_requested (ptid_t ptid
)
3273 process_stratum_target
*curr_target
= current_inferior ()->process_target ();
3275 /* PTID was requested to stop. If the thread was already stopped,
3276 but the user/frontend doesn't know about that yet (e.g., the
3277 thread had been temporarily paused for some step-over), set up
3278 for reporting the stop now. */
3279 for (thread_info
*tp
: all_threads (curr_target
, ptid
))
3281 if (tp
->state
!= THREAD_RUNNING
)
3286 /* Remove matching threads from the step-over queue, so
3287 start_step_over doesn't try to resume them
3289 if (thread_is_in_step_over_chain (tp
))
3290 thread_step_over_chain_remove (tp
);
3292 /* If the thread is stopped, but the user/frontend doesn't
3293 know about that yet, queue a pending event, as if the
3294 thread had just stopped now. Unless the thread already had
3296 if (!tp
->suspend
.waitstatus_pending_p
)
3298 tp
->suspend
.waitstatus_pending_p
= 1;
3299 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_STOPPED
;
3300 tp
->suspend
.waitstatus
.value
.sig
= GDB_SIGNAL_0
;
3303 /* Clear the inline-frame state, since we're re-processing the
3305 clear_inline_frame_state (tp
);
3307 /* If this thread was paused because some other thread was
3308 doing an inline-step over, let that finish first. Once
3309 that happens, we'll restart all threads and consume pending
3310 stop events then. */
3311 if (step_over_info_valid_p ())
3314 /* Otherwise we can process the (new) pending event now. Set
3315 it so this pending event is considered by
3322 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3324 if (target_last_proc_target
== tp
->inf
->process_target ()
3325 && target_last_wait_ptid
== tp
->ptid
)
3326 nullify_last_target_wait_ptid ();
3329 /* Delete the step resume, single-step and longjmp/exception resume
3330 breakpoints of TP. */
3333 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3335 delete_step_resume_breakpoint (tp
);
3336 delete_exception_resume_breakpoint (tp
);
3337 delete_single_step_breakpoints (tp
);
3340 /* If the target still has execution, call FUNC for each thread that
3341 just stopped. In all-stop, that's all the non-exited threads; in
3342 non-stop, that's the current thread, only. */
3344 typedef void (*for_each_just_stopped_thread_callback_func
)
3345 (struct thread_info
*tp
);
3348 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3350 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
3353 if (target_is_non_stop_p ())
3355 /* If in non-stop mode, only the current thread stopped. */
3356 func (inferior_thread ());
3360 /* In all-stop mode, all threads have stopped. */
3361 for (thread_info
*tp
: all_non_exited_threads ())
3366 /* Delete the step resume and longjmp/exception resume breakpoints of
3367 the threads that just stopped. */
3370 delete_just_stopped_threads_infrun_breakpoints (void)
3372 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3375 /* Delete the single-step breakpoints of the threads that just
3379 delete_just_stopped_threads_single_step_breakpoints (void)
3381 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3387 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3388 const struct target_waitstatus
*ws
)
3390 std::string status_string
= target_waitstatus_to_string (ws
);
3393 /* The text is split over several lines because it was getting too long.
3394 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3395 output as a unit; we want only one timestamp printed if debug_timestamp
3398 stb
.printf ("infrun: target_wait (%d.%ld.%ld",
3401 waiton_ptid
.tid ());
3402 if (waiton_ptid
.pid () != -1)
3403 stb
.printf (" [%s]", target_pid_to_str (waiton_ptid
).c_str ());
3404 stb
.printf (", status) =\n");
3405 stb
.printf ("infrun: %d.%ld.%ld [%s],\n",
3409 target_pid_to_str (result_ptid
).c_str ());
3410 stb
.printf ("infrun: %s\n", status_string
.c_str ());
3412 /* This uses %s in part to handle %'s in the text, but also to avoid
3413 a gcc error: the format attribute requires a string literal. */
3414 fprintf_unfiltered (gdb_stdlog
, "%s", stb
.c_str ());
3417 /* Select a thread at random, out of those which are resumed and have
3420 static struct thread_info
*
3421 random_pending_event_thread (inferior
*inf
, ptid_t waiton_ptid
)
3425 auto has_event
= [&] (thread_info
*tp
)
3427 return (tp
->ptid
.matches (waiton_ptid
)
3429 && tp
->suspend
.waitstatus_pending_p
);
3432 /* First see how many events we have. Count only resumed threads
3433 that have an event pending. */
3434 for (thread_info
*tp
: inf
->non_exited_threads ())
3438 if (num_events
== 0)
3441 /* Now randomly pick a thread out of those that have had events. */
3442 int random_selector
= (int) ((num_events
* (double) rand ())
3443 / (RAND_MAX
+ 1.0));
3445 if (debug_infrun
&& num_events
> 1)
3446 fprintf_unfiltered (gdb_stdlog
,
3447 "infrun: Found %d events, selecting #%d\n",
3448 num_events
, random_selector
);
3450 /* Select the Nth thread that has had an event. */
3451 for (thread_info
*tp
: inf
->non_exited_threads ())
3453 if (random_selector
-- == 0)
3456 gdb_assert_not_reached ("event thread not found");
3459 /* Wrapper for target_wait that first checks whether threads have
3460 pending statuses to report before actually asking the target for
3461 more events. INF is the inferior we're using to call target_wait
3465 do_target_wait_1 (inferior
*inf
, ptid_t ptid
,
3466 target_waitstatus
*status
, int options
)
3469 struct thread_info
*tp
;
3471 /* First check if there is a resumed thread with a wait status
3473 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
3475 tp
= random_pending_event_thread (inf
, ptid
);
3480 fprintf_unfiltered (gdb_stdlog
,
3481 "infrun: Waiting for specific thread %s.\n",
3482 target_pid_to_str (ptid
).c_str ());
3484 /* We have a specific thread to check. */
3485 tp
= find_thread_ptid (inf
, ptid
);
3486 gdb_assert (tp
!= NULL
);
3487 if (!tp
->suspend
.waitstatus_pending_p
)
3492 && (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3493 || tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
3495 struct regcache
*regcache
= get_thread_regcache (tp
);
3496 struct gdbarch
*gdbarch
= regcache
->arch ();
3500 pc
= regcache_read_pc (regcache
);
3502 if (pc
!= tp
->suspend
.stop_pc
)
3505 fprintf_unfiltered (gdb_stdlog
,
3506 "infrun: PC of %s changed. was=%s, now=%s\n",
3507 target_pid_to_str (tp
->ptid
).c_str (),
3508 paddress (gdbarch
, tp
->suspend
.stop_pc
),
3509 paddress (gdbarch
, pc
));
3512 else if (!breakpoint_inserted_here_p (regcache
->aspace (), pc
))
3515 fprintf_unfiltered (gdb_stdlog
,
3516 "infrun: previous breakpoint of %s, at %s gone\n",
3517 target_pid_to_str (tp
->ptid
).c_str (),
3518 paddress (gdbarch
, pc
));
3526 fprintf_unfiltered (gdb_stdlog
,
3527 "infrun: pending event of %s cancelled.\n",
3528 target_pid_to_str (tp
->ptid
).c_str ());
3530 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_SPURIOUS
;
3531 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3540 = target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
3542 fprintf_unfiltered (gdb_stdlog
,
3543 "infrun: Using pending wait status %s for %s.\n",
3545 target_pid_to_str (tp
->ptid
).c_str ());
3548 /* Now that we've selected our final event LWP, un-adjust its PC
3549 if it was a software breakpoint (and the target doesn't
3550 always adjust the PC itself). */
3551 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3552 && !target_supports_stopped_by_sw_breakpoint ())
3554 struct regcache
*regcache
;
3555 struct gdbarch
*gdbarch
;
3558 regcache
= get_thread_regcache (tp
);
3559 gdbarch
= regcache
->arch ();
3561 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3566 pc
= regcache_read_pc (regcache
);
3567 regcache_write_pc (regcache
, pc
+ decr_pc
);
3571 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3572 *status
= tp
->suspend
.waitstatus
;
3573 tp
->suspend
.waitstatus_pending_p
= 0;
3575 /* Wake up the event loop again, until all pending events are
3577 if (target_is_async_p ())
3578 mark_async_event_handler (infrun_async_inferior_event_token
);
3582 /* But if we don't find one, we'll have to wait. */
3584 if (deprecated_target_wait_hook
)
3585 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3587 event_ptid
= target_wait (ptid
, status
, options
);
3592 /* Returns true if INF has any resumed thread with a status
3596 threads_are_resumed_pending_p (inferior
*inf
)
3598 for (thread_info
*tp
: inf
->non_exited_threads ())
3600 && tp
->suspend
.waitstatus_pending_p
)
3606 /* Wrapper for target_wait that first checks whether threads have
3607 pending statuses to report before actually asking the target for
3608 more events. Polls for events from all inferiors/targets. */
3611 do_target_wait (ptid_t wait_ptid
, execution_control_state
*ecs
, int options
)
3613 int num_inferiors
= 0;
3614 int random_selector
;
3616 /* For fairness, we pick the first inferior/target to poll at
3617 random, and then continue polling the rest of the inferior list
3618 starting from that one in a circular fashion until the whole list
3621 auto inferior_matches
= [&wait_ptid
] (inferior
*inf
)
3623 return (inf
->process_target () != NULL
3624 && (threads_are_executing (inf
->process_target ())
3625 || threads_are_resumed_pending_p (inf
))
3626 && ptid_t (inf
->pid
).matches (wait_ptid
));
3629 /* First see how many resumed inferiors we have. */
3630 for (inferior
*inf
: all_inferiors ())
3631 if (inferior_matches (inf
))
3634 if (num_inferiors
== 0)
3636 ecs
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
3640 /* Now randomly pick an inferior out of those that were resumed. */
3641 random_selector
= (int)
3642 ((num_inferiors
* (double) rand ()) / (RAND_MAX
+ 1.0));
3644 if (debug_infrun
&& num_inferiors
> 1)
3645 fprintf_unfiltered (gdb_stdlog
,
3646 "infrun: Found %d inferiors, starting at #%d\n",
3647 num_inferiors
, random_selector
);
3649 /* Select the Nth inferior that was resumed. */
3651 inferior
*selected
= nullptr;
3653 for (inferior
*inf
: all_inferiors ())
3654 if (inferior_matches (inf
))
3655 if (random_selector
-- == 0)
3661 /* Now poll for events out of each of the resumed inferior's
3662 targets, starting from the selected one. */
3664 auto do_wait
= [&] (inferior
*inf
)
3666 switch_to_inferior_no_thread (inf
);
3668 ecs
->ptid
= do_target_wait_1 (inf
, wait_ptid
, &ecs
->ws
, options
);
3669 ecs
->target
= inf
->process_target ();
3670 return (ecs
->ws
.kind
!= TARGET_WAITKIND_IGNORE
);
3673 /* Needed in all-stop+target-non-stop mode, because we end up here
3674 spuriously after the target is all stopped and we've already
3675 reported the stop to the user, polling for events. */
3676 scoped_restore_current_thread restore_thread
;
3678 int inf_num
= selected
->num
;
3679 for (inferior
*inf
= selected
; inf
!= NULL
; inf
= inf
->next
)
3680 if (inferior_matches (inf
))
3684 for (inferior
*inf
= inferior_list
;
3685 inf
!= NULL
&& inf
->num
< inf_num
;
3687 if (inferior_matches (inf
))
3691 ecs
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
3695 /* Prepare and stabilize the inferior for detaching it. E.g.,
3696 detaching while a thread is displaced stepping is a recipe for
3697 crashing it, as nothing would readjust the PC out of the scratch
3701 prepare_for_detach (void)
3703 struct inferior
*inf
= current_inferior ();
3704 ptid_t pid_ptid
= ptid_t (inf
->pid
);
3706 displaced_step_inferior_state
*displaced
= get_displaced_stepping_state (inf
);
3708 /* Is any thread of this process displaced stepping? If not,
3709 there's nothing else to do. */
3710 if (displaced
->step_thread
== nullptr)
3714 fprintf_unfiltered (gdb_stdlog
,
3715 "displaced-stepping in-process while detaching");
3717 scoped_restore restore_detaching
= make_scoped_restore (&inf
->detaching
, true);
3719 while (displaced
->step_thread
!= nullptr)
3721 struct execution_control_state ecss
;
3722 struct execution_control_state
*ecs
;
3725 memset (ecs
, 0, sizeof (*ecs
));
3727 overlay_cache_invalid
= 1;
3728 /* Flush target cache before starting to handle each event.
3729 Target was running and cache could be stale. This is just a
3730 heuristic. Running threads may modify target memory, but we
3731 don't get any event. */
3732 target_dcache_invalidate ();
3734 do_target_wait (pid_ptid
, ecs
, 0);
3737 print_target_wait_results (pid_ptid
, ecs
->ptid
, &ecs
->ws
);
3739 /* If an error happens while handling the event, propagate GDB's
3740 knowledge of the executing state to the frontend/user running
3742 scoped_finish_thread_state
finish_state (inf
->process_target (),
3745 /* Now figure out what to do with the result of the result. */
3746 handle_inferior_event (ecs
);
3748 /* No error, don't finish the state yet. */
3749 finish_state
.release ();
3751 /* Breakpoints and watchpoints are not installed on the target
3752 at this point, and signals are passed directly to the
3753 inferior, so this must mean the process is gone. */
3754 if (!ecs
->wait_some_more
)
3756 restore_detaching
.release ();
3757 error (_("Program exited while detaching"));
3761 restore_detaching
.release ();
3764 /* Wait for control to return from inferior to debugger.
3766 If inferior gets a signal, we may decide to start it up again
3767 instead of returning. That is why there is a loop in this function.
3768 When this function actually returns it means the inferior
3769 should be left stopped and GDB should read more commands. */
3772 wait_for_inferior (inferior
*inf
)
3776 (gdb_stdlog
, "infrun: wait_for_inferior ()\n");
3778 SCOPE_EXIT
{ delete_just_stopped_threads_infrun_breakpoints (); };
3780 /* If an error happens while handling the event, propagate GDB's
3781 knowledge of the executing state to the frontend/user running
3783 scoped_finish_thread_state finish_state
3784 (inf
->process_target (), minus_one_ptid
);
3788 struct execution_control_state ecss
;
3789 struct execution_control_state
*ecs
= &ecss
;
3791 memset (ecs
, 0, sizeof (*ecs
));
3793 overlay_cache_invalid
= 1;
3795 /* Flush target cache before starting to handle each event.
3796 Target was running and cache could be stale. This is just a
3797 heuristic. Running threads may modify target memory, but we
3798 don't get any event. */
3799 target_dcache_invalidate ();
3801 ecs
->ptid
= do_target_wait_1 (inf
, minus_one_ptid
, &ecs
->ws
, 0);
3802 ecs
->target
= inf
->process_target ();
3805 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, &ecs
->ws
);
3807 /* Now figure out what to do with the result of the result. */
3808 handle_inferior_event (ecs
);
3810 if (!ecs
->wait_some_more
)
3814 /* No error, don't finish the state yet. */
3815 finish_state
.release ();
3818 /* Cleanup that reinstalls the readline callback handler, if the
3819 target is running in the background. If while handling the target
3820 event something triggered a secondary prompt, like e.g., a
3821 pagination prompt, we'll have removed the callback handler (see
3822 gdb_readline_wrapper_line). Need to do this as we go back to the
3823 event loop, ready to process further input. Note this has no
3824 effect if the handler hasn't actually been removed, because calling
3825 rl_callback_handler_install resets the line buffer, thus losing
3829 reinstall_readline_callback_handler_cleanup ()
3831 struct ui
*ui
= current_ui
;
3835 /* We're not going back to the top level event loop yet. Don't
3836 install the readline callback, as it'd prep the terminal,
3837 readline-style (raw, noecho) (e.g., --batch). We'll install
3838 it the next time the prompt is displayed, when we're ready
3843 if (ui
->command_editing
&& ui
->prompt_state
!= PROMPT_BLOCKED
)
3844 gdb_rl_callback_handler_reinstall ();
3847 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3848 that's just the event thread. In all-stop, that's all threads. */
3851 clean_up_just_stopped_threads_fsms (struct execution_control_state
*ecs
)
3853 if (ecs
->event_thread
!= NULL
3854 && ecs
->event_thread
->thread_fsm
!= NULL
)
3855 ecs
->event_thread
->thread_fsm
->clean_up (ecs
->event_thread
);
3859 for (thread_info
*thr
: all_non_exited_threads ())
3861 if (thr
->thread_fsm
== NULL
)
3863 if (thr
== ecs
->event_thread
)
3866 switch_to_thread (thr
);
3867 thr
->thread_fsm
->clean_up (thr
);
3870 if (ecs
->event_thread
!= NULL
)
3871 switch_to_thread (ecs
->event_thread
);
3875 /* Helper for all_uis_check_sync_execution_done that works on the
3879 check_curr_ui_sync_execution_done (void)
3881 struct ui
*ui
= current_ui
;
3883 if (ui
->prompt_state
== PROMPT_NEEDED
3885 && !gdb_in_secondary_prompt_p (ui
))
3887 target_terminal::ours ();
3888 gdb::observers::sync_execution_done
.notify ();
3889 ui_register_input_event_handler (ui
);
3896 all_uis_check_sync_execution_done (void)
3898 SWITCH_THRU_ALL_UIS ()
3900 check_curr_ui_sync_execution_done ();
3907 all_uis_on_sync_execution_starting (void)
3909 SWITCH_THRU_ALL_UIS ()
3911 if (current_ui
->prompt_state
== PROMPT_NEEDED
)
3912 async_disable_stdin ();
3916 /* Asynchronous version of wait_for_inferior. It is called by the
3917 event loop whenever a change of state is detected on the file
3918 descriptor corresponding to the target. It can be called more than
3919 once to complete a single execution command. In such cases we need
3920 to keep the state in a global variable ECSS. If it is the last time
3921 that this function is called for a single execution command, then
3922 report to the user that the inferior has stopped, and do the
3923 necessary cleanups. */
3926 fetch_inferior_event (void *client_data
)
3928 struct execution_control_state ecss
;
3929 struct execution_control_state
*ecs
= &ecss
;
3932 memset (ecs
, 0, sizeof (*ecs
));
3934 /* Events are always processed with the main UI as current UI. This
3935 way, warnings, debug output, etc. are always consistently sent to
3936 the main console. */
3937 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, main_ui
);
3939 /* End up with readline processing input, if necessary. */
3941 SCOPE_EXIT
{ reinstall_readline_callback_handler_cleanup (); };
3943 /* We're handling a live event, so make sure we're doing live
3944 debugging. If we're looking at traceframes while the target is
3945 running, we're going to need to get back to that mode after
3946 handling the event. */
3947 gdb::optional
<scoped_restore_current_traceframe
> maybe_restore_traceframe
;
3950 maybe_restore_traceframe
.emplace ();
3951 set_current_traceframe (-1);
3954 /* The user/frontend should not notice a thread switch due to
3955 internal events. Make sure we revert to the user selected
3956 thread and frame after handling the event and running any
3957 breakpoint commands. */
3958 scoped_restore_current_thread restore_thread
;
3960 overlay_cache_invalid
= 1;
3961 /* Flush target cache before starting to handle each event. Target
3962 was running and cache could be stale. This is just a heuristic.
3963 Running threads may modify target memory, but we don't get any
3965 target_dcache_invalidate ();
3967 scoped_restore save_exec_dir
3968 = make_scoped_restore (&execution_direction
,
3969 target_execution_direction ());
3971 if (!do_target_wait (minus_one_ptid
, ecs
, TARGET_WNOHANG
))
3974 gdb_assert (ecs
->ws
.kind
!= TARGET_WAITKIND_IGNORE
);
3976 /* Switch to the target that generated the event, so we can do
3977 target calls. Any inferior bound to the target will do, so we
3978 just switch to the first we find. */
3979 for (inferior
*inf
: all_inferiors (ecs
->target
))
3981 switch_to_inferior_no_thread (inf
);
3986 print_target_wait_results (minus_one_ptid
, ecs
->ptid
, &ecs
->ws
);
3988 /* If an error happens while handling the event, propagate GDB's
3989 knowledge of the executing state to the frontend/user running
3991 ptid_t finish_ptid
= !target_is_non_stop_p () ? minus_one_ptid
: ecs
->ptid
;
3992 scoped_finish_thread_state
finish_state (ecs
->target
, finish_ptid
);
3994 /* Get executed before scoped_restore_current_thread above to apply
3995 still for the thread which has thrown the exception. */
3996 auto defer_bpstat_clear
3997 = make_scope_exit (bpstat_clear_actions
);
3998 auto defer_delete_threads
3999 = make_scope_exit (delete_just_stopped_threads_infrun_breakpoints
);
4001 /* Now figure out what to do with the result of the result. */
4002 handle_inferior_event (ecs
);
4004 if (!ecs
->wait_some_more
)
4006 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4007 int should_stop
= 1;
4008 struct thread_info
*thr
= ecs
->event_thread
;
4010 delete_just_stopped_threads_infrun_breakpoints ();
4014 struct thread_fsm
*thread_fsm
= thr
->thread_fsm
;
4016 if (thread_fsm
!= NULL
)
4017 should_stop
= thread_fsm
->should_stop (thr
);
4026 bool should_notify_stop
= true;
4029 clean_up_just_stopped_threads_fsms (ecs
);
4031 if (thr
!= NULL
&& thr
->thread_fsm
!= NULL
)
4032 should_notify_stop
= thr
->thread_fsm
->should_notify_stop ();
4034 if (should_notify_stop
)
4036 /* We may not find an inferior if this was a process exit. */
4037 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
4038 proceeded
= normal_stop ();
4043 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
4047 /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
4048 previously selected thread is gone. We have two
4049 choices - switch to no thread selected, or restore the
4050 previously selected thread (now exited). We chose the
4051 later, just because that's what GDB used to do. After
4052 this, "info threads" says "The current thread <Thread
4053 ID 2> has terminated." instead of "No thread
4057 && ecs
->ws
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
4058 restore_thread
.dont_restore ();
4062 defer_delete_threads
.release ();
4063 defer_bpstat_clear
.release ();
4065 /* No error, don't finish the thread states yet. */
4066 finish_state
.release ();
4068 /* This scope is used to ensure that readline callbacks are
4069 reinstalled here. */
4072 /* If a UI was in sync execution mode, and now isn't, restore its
4073 prompt (a synchronous execution command has finished, and we're
4074 ready for input). */
4075 all_uis_check_sync_execution_done ();
4078 && exec_done_display_p
4079 && (inferior_ptid
== null_ptid
4080 || inferior_thread ()->state
!= THREAD_RUNNING
))
4081 printf_unfiltered (_("completed.\n"));
4084 /* Record the frame and location we're currently stepping through. */
4086 set_step_info (struct frame_info
*frame
, struct symtab_and_line sal
)
4088 struct thread_info
*tp
= inferior_thread ();
4090 tp
->control
.step_frame_id
= get_frame_id (frame
);
4091 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
4093 tp
->current_symtab
= sal
.symtab
;
4094 tp
->current_line
= sal
.line
;
4097 /* Clear context switchable stepping state. */
4100 init_thread_stepping_state (struct thread_info
*tss
)
4102 tss
->stepped_breakpoint
= 0;
4103 tss
->stepping_over_breakpoint
= 0;
4104 tss
->stepping_over_watchpoint
= 0;
4105 tss
->step_after_step_resume_breakpoint
= 0;
4111 set_last_target_status (process_stratum_target
*target
, ptid_t ptid
,
4112 target_waitstatus status
)
4114 target_last_proc_target
= target
;
4115 target_last_wait_ptid
= ptid
;
4116 target_last_waitstatus
= status
;
4122 get_last_target_status (process_stratum_target
**target
, ptid_t
*ptid
,
4123 target_waitstatus
*status
)
4125 if (target
!= nullptr)
4126 *target
= target_last_proc_target
;
4127 if (ptid
!= nullptr)
4128 *ptid
= target_last_wait_ptid
;
4129 if (status
!= nullptr)
4130 *status
= target_last_waitstatus
;
4136 nullify_last_target_wait_ptid (void)
4138 target_last_proc_target
= nullptr;
4139 target_last_wait_ptid
= minus_one_ptid
;
4140 target_last_waitstatus
= {};
4143 /* Switch thread contexts. */
4146 context_switch (execution_control_state
*ecs
)
4149 && ecs
->ptid
!= inferior_ptid
4150 && (inferior_ptid
== null_ptid
4151 || ecs
->event_thread
!= inferior_thread ()))
4153 fprintf_unfiltered (gdb_stdlog
, "infrun: Switching context from %s ",
4154 target_pid_to_str (inferior_ptid
).c_str ());
4155 fprintf_unfiltered (gdb_stdlog
, "to %s\n",
4156 target_pid_to_str (ecs
->ptid
).c_str ());
4159 switch_to_thread (ecs
->event_thread
);
4162 /* If the target can't tell whether we've hit breakpoints
4163 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4164 check whether that could have been caused by a breakpoint. If so,
4165 adjust the PC, per gdbarch_decr_pc_after_break. */
4168 adjust_pc_after_break (struct thread_info
*thread
,
4169 struct target_waitstatus
*ws
)
4171 struct regcache
*regcache
;
4172 struct gdbarch
*gdbarch
;
4173 CORE_ADDR breakpoint_pc
, decr_pc
;
4175 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4176 we aren't, just return.
4178 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4179 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4180 implemented by software breakpoints should be handled through the normal
4183 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4184 different signals (SIGILL or SIGEMT for instance), but it is less
4185 clear where the PC is pointing afterwards. It may not match
4186 gdbarch_decr_pc_after_break. I don't know any specific target that
4187 generates these signals at breakpoints (the code has been in GDB since at
4188 least 1992) so I can not guess how to handle them here.
4190 In earlier versions of GDB, a target with
4191 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4192 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4193 target with both of these set in GDB history, and it seems unlikely to be
4194 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4196 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
4199 if (ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
4202 /* In reverse execution, when a breakpoint is hit, the instruction
4203 under it has already been de-executed. The reported PC always
4204 points at the breakpoint address, so adjusting it further would
4205 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4208 B1 0x08000000 : INSN1
4209 B2 0x08000001 : INSN2
4211 PC -> 0x08000003 : INSN4
4213 Say you're stopped at 0x08000003 as above. Reverse continuing
4214 from that point should hit B2 as below. Reading the PC when the
4215 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4216 been de-executed already.
4218 B1 0x08000000 : INSN1
4219 B2 PC -> 0x08000001 : INSN2
4223 We can't apply the same logic as for forward execution, because
4224 we would wrongly adjust the PC to 0x08000000, since there's a
4225 breakpoint at PC - 1. We'd then report a hit on B1, although
4226 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4228 if (execution_direction
== EXEC_REVERSE
)
4231 /* If the target can tell whether the thread hit a SW breakpoint,
4232 trust it. Targets that can tell also adjust the PC
4234 if (target_supports_stopped_by_sw_breakpoint ())
4237 /* Note that relying on whether a breakpoint is planted in memory to
4238 determine this can fail. E.g,. the breakpoint could have been
4239 removed since. Or the thread could have been told to step an
4240 instruction the size of a breakpoint instruction, and only
4241 _after_ was a breakpoint inserted at its address. */
4243 /* If this target does not decrement the PC after breakpoints, then
4244 we have nothing to do. */
4245 regcache
= get_thread_regcache (thread
);
4246 gdbarch
= regcache
->arch ();
4248 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4252 const address_space
*aspace
= regcache
->aspace ();
4254 /* Find the location where (if we've hit a breakpoint) the
4255 breakpoint would be. */
4256 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4258 /* If the target can't tell whether a software breakpoint triggered,
4259 fallback to figuring it out based on breakpoints we think were
4260 inserted in the target, and on whether the thread was stepped or
4263 /* Check whether there actually is a software breakpoint inserted at
4266 If in non-stop mode, a race condition is possible where we've
4267 removed a breakpoint, but stop events for that breakpoint were
4268 already queued and arrive later. To suppress those spurious
4269 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4270 and retire them after a number of stop events are reported. Note
4271 this is an heuristic and can thus get confused. The real fix is
4272 to get the "stopped by SW BP and needs adjustment" info out of
4273 the target/kernel (and thus never reach here; see above). */
4274 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4275 || (target_is_non_stop_p ()
4276 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4278 gdb::optional
<scoped_restore_tmpl
<int>> restore_operation_disable
;
4280 if (record_full_is_used ())
4281 restore_operation_disable
.emplace
4282 (record_full_gdb_operation_disable_set ());
4284 /* When using hardware single-step, a SIGTRAP is reported for both
4285 a completed single-step and a software breakpoint. Need to
4286 differentiate between the two, as the latter needs adjusting
4287 but the former does not.
4289 The SIGTRAP can be due to a completed hardware single-step only if
4290 - we didn't insert software single-step breakpoints
4291 - this thread is currently being stepped
4293 If any of these events did not occur, we must have stopped due
4294 to hitting a software breakpoint, and have to back up to the
4297 As a special case, we could have hardware single-stepped a
4298 software breakpoint. In this case (prev_pc == breakpoint_pc),
4299 we also need to back up to the breakpoint address. */
4301 if (thread_has_single_step_breakpoints_set (thread
)
4302 || !currently_stepping (thread
)
4303 || (thread
->stepped_breakpoint
4304 && thread
->prev_pc
== breakpoint_pc
))
4305 regcache_write_pc (regcache
, breakpoint_pc
);
4310 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4312 for (frame
= get_prev_frame (frame
);
4314 frame
= get_prev_frame (frame
))
4316 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4318 if (get_frame_type (frame
) != INLINE_FRAME
)
4325 /* Look for an inline frame that is marked for skip.
4326 If PREV_FRAME is TRUE start at the previous frame,
4327 otherwise start at the current frame. Stop at the
4328 first non-inline frame, or at the frame where the
4332 inline_frame_is_marked_for_skip (bool prev_frame
, struct thread_info
*tp
)
4334 struct frame_info
*frame
= get_current_frame ();
4337 frame
= get_prev_frame (frame
);
4339 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
4341 const char *fn
= NULL
;
4342 symtab_and_line sal
;
4345 if (frame_id_eq (get_frame_id (frame
), tp
->control
.step_frame_id
))
4347 if (get_frame_type (frame
) != INLINE_FRAME
)
4350 sal
= find_frame_sal (frame
);
4351 sym
= get_frame_function (frame
);
4354 fn
= sym
->print_name ();
4357 && function_name_is_marked_for_skip (fn
, sal
))
4364 /* If the event thread has the stop requested flag set, pretend it
4365 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4369 handle_stop_requested (struct execution_control_state
*ecs
)
4371 if (ecs
->event_thread
->stop_requested
)
4373 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
4374 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
4375 handle_signal_stop (ecs
);
4381 /* Auxiliary function that handles syscall entry/return events.
4382 It returns 1 if the inferior should keep going (and GDB
4383 should ignore the event), or 0 if the event deserves to be
4387 handle_syscall_event (struct execution_control_state
*ecs
)
4389 struct regcache
*regcache
;
4392 context_switch (ecs
);
4394 regcache
= get_thread_regcache (ecs
->event_thread
);
4395 syscall_number
= ecs
->ws
.value
.syscall_number
;
4396 ecs
->event_thread
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4398 if (catch_syscall_enabled () > 0
4399 && catching_syscall_number (syscall_number
) > 0)
4402 fprintf_unfiltered (gdb_stdlog
, "infrun: syscall number = '%d'\n",
4405 ecs
->event_thread
->control
.stop_bpstat
4406 = bpstat_stop_status (regcache
->aspace (),
4407 ecs
->event_thread
->suspend
.stop_pc
,
4408 ecs
->event_thread
, &ecs
->ws
);
4410 if (handle_stop_requested (ecs
))
4413 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4415 /* Catchpoint hit. */
4420 if (handle_stop_requested (ecs
))
4423 /* If no catchpoint triggered for this, then keep going. */
4428 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4431 fill_in_stop_func (struct gdbarch
*gdbarch
,
4432 struct execution_control_state
*ecs
)
4434 if (!ecs
->stop_func_filled_in
)
4438 /* Don't care about return value; stop_func_start and stop_func_name
4439 will both be 0 if it doesn't work. */
4440 find_pc_partial_function (ecs
->event_thread
->suspend
.stop_pc
,
4441 &ecs
->stop_func_name
,
4442 &ecs
->stop_func_start
,
4443 &ecs
->stop_func_end
,
4446 /* The call to find_pc_partial_function, above, will set
4447 stop_func_start and stop_func_end to the start and end
4448 of the range containing the stop pc. If this range
4449 contains the entry pc for the block (which is always the
4450 case for contiguous blocks), advance stop_func_start past
4451 the function's start offset and entrypoint. Note that
4452 stop_func_start is NOT advanced when in a range of a
4453 non-contiguous block that does not contain the entry pc. */
4454 if (block
!= nullptr
4455 && ecs
->stop_func_start
<= BLOCK_ENTRY_PC (block
)
4456 && BLOCK_ENTRY_PC (block
) < ecs
->stop_func_end
)
4458 ecs
->stop_func_start
4459 += gdbarch_deprecated_function_start_offset (gdbarch
);
4461 if (gdbarch_skip_entrypoint_p (gdbarch
))
4462 ecs
->stop_func_start
4463 = gdbarch_skip_entrypoint (gdbarch
, ecs
->stop_func_start
);
4466 ecs
->stop_func_filled_in
= 1;
4471 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
4473 static enum stop_kind
4474 get_inferior_stop_soon (execution_control_state
*ecs
)
4476 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
4478 gdb_assert (inf
!= NULL
);
4479 return inf
->control
.stop_soon
;
4482 /* Poll for one event out of the current target. Store the resulting
4483 waitstatus in WS, and return the event ptid. Does not block. */
4486 poll_one_curr_target (struct target_waitstatus
*ws
)
4490 overlay_cache_invalid
= 1;
4492 /* Flush target cache before starting to handle each event.
4493 Target was running and cache could be stale. This is just a
4494 heuristic. Running threads may modify target memory, but we
4495 don't get any event. */
4496 target_dcache_invalidate ();
4498 if (deprecated_target_wait_hook
)
4499 event_ptid
= deprecated_target_wait_hook (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4501 event_ptid
= target_wait (minus_one_ptid
, ws
, TARGET_WNOHANG
);
4504 print_target_wait_results (minus_one_ptid
, event_ptid
, ws
);
4509 /* An event reported by wait_one. */
4511 struct wait_one_event
4513 /* The target the event came out of. */
4514 process_stratum_target
*target
;
4516 /* The PTID the event was for. */
4519 /* The waitstatus. */
4520 target_waitstatus ws
;
4523 /* Wait for one event out of any target. */
4525 static wait_one_event
4530 for (inferior
*inf
: all_inferiors ())
4532 process_stratum_target
*target
= inf
->process_target ();
4534 || !target
->is_async_p ()
4535 || !target
->threads_executing
)
4538 switch_to_inferior_no_thread (inf
);
4540 wait_one_event event
;
4541 event
.target
= target
;
4542 event
.ptid
= poll_one_curr_target (&event
.ws
);
4544 if (event
.ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4546 /* If nothing is resumed, remove the target from the
4550 else if (event
.ws
.kind
!= TARGET_WAITKIND_IGNORE
)
4554 /* Block waiting for some event. */
4561 for (inferior
*inf
: all_inferiors ())
4563 process_stratum_target
*target
= inf
->process_target ();
4565 || !target
->is_async_p ()
4566 || !target
->threads_executing
)
4569 int fd
= target
->async_wait_fd ();
4570 FD_SET (fd
, &readfds
);
4577 /* No waitable targets left. All must be stopped. */
4578 return {NULL
, minus_one_ptid
, {TARGET_WAITKIND_NO_RESUMED
}};
4583 int numfds
= interruptible_select (nfds
, &readfds
, 0, NULL
, 0);
4589 perror_with_name ("interruptible_select");
4594 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4595 instead of the current thread. */
4596 #define THREAD_STOPPED_BY(REASON) \
4598 thread_stopped_by_ ## REASON (ptid_t ptid) \
4600 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); \
4601 inferior_ptid = ptid; \
4603 return target_stopped_by_ ## REASON (); \
4606 /* Generate thread_stopped_by_watchpoint. */
4607 THREAD_STOPPED_BY (watchpoint
)
4608 /* Generate thread_stopped_by_sw_breakpoint. */
4609 THREAD_STOPPED_BY (sw_breakpoint
)
4610 /* Generate thread_stopped_by_hw_breakpoint. */
4611 THREAD_STOPPED_BY (hw_breakpoint
)
4613 /* Save the thread's event and stop reason to process it later. */
4616 save_waitstatus (struct thread_info
*tp
, const target_waitstatus
*ws
)
4620 std::string statstr
= target_waitstatus_to_string (ws
);
4622 fprintf_unfiltered (gdb_stdlog
,
4623 "infrun: saving status %s for %d.%ld.%ld\n",
4630 /* Record for later. */
4631 tp
->suspend
.waitstatus
= *ws
;
4632 tp
->suspend
.waitstatus_pending_p
= 1;
4634 struct regcache
*regcache
= get_thread_regcache (tp
);
4635 const address_space
*aspace
= regcache
->aspace ();
4637 if (ws
->kind
== TARGET_WAITKIND_STOPPED
4638 && ws
->value
.sig
== GDB_SIGNAL_TRAP
)
4640 CORE_ADDR pc
= regcache_read_pc (regcache
);
4642 adjust_pc_after_break (tp
, &tp
->suspend
.waitstatus
);
4644 if (thread_stopped_by_watchpoint (tp
->ptid
))
4646 tp
->suspend
.stop_reason
4647 = TARGET_STOPPED_BY_WATCHPOINT
;
4649 else if (target_supports_stopped_by_sw_breakpoint ()
4650 && thread_stopped_by_sw_breakpoint (tp
->ptid
))
4652 tp
->suspend
.stop_reason
4653 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4655 else if (target_supports_stopped_by_hw_breakpoint ()
4656 && thread_stopped_by_hw_breakpoint (tp
->ptid
))
4658 tp
->suspend
.stop_reason
4659 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4661 else if (!target_supports_stopped_by_hw_breakpoint ()
4662 && hardware_breakpoint_inserted_here_p (aspace
,
4665 tp
->suspend
.stop_reason
4666 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4668 else if (!target_supports_stopped_by_sw_breakpoint ()
4669 && software_breakpoint_inserted_here_p (aspace
,
4672 tp
->suspend
.stop_reason
4673 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4675 else if (!thread_has_single_step_breakpoints_set (tp
)
4676 && currently_stepping (tp
))
4678 tp
->suspend
.stop_reason
4679 = TARGET_STOPPED_BY_SINGLE_STEP
;
4687 stop_all_threads (void)
4689 /* We may need multiple passes to discover all threads. */
4693 gdb_assert (target_is_non_stop_p ());
4696 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads\n");
4698 scoped_restore_current_thread restore_thread
;
4700 target_thread_events (1);
4701 SCOPE_EXIT
{ target_thread_events (0); };
4703 /* Request threads to stop, and then wait for the stops. Because
4704 threads we already know about can spawn more threads while we're
4705 trying to stop them, and we only learn about new threads when we
4706 update the thread list, do this in a loop, and keep iterating
4707 until two passes find no threads that need to be stopped. */
4708 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4711 fprintf_unfiltered (gdb_stdlog
,
4712 "infrun: stop_all_threads, pass=%d, "
4713 "iterations=%d\n", pass
, iterations
);
4718 update_thread_list ();
4720 /* Go through all threads looking for threads that we need
4721 to tell the target to stop. */
4722 for (thread_info
*t
: all_non_exited_threads ())
4726 /* If already stopping, don't request a stop again.
4727 We just haven't seen the notification yet. */
4728 if (!t
->stop_requested
)
4731 fprintf_unfiltered (gdb_stdlog
,
4732 "infrun: %s executing, "
4734 target_pid_to_str (t
->ptid
).c_str ());
4735 switch_to_thread_no_regs (t
);
4736 target_stop (t
->ptid
);
4737 t
->stop_requested
= 1;
4742 fprintf_unfiltered (gdb_stdlog
,
4743 "infrun: %s executing, "
4744 "already stopping\n",
4745 target_pid_to_str (t
->ptid
).c_str ());
4748 if (t
->stop_requested
)
4754 fprintf_unfiltered (gdb_stdlog
,
4755 "infrun: %s not executing\n",
4756 target_pid_to_str (t
->ptid
).c_str ());
4758 /* The thread may be not executing, but still be
4759 resumed with a pending status to process. */
4767 /* If we find new threads on the second iteration, restart
4768 over. We want to see two iterations in a row with all
4773 wait_one_event event
= wait_one ();
4777 fprintf_unfiltered (gdb_stdlog
,
4778 "infrun: stop_all_threads %s %s\n",
4779 target_waitstatus_to_string (&event
.ws
).c_str (),
4780 target_pid_to_str (event
.ptid
).c_str ());
4783 if (event
.ws
.kind
== TARGET_WAITKIND_NO_RESUMED
4784 || event
.ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
4785 || event
.ws
.kind
== TARGET_WAITKIND_EXITED
4786 || event
.ws
.kind
== TARGET_WAITKIND_SIGNALLED
)
4788 /* All resumed threads exited
4789 or one thread/process exited/signalled. */
4793 thread_info
*t
= find_thread_ptid (event
.target
, event
.ptid
);
4795 t
= add_thread (event
.target
, event
.ptid
);
4797 t
->stop_requested
= 0;
4800 t
->control
.may_range_step
= 0;
4802 /* This may be the first time we see the inferior report
4804 inferior
*inf
= find_inferior_ptid (event
.target
, event
.ptid
);
4805 if (inf
->needs_setup
)
4807 switch_to_thread_no_regs (t
);
4811 if (event
.ws
.kind
== TARGET_WAITKIND_STOPPED
4812 && event
.ws
.value
.sig
== GDB_SIGNAL_0
)
4814 /* We caught the event that we intended to catch, so
4815 there's no event pending. */
4816 t
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
4817 t
->suspend
.waitstatus_pending_p
= 0;
4819 if (displaced_step_fixup (t
, GDB_SIGNAL_0
) < 0)
4821 /* Add it back to the step-over queue. */
4824 fprintf_unfiltered (gdb_stdlog
,
4825 "infrun: displaced-step of %s "
4826 "canceled: adding back to the "
4827 "step-over queue\n",
4828 target_pid_to_str (t
->ptid
).c_str ());
4830 t
->control
.trap_expected
= 0;
4831 thread_step_over_chain_enqueue (t
);
4836 enum gdb_signal sig
;
4837 struct regcache
*regcache
;
4841 std::string statstr
= target_waitstatus_to_string (&event
.ws
);
4843 fprintf_unfiltered (gdb_stdlog
,
4844 "infrun: target_wait %s, saving "
4845 "status for %d.%ld.%ld\n",
4852 /* Record for later. */
4853 save_waitstatus (t
, &event
.ws
);
4855 sig
= (event
.ws
.kind
== TARGET_WAITKIND_STOPPED
4856 ? event
.ws
.value
.sig
: GDB_SIGNAL_0
);
4858 if (displaced_step_fixup (t
, sig
) < 0)
4860 /* Add it back to the step-over queue. */
4861 t
->control
.trap_expected
= 0;
4862 thread_step_over_chain_enqueue (t
);
4865 regcache
= get_thread_regcache (t
);
4866 t
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4870 fprintf_unfiltered (gdb_stdlog
,
4871 "infrun: saved stop_pc=%s for %s "
4872 "(currently_stepping=%d)\n",
4873 paddress (target_gdbarch (),
4874 t
->suspend
.stop_pc
),
4875 target_pid_to_str (t
->ptid
).c_str (),
4876 currently_stepping (t
));
4884 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads done\n");
4887 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
4890 handle_no_resumed (struct execution_control_state
*ecs
)
4892 if (target_can_async_p ())
4899 if (ui
->prompt_state
== PROMPT_BLOCKED
)
4907 /* There were no unwaited-for children left in the target, but,
4908 we're not synchronously waiting for events either. Just
4912 fprintf_unfiltered (gdb_stdlog
,
4913 "infrun: TARGET_WAITKIND_NO_RESUMED "
4914 "(ignoring: bg)\n");
4915 prepare_to_wait (ecs
);
4920 /* Otherwise, if we were running a synchronous execution command, we
4921 may need to cancel it and give the user back the terminal.
4923 In non-stop mode, the target can't tell whether we've already
4924 consumed previous stop events, so it can end up sending us a
4925 no-resumed event like so:
4927 #0 - thread 1 is left stopped
4929 #1 - thread 2 is resumed and hits breakpoint
4930 -> TARGET_WAITKIND_STOPPED
4932 #2 - thread 3 is resumed and exits
4933 this is the last resumed thread, so
4934 -> TARGET_WAITKIND_NO_RESUMED
4936 #3 - gdb processes stop for thread 2 and decides to re-resume
4939 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
4940 thread 2 is now resumed, so the event should be ignored.
4942 IOW, if the stop for thread 2 doesn't end a foreground command,
4943 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
4944 event. But it could be that the event meant that thread 2 itself
4945 (or whatever other thread was the last resumed thread) exited.
4947 To address this we refresh the thread list and check whether we
4948 have resumed threads _now_. In the example above, this removes
4949 thread 3 from the thread list. If thread 2 was re-resumed, we
4950 ignore this event. If we find no thread resumed, then we cancel
4951 the synchronous command show "no unwaited-for " to the user. */
4952 update_thread_list ();
4954 for (thread_info
*thread
: all_non_exited_threads (ecs
->target
))
4956 if (thread
->executing
4957 || thread
->suspend
.waitstatus_pending_p
)
4959 /* There were no unwaited-for children left in the target at
4960 some point, but there are now. Just ignore. */
4962 fprintf_unfiltered (gdb_stdlog
,
4963 "infrun: TARGET_WAITKIND_NO_RESUMED "
4964 "(ignoring: found resumed)\n");
4965 prepare_to_wait (ecs
);
4970 /* Note however that we may find no resumed thread because the whole
4971 process exited meanwhile (thus updating the thread list results
4972 in an empty thread list). In this case we know we'll be getting
4973 a process exit event shortly. */
4974 for (inferior
*inf
: all_non_exited_inferiors (ecs
->target
))
4976 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4980 fprintf_unfiltered (gdb_stdlog
,
4981 "infrun: TARGET_WAITKIND_NO_RESUMED "
4982 "(expect process exit)\n");
4983 prepare_to_wait (ecs
);
4988 /* Go ahead and report the event. */
4992 /* Given an execution control state that has been freshly filled in by
4993 an event from the inferior, figure out what it means and take
4996 The alternatives are:
4998 1) stop_waiting and return; to really stop and return to the
5001 2) keep_going and return; to wait for the next event (set
5002 ecs->event_thread->stepping_over_breakpoint to 1 to single step
5006 handle_inferior_event (struct execution_control_state
*ecs
)
5008 /* Make sure that all temporary struct value objects that were
5009 created during the handling of the event get deleted at the
5011 scoped_value_mark free_values
;
5013 enum stop_kind stop_soon
;
5016 fprintf_unfiltered (gdb_stdlog
, "infrun: handle_inferior_event %s\n",
5017 target_waitstatus_to_string (&ecs
->ws
).c_str ());
5019 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
5021 /* We had an event in the inferior, but we are not interested in
5022 handling it at this level. The lower layers have already
5023 done what needs to be done, if anything.
5025 One of the possible circumstances for this is when the
5026 inferior produces output for the console. The inferior has
5027 not stopped, and we are ignoring the event. Another possible
5028 circumstance is any event which the lower level knows will be
5029 reported multiple times without an intervening resume. */
5030 prepare_to_wait (ecs
);
5034 if (ecs
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
5036 prepare_to_wait (ecs
);
5040 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
5041 && handle_no_resumed (ecs
))
5044 /* Cache the last target/ptid/waitstatus. */
5045 set_last_target_status (ecs
->target
, ecs
->ptid
, ecs
->ws
);
5047 /* Always clear state belonging to the previous time we stopped. */
5048 stop_stack_dummy
= STOP_NONE
;
5050 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
5052 /* No unwaited-for children left. IOW, all resumed children
5054 stop_print_frame
= 0;
5059 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
5060 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
5062 ecs
->event_thread
= find_thread_ptid (ecs
->target
, ecs
->ptid
);
5063 /* If it's a new thread, add it to the thread database. */
5064 if (ecs
->event_thread
== NULL
)
5065 ecs
->event_thread
= add_thread (ecs
->target
, ecs
->ptid
);
5067 /* Disable range stepping. If the next step request could use a
5068 range, this will be end up re-enabled then. */
5069 ecs
->event_thread
->control
.may_range_step
= 0;
5072 /* Dependent on valid ECS->EVENT_THREAD. */
5073 adjust_pc_after_break (ecs
->event_thread
, &ecs
->ws
);
5075 /* Dependent on the current PC value modified by adjust_pc_after_break. */
5076 reinit_frame_cache ();
5078 breakpoint_retire_moribund ();
5080 /* First, distinguish signals caused by the debugger from signals
5081 that have to do with the program's own actions. Note that
5082 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
5083 on the operating system version. Here we detect when a SIGILL or
5084 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
5085 something similar for SIGSEGV, since a SIGSEGV will be generated
5086 when we're trying to execute a breakpoint instruction on a
5087 non-executable stack. This happens for call dummy breakpoints
5088 for architectures like SPARC that place call dummies on the
5090 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
5091 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
5092 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
5093 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
5095 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5097 if (breakpoint_inserted_here_p (regcache
->aspace (),
5098 regcache_read_pc (regcache
)))
5101 fprintf_unfiltered (gdb_stdlog
,
5102 "infrun: Treating signal as SIGTRAP\n");
5103 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
5107 /* Mark the non-executing threads accordingly. In all-stop, all
5108 threads of all processes are stopped when we get any event
5109 reported. In non-stop mode, only the event thread stops. */
5113 if (!target_is_non_stop_p ())
5114 mark_ptid
= minus_one_ptid
;
5115 else if (ecs
->ws
.kind
== TARGET_WAITKIND_SIGNALLED
5116 || ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
5118 /* If we're handling a process exit in non-stop mode, even
5119 though threads haven't been deleted yet, one would think
5120 that there is nothing to do, as threads of the dead process
5121 will be soon deleted, and threads of any other process were
5122 left running. However, on some targets, threads survive a
5123 process exit event. E.g., for the "checkpoint" command,
5124 when the current checkpoint/fork exits, linux-fork.c
5125 automatically switches to another fork from within
5126 target_mourn_inferior, by associating the same
5127 inferior/thread to another fork. We haven't mourned yet at
5128 this point, but we must mark any threads left in the
5129 process as not-executing so that finish_thread_state marks
5130 them stopped (in the user's perspective) if/when we present
5131 the stop to the user. */
5132 mark_ptid
= ptid_t (ecs
->ptid
.pid ());
5135 mark_ptid
= ecs
->ptid
;
5137 set_executing (ecs
->target
, mark_ptid
, 0);
5139 /* Likewise the resumed flag. */
5140 set_resumed (ecs
->target
, mark_ptid
, 0);
5143 switch (ecs
->ws
.kind
)
5145 case TARGET_WAITKIND_LOADED
:
5146 context_switch (ecs
);
5147 /* Ignore gracefully during startup of the inferior, as it might
5148 be the shell which has just loaded some objects, otherwise
5149 add the symbols for the newly loaded objects. Also ignore at
5150 the beginning of an attach or remote session; we will query
5151 the full list of libraries once the connection is
5154 stop_soon
= get_inferior_stop_soon (ecs
);
5155 if (stop_soon
== NO_STOP_QUIETLY
)
5157 struct regcache
*regcache
;
5159 regcache
= get_thread_regcache (ecs
->event_thread
);
5161 handle_solib_event ();
5163 ecs
->event_thread
->control
.stop_bpstat
5164 = bpstat_stop_status (regcache
->aspace (),
5165 ecs
->event_thread
->suspend
.stop_pc
,
5166 ecs
->event_thread
, &ecs
->ws
);
5168 if (handle_stop_requested (ecs
))
5171 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5173 /* A catchpoint triggered. */
5174 process_event_stop_test (ecs
);
5178 /* If requested, stop when the dynamic linker notifies
5179 gdb of events. This allows the user to get control
5180 and place breakpoints in initializer routines for
5181 dynamically loaded objects (among other things). */
5182 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5183 if (stop_on_solib_events
)
5185 /* Make sure we print "Stopped due to solib-event" in
5187 stop_print_frame
= 1;
5194 /* If we are skipping through a shell, or through shared library
5195 loading that we aren't interested in, resume the program. If
5196 we're running the program normally, also resume. */
5197 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
5199 /* Loading of shared libraries might have changed breakpoint
5200 addresses. Make sure new breakpoints are inserted. */
5201 if (stop_soon
== NO_STOP_QUIETLY
)
5202 insert_breakpoints ();
5203 resume (GDB_SIGNAL_0
);
5204 prepare_to_wait (ecs
);
5208 /* But stop if we're attaching or setting up a remote
5210 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5211 || stop_soon
== STOP_QUIETLY_REMOTE
)
5214 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
5219 internal_error (__FILE__
, __LINE__
,
5220 _("unhandled stop_soon: %d"), (int) stop_soon
);
5222 case TARGET_WAITKIND_SPURIOUS
:
5223 if (handle_stop_requested (ecs
))
5225 context_switch (ecs
);
5226 resume (GDB_SIGNAL_0
);
5227 prepare_to_wait (ecs
);
5230 case TARGET_WAITKIND_THREAD_CREATED
:
5231 if (handle_stop_requested (ecs
))
5233 context_switch (ecs
);
5234 if (!switch_back_to_stepped_thread (ecs
))
5238 case TARGET_WAITKIND_EXITED
:
5239 case TARGET_WAITKIND_SIGNALLED
:
5240 inferior_ptid
= ecs
->ptid
;
5241 set_current_inferior (find_inferior_ptid (ecs
->target
, ecs
->ptid
));
5242 set_current_program_space (current_inferior ()->pspace
);
5243 handle_vfork_child_exec_or_exit (0);
5244 target_terminal::ours (); /* Must do this before mourn anyway. */
5246 /* Clearing any previous state of convenience variables. */
5247 clear_exit_convenience_vars ();
5249 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
5251 /* Record the exit code in the convenience variable $_exitcode, so
5252 that the user can inspect this again later. */
5253 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5254 (LONGEST
) ecs
->ws
.value
.integer
);
5256 /* Also record this in the inferior itself. */
5257 current_inferior ()->has_exit_code
= 1;
5258 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
5260 /* Support the --return-child-result option. */
5261 return_child_result_value
= ecs
->ws
.value
.integer
;
5263 gdb::observers::exited
.notify (ecs
->ws
.value
.integer
);
5267 struct gdbarch
*gdbarch
= current_inferior ()->gdbarch
;
5269 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
5271 /* Set the value of the internal variable $_exitsignal,
5272 which holds the signal uncaught by the inferior. */
5273 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5274 gdbarch_gdb_signal_to_target (gdbarch
,
5275 ecs
->ws
.value
.sig
));
5279 /* We don't have access to the target's method used for
5280 converting between signal numbers (GDB's internal
5281 representation <-> target's representation).
5282 Therefore, we cannot do a good job at displaying this
5283 information to the user. It's better to just warn
5284 her about it (if infrun debugging is enabled), and
5287 fprintf_filtered (gdb_stdlog
, _("\
5288 Cannot fill $_exitsignal with the correct signal number.\n"));
5291 gdb::observers::signal_exited
.notify (ecs
->ws
.value
.sig
);
5294 gdb_flush (gdb_stdout
);
5295 target_mourn_inferior (inferior_ptid
);
5296 stop_print_frame
= 0;
5300 case TARGET_WAITKIND_FORKED
:
5301 case TARGET_WAITKIND_VFORKED
:
5302 /* Check whether the inferior is displaced stepping. */
5304 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5305 struct gdbarch
*gdbarch
= regcache
->arch ();
5307 /* If checking displaced stepping is supported, and thread
5308 ecs->ptid is displaced stepping. */
5309 if (displaced_step_in_progress_thread (ecs
->event_thread
))
5311 struct inferior
*parent_inf
5312 = find_inferior_ptid (ecs
->target
, ecs
->ptid
);
5313 struct regcache
*child_regcache
;
5314 CORE_ADDR parent_pc
;
5316 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5317 indicating that the displaced stepping of syscall instruction
5318 has been done. Perform cleanup for parent process here. Note
5319 that this operation also cleans up the child process for vfork,
5320 because their pages are shared. */
5321 displaced_step_fixup (ecs
->event_thread
, GDB_SIGNAL_TRAP
);
5322 /* Start a new step-over in another thread if there's one
5326 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
5328 struct displaced_step_inferior_state
*displaced
5329 = get_displaced_stepping_state (parent_inf
);
5331 /* Restore scratch pad for child process. */
5332 displaced_step_restore (displaced
, ecs
->ws
.value
.related_pid
);
5335 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5336 the child's PC is also within the scratchpad. Set the child's PC
5337 to the parent's PC value, which has already been fixed up.
5338 FIXME: we use the parent's aspace here, although we're touching
5339 the child, because the child hasn't been added to the inferior
5340 list yet at this point. */
5343 = get_thread_arch_aspace_regcache (parent_inf
->process_target (),
5344 ecs
->ws
.value
.related_pid
,
5346 parent_inf
->aspace
);
5347 /* Read PC value of parent process. */
5348 parent_pc
= regcache_read_pc (regcache
);
5350 if (debug_displaced
)
5351 fprintf_unfiltered (gdb_stdlog
,
5352 "displaced: write child pc from %s to %s\n",
5354 regcache_read_pc (child_regcache
)),
5355 paddress (gdbarch
, parent_pc
));
5357 regcache_write_pc (child_regcache
, parent_pc
);
5361 context_switch (ecs
);
5363 /* Immediately detach breakpoints from the child before there's
5364 any chance of letting the user delete breakpoints from the
5365 breakpoint lists. If we don't do this early, it's easy to
5366 leave left over traps in the child, vis: "break foo; catch
5367 fork; c; <fork>; del; c; <child calls foo>". We only follow
5368 the fork on the last `continue', and by that time the
5369 breakpoint at "foo" is long gone from the breakpoint table.
5370 If we vforked, then we don't need to unpatch here, since both
5371 parent and child are sharing the same memory pages; we'll
5372 need to unpatch at follow/detach time instead to be certain
5373 that new breakpoints added between catchpoint hit time and
5374 vfork follow are detached. */
5375 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
5377 /* This won't actually modify the breakpoint list, but will
5378 physically remove the breakpoints from the child. */
5379 detach_breakpoints (ecs
->ws
.value
.related_pid
);
5382 delete_just_stopped_threads_single_step_breakpoints ();
5384 /* In case the event is caught by a catchpoint, remember that
5385 the event is to be followed at the next resume of the thread,
5386 and not immediately. */
5387 ecs
->event_thread
->pending_follow
= ecs
->ws
;
5389 ecs
->event_thread
->suspend
.stop_pc
5390 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
5392 ecs
->event_thread
->control
.stop_bpstat
5393 = bpstat_stop_status (get_current_regcache ()->aspace (),
5394 ecs
->event_thread
->suspend
.stop_pc
,
5395 ecs
->event_thread
, &ecs
->ws
);
5397 if (handle_stop_requested (ecs
))
5400 /* If no catchpoint triggered for this, then keep going. Note
5401 that we're interested in knowing the bpstat actually causes a
5402 stop, not just if it may explain the signal. Software
5403 watchpoints, for example, always appear in the bpstat. */
5404 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5408 = (follow_fork_mode_string
== follow_fork_mode_child
);
5410 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5412 process_stratum_target
*targ
5413 = ecs
->event_thread
->inf
->process_target ();
5415 should_resume
= follow_fork ();
5417 /* Note that one of these may be an invalid pointer,
5418 depending on detach_fork. */
5419 thread_info
*parent
= ecs
->event_thread
;
5421 = find_thread_ptid (targ
, ecs
->ws
.value
.related_pid
);
5423 /* At this point, the parent is marked running, and the
5424 child is marked stopped. */
5426 /* If not resuming the parent, mark it stopped. */
5427 if (follow_child
&& !detach_fork
&& !non_stop
&& !sched_multi
)
5428 parent
->set_running (false);
5430 /* If resuming the child, mark it running. */
5431 if (follow_child
|| (!detach_fork
&& (non_stop
|| sched_multi
)))
5432 child
->set_running (true);
5434 /* In non-stop mode, also resume the other branch. */
5435 if (!detach_fork
&& (non_stop
5436 || (sched_multi
&& target_is_non_stop_p ())))
5439 switch_to_thread (parent
);
5441 switch_to_thread (child
);
5443 ecs
->event_thread
= inferior_thread ();
5444 ecs
->ptid
= inferior_ptid
;
5449 switch_to_thread (child
);
5451 switch_to_thread (parent
);
5453 ecs
->event_thread
= inferior_thread ();
5454 ecs
->ptid
= inferior_ptid
;
5462 process_event_stop_test (ecs
);
5465 case TARGET_WAITKIND_VFORK_DONE
:
5466 /* Done with the shared memory region. Re-insert breakpoints in
5467 the parent, and keep going. */
5469 context_switch (ecs
);
5471 current_inferior ()->waiting_for_vfork_done
= 0;
5472 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
5474 if (handle_stop_requested (ecs
))
5477 /* This also takes care of reinserting breakpoints in the
5478 previously locked inferior. */
5482 case TARGET_WAITKIND_EXECD
:
5484 /* Note we can't read registers yet (the stop_pc), because we
5485 don't yet know the inferior's post-exec architecture.
5486 'stop_pc' is explicitly read below instead. */
5487 switch_to_thread_no_regs (ecs
->event_thread
);
5489 /* Do whatever is necessary to the parent branch of the vfork. */
5490 handle_vfork_child_exec_or_exit (1);
5492 /* This causes the eventpoints and symbol table to be reset.
5493 Must do this now, before trying to determine whether to
5495 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
5497 /* In follow_exec we may have deleted the original thread and
5498 created a new one. Make sure that the event thread is the
5499 execd thread for that case (this is a nop otherwise). */
5500 ecs
->event_thread
= inferior_thread ();
5502 ecs
->event_thread
->suspend
.stop_pc
5503 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
5505 ecs
->event_thread
->control
.stop_bpstat
5506 = bpstat_stop_status (get_current_regcache ()->aspace (),
5507 ecs
->event_thread
->suspend
.stop_pc
,
5508 ecs
->event_thread
, &ecs
->ws
);
5510 /* Note that this may be referenced from inside
5511 bpstat_stop_status above, through inferior_has_execd. */
5512 xfree (ecs
->ws
.value
.execd_pathname
);
5513 ecs
->ws
.value
.execd_pathname
= NULL
;
5515 if (handle_stop_requested (ecs
))
5518 /* If no catchpoint triggered for this, then keep going. */
5519 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5521 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5525 process_event_stop_test (ecs
);
5528 /* Be careful not to try to gather much state about a thread
5529 that's in a syscall. It's frequently a losing proposition. */
5530 case TARGET_WAITKIND_SYSCALL_ENTRY
:
5531 /* Getting the current syscall number. */
5532 if (handle_syscall_event (ecs
) == 0)
5533 process_event_stop_test (ecs
);
5536 /* Before examining the threads further, step this thread to
5537 get it entirely out of the syscall. (We get notice of the
5538 event when the thread is just on the verge of exiting a
5539 syscall. Stepping one instruction seems to get it back
5541 case TARGET_WAITKIND_SYSCALL_RETURN
:
5542 if (handle_syscall_event (ecs
) == 0)
5543 process_event_stop_test (ecs
);
5546 case TARGET_WAITKIND_STOPPED
:
5547 handle_signal_stop (ecs
);
5550 case TARGET_WAITKIND_NO_HISTORY
:
5551 /* Reverse execution: target ran out of history info. */
5553 /* Switch to the stopped thread. */
5554 context_switch (ecs
);
5556 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped\n");
5558 delete_just_stopped_threads_single_step_breakpoints ();
5559 ecs
->event_thread
->suspend
.stop_pc
5560 = regcache_read_pc (get_thread_regcache (inferior_thread ()));
5562 if (handle_stop_requested (ecs
))
5565 gdb::observers::no_history
.notify ();
5571 /* Restart threads back to what they were trying to do back when we
5572 paused them for an in-line step-over. The EVENT_THREAD thread is
5576 restart_threads (struct thread_info
*event_thread
)
5578 /* In case the instruction just stepped spawned a new thread. */
5579 update_thread_list ();
5581 for (thread_info
*tp
: all_non_exited_threads ())
5583 switch_to_thread_no_regs (tp
);
5585 if (tp
== event_thread
)
5588 fprintf_unfiltered (gdb_stdlog
,
5589 "infrun: restart threads: "
5590 "[%s] is event thread\n",
5591 target_pid_to_str (tp
->ptid
).c_str ());
5595 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5598 fprintf_unfiltered (gdb_stdlog
,
5599 "infrun: restart threads: "
5600 "[%s] not meant to be running\n",
5601 target_pid_to_str (tp
->ptid
).c_str ());
5608 fprintf_unfiltered (gdb_stdlog
,
5609 "infrun: restart threads: [%s] resumed\n",
5610 target_pid_to_str (tp
->ptid
).c_str ());
5611 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
5615 if (thread_is_in_step_over_chain (tp
))
5618 fprintf_unfiltered (gdb_stdlog
,
5619 "infrun: restart threads: "
5620 "[%s] needs step-over\n",
5621 target_pid_to_str (tp
->ptid
).c_str ());
5622 gdb_assert (!tp
->resumed
);
5627 if (tp
->suspend
.waitstatus_pending_p
)
5630 fprintf_unfiltered (gdb_stdlog
,
5631 "infrun: restart threads: "
5632 "[%s] has pending status\n",
5633 target_pid_to_str (tp
->ptid
).c_str ());
5638 gdb_assert (!tp
->stop_requested
);
5640 /* If some thread needs to start a step-over at this point, it
5641 should still be in the step-over queue, and thus skipped
5643 if (thread_still_needs_step_over (tp
))
5645 internal_error (__FILE__
, __LINE__
,
5646 "thread [%s] needs a step-over, but not in "
5647 "step-over queue\n",
5648 target_pid_to_str (tp
->ptid
).c_str ());
5651 if (currently_stepping (tp
))
5654 fprintf_unfiltered (gdb_stdlog
,
5655 "infrun: restart threads: [%s] was stepping\n",
5656 target_pid_to_str (tp
->ptid
).c_str ());
5657 keep_going_stepped_thread (tp
);
5661 struct execution_control_state ecss
;
5662 struct execution_control_state
*ecs
= &ecss
;
5665 fprintf_unfiltered (gdb_stdlog
,
5666 "infrun: restart threads: [%s] continuing\n",
5667 target_pid_to_str (tp
->ptid
).c_str ());
5668 reset_ecs (ecs
, tp
);
5669 switch_to_thread (tp
);
5670 keep_going_pass_signal (ecs
);
5675 /* Callback for iterate_over_threads. Find a resumed thread that has
5676 a pending waitstatus. */
5679 resumed_thread_with_pending_status (struct thread_info
*tp
,
5683 && tp
->suspend
.waitstatus_pending_p
);
5686 /* Called when we get an event that may finish an in-line or
5687 out-of-line (displaced stepping) step-over started previously.
5688 Return true if the event is processed and we should go back to the
5689 event loop; false if the caller should continue processing the
5693 finish_step_over (struct execution_control_state
*ecs
)
5695 int had_step_over_info
;
5697 displaced_step_fixup (ecs
->event_thread
,
5698 ecs
->event_thread
->suspend
.stop_signal
);
5700 had_step_over_info
= step_over_info_valid_p ();
5702 if (had_step_over_info
)
5704 /* If we're stepping over a breakpoint with all threads locked,
5705 then only the thread that was stepped should be reporting
5707 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5709 clear_step_over_info ();
5712 if (!target_is_non_stop_p ())
5715 /* Start a new step-over in another thread if there's one that
5719 /* If we were stepping over a breakpoint before, and haven't started
5720 a new in-line step-over sequence, then restart all other threads
5721 (except the event thread). We can't do this in all-stop, as then
5722 e.g., we wouldn't be able to issue any other remote packet until
5723 these other threads stop. */
5724 if (had_step_over_info
&& !step_over_info_valid_p ())
5726 struct thread_info
*pending
;
5728 /* If we only have threads with pending statuses, the restart
5729 below won't restart any thread and so nothing re-inserts the
5730 breakpoint we just stepped over. But we need it inserted
5731 when we later process the pending events, otherwise if
5732 another thread has a pending event for this breakpoint too,
5733 we'd discard its event (because the breakpoint that
5734 originally caused the event was no longer inserted). */
5735 context_switch (ecs
);
5736 insert_breakpoints ();
5738 restart_threads (ecs
->event_thread
);
5740 /* If we have events pending, go through handle_inferior_event
5741 again, picking up a pending event at random. This avoids
5742 thread starvation. */
5744 /* But not if we just stepped over a watchpoint in order to let
5745 the instruction execute so we can evaluate its expression.
5746 The set of watchpoints that triggered is recorded in the
5747 breakpoint objects themselves (see bp->watchpoint_triggered).
5748 If we processed another event first, that other event could
5749 clobber this info. */
5750 if (ecs
->event_thread
->stepping_over_watchpoint
)
5753 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5755 if (pending
!= NULL
)
5757 struct thread_info
*tp
= ecs
->event_thread
;
5758 struct regcache
*regcache
;
5762 fprintf_unfiltered (gdb_stdlog
,
5763 "infrun: found resumed threads with "
5764 "pending events, saving status\n");
5767 gdb_assert (pending
!= tp
);
5769 /* Record the event thread's event for later. */
5770 save_waitstatus (tp
, &ecs
->ws
);
5771 /* This was cleared early, by handle_inferior_event. Set it
5772 so this pending event is considered by
5776 gdb_assert (!tp
->executing
);
5778 regcache
= get_thread_regcache (tp
);
5779 tp
->suspend
.stop_pc
= regcache_read_pc (regcache
);
5783 fprintf_unfiltered (gdb_stdlog
,
5784 "infrun: saved stop_pc=%s for %s "
5785 "(currently_stepping=%d)\n",
5786 paddress (target_gdbarch (),
5787 tp
->suspend
.stop_pc
),
5788 target_pid_to_str (tp
->ptid
).c_str (),
5789 currently_stepping (tp
));
5792 /* This in-line step-over finished; clear this so we won't
5793 start a new one. This is what handle_signal_stop would
5794 do, if we returned false. */
5795 tp
->stepping_over_breakpoint
= 0;
5797 /* Wake up the event loop again. */
5798 mark_async_event_handler (infrun_async_inferior_event_token
);
5800 prepare_to_wait (ecs
);
5808 /* Come here when the program has stopped with a signal. */
5811 handle_signal_stop (struct execution_control_state
*ecs
)
5813 struct frame_info
*frame
;
5814 struct gdbarch
*gdbarch
;
5815 int stopped_by_watchpoint
;
5816 enum stop_kind stop_soon
;
5819 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5821 ecs
->event_thread
->suspend
.stop_signal
= ecs
->ws
.value
.sig
;
5823 /* Do we need to clean up the state of a thread that has
5824 completed a displaced single-step? (Doing so usually affects
5825 the PC, so do it here, before we set stop_pc.) */
5826 if (finish_step_over (ecs
))
5829 /* If we either finished a single-step or hit a breakpoint, but
5830 the user wanted this thread to be stopped, pretend we got a
5831 SIG0 (generic unsignaled stop). */
5832 if (ecs
->event_thread
->stop_requested
5833 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5834 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5836 ecs
->event_thread
->suspend
.stop_pc
5837 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
5841 struct regcache
*regcache
= get_thread_regcache (ecs
->event_thread
);
5842 struct gdbarch
*reg_gdbarch
= regcache
->arch ();
5844 switch_to_thread (ecs
->event_thread
);
5846 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_pc = %s\n",
5847 paddress (reg_gdbarch
,
5848 ecs
->event_thread
->suspend
.stop_pc
));
5849 if (target_stopped_by_watchpoint ())
5853 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped by watchpoint\n");
5855 if (target_stopped_data_address (current_top_target (), &addr
))
5856 fprintf_unfiltered (gdb_stdlog
,
5857 "infrun: stopped data address = %s\n",
5858 paddress (reg_gdbarch
, addr
));
5860 fprintf_unfiltered (gdb_stdlog
,
5861 "infrun: (no data address available)\n");
5865 /* This is originated from start_remote(), start_inferior() and
5866 shared libraries hook functions. */
5867 stop_soon
= get_inferior_stop_soon (ecs
);
5868 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5870 context_switch (ecs
);
5872 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
5873 stop_print_frame
= 1;
5878 /* This originates from attach_command(). We need to overwrite
5879 the stop_signal here, because some kernels don't ignore a
5880 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5881 See more comments in inferior.h. On the other hand, if we
5882 get a non-SIGSTOP, report it to the user - assume the backend
5883 will handle the SIGSTOP if it should show up later.
5885 Also consider that the attach is complete when we see a
5886 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5887 target extended-remote report it instead of a SIGSTOP
5888 (e.g. gdbserver). We already rely on SIGTRAP being our
5889 signal, so this is no exception.
5891 Also consider that the attach is complete when we see a
5892 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5893 the target to stop all threads of the inferior, in case the
5894 low level attach operation doesn't stop them implicitly. If
5895 they weren't stopped implicitly, then the stub will report a
5896 GDB_SIGNAL_0, meaning: stopped for no particular reason
5897 other than GDB's request. */
5898 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5899 && (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_STOP
5900 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5901 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_0
))
5903 stop_print_frame
= 1;
5905 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5909 /* See if something interesting happened to the non-current thread. If
5910 so, then switch to that thread. */
5911 if (ecs
->ptid
!= inferior_ptid
)
5914 fprintf_unfiltered (gdb_stdlog
, "infrun: context switch\n");
5916 context_switch (ecs
);
5918 if (deprecated_context_hook
)
5919 deprecated_context_hook (ecs
->event_thread
->global_num
);
5922 /* At this point, get hold of the now-current thread's frame. */
5923 frame
= get_current_frame ();
5924 gdbarch
= get_frame_arch (frame
);
5926 /* Pull the single step breakpoints out of the target. */
5927 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5929 struct regcache
*regcache
;
5932 regcache
= get_thread_regcache (ecs
->event_thread
);
5933 const address_space
*aspace
= regcache
->aspace ();
5935 pc
= regcache_read_pc (regcache
);
5937 /* However, before doing so, if this single-step breakpoint was
5938 actually for another thread, set this thread up for moving
5940 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
5943 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
5947 fprintf_unfiltered (gdb_stdlog
,
5948 "infrun: [%s] hit another thread's "
5949 "single-step breakpoint\n",
5950 target_pid_to_str (ecs
->ptid
).c_str ());
5952 ecs
->hit_singlestep_breakpoint
= 1;
5959 fprintf_unfiltered (gdb_stdlog
,
5960 "infrun: [%s] hit its "
5961 "single-step breakpoint\n",
5962 target_pid_to_str (ecs
->ptid
).c_str ());
5966 delete_just_stopped_threads_single_step_breakpoints ();
5968 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5969 && ecs
->event_thread
->control
.trap_expected
5970 && ecs
->event_thread
->stepping_over_watchpoint
)
5971 stopped_by_watchpoint
= 0;
5973 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
5975 /* If necessary, step over this watchpoint. We'll be back to display
5977 if (stopped_by_watchpoint
5978 && (target_have_steppable_watchpoint
5979 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
5981 /* At this point, we are stopped at an instruction which has
5982 attempted to write to a piece of memory under control of
5983 a watchpoint. The instruction hasn't actually executed
5984 yet. If we were to evaluate the watchpoint expression
5985 now, we would get the old value, and therefore no change
5986 would seem to have occurred.
5988 In order to make watchpoints work `right', we really need
5989 to complete the memory write, and then evaluate the
5990 watchpoint expression. We do this by single-stepping the
5993 It may not be necessary to disable the watchpoint to step over
5994 it. For example, the PA can (with some kernel cooperation)
5995 single step over a watchpoint without disabling the watchpoint.
5997 It is far more common to need to disable a watchpoint to step
5998 the inferior over it. If we have non-steppable watchpoints,
5999 we must disable the current watchpoint; it's simplest to
6000 disable all watchpoints.
6002 Any breakpoint at PC must also be stepped over -- if there's
6003 one, it will have already triggered before the watchpoint
6004 triggered, and we either already reported it to the user, or
6005 it didn't cause a stop and we called keep_going. In either
6006 case, if there was a breakpoint at PC, we must be trying to
6008 ecs
->event_thread
->stepping_over_watchpoint
= 1;
6013 ecs
->event_thread
->stepping_over_breakpoint
= 0;
6014 ecs
->event_thread
->stepping_over_watchpoint
= 0;
6015 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
6016 ecs
->event_thread
->control
.stop_step
= 0;
6017 stop_print_frame
= 1;
6018 stopped_by_random_signal
= 0;
6019 bpstat stop_chain
= NULL
;
6021 /* Hide inlined functions starting here, unless we just performed stepi or
6022 nexti. After stepi and nexti, always show the innermost frame (not any
6023 inline function call sites). */
6024 if (ecs
->event_thread
->control
.step_range_end
!= 1)
6026 const address_space
*aspace
6027 = get_thread_regcache (ecs
->event_thread
)->aspace ();
6029 /* skip_inline_frames is expensive, so we avoid it if we can
6030 determine that the address is one where functions cannot have
6031 been inlined. This improves performance with inferiors that
6032 load a lot of shared libraries, because the solib event
6033 breakpoint is defined as the address of a function (i.e. not
6034 inline). Note that we have to check the previous PC as well
6035 as the current one to catch cases when we have just
6036 single-stepped off a breakpoint prior to reinstating it.
6037 Note that we're assuming that the code we single-step to is
6038 not inline, but that's not definitive: there's nothing
6039 preventing the event breakpoint function from containing
6040 inlined code, and the single-step ending up there. If the
6041 user had set a breakpoint on that inlined code, the missing
6042 skip_inline_frames call would break things. Fortunately
6043 that's an extremely unlikely scenario. */
6044 if (!pc_at_non_inline_function (aspace
,
6045 ecs
->event_thread
->suspend
.stop_pc
,
6047 && !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6048 && ecs
->event_thread
->control
.trap_expected
6049 && pc_at_non_inline_function (aspace
,
6050 ecs
->event_thread
->prev_pc
,
6053 stop_chain
= build_bpstat_chain (aspace
,
6054 ecs
->event_thread
->suspend
.stop_pc
,
6056 skip_inline_frames (ecs
->event_thread
, stop_chain
);
6058 /* Re-fetch current thread's frame in case that invalidated
6060 frame
= get_current_frame ();
6061 gdbarch
= get_frame_arch (frame
);
6065 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6066 && ecs
->event_thread
->control
.trap_expected
6067 && gdbarch_single_step_through_delay_p (gdbarch
)
6068 && currently_stepping (ecs
->event_thread
))
6070 /* We're trying to step off a breakpoint. Turns out that we're
6071 also on an instruction that needs to be stepped multiple
6072 times before it's been fully executing. E.g., architectures
6073 with a delay slot. It needs to be stepped twice, once for
6074 the instruction and once for the delay slot. */
6075 int step_through_delay
6076 = gdbarch_single_step_through_delay (gdbarch
, frame
);
6078 if (debug_infrun
&& step_through_delay
)
6079 fprintf_unfiltered (gdb_stdlog
, "infrun: step through delay\n");
6080 if (ecs
->event_thread
->control
.step_range_end
== 0
6081 && step_through_delay
)
6083 /* The user issued a continue when stopped at a breakpoint.
6084 Set up for another trap and get out of here. */
6085 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6089 else if (step_through_delay
)
6091 /* The user issued a step when stopped at a breakpoint.
6092 Maybe we should stop, maybe we should not - the delay
6093 slot *might* correspond to a line of source. In any
6094 case, don't decide that here, just set
6095 ecs->stepping_over_breakpoint, making sure we
6096 single-step again before breakpoints are re-inserted. */
6097 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6101 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
6102 handles this event. */
6103 ecs
->event_thread
->control
.stop_bpstat
6104 = bpstat_stop_status (get_current_regcache ()->aspace (),
6105 ecs
->event_thread
->suspend
.stop_pc
,
6106 ecs
->event_thread
, &ecs
->ws
, stop_chain
);
6108 /* Following in case break condition called a
6110 stop_print_frame
= 1;
6112 /* This is where we handle "moribund" watchpoints. Unlike
6113 software breakpoints traps, hardware watchpoint traps are
6114 always distinguishable from random traps. If no high-level
6115 watchpoint is associated with the reported stop data address
6116 anymore, then the bpstat does not explain the signal ---
6117 simply make sure to ignore it if `stopped_by_watchpoint' is
6121 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6122 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6124 && stopped_by_watchpoint
)
6125 fprintf_unfiltered (gdb_stdlog
,
6126 "infrun: no user watchpoint explains "
6127 "watchpoint SIGTRAP, ignoring\n");
6129 /* NOTE: cagney/2003-03-29: These checks for a random signal
6130 at one stage in the past included checks for an inferior
6131 function call's call dummy's return breakpoint. The original
6132 comment, that went with the test, read:
6134 ``End of a stack dummy. Some systems (e.g. Sony news) give
6135 another signal besides SIGTRAP, so check here as well as
6138 If someone ever tries to get call dummys on a
6139 non-executable stack to work (where the target would stop
6140 with something like a SIGSEGV), then those tests might need
6141 to be re-instated. Given, however, that the tests were only
6142 enabled when momentary breakpoints were not being used, I
6143 suspect that it won't be the case.
6145 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
6146 be necessary for call dummies on a non-executable stack on
6149 /* See if the breakpoints module can explain the signal. */
6151 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
6152 ecs
->event_thread
->suspend
.stop_signal
);
6154 /* Maybe this was a trap for a software breakpoint that has since
6156 if (random_signal
&& target_stopped_by_sw_breakpoint ())
6158 if (program_breakpoint_here_p (gdbarch
,
6159 ecs
->event_thread
->suspend
.stop_pc
))
6161 struct regcache
*regcache
;
6164 /* Re-adjust PC to what the program would see if GDB was not
6166 regcache
= get_thread_regcache (ecs
->event_thread
);
6167 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
6170 gdb::optional
<scoped_restore_tmpl
<int>>
6171 restore_operation_disable
;
6173 if (record_full_is_used ())
6174 restore_operation_disable
.emplace
6175 (record_full_gdb_operation_disable_set ());
6177 regcache_write_pc (regcache
,
6178 ecs
->event_thread
->suspend
.stop_pc
+ decr_pc
);
6183 /* A delayed software breakpoint event. Ignore the trap. */
6185 fprintf_unfiltered (gdb_stdlog
,
6186 "infrun: delayed software breakpoint "
6187 "trap, ignoring\n");
6192 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6193 has since been removed. */
6194 if (random_signal
&& target_stopped_by_hw_breakpoint ())
6196 /* A delayed hardware breakpoint event. Ignore the trap. */
6198 fprintf_unfiltered (gdb_stdlog
,
6199 "infrun: delayed hardware breakpoint/watchpoint "
6200 "trap, ignoring\n");
6204 /* If not, perhaps stepping/nexting can. */
6206 random_signal
= !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6207 && currently_stepping (ecs
->event_thread
));
6209 /* Perhaps the thread hit a single-step breakpoint of _another_
6210 thread. Single-step breakpoints are transparent to the
6211 breakpoints module. */
6213 random_signal
= !ecs
->hit_singlestep_breakpoint
;
6215 /* No? Perhaps we got a moribund watchpoint. */
6217 random_signal
= !stopped_by_watchpoint
;
6219 /* Always stop if the user explicitly requested this thread to
6221 if (ecs
->event_thread
->stop_requested
)
6225 fprintf_unfiltered (gdb_stdlog
, "infrun: user-requested stop\n");
6228 /* For the program's own signals, act according to
6229 the signal handling tables. */
6233 /* Signal not for debugging purposes. */
6234 struct inferior
*inf
= find_inferior_ptid (ecs
->target
, ecs
->ptid
);
6235 enum gdb_signal stop_signal
= ecs
->event_thread
->suspend
.stop_signal
;
6238 fprintf_unfiltered (gdb_stdlog
, "infrun: random signal (%s)\n",
6239 gdb_signal_to_symbol_string (stop_signal
));
6241 stopped_by_random_signal
= 1;
6243 /* Always stop on signals if we're either just gaining control
6244 of the program, or the user explicitly requested this thread
6245 to remain stopped. */
6246 if (stop_soon
!= NO_STOP_QUIETLY
6247 || ecs
->event_thread
->stop_requested
6249 && signal_stop_state (ecs
->event_thread
->suspend
.stop_signal
)))
6255 /* Notify observers the signal has "handle print" set. Note we
6256 returned early above if stopping; normal_stop handles the
6257 printing in that case. */
6258 if (signal_print
[ecs
->event_thread
->suspend
.stop_signal
])
6260 /* The signal table tells us to print about this signal. */
6261 target_terminal::ours_for_output ();
6262 gdb::observers::signal_received
.notify (ecs
->event_thread
->suspend
.stop_signal
);
6263 target_terminal::inferior ();
6266 /* Clear the signal if it should not be passed. */
6267 if (signal_program
[ecs
->event_thread
->suspend
.stop_signal
] == 0)
6268 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6270 if (ecs
->event_thread
->prev_pc
== ecs
->event_thread
->suspend
.stop_pc
6271 && ecs
->event_thread
->control
.trap_expected
6272 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6274 /* We were just starting a new sequence, attempting to
6275 single-step off of a breakpoint and expecting a SIGTRAP.
6276 Instead this signal arrives. This signal will take us out
6277 of the stepping range so GDB needs to remember to, when
6278 the signal handler returns, resume stepping off that
6280 /* To simplify things, "continue" is forced to use the same
6281 code paths as single-step - set a breakpoint at the
6282 signal return address and then, once hit, step off that
6285 fprintf_unfiltered (gdb_stdlog
,
6286 "infrun: signal arrived while stepping over "
6289 insert_hp_step_resume_breakpoint_at_frame (frame
);
6290 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6291 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6292 ecs
->event_thread
->control
.trap_expected
= 0;
6294 /* If we were nexting/stepping some other thread, switch to
6295 it, so that we don't continue it, losing control. */
6296 if (!switch_back_to_stepped_thread (ecs
))
6301 if (ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
6302 && (pc_in_thread_step_range (ecs
->event_thread
->suspend
.stop_pc
,
6304 || ecs
->event_thread
->control
.step_range_end
== 1)
6305 && frame_id_eq (get_stack_frame_id (frame
),
6306 ecs
->event_thread
->control
.step_stack_frame_id
)
6307 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
6309 /* The inferior is about to take a signal that will take it
6310 out of the single step range. Set a breakpoint at the
6311 current PC (which is presumably where the signal handler
6312 will eventually return) and then allow the inferior to
6315 Note that this is only needed for a signal delivered
6316 while in the single-step range. Nested signals aren't a
6317 problem as they eventually all return. */
6319 fprintf_unfiltered (gdb_stdlog
,
6320 "infrun: signal may take us out of "
6321 "single-step range\n");
6323 clear_step_over_info ();
6324 insert_hp_step_resume_breakpoint_at_frame (frame
);
6325 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
6326 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6327 ecs
->event_thread
->control
.trap_expected
= 0;
6332 /* Note: step_resume_breakpoint may be non-NULL. This occurs
6333 when either there's a nested signal, or when there's a
6334 pending signal enabled just as the signal handler returns
6335 (leaving the inferior at the step-resume-breakpoint without
6336 actually executing it). Either way continue until the
6337 breakpoint is really hit. */
6339 if (!switch_back_to_stepped_thread (ecs
))
6342 fprintf_unfiltered (gdb_stdlog
,
6343 "infrun: random signal, keep going\n");
6350 process_event_stop_test (ecs
);
6353 /* Come here when we've got some debug event / signal we can explain
6354 (IOW, not a random signal), and test whether it should cause a
6355 stop, or whether we should resume the inferior (transparently).
6356 E.g., could be a breakpoint whose condition evaluates false; we
6357 could be still stepping within the line; etc. */
6360 process_event_stop_test (struct execution_control_state
*ecs
)
6362 struct symtab_and_line stop_pc_sal
;
6363 struct frame_info
*frame
;
6364 struct gdbarch
*gdbarch
;
6365 CORE_ADDR jmp_buf_pc
;
6366 struct bpstat_what what
;
6368 /* Handle cases caused by hitting a breakpoint. */
6370 frame
= get_current_frame ();
6371 gdbarch
= get_frame_arch (frame
);
6373 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
6375 if (what
.call_dummy
)
6377 stop_stack_dummy
= what
.call_dummy
;
6380 /* A few breakpoint types have callbacks associated (e.g.,
6381 bp_jit_event). Run them now. */
6382 bpstat_run_callbacks (ecs
->event_thread
->control
.stop_bpstat
);
6384 /* If we hit an internal event that triggers symbol changes, the
6385 current frame will be invalidated within bpstat_what (e.g., if we
6386 hit an internal solib event). Re-fetch it. */
6387 frame
= get_current_frame ();
6388 gdbarch
= get_frame_arch (frame
);
6390 switch (what
.main_action
)
6392 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
6393 /* If we hit the breakpoint at longjmp while stepping, we
6394 install a momentary breakpoint at the target of the
6398 fprintf_unfiltered (gdb_stdlog
,
6399 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
6401 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6403 if (what
.is_longjmp
)
6405 struct value
*arg_value
;
6407 /* If we set the longjmp breakpoint via a SystemTap probe,
6408 then use it to extract the arguments. The destination PC
6409 is the third argument to the probe. */
6410 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
6413 jmp_buf_pc
= value_as_address (arg_value
);
6414 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
6416 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
6417 || !gdbarch_get_longjmp_target (gdbarch
,
6418 frame
, &jmp_buf_pc
))
6421 fprintf_unfiltered (gdb_stdlog
,
6422 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
6423 "(!gdbarch_get_longjmp_target)\n");
6428 /* Insert a breakpoint at resume address. */
6429 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
6432 check_exception_resume (ecs
, frame
);
6436 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
6438 struct frame_info
*init_frame
;
6440 /* There are several cases to consider.
6442 1. The initiating frame no longer exists. In this case we
6443 must stop, because the exception or longjmp has gone too
6446 2. The initiating frame exists, and is the same as the
6447 current frame. We stop, because the exception or longjmp
6450 3. The initiating frame exists and is different from the
6451 current frame. This means the exception or longjmp has
6452 been caught beneath the initiating frame, so keep going.
6454 4. longjmp breakpoint has been placed just to protect
6455 against stale dummy frames and user is not interested in
6456 stopping around longjmps. */
6459 fprintf_unfiltered (gdb_stdlog
,
6460 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
6462 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
6464 delete_exception_resume_breakpoint (ecs
->event_thread
);
6466 if (what
.is_longjmp
)
6468 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
6470 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
6478 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
6482 struct frame_id current_id
6483 = get_frame_id (get_current_frame ());
6484 if (frame_id_eq (current_id
,
6485 ecs
->event_thread
->initiating_frame
))
6487 /* Case 2. Fall through. */
6497 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6499 delete_step_resume_breakpoint (ecs
->event_thread
);
6501 end_stepping_range (ecs
);
6505 case BPSTAT_WHAT_SINGLE
:
6507 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_SINGLE\n");
6508 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6509 /* Still need to check other stuff, at least the case where we
6510 are stepping and step out of the right range. */
6513 case BPSTAT_WHAT_STEP_RESUME
:
6515 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6517 delete_step_resume_breakpoint (ecs
->event_thread
);
6518 if (ecs
->event_thread
->control
.proceed_to_finish
6519 && execution_direction
== EXEC_REVERSE
)
6521 struct thread_info
*tp
= ecs
->event_thread
;
6523 /* We are finishing a function in reverse, and just hit the
6524 step-resume breakpoint at the start address of the
6525 function, and we're almost there -- just need to back up
6526 by one more single-step, which should take us back to the
6528 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6532 fill_in_stop_func (gdbarch
, ecs
);
6533 if (ecs
->event_thread
->suspend
.stop_pc
== ecs
->stop_func_start
6534 && execution_direction
== EXEC_REVERSE
)
6536 /* We are stepping over a function call in reverse, and just
6537 hit the step-resume breakpoint at the start address of
6538 the function. Go back to single-stepping, which should
6539 take us back to the function call. */
6540 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6546 case BPSTAT_WHAT_STOP_NOISY
:
6548 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6549 stop_print_frame
= 1;
6551 /* Assume the thread stopped for a breapoint. We'll still check
6552 whether a/the breakpoint is there when the thread is next
6554 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6559 case BPSTAT_WHAT_STOP_SILENT
:
6561 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6562 stop_print_frame
= 0;
6564 /* Assume the thread stopped for a breapoint. We'll still check
6565 whether a/the breakpoint is there when the thread is next
6567 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6571 case BPSTAT_WHAT_HP_STEP_RESUME
:
6573 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6575 delete_step_resume_breakpoint (ecs
->event_thread
);
6576 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6578 /* Back when the step-resume breakpoint was inserted, we
6579 were trying to single-step off a breakpoint. Go back to
6581 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6582 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6588 case BPSTAT_WHAT_KEEP_CHECKING
:
6592 /* If we stepped a permanent breakpoint and we had a high priority
6593 step-resume breakpoint for the address we stepped, but we didn't
6594 hit it, then we must have stepped into the signal handler. The
6595 step-resume was only necessary to catch the case of _not_
6596 stepping into the handler, so delete it, and fall through to
6597 checking whether the step finished. */
6598 if (ecs
->event_thread
->stepped_breakpoint
)
6600 struct breakpoint
*sr_bp
6601 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6604 && sr_bp
->loc
->permanent
6605 && sr_bp
->type
== bp_hp_step_resume
6606 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6609 fprintf_unfiltered (gdb_stdlog
,
6610 "infrun: stepped permanent breakpoint, stopped in "
6612 delete_step_resume_breakpoint (ecs
->event_thread
);
6613 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6617 /* We come here if we hit a breakpoint but should not stop for it.
6618 Possibly we also were stepping and should stop for that. So fall
6619 through and test for stepping. But, if not stepping, do not
6622 /* In all-stop mode, if we're currently stepping but have stopped in
6623 some other thread, we need to switch back to the stepped thread. */
6624 if (switch_back_to_stepped_thread (ecs
))
6627 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6630 fprintf_unfiltered (gdb_stdlog
,
6631 "infrun: step-resume breakpoint is inserted\n");
6633 /* Having a step-resume breakpoint overrides anything
6634 else having to do with stepping commands until
6635 that breakpoint is reached. */
6640 if (ecs
->event_thread
->control
.step_range_end
== 0)
6643 fprintf_unfiltered (gdb_stdlog
, "infrun: no stepping, continue\n");
6644 /* Likewise if we aren't even stepping. */
6649 /* Re-fetch current thread's frame in case the code above caused
6650 the frame cache to be re-initialized, making our FRAME variable
6651 a dangling pointer. */
6652 frame
= get_current_frame ();
6653 gdbarch
= get_frame_arch (frame
);
6654 fill_in_stop_func (gdbarch
, ecs
);
6656 /* If stepping through a line, keep going if still within it.
6658 Note that step_range_end is the address of the first instruction
6659 beyond the step range, and NOT the address of the last instruction
6662 Note also that during reverse execution, we may be stepping
6663 through a function epilogue and therefore must detect when
6664 the current-frame changes in the middle of a line. */
6666 if (pc_in_thread_step_range (ecs
->event_thread
->suspend
.stop_pc
,
6668 && (execution_direction
!= EXEC_REVERSE
6669 || frame_id_eq (get_frame_id (frame
),
6670 ecs
->event_thread
->control
.step_frame_id
)))
6674 (gdb_stdlog
, "infrun: stepping inside range [%s-%s]\n",
6675 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6676 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6678 /* Tentatively re-enable range stepping; `resume' disables it if
6679 necessary (e.g., if we're stepping over a breakpoint or we
6680 have software watchpoints). */
6681 ecs
->event_thread
->control
.may_range_step
= 1;
6683 /* When stepping backward, stop at beginning of line range
6684 (unless it's the function entry point, in which case
6685 keep going back to the call point). */
6686 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6687 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6688 && stop_pc
!= ecs
->stop_func_start
6689 && execution_direction
== EXEC_REVERSE
)
6690 end_stepping_range (ecs
);
6697 /* We stepped out of the stepping range. */
6699 /* If we are stepping at the source level and entered the runtime
6700 loader dynamic symbol resolution code...
6702 EXEC_FORWARD: we keep on single stepping until we exit the run
6703 time loader code and reach the callee's address.
6705 EXEC_REVERSE: we've already executed the callee (backward), and
6706 the runtime loader code is handled just like any other
6707 undebuggable function call. Now we need only keep stepping
6708 backward through the trampoline code, and that's handled further
6709 down, so there is nothing for us to do here. */
6711 if (execution_direction
!= EXEC_REVERSE
6712 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6713 && in_solib_dynsym_resolve_code (ecs
->event_thread
->suspend
.stop_pc
))
6715 CORE_ADDR pc_after_resolver
=
6716 gdbarch_skip_solib_resolver (gdbarch
,
6717 ecs
->event_thread
->suspend
.stop_pc
);
6720 fprintf_unfiltered (gdb_stdlog
,
6721 "infrun: stepped into dynsym resolve code\n");
6723 if (pc_after_resolver
)
6725 /* Set up a step-resume breakpoint at the address
6726 indicated by SKIP_SOLIB_RESOLVER. */
6727 symtab_and_line sr_sal
;
6728 sr_sal
.pc
= pc_after_resolver
;
6729 sr_sal
.pspace
= get_frame_program_space (frame
);
6731 insert_step_resume_breakpoint_at_sal (gdbarch
,
6732 sr_sal
, null_frame_id
);
6739 /* Step through an indirect branch thunk. */
6740 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6741 && gdbarch_in_indirect_branch_thunk (gdbarch
,
6742 ecs
->event_thread
->suspend
.stop_pc
))
6745 fprintf_unfiltered (gdb_stdlog
,
6746 "infrun: stepped into indirect branch thunk\n");
6751 if (ecs
->event_thread
->control
.step_range_end
!= 1
6752 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6753 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6754 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6757 fprintf_unfiltered (gdb_stdlog
,
6758 "infrun: stepped into signal trampoline\n");
6759 /* The inferior, while doing a "step" or "next", has ended up in
6760 a signal trampoline (either by a signal being delivered or by
6761 the signal handler returning). Just single-step until the
6762 inferior leaves the trampoline (either by calling the handler
6768 /* If we're in the return path from a shared library trampoline,
6769 we want to proceed through the trampoline when stepping. */
6770 /* macro/2012-04-25: This needs to come before the subroutine
6771 call check below as on some targets return trampolines look
6772 like subroutine calls (MIPS16 return thunks). */
6773 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6774 ecs
->event_thread
->suspend
.stop_pc
,
6775 ecs
->stop_func_name
)
6776 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6778 /* Determine where this trampoline returns. */
6779 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6780 CORE_ADDR real_stop_pc
6781 = gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6784 fprintf_unfiltered (gdb_stdlog
,
6785 "infrun: stepped into solib return tramp\n");
6787 /* Only proceed through if we know where it's going. */
6790 /* And put the step-breakpoint there and go until there. */
6791 symtab_and_line sr_sal
;
6792 sr_sal
.pc
= real_stop_pc
;
6793 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6794 sr_sal
.pspace
= get_frame_program_space (frame
);
6796 /* Do not specify what the fp should be when we stop since
6797 on some machines the prologue is where the new fp value
6799 insert_step_resume_breakpoint_at_sal (gdbarch
,
6800 sr_sal
, null_frame_id
);
6802 /* Restart without fiddling with the step ranges or
6809 /* Check for subroutine calls. The check for the current frame
6810 equalling the step ID is not necessary - the check of the
6811 previous frame's ID is sufficient - but it is a common case and
6812 cheaper than checking the previous frame's ID.
6814 NOTE: frame_id_eq will never report two invalid frame IDs as
6815 being equal, so to get into this block, both the current and
6816 previous frame must have valid frame IDs. */
6817 /* The outer_frame_id check is a heuristic to detect stepping
6818 through startup code. If we step over an instruction which
6819 sets the stack pointer from an invalid value to a valid value,
6820 we may detect that as a subroutine call from the mythical
6821 "outermost" function. This could be fixed by marking
6822 outermost frames as !stack_p,code_p,special_p. Then the
6823 initial outermost frame, before sp was valid, would
6824 have code_addr == &_start. See the comment in frame_id_eq
6826 if (!frame_id_eq (get_stack_frame_id (frame
),
6827 ecs
->event_thread
->control
.step_stack_frame_id
)
6828 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6829 ecs
->event_thread
->control
.step_stack_frame_id
)
6830 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6832 || (ecs
->event_thread
->control
.step_start_function
6833 != find_pc_function (ecs
->event_thread
->suspend
.stop_pc
)))))
6835 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6836 CORE_ADDR real_stop_pc
;
6839 fprintf_unfiltered (gdb_stdlog
, "infrun: stepped into subroutine\n");
6841 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6843 /* I presume that step_over_calls is only 0 when we're
6844 supposed to be stepping at the assembly language level
6845 ("stepi"). Just stop. */
6846 /* And this works the same backward as frontward. MVS */
6847 end_stepping_range (ecs
);
6851 /* Reverse stepping through solib trampolines. */
6853 if (execution_direction
== EXEC_REVERSE
6854 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6855 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6856 || (ecs
->stop_func_start
== 0
6857 && in_solib_dynsym_resolve_code (stop_pc
))))
6859 /* Any solib trampoline code can be handled in reverse
6860 by simply continuing to single-step. We have already
6861 executed the solib function (backwards), and a few
6862 steps will take us back through the trampoline to the
6868 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6870 /* We're doing a "next".
6872 Normal (forward) execution: set a breakpoint at the
6873 callee's return address (the address at which the caller
6876 Reverse (backward) execution. set the step-resume
6877 breakpoint at the start of the function that we just
6878 stepped into (backwards), and continue to there. When we
6879 get there, we'll need to single-step back to the caller. */
6881 if (execution_direction
== EXEC_REVERSE
)
6883 /* If we're already at the start of the function, we've either
6884 just stepped backward into a single instruction function,
6885 or stepped back out of a signal handler to the first instruction
6886 of the function. Just keep going, which will single-step back
6888 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6890 /* Normal function call return (static or dynamic). */
6891 symtab_and_line sr_sal
;
6892 sr_sal
.pc
= ecs
->stop_func_start
;
6893 sr_sal
.pspace
= get_frame_program_space (frame
);
6894 insert_step_resume_breakpoint_at_sal (gdbarch
,
6895 sr_sal
, null_frame_id
);
6899 insert_step_resume_breakpoint_at_caller (frame
);
6905 /* If we are in a function call trampoline (a stub between the
6906 calling routine and the real function), locate the real
6907 function. That's what tells us (a) whether we want to step
6908 into it at all, and (b) what prologue we want to run to the
6909 end of, if we do step into it. */
6910 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6911 if (real_stop_pc
== 0)
6912 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6913 if (real_stop_pc
!= 0)
6914 ecs
->stop_func_start
= real_stop_pc
;
6916 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6918 symtab_and_line sr_sal
;
6919 sr_sal
.pc
= ecs
->stop_func_start
;
6920 sr_sal
.pspace
= get_frame_program_space (frame
);
6922 insert_step_resume_breakpoint_at_sal (gdbarch
,
6923 sr_sal
, null_frame_id
);
6928 /* If we have line number information for the function we are
6929 thinking of stepping into and the function isn't on the skip
6932 If there are several symtabs at that PC (e.g. with include
6933 files), just want to know whether *any* of them have line
6934 numbers. find_pc_line handles this. */
6936 struct symtab_and_line tmp_sal
;
6938 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6939 if (tmp_sal
.line
!= 0
6940 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6942 && !inline_frame_is_marked_for_skip (true, ecs
->event_thread
))
6944 if (execution_direction
== EXEC_REVERSE
)
6945 handle_step_into_function_backward (gdbarch
, ecs
);
6947 handle_step_into_function (gdbarch
, ecs
);
6952 /* If we have no line number and the step-stop-if-no-debug is
6953 set, we stop the step so that the user has a chance to switch
6954 in assembly mode. */
6955 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6956 && step_stop_if_no_debug
)
6958 end_stepping_range (ecs
);
6962 if (execution_direction
== EXEC_REVERSE
)
6964 /* If we're already at the start of the function, we've either just
6965 stepped backward into a single instruction function without line
6966 number info, or stepped back out of a signal handler to the first
6967 instruction of the function without line number info. Just keep
6968 going, which will single-step back to the caller. */
6969 if (ecs
->stop_func_start
!= stop_pc
)
6971 /* Set a breakpoint at callee's start address.
6972 From there we can step once and be back in the caller. */
6973 symtab_and_line sr_sal
;
6974 sr_sal
.pc
= ecs
->stop_func_start
;
6975 sr_sal
.pspace
= get_frame_program_space (frame
);
6976 insert_step_resume_breakpoint_at_sal (gdbarch
,
6977 sr_sal
, null_frame_id
);
6981 /* Set a breakpoint at callee's return address (the address
6982 at which the caller will resume). */
6983 insert_step_resume_breakpoint_at_caller (frame
);
6989 /* Reverse stepping through solib trampolines. */
6991 if (execution_direction
== EXEC_REVERSE
6992 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6994 CORE_ADDR stop_pc
= ecs
->event_thread
->suspend
.stop_pc
;
6996 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6997 || (ecs
->stop_func_start
== 0
6998 && in_solib_dynsym_resolve_code (stop_pc
)))
7000 /* Any solib trampoline code can be handled in reverse
7001 by simply continuing to single-step. We have already
7002 executed the solib function (backwards), and a few
7003 steps will take us back through the trampoline to the
7008 else if (in_solib_dynsym_resolve_code (stop_pc
))
7010 /* Stepped backward into the solib dynsym resolver.
7011 Set a breakpoint at its start and continue, then
7012 one more step will take us out. */
7013 symtab_and_line sr_sal
;
7014 sr_sal
.pc
= ecs
->stop_func_start
;
7015 sr_sal
.pspace
= get_frame_program_space (frame
);
7016 insert_step_resume_breakpoint_at_sal (gdbarch
,
7017 sr_sal
, null_frame_id
);
7023 stop_pc_sal
= find_pc_line (ecs
->event_thread
->suspend
.stop_pc
, 0);
7025 /* NOTE: tausq/2004-05-24: This if block used to be done before all
7026 the trampoline processing logic, however, there are some trampolines
7027 that have no names, so we should do trampoline handling first. */
7028 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
7029 && ecs
->stop_func_name
== NULL
7030 && stop_pc_sal
.line
== 0)
7033 fprintf_unfiltered (gdb_stdlog
,
7034 "infrun: stepped into undebuggable function\n");
7036 /* The inferior just stepped into, or returned to, an
7037 undebuggable function (where there is no debugging information
7038 and no line number corresponding to the address where the
7039 inferior stopped). Since we want to skip this kind of code,
7040 we keep going until the inferior returns from this
7041 function - unless the user has asked us not to (via
7042 set step-mode) or we no longer know how to get back
7043 to the call site. */
7044 if (step_stop_if_no_debug
7045 || !frame_id_p (frame_unwind_caller_id (frame
)))
7047 /* If we have no line number and the step-stop-if-no-debug
7048 is set, we stop the step so that the user has a chance to
7049 switch in assembly mode. */
7050 end_stepping_range (ecs
);
7055 /* Set a breakpoint at callee's return address (the address
7056 at which the caller will resume). */
7057 insert_step_resume_breakpoint_at_caller (frame
);
7063 if (ecs
->event_thread
->control
.step_range_end
== 1)
7065 /* It is stepi or nexti. We always want to stop stepping after
7068 fprintf_unfiltered (gdb_stdlog
, "infrun: stepi/nexti\n");
7069 end_stepping_range (ecs
);
7073 if (stop_pc_sal
.line
== 0)
7075 /* We have no line number information. That means to stop
7076 stepping (does this always happen right after one instruction,
7077 when we do "s" in a function with no line numbers,
7078 or can this happen as a result of a return or longjmp?). */
7080 fprintf_unfiltered (gdb_stdlog
, "infrun: no line number info\n");
7081 end_stepping_range (ecs
);
7085 /* Look for "calls" to inlined functions, part one. If the inline
7086 frame machinery detected some skipped call sites, we have entered
7087 a new inline function. */
7089 if (frame_id_eq (get_frame_id (get_current_frame ()),
7090 ecs
->event_thread
->control
.step_frame_id
)
7091 && inline_skipped_frames (ecs
->event_thread
))
7094 fprintf_unfiltered (gdb_stdlog
,
7095 "infrun: stepped into inlined function\n");
7097 symtab_and_line call_sal
= find_frame_sal (get_current_frame ());
7099 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
7101 /* For "step", we're going to stop. But if the call site
7102 for this inlined function is on the same source line as
7103 we were previously stepping, go down into the function
7104 first. Otherwise stop at the call site. */
7106 if (call_sal
.line
== ecs
->event_thread
->current_line
7107 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7109 step_into_inline_frame (ecs
->event_thread
);
7110 if (inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7117 end_stepping_range (ecs
);
7122 /* For "next", we should stop at the call site if it is on a
7123 different source line. Otherwise continue through the
7124 inlined function. */
7125 if (call_sal
.line
== ecs
->event_thread
->current_line
7126 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
7129 end_stepping_range (ecs
);
7134 /* Look for "calls" to inlined functions, part two. If we are still
7135 in the same real function we were stepping through, but we have
7136 to go further up to find the exact frame ID, we are stepping
7137 through a more inlined call beyond its call site. */
7139 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
7140 && !frame_id_eq (get_frame_id (get_current_frame ()),
7141 ecs
->event_thread
->control
.step_frame_id
)
7142 && stepped_in_from (get_current_frame (),
7143 ecs
->event_thread
->control
.step_frame_id
))
7146 fprintf_unfiltered (gdb_stdlog
,
7147 "infrun: stepping through inlined function\n");
7149 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
7150 || inline_frame_is_marked_for_skip (false, ecs
->event_thread
))
7153 end_stepping_range (ecs
);
7157 if ((ecs
->event_thread
->suspend
.stop_pc
== stop_pc_sal
.pc
)
7158 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
7159 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
7161 /* We are at the start of a different line. So stop. Note that
7162 we don't stop if we step into the middle of a different line.
7163 That is said to make things like for (;;) statements work
7166 fprintf_unfiltered (gdb_stdlog
,
7167 "infrun: stepped to a different line\n");
7168 end_stepping_range (ecs
);
7172 /* We aren't done stepping.
7174 Optimize by setting the stepping range to the line.
7175 (We might not be in the original line, but if we entered a
7176 new line in mid-statement, we continue stepping. This makes
7177 things like for(;;) statements work better.) */
7179 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
7180 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
7181 ecs
->event_thread
->control
.may_range_step
= 1;
7182 set_step_info (frame
, stop_pc_sal
);
7185 fprintf_unfiltered (gdb_stdlog
, "infrun: keep going\n");
7189 /* In all-stop mode, if we're currently stepping but have stopped in
7190 some other thread, we may need to switch back to the stepped
7191 thread. Returns true we set the inferior running, false if we left
7192 it stopped (and the event needs further processing). */
7195 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
7197 if (!target_is_non_stop_p ())
7199 struct thread_info
*stepping_thread
;
7201 /* If any thread is blocked on some internal breakpoint, and we
7202 simply need to step over that breakpoint to get it going
7203 again, do that first. */
7205 /* However, if we see an event for the stepping thread, then we
7206 know all other threads have been moved past their breakpoints
7207 already. Let the caller check whether the step is finished,
7208 etc., before deciding to move it past a breakpoint. */
7209 if (ecs
->event_thread
->control
.step_range_end
!= 0)
7212 /* Check if the current thread is blocked on an incomplete
7213 step-over, interrupted by a random signal. */
7214 if (ecs
->event_thread
->control
.trap_expected
7215 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
7219 fprintf_unfiltered (gdb_stdlog
,
7220 "infrun: need to finish step-over of [%s]\n",
7221 target_pid_to_str (ecs
->event_thread
->ptid
).c_str ());
7227 /* Check if the current thread is blocked by a single-step
7228 breakpoint of another thread. */
7229 if (ecs
->hit_singlestep_breakpoint
)
7233 fprintf_unfiltered (gdb_stdlog
,
7234 "infrun: need to step [%s] over single-step "
7236 target_pid_to_str (ecs
->ptid
).c_str ());
7242 /* If this thread needs yet another step-over (e.g., stepping
7243 through a delay slot), do it first before moving on to
7245 if (thread_still_needs_step_over (ecs
->event_thread
))
7249 fprintf_unfiltered (gdb_stdlog
,
7250 "infrun: thread [%s] still needs step-over\n",
7251 target_pid_to_str (ecs
->event_thread
->ptid
).c_str ());
7257 /* If scheduler locking applies even if not stepping, there's no
7258 need to walk over threads. Above we've checked whether the
7259 current thread is stepping. If some other thread not the
7260 event thread is stepping, then it must be that scheduler
7261 locking is not in effect. */
7262 if (schedlock_applies (ecs
->event_thread
))
7265 /* Otherwise, we no longer expect a trap in the current thread.
7266 Clear the trap_expected flag before switching back -- this is
7267 what keep_going does as well, if we call it. */
7268 ecs
->event_thread
->control
.trap_expected
= 0;
7270 /* Likewise, clear the signal if it should not be passed. */
7271 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7272 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7274 /* Do all pending step-overs before actually proceeding with
7276 if (start_step_over ())
7278 prepare_to_wait (ecs
);
7282 /* Look for the stepping/nexting thread. */
7283 stepping_thread
= NULL
;
7285 for (thread_info
*tp
: all_non_exited_threads ())
7287 switch_to_thread_no_regs (tp
);
7289 /* Ignore threads of processes the caller is not
7292 && (tp
->inf
->process_target () != ecs
->target
7293 || tp
->inf
->pid
!= ecs
->ptid
.pid ()))
7296 /* When stepping over a breakpoint, we lock all threads
7297 except the one that needs to move past the breakpoint.
7298 If a non-event thread has this set, the "incomplete
7299 step-over" check above should have caught it earlier. */
7300 if (tp
->control
.trap_expected
)
7302 internal_error (__FILE__
, __LINE__
,
7303 "[%s] has inconsistent state: "
7304 "trap_expected=%d\n",
7305 target_pid_to_str (tp
->ptid
).c_str (),
7306 tp
->control
.trap_expected
);
7309 /* Did we find the stepping thread? */
7310 if (tp
->control
.step_range_end
)
7312 /* Yep. There should only one though. */
7313 gdb_assert (stepping_thread
== NULL
);
7315 /* The event thread is handled at the top, before we
7317 gdb_assert (tp
!= ecs
->event_thread
);
7319 /* If some thread other than the event thread is
7320 stepping, then scheduler locking can't be in effect,
7321 otherwise we wouldn't have resumed the current event
7322 thread in the first place. */
7323 gdb_assert (!schedlock_applies (tp
));
7325 stepping_thread
= tp
;
7329 if (stepping_thread
!= NULL
)
7332 fprintf_unfiltered (gdb_stdlog
,
7333 "infrun: switching back to stepped thread\n");
7335 if (keep_going_stepped_thread (stepping_thread
))
7337 prepare_to_wait (ecs
);
7342 switch_to_thread (ecs
->event_thread
);
7348 /* Set a previously stepped thread back to stepping. Returns true on
7349 success, false if the resume is not possible (e.g., the thread
7353 keep_going_stepped_thread (struct thread_info
*tp
)
7355 struct frame_info
*frame
;
7356 struct execution_control_state ecss
;
7357 struct execution_control_state
*ecs
= &ecss
;
7359 /* If the stepping thread exited, then don't try to switch back and
7360 resume it, which could fail in several different ways depending
7361 on the target. Instead, just keep going.
7363 We can find a stepping dead thread in the thread list in two
7366 - The target supports thread exit events, and when the target
7367 tries to delete the thread from the thread list, inferior_ptid
7368 pointed at the exiting thread. In such case, calling
7369 delete_thread does not really remove the thread from the list;
7370 instead, the thread is left listed, with 'exited' state.
7372 - The target's debug interface does not support thread exit
7373 events, and so we have no idea whatsoever if the previously
7374 stepping thread is still alive. For that reason, we need to
7375 synchronously query the target now. */
7377 if (tp
->state
== THREAD_EXITED
|| !target_thread_alive (tp
->ptid
))
7380 fprintf_unfiltered (gdb_stdlog
,
7381 "infrun: not resuming previously "
7382 "stepped thread, it has vanished\n");
7389 fprintf_unfiltered (gdb_stdlog
,
7390 "infrun: resuming previously stepped thread\n");
7392 reset_ecs (ecs
, tp
);
7393 switch_to_thread (tp
);
7395 tp
->suspend
.stop_pc
= regcache_read_pc (get_thread_regcache (tp
));
7396 frame
= get_current_frame ();
7398 /* If the PC of the thread we were trying to single-step has
7399 changed, then that thread has trapped or been signaled, but the
7400 event has not been reported to GDB yet. Re-poll the target
7401 looking for this particular thread's event (i.e. temporarily
7402 enable schedlock) by:
7404 - setting a break at the current PC
7405 - resuming that particular thread, only (by setting trap
7408 This prevents us continuously moving the single-step breakpoint
7409 forward, one instruction at a time, overstepping. */
7411 if (tp
->suspend
.stop_pc
!= tp
->prev_pc
)
7416 fprintf_unfiltered (gdb_stdlog
,
7417 "infrun: expected thread advanced also (%s -> %s)\n",
7418 paddress (target_gdbarch (), tp
->prev_pc
),
7419 paddress (target_gdbarch (), tp
->suspend
.stop_pc
));
7421 /* Clear the info of the previous step-over, as it's no longer
7422 valid (if the thread was trying to step over a breakpoint, it
7423 has already succeeded). It's what keep_going would do too,
7424 if we called it. Do this before trying to insert the sss
7425 breakpoint, otherwise if we were previously trying to step
7426 over this exact address in another thread, the breakpoint is
7428 clear_step_over_info ();
7429 tp
->control
.trap_expected
= 0;
7431 insert_single_step_breakpoint (get_frame_arch (frame
),
7432 get_frame_address_space (frame
),
7433 tp
->suspend
.stop_pc
);
7436 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
7437 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
7442 fprintf_unfiltered (gdb_stdlog
,
7443 "infrun: expected thread still hasn't advanced\n");
7445 keep_going_pass_signal (ecs
);
7450 /* Is thread TP in the middle of (software or hardware)
7451 single-stepping? (Note the result of this function must never be
7452 passed directly as target_resume's STEP parameter.) */
7455 currently_stepping (struct thread_info
*tp
)
7457 return ((tp
->control
.step_range_end
7458 && tp
->control
.step_resume_breakpoint
== NULL
)
7459 || tp
->control
.trap_expected
7460 || tp
->stepped_breakpoint
7461 || bpstat_should_step ());
7464 /* Inferior has stepped into a subroutine call with source code that
7465 we should not step over. Do step to the first line of code in
7469 handle_step_into_function (struct gdbarch
*gdbarch
,
7470 struct execution_control_state
*ecs
)
7472 fill_in_stop_func (gdbarch
, ecs
);
7474 compunit_symtab
*cust
7475 = find_pc_compunit_symtab (ecs
->event_thread
->suspend
.stop_pc
);
7476 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7477 ecs
->stop_func_start
7478 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7480 symtab_and_line stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
7481 /* Use the step_resume_break to step until the end of the prologue,
7482 even if that involves jumps (as it seems to on the vax under
7484 /* If the prologue ends in the middle of a source line, continue to
7485 the end of that source line (if it is still within the function).
7486 Otherwise, just go to end of prologue. */
7487 if (stop_func_sal
.end
7488 && stop_func_sal
.pc
!= ecs
->stop_func_start
7489 && stop_func_sal
.end
< ecs
->stop_func_end
)
7490 ecs
->stop_func_start
= stop_func_sal
.end
;
7492 /* Architectures which require breakpoint adjustment might not be able
7493 to place a breakpoint at the computed address. If so, the test
7494 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7495 ecs->stop_func_start to an address at which a breakpoint may be
7496 legitimately placed.
7498 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7499 made, GDB will enter an infinite loop when stepping through
7500 optimized code consisting of VLIW instructions which contain
7501 subinstructions corresponding to different source lines. On
7502 FR-V, it's not permitted to place a breakpoint on any but the
7503 first subinstruction of a VLIW instruction. When a breakpoint is
7504 set, GDB will adjust the breakpoint address to the beginning of
7505 the VLIW instruction. Thus, we need to make the corresponding
7506 adjustment here when computing the stop address. */
7508 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7510 ecs
->stop_func_start
7511 = gdbarch_adjust_breakpoint_address (gdbarch
,
7512 ecs
->stop_func_start
);
7515 if (ecs
->stop_func_start
== ecs
->event_thread
->suspend
.stop_pc
)
7517 /* We are already there: stop now. */
7518 end_stepping_range (ecs
);
7523 /* Put the step-breakpoint there and go until there. */
7524 symtab_and_line sr_sal
;
7525 sr_sal
.pc
= ecs
->stop_func_start
;
7526 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7527 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7529 /* Do not specify what the fp should be when we stop since on
7530 some machines the prologue is where the new fp value is
7532 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7534 /* And make sure stepping stops right away then. */
7535 ecs
->event_thread
->control
.step_range_end
7536 = ecs
->event_thread
->control
.step_range_start
;
7541 /* Inferior has stepped backward into a subroutine call with source
7542 code that we should not step over. Do step to the beginning of the
7543 last line of code in it. */
7546 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7547 struct execution_control_state
*ecs
)
7549 struct compunit_symtab
*cust
;
7550 struct symtab_and_line stop_func_sal
;
7552 fill_in_stop_func (gdbarch
, ecs
);
7554 cust
= find_pc_compunit_symtab (ecs
->event_thread
->suspend
.stop_pc
);
7555 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7556 ecs
->stop_func_start
7557 = gdbarch_skip_prologue_noexcept (gdbarch
, ecs
->stop_func_start
);
7559 stop_func_sal
= find_pc_line (ecs
->event_thread
->suspend
.stop_pc
, 0);
7561 /* OK, we're just going to keep stepping here. */
7562 if (stop_func_sal
.pc
== ecs
->event_thread
->suspend
.stop_pc
)
7564 /* We're there already. Just stop stepping now. */
7565 end_stepping_range (ecs
);
7569 /* Else just reset the step range and keep going.
7570 No step-resume breakpoint, they don't work for
7571 epilogues, which can have multiple entry paths. */
7572 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7573 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7579 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7580 This is used to both functions and to skip over code. */
7583 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7584 struct symtab_and_line sr_sal
,
7585 struct frame_id sr_id
,
7586 enum bptype sr_type
)
7588 /* There should never be more than one step-resume or longjmp-resume
7589 breakpoint per thread, so we should never be setting a new
7590 step_resume_breakpoint when one is already active. */
7591 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7592 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7595 fprintf_unfiltered (gdb_stdlog
,
7596 "infrun: inserting step-resume breakpoint at %s\n",
7597 paddress (gdbarch
, sr_sal
.pc
));
7599 inferior_thread ()->control
.step_resume_breakpoint
7600 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
).release ();
7604 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7605 struct symtab_and_line sr_sal
,
7606 struct frame_id sr_id
)
7608 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7613 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7614 This is used to skip a potential signal handler.
7616 This is called with the interrupted function's frame. The signal
7617 handler, when it returns, will resume the interrupted function at
7621 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7623 gdb_assert (return_frame
!= NULL
);
7625 struct gdbarch
*gdbarch
= get_frame_arch (return_frame
);
7627 symtab_and_line sr_sal
;
7628 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7629 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7630 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7632 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7633 get_stack_frame_id (return_frame
),
7637 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7638 is used to skip a function after stepping into it (for "next" or if
7639 the called function has no debugging information).
7641 The current function has almost always been reached by single
7642 stepping a call or return instruction. NEXT_FRAME belongs to the
7643 current function, and the breakpoint will be set at the caller's
7646 This is a separate function rather than reusing
7647 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7648 get_prev_frame, which may stop prematurely (see the implementation
7649 of frame_unwind_caller_id for an example). */
7652 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7654 /* We shouldn't have gotten here if we don't know where the call site
7656 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7658 struct gdbarch
*gdbarch
= frame_unwind_caller_arch (next_frame
);
7660 symtab_and_line sr_sal
;
7661 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7662 frame_unwind_caller_pc (next_frame
));
7663 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7664 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7666 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7667 frame_unwind_caller_id (next_frame
));
7670 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7671 new breakpoint at the target of a jmp_buf. The handling of
7672 longjmp-resume uses the same mechanisms used for handling
7673 "step-resume" breakpoints. */
7676 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7678 /* There should never be more than one longjmp-resume breakpoint per
7679 thread, so we should never be setting a new
7680 longjmp_resume_breakpoint when one is already active. */
7681 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7684 fprintf_unfiltered (gdb_stdlog
,
7685 "infrun: inserting longjmp-resume breakpoint at %s\n",
7686 paddress (gdbarch
, pc
));
7688 inferior_thread ()->control
.exception_resume_breakpoint
=
7689 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
).release ();
7692 /* Insert an exception resume breakpoint. TP is the thread throwing
7693 the exception. The block B is the block of the unwinder debug hook
7694 function. FRAME is the frame corresponding to the call to this
7695 function. SYM is the symbol of the function argument holding the
7696 target PC of the exception. */
7699 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7700 const struct block
*b
,
7701 struct frame_info
*frame
,
7706 struct block_symbol vsym
;
7707 struct value
*value
;
7709 struct breakpoint
*bp
;
7711 vsym
= lookup_symbol_search_name (sym
->search_name (),
7713 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
7714 /* If the value was optimized out, revert to the old behavior. */
7715 if (! value_optimized_out (value
))
7717 handler
= value_as_address (value
);
7720 fprintf_unfiltered (gdb_stdlog
,
7721 "infrun: exception resume at %lx\n",
7722 (unsigned long) handler
);
7724 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7726 bp_exception_resume
).release ();
7728 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7731 bp
->thread
= tp
->global_num
;
7732 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7735 catch (const gdb_exception_error
&e
)
7737 /* We want to ignore errors here. */
7741 /* A helper for check_exception_resume that sets an
7742 exception-breakpoint based on a SystemTap probe. */
7745 insert_exception_resume_from_probe (struct thread_info
*tp
,
7746 const struct bound_probe
*probe
,
7747 struct frame_info
*frame
)
7749 struct value
*arg_value
;
7751 struct breakpoint
*bp
;
7753 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7757 handler
= value_as_address (arg_value
);
7760 fprintf_unfiltered (gdb_stdlog
,
7761 "infrun: exception resume at %s\n",
7762 paddress (get_objfile_arch (probe
->objfile
),
7765 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7766 handler
, bp_exception_resume
).release ();
7767 bp
->thread
= tp
->global_num
;
7768 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7771 /* This is called when an exception has been intercepted. Check to
7772 see whether the exception's destination is of interest, and if so,
7773 set an exception resume breakpoint there. */
7776 check_exception_resume (struct execution_control_state
*ecs
,
7777 struct frame_info
*frame
)
7779 struct bound_probe probe
;
7780 struct symbol
*func
;
7782 /* First see if this exception unwinding breakpoint was set via a
7783 SystemTap probe point. If so, the probe has two arguments: the
7784 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7785 set a breakpoint there. */
7786 probe
= find_probe_by_pc (get_frame_pc (frame
));
7789 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7793 func
= get_frame_function (frame
);
7799 const struct block
*b
;
7800 struct block_iterator iter
;
7804 /* The exception breakpoint is a thread-specific breakpoint on
7805 the unwinder's debug hook, declared as:
7807 void _Unwind_DebugHook (void *cfa, void *handler);
7809 The CFA argument indicates the frame to which control is
7810 about to be transferred. HANDLER is the destination PC.
7812 We ignore the CFA and set a temporary breakpoint at HANDLER.
7813 This is not extremely efficient but it avoids issues in gdb
7814 with computing the DWARF CFA, and it also works even in weird
7815 cases such as throwing an exception from inside a signal
7818 b
= SYMBOL_BLOCK_VALUE (func
);
7819 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7821 if (!SYMBOL_IS_ARGUMENT (sym
))
7828 insert_exception_resume_breakpoint (ecs
->event_thread
,
7834 catch (const gdb_exception_error
&e
)
7840 stop_waiting (struct execution_control_state
*ecs
)
7843 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_waiting\n");
7845 /* Let callers know we don't want to wait for the inferior anymore. */
7846 ecs
->wait_some_more
= 0;
7848 /* If all-stop, but the target is always in non-stop mode, stop all
7849 threads now that we're presenting the stop to the user. */
7850 if (!non_stop
&& target_is_non_stop_p ())
7851 stop_all_threads ();
7854 /* Like keep_going, but passes the signal to the inferior, even if the
7855 signal is set to nopass. */
7858 keep_going_pass_signal (struct execution_control_state
*ecs
)
7860 gdb_assert (ecs
->event_thread
->ptid
== inferior_ptid
);
7861 gdb_assert (!ecs
->event_thread
->resumed
);
7863 /* Save the pc before execution, to compare with pc after stop. */
7864 ecs
->event_thread
->prev_pc
7865 = regcache_read_pc (get_thread_regcache (ecs
->event_thread
));
7867 if (ecs
->event_thread
->control
.trap_expected
)
7869 struct thread_info
*tp
= ecs
->event_thread
;
7872 fprintf_unfiltered (gdb_stdlog
,
7873 "infrun: %s has trap_expected set, "
7874 "resuming to collect trap\n",
7875 target_pid_to_str (tp
->ptid
).c_str ());
7877 /* We haven't yet gotten our trap, and either: intercepted a
7878 non-signal event (e.g., a fork); or took a signal which we
7879 are supposed to pass through to the inferior. Simply
7881 resume (ecs
->event_thread
->suspend
.stop_signal
);
7883 else if (step_over_info_valid_p ())
7885 /* Another thread is stepping over a breakpoint in-line. If
7886 this thread needs a step-over too, queue the request. In
7887 either case, this resume must be deferred for later. */
7888 struct thread_info
*tp
= ecs
->event_thread
;
7890 if (ecs
->hit_singlestep_breakpoint
7891 || thread_still_needs_step_over (tp
))
7894 fprintf_unfiltered (gdb_stdlog
,
7895 "infrun: step-over already in progress: "
7896 "step-over for %s deferred\n",
7897 target_pid_to_str (tp
->ptid
).c_str ());
7898 thread_step_over_chain_enqueue (tp
);
7903 fprintf_unfiltered (gdb_stdlog
,
7904 "infrun: step-over in progress: "
7905 "resume of %s deferred\n",
7906 target_pid_to_str (tp
->ptid
).c_str ());
7911 struct regcache
*regcache
= get_current_regcache ();
7914 step_over_what step_what
;
7916 /* Either the trap was not expected, but we are continuing
7917 anyway (if we got a signal, the user asked it be passed to
7920 We got our expected trap, but decided we should resume from
7923 We're going to run this baby now!
7925 Note that insert_breakpoints won't try to re-insert
7926 already inserted breakpoints. Therefore, we don't
7927 care if breakpoints were already inserted, or not. */
7929 /* If we need to step over a breakpoint, and we're not using
7930 displaced stepping to do so, insert all breakpoints
7931 (watchpoints, etc.) but the one we're stepping over, step one
7932 instruction, and then re-insert the breakpoint when that step
7935 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
7937 remove_bp
= (ecs
->hit_singlestep_breakpoint
7938 || (step_what
& STEP_OVER_BREAKPOINT
));
7939 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
7941 /* We can't use displaced stepping if we need to step past a
7942 watchpoint. The instruction copied to the scratch pad would
7943 still trigger the watchpoint. */
7945 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
7947 set_step_over_info (regcache
->aspace (),
7948 regcache_read_pc (regcache
), remove_wps
,
7949 ecs
->event_thread
->global_num
);
7951 else if (remove_wps
)
7952 set_step_over_info (NULL
, 0, remove_wps
, -1);
7954 /* If we now need to do an in-line step-over, we need to stop
7955 all other threads. Note this must be done before
7956 insert_breakpoints below, because that removes the breakpoint
7957 we're about to step over, otherwise other threads could miss
7959 if (step_over_info_valid_p () && target_is_non_stop_p ())
7960 stop_all_threads ();
7962 /* Stop stepping if inserting breakpoints fails. */
7965 insert_breakpoints ();
7967 catch (const gdb_exception_error
&e
)
7969 exception_print (gdb_stderr
, e
);
7971 clear_step_over_info ();
7975 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
7977 resume (ecs
->event_thread
->suspend
.stop_signal
);
7980 prepare_to_wait (ecs
);
7983 /* Called when we should continue running the inferior, because the
7984 current event doesn't cause a user visible stop. This does the
7985 resuming part; waiting for the next event is done elsewhere. */
7988 keep_going (struct execution_control_state
*ecs
)
7990 if (ecs
->event_thread
->control
.trap_expected
7991 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
7992 ecs
->event_thread
->control
.trap_expected
= 0;
7994 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7995 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7996 keep_going_pass_signal (ecs
);
7999 /* This function normally comes after a resume, before
8000 handle_inferior_event exits. It takes care of any last bits of
8001 housekeeping, and sets the all-important wait_some_more flag. */
8004 prepare_to_wait (struct execution_control_state
*ecs
)
8007 fprintf_unfiltered (gdb_stdlog
, "infrun: prepare_to_wait\n");
8009 ecs
->wait_some_more
= 1;
8011 if (!target_is_async_p ())
8012 mark_infrun_async_event_handler ();
8015 /* We are done with the step range of a step/next/si/ni command.
8016 Called once for each n of a "step n" operation. */
8019 end_stepping_range (struct execution_control_state
*ecs
)
8021 ecs
->event_thread
->control
.stop_step
= 1;
8025 /* Several print_*_reason functions to print why the inferior has stopped.
8026 We always print something when the inferior exits, or receives a signal.
8027 The rest of the cases are dealt with later on in normal_stop and
8028 print_it_typical. Ideally there should be a call to one of these
8029 print_*_reason functions functions from handle_inferior_event each time
8030 stop_waiting is called.
8032 Note that we don't call these directly, instead we delegate that to
8033 the interpreters, through observers. Interpreters then call these
8034 with whatever uiout is right. */
8037 print_end_stepping_range_reason (struct ui_out
*uiout
)
8039 /* For CLI-like interpreters, print nothing. */
8041 if (uiout
->is_mi_like_p ())
8043 uiout
->field_string ("reason",
8044 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
8049 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
8051 annotate_signalled ();
8052 if (uiout
->is_mi_like_p ())
8054 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
8055 uiout
->text ("\nProgram terminated with signal ");
8056 annotate_signal_name ();
8057 uiout
->field_string ("signal-name",
8058 gdb_signal_to_name (siggnal
));
8059 annotate_signal_name_end ();
8061 annotate_signal_string ();
8062 uiout
->field_string ("signal-meaning",
8063 gdb_signal_to_string (siggnal
));
8064 annotate_signal_string_end ();
8065 uiout
->text (".\n");
8066 uiout
->text ("The program no longer exists.\n");
8070 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
8072 struct inferior
*inf
= current_inferior ();
8073 std::string pidstr
= target_pid_to_str (ptid_t (inf
->pid
));
8075 annotate_exited (exitstatus
);
8078 if (uiout
->is_mi_like_p ())
8079 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED
));
8080 std::string exit_code_str
8081 = string_printf ("0%o", (unsigned int) exitstatus
);
8082 uiout
->message ("[Inferior %s (%s) exited with code %pF]\n",
8083 plongest (inf
->num
), pidstr
.c_str (),
8084 string_field ("exit-code", exit_code_str
.c_str ()));
8088 if (uiout
->is_mi_like_p ())
8090 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
8091 uiout
->message ("[Inferior %s (%s) exited normally]\n",
8092 plongest (inf
->num
), pidstr
.c_str ());
8096 /* Some targets/architectures can do extra processing/display of
8097 segmentation faults. E.g., Intel MPX boundary faults.
8098 Call the architecture dependent function to handle the fault. */
8101 handle_segmentation_fault (struct ui_out
*uiout
)
8103 struct regcache
*regcache
= get_current_regcache ();
8104 struct gdbarch
*gdbarch
= regcache
->arch ();
8106 if (gdbarch_handle_segmentation_fault_p (gdbarch
))
8107 gdbarch_handle_segmentation_fault (gdbarch
, uiout
);
8111 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
8113 struct thread_info
*thr
= inferior_thread ();
8117 if (uiout
->is_mi_like_p ())
8119 else if (show_thread_that_caused_stop ())
8123 uiout
->text ("\nThread ");
8124 uiout
->field_string ("thread-id", print_thread_id (thr
));
8126 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
8129 uiout
->text (" \"");
8130 uiout
->field_string ("name", name
);
8135 uiout
->text ("\nProgram");
8137 if (siggnal
== GDB_SIGNAL_0
&& !uiout
->is_mi_like_p ())
8138 uiout
->text (" stopped");
8141 uiout
->text (" received signal ");
8142 annotate_signal_name ();
8143 if (uiout
->is_mi_like_p ())
8145 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
8146 uiout
->field_string ("signal-name", gdb_signal_to_name (siggnal
));
8147 annotate_signal_name_end ();
8149 annotate_signal_string ();
8150 uiout
->field_string ("signal-meaning", gdb_signal_to_string (siggnal
));
8152 if (siggnal
== GDB_SIGNAL_SEGV
)
8153 handle_segmentation_fault (uiout
);
8155 annotate_signal_string_end ();
8157 uiout
->text (".\n");
8161 print_no_history_reason (struct ui_out
*uiout
)
8163 uiout
->text ("\nNo more reverse-execution history.\n");
8166 /* Print current location without a level number, if we have changed
8167 functions or hit a breakpoint. Print source line if we have one.
8168 bpstat_print contains the logic deciding in detail what to print,
8169 based on the event(s) that just occurred. */
8172 print_stop_location (struct target_waitstatus
*ws
)
8175 enum print_what source_flag
;
8176 int do_frame_printing
= 1;
8177 struct thread_info
*tp
= inferior_thread ();
8179 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
8183 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8184 should) carry around the function and does (or should) use
8185 that when doing a frame comparison. */
8186 if (tp
->control
.stop_step
8187 && frame_id_eq (tp
->control
.step_frame_id
,
8188 get_frame_id (get_current_frame ()))
8189 && (tp
->control
.step_start_function
8190 == find_pc_function (tp
->suspend
.stop_pc
)))
8192 /* Finished step, just print source line. */
8193 source_flag
= SRC_LINE
;
8197 /* Print location and source line. */
8198 source_flag
= SRC_AND_LOC
;
8201 case PRINT_SRC_AND_LOC
:
8202 /* Print location and source line. */
8203 source_flag
= SRC_AND_LOC
;
8205 case PRINT_SRC_ONLY
:
8206 source_flag
= SRC_LINE
;
8209 /* Something bogus. */
8210 source_flag
= SRC_LINE
;
8211 do_frame_printing
= 0;
8214 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
8217 /* The behavior of this routine with respect to the source
8219 SRC_LINE: Print only source line
8220 LOCATION: Print only location
8221 SRC_AND_LOC: Print location and source line. */
8222 if (do_frame_printing
)
8223 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
8229 print_stop_event (struct ui_out
*uiout
, bool displays
)
8231 struct target_waitstatus last
;
8232 struct thread_info
*tp
;
8234 get_last_target_status (nullptr, nullptr, &last
);
8237 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
8239 print_stop_location (&last
);
8241 /* Display the auto-display expressions. */
8246 tp
= inferior_thread ();
8247 if (tp
->thread_fsm
!= NULL
8248 && tp
->thread_fsm
->finished_p ())
8250 struct return_value_info
*rv
;
8252 rv
= tp
->thread_fsm
->return_value ();
8254 print_return_value (uiout
, rv
);
8261 maybe_remove_breakpoints (void)
8263 if (!breakpoints_should_be_inserted_now () && target_has_execution
)
8265 if (remove_breakpoints ())
8267 target_terminal::ours_for_output ();
8268 printf_filtered (_("Cannot remove breakpoints because "
8269 "program is no longer writable.\nFurther "
8270 "execution is probably impossible.\n"));
8275 /* The execution context that just caused a normal stop. */
8282 DISABLE_COPY_AND_ASSIGN (stop_context
);
8284 bool changed () const;
8289 /* The event PTID. */
8293 /* If stopp for a thread event, this is the thread that caused the
8295 struct thread_info
*thread
;
8297 /* The inferior that caused the stop. */
8301 /* Initializes a new stop context. If stopped for a thread event, this
8302 takes a strong reference to the thread. */
8304 stop_context::stop_context ()
8306 stop_id
= get_stop_id ();
8307 ptid
= inferior_ptid
;
8308 inf_num
= current_inferior ()->num
;
8310 if (inferior_ptid
!= null_ptid
)
8312 /* Take a strong reference so that the thread can't be deleted
8314 thread
= inferior_thread ();
8321 /* Release a stop context previously created with save_stop_context.
8322 Releases the strong reference to the thread as well. */
8324 stop_context::~stop_context ()
8330 /* Return true if the current context no longer matches the saved stop
8334 stop_context::changed () const
8336 if (ptid
!= inferior_ptid
)
8338 if (inf_num
!= current_inferior ()->num
)
8340 if (thread
!= NULL
&& thread
->state
!= THREAD_STOPPED
)
8342 if (get_stop_id () != stop_id
)
8352 struct target_waitstatus last
;
8354 get_last_target_status (nullptr, nullptr, &last
);
8358 /* If an exception is thrown from this point on, make sure to
8359 propagate GDB's knowledge of the executing state to the
8360 frontend/user running state. A QUIT is an easy exception to see
8361 here, so do this before any filtered output. */
8363 ptid_t finish_ptid
= null_ptid
;
8366 finish_ptid
= minus_one_ptid
;
8367 else if (last
.kind
== TARGET_WAITKIND_SIGNALLED
8368 || last
.kind
== TARGET_WAITKIND_EXITED
)
8370 /* On some targets, we may still have live threads in the
8371 inferior when we get a process exit event. E.g., for
8372 "checkpoint", when the current checkpoint/fork exits,
8373 linux-fork.c automatically switches to another fork from
8374 within target_mourn_inferior. */
8375 if (inferior_ptid
!= null_ptid
)
8376 finish_ptid
= ptid_t (inferior_ptid
.pid ());
8378 else if (last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8379 finish_ptid
= inferior_ptid
;
8381 gdb::optional
<scoped_finish_thread_state
> maybe_finish_thread_state
;
8382 if (finish_ptid
!= null_ptid
)
8384 maybe_finish_thread_state
.emplace
8385 (user_visible_resume_target (finish_ptid
), finish_ptid
);
8388 /* As we're presenting a stop, and potentially removing breakpoints,
8389 update the thread list so we can tell whether there are threads
8390 running on the target. With target remote, for example, we can
8391 only learn about new threads when we explicitly update the thread
8392 list. Do this before notifying the interpreters about signal
8393 stops, end of stepping ranges, etc., so that the "new thread"
8394 output is emitted before e.g., "Program received signal FOO",
8395 instead of after. */
8396 update_thread_list ();
8398 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
8399 gdb::observers::signal_received
.notify (inferior_thread ()->suspend
.stop_signal
);
8401 /* As with the notification of thread events, we want to delay
8402 notifying the user that we've switched thread context until
8403 the inferior actually stops.
8405 There's no point in saying anything if the inferior has exited.
8406 Note that SIGNALLED here means "exited with a signal", not
8407 "received a signal".
8409 Also skip saying anything in non-stop mode. In that mode, as we
8410 don't want GDB to switch threads behind the user's back, to avoid
8411 races where the user is typing a command to apply to thread x,
8412 but GDB switches to thread y before the user finishes entering
8413 the command, fetch_inferior_event installs a cleanup to restore
8414 the current thread back to the thread the user had selected right
8415 after this event is handled, so we're not really switching, only
8416 informing of a stop. */
8418 && previous_inferior_ptid
!= inferior_ptid
8419 && target_has_execution
8420 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
8421 && last
.kind
!= TARGET_WAITKIND_EXITED
8422 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8424 SWITCH_THRU_ALL_UIS ()
8426 target_terminal::ours_for_output ();
8427 printf_filtered (_("[Switching to %s]\n"),
8428 target_pid_to_str (inferior_ptid
).c_str ());
8429 annotate_thread_changed ();
8431 previous_inferior_ptid
= inferior_ptid
;
8434 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
8436 SWITCH_THRU_ALL_UIS ()
8437 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
8439 target_terminal::ours_for_output ();
8440 printf_filtered (_("No unwaited-for children left.\n"));
8444 /* Note: this depends on the update_thread_list call above. */
8445 maybe_remove_breakpoints ();
8447 /* If an auto-display called a function and that got a signal,
8448 delete that auto-display to avoid an infinite recursion. */
8450 if (stopped_by_random_signal
)
8451 disable_current_display ();
8453 SWITCH_THRU_ALL_UIS ()
8455 async_enable_stdin ();
8458 /* Let the user/frontend see the threads as stopped. */
8459 maybe_finish_thread_state
.reset ();
8461 /* Select innermost stack frame - i.e., current frame is frame 0,
8462 and current location is based on that. Handle the case where the
8463 dummy call is returning after being stopped. E.g. the dummy call
8464 previously hit a breakpoint. (If the dummy call returns
8465 normally, we won't reach here.) Do this before the stop hook is
8466 run, so that it doesn't get to see the temporary dummy frame,
8467 which is not where we'll present the stop. */
8468 if (has_stack_frames ())
8470 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
8472 /* Pop the empty frame that contains the stack dummy. This
8473 also restores inferior state prior to the call (struct
8474 infcall_suspend_state). */
8475 struct frame_info
*frame
= get_current_frame ();
8477 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
8479 /* frame_pop calls reinit_frame_cache as the last thing it
8480 does which means there's now no selected frame. */
8483 select_frame (get_current_frame ());
8485 /* Set the current source location. */
8486 set_current_sal_from_frame (get_current_frame ());
8489 /* Look up the hook_stop and run it (CLI internally handles problem
8490 of stop_command's pre-hook not existing). */
8491 if (stop_command
!= NULL
)
8493 stop_context saved_context
;
8497 execute_cmd_pre_hook (stop_command
);
8499 catch (const gdb_exception
&ex
)
8501 exception_fprintf (gdb_stderr
, ex
,
8502 "Error while running hook_stop:\n");
8505 /* If the stop hook resumes the target, then there's no point in
8506 trying to notify about the previous stop; its context is
8507 gone. Likewise if the command switches thread or inferior --
8508 the observers would print a stop for the wrong
8510 if (saved_context
.changed ())
8514 /* Notify observers about the stop. This is where the interpreters
8515 print the stop event. */
8516 if (inferior_ptid
!= null_ptid
)
8517 gdb::observers::normal_stop
.notify (inferior_thread ()->control
.stop_bpstat
,
8520 gdb::observers::normal_stop
.notify (NULL
, stop_print_frame
);
8522 annotate_stopped ();
8524 if (target_has_execution
)
8526 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
8527 && last
.kind
!= TARGET_WAITKIND_EXITED
8528 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
8529 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8530 Delete any breakpoint that is to be deleted at the next stop. */
8531 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
8534 /* Try to get rid of automatically added inferiors that are no
8535 longer needed. Keeping those around slows down things linearly.
8536 Note that this never removes the current inferior. */
8543 signal_stop_state (int signo
)
8545 return signal_stop
[signo
];
8549 signal_print_state (int signo
)
8551 return signal_print
[signo
];
8555 signal_pass_state (int signo
)
8557 return signal_program
[signo
];
8561 signal_cache_update (int signo
)
8565 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
8566 signal_cache_update (signo
);
8571 signal_pass
[signo
] = (signal_stop
[signo
] == 0
8572 && signal_print
[signo
] == 0
8573 && signal_program
[signo
] == 1
8574 && signal_catch
[signo
] == 0);
8578 signal_stop_update (int signo
, int state
)
8580 int ret
= signal_stop
[signo
];
8582 signal_stop
[signo
] = state
;
8583 signal_cache_update (signo
);
8588 signal_print_update (int signo
, int state
)
8590 int ret
= signal_print
[signo
];
8592 signal_print
[signo
] = state
;
8593 signal_cache_update (signo
);
8598 signal_pass_update (int signo
, int state
)
8600 int ret
= signal_program
[signo
];
8602 signal_program
[signo
] = state
;
8603 signal_cache_update (signo
);
8607 /* Update the global 'signal_catch' from INFO and notify the
8611 signal_catch_update (const unsigned int *info
)
8615 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8616 signal_catch
[i
] = info
[i
] > 0;
8617 signal_cache_update (-1);
8618 target_pass_signals (signal_pass
);
8622 sig_print_header (void)
8624 printf_filtered (_("Signal Stop\tPrint\tPass "
8625 "to program\tDescription\n"));
8629 sig_print_info (enum gdb_signal oursig
)
8631 const char *name
= gdb_signal_to_name (oursig
);
8632 int name_padding
= 13 - strlen (name
);
8634 if (name_padding
<= 0)
8637 printf_filtered ("%s", name
);
8638 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8639 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8640 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8641 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8642 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8645 /* Specify how various signals in the inferior should be handled. */
8648 handle_command (const char *args
, int from_tty
)
8650 int digits
, wordlen
;
8651 int sigfirst
, siglast
;
8652 enum gdb_signal oursig
;
8657 error_no_arg (_("signal to handle"));
8660 /* Allocate and zero an array of flags for which signals to handle. */
8662 const size_t nsigs
= GDB_SIGNAL_LAST
;
8663 unsigned char sigs
[nsigs
] {};
8665 /* Break the command line up into args. */
8667 gdb_argv
built_argv (args
);
8669 /* Walk through the args, looking for signal oursigs, signal names, and
8670 actions. Signal numbers and signal names may be interspersed with
8671 actions, with the actions being performed for all signals cumulatively
8672 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8674 for (char *arg
: built_argv
)
8676 wordlen
= strlen (arg
);
8677 for (digits
= 0; isdigit (arg
[digits
]); digits
++)
8681 sigfirst
= siglast
= -1;
8683 if (wordlen
>= 1 && !strncmp (arg
, "all", wordlen
))
8685 /* Apply action to all signals except those used by the
8686 debugger. Silently skip those. */
8689 siglast
= nsigs
- 1;
8691 else if (wordlen
>= 1 && !strncmp (arg
, "stop", wordlen
))
8693 SET_SIGS (nsigs
, sigs
, signal_stop
);
8694 SET_SIGS (nsigs
, sigs
, signal_print
);
8696 else if (wordlen
>= 1 && !strncmp (arg
, "ignore", wordlen
))
8698 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8700 else if (wordlen
>= 2 && !strncmp (arg
, "print", wordlen
))
8702 SET_SIGS (nsigs
, sigs
, signal_print
);
8704 else if (wordlen
>= 2 && !strncmp (arg
, "pass", wordlen
))
8706 SET_SIGS (nsigs
, sigs
, signal_program
);
8708 else if (wordlen
>= 3 && !strncmp (arg
, "nostop", wordlen
))
8710 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8712 else if (wordlen
>= 3 && !strncmp (arg
, "noignore", wordlen
))
8714 SET_SIGS (nsigs
, sigs
, signal_program
);
8716 else if (wordlen
>= 4 && !strncmp (arg
, "noprint", wordlen
))
8718 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8719 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8721 else if (wordlen
>= 4 && !strncmp (arg
, "nopass", wordlen
))
8723 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8725 else if (digits
> 0)
8727 /* It is numeric. The numeric signal refers to our own
8728 internal signal numbering from target.h, not to host/target
8729 signal number. This is a feature; users really should be
8730 using symbolic names anyway, and the common ones like
8731 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8733 sigfirst
= siglast
= (int)
8734 gdb_signal_from_command (atoi (arg
));
8735 if (arg
[digits
] == '-')
8738 gdb_signal_from_command (atoi (arg
+ digits
+ 1));
8740 if (sigfirst
> siglast
)
8742 /* Bet he didn't figure we'd think of this case... */
8743 std::swap (sigfirst
, siglast
);
8748 oursig
= gdb_signal_from_name (arg
);
8749 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8751 sigfirst
= siglast
= (int) oursig
;
8755 /* Not a number and not a recognized flag word => complain. */
8756 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg
);
8760 /* If any signal numbers or symbol names were found, set flags for
8761 which signals to apply actions to. */
8763 for (int signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8765 switch ((enum gdb_signal
) signum
)
8767 case GDB_SIGNAL_TRAP
:
8768 case GDB_SIGNAL_INT
:
8769 if (!allsigs
&& !sigs
[signum
])
8771 if (query (_("%s is used by the debugger.\n\
8772 Are you sure you want to change it? "),
8773 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8778 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8782 case GDB_SIGNAL_DEFAULT
:
8783 case GDB_SIGNAL_UNKNOWN
:
8784 /* Make sure that "all" doesn't print these. */
8793 for (int signum
= 0; signum
< nsigs
; signum
++)
8796 signal_cache_update (-1);
8797 target_pass_signals (signal_pass
);
8798 target_program_signals (signal_program
);
8802 /* Show the results. */
8803 sig_print_header ();
8804 for (; signum
< nsigs
; signum
++)
8806 sig_print_info ((enum gdb_signal
) signum
);
8813 /* Complete the "handle" command. */
8816 handle_completer (struct cmd_list_element
*ignore
,
8817 completion_tracker
&tracker
,
8818 const char *text
, const char *word
)
8820 static const char * const keywords
[] =
8834 signal_completer (ignore
, tracker
, text
, word
);
8835 complete_on_enum (tracker
, keywords
, word
, word
);
8839 gdb_signal_from_command (int num
)
8841 if (num
>= 1 && num
<= 15)
8842 return (enum gdb_signal
) num
;
8843 error (_("Only signals 1-15 are valid as numeric signals.\n\
8844 Use \"info signals\" for a list of symbolic signals."));
8847 /* Print current contents of the tables set by the handle command.
8848 It is possible we should just be printing signals actually used
8849 by the current target (but for things to work right when switching
8850 targets, all signals should be in the signal tables). */
8853 info_signals_command (const char *signum_exp
, int from_tty
)
8855 enum gdb_signal oursig
;
8857 sig_print_header ();
8861 /* First see if this is a symbol name. */
8862 oursig
= gdb_signal_from_name (signum_exp
);
8863 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8865 /* No, try numeric. */
8867 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8869 sig_print_info (oursig
);
8873 printf_filtered ("\n");
8874 /* These ugly casts brought to you by the native VAX compiler. */
8875 for (oursig
= GDB_SIGNAL_FIRST
;
8876 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8877 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8881 if (oursig
!= GDB_SIGNAL_UNKNOWN
8882 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8883 sig_print_info (oursig
);
8886 printf_filtered (_("\nUse the \"handle\" command "
8887 "to change these tables.\n"));
8890 /* The $_siginfo convenience variable is a bit special. We don't know
8891 for sure the type of the value until we actually have a chance to
8892 fetch the data. The type can change depending on gdbarch, so it is
8893 also dependent on which thread you have selected.
8895 1. making $_siginfo be an internalvar that creates a new value on
8898 2. making the value of $_siginfo be an lval_computed value. */
8900 /* This function implements the lval_computed support for reading a
8904 siginfo_value_read (struct value
*v
)
8906 LONGEST transferred
;
8908 /* If we can access registers, so can we access $_siginfo. Likewise
8910 validate_registers_access ();
8913 target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
,
8915 value_contents_all_raw (v
),
8917 TYPE_LENGTH (value_type (v
)));
8919 if (transferred
!= TYPE_LENGTH (value_type (v
)))
8920 error (_("Unable to read siginfo"));
8923 /* This function implements the lval_computed support for writing a
8927 siginfo_value_write (struct value
*v
, struct value
*fromval
)
8929 LONGEST transferred
;
8931 /* If we can access registers, so can we access $_siginfo. Likewise
8933 validate_registers_access ();
8935 transferred
= target_write (current_top_target (),
8936 TARGET_OBJECT_SIGNAL_INFO
,
8938 value_contents_all_raw (fromval
),
8940 TYPE_LENGTH (value_type (fromval
)));
8942 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
8943 error (_("Unable to write siginfo"));
8946 static const struct lval_funcs siginfo_value_funcs
=
8952 /* Return a new value with the correct type for the siginfo object of
8953 the current thread using architecture GDBARCH. Return a void value
8954 if there's no object available. */
8956 static struct value
*
8957 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
8960 if (target_has_stack
8961 && inferior_ptid
!= null_ptid
8962 && gdbarch_get_siginfo_type_p (gdbarch
))
8964 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8966 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
8969 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
8973 /* infcall_suspend_state contains state about the program itself like its
8974 registers and any signal it received when it last stopped.
8975 This state must be restored regardless of how the inferior function call
8976 ends (either successfully, or after it hits a breakpoint or signal)
8977 if the program is to properly continue where it left off. */
8979 class infcall_suspend_state
8982 /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
8983 once the inferior function call has finished. */
8984 infcall_suspend_state (struct gdbarch
*gdbarch
,
8985 const struct thread_info
*tp
,
8986 struct regcache
*regcache
)
8987 : m_thread_suspend (tp
->suspend
),
8988 m_registers (new readonly_detached_regcache (*regcache
))
8990 gdb::unique_xmalloc_ptr
<gdb_byte
> siginfo_data
;
8992 if (gdbarch_get_siginfo_type_p (gdbarch
))
8994 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8995 size_t len
= TYPE_LENGTH (type
);
8997 siginfo_data
.reset ((gdb_byte
*) xmalloc (len
));
8999 if (target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
9000 siginfo_data
.get (), 0, len
) != len
)
9002 /* Errors ignored. */
9003 siginfo_data
.reset (nullptr);
9009 m_siginfo_gdbarch
= gdbarch
;
9010 m_siginfo_data
= std::move (siginfo_data
);
9014 /* Return a pointer to the stored register state. */
9016 readonly_detached_regcache
*registers () const
9018 return m_registers
.get ();
9021 /* Restores the stored state into GDBARCH, TP, and REGCACHE. */
9023 void restore (struct gdbarch
*gdbarch
,
9024 struct thread_info
*tp
,
9025 struct regcache
*regcache
) const
9027 tp
->suspend
= m_thread_suspend
;
9029 if (m_siginfo_gdbarch
== gdbarch
)
9031 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
9033 /* Errors ignored. */
9034 target_write (current_top_target (), TARGET_OBJECT_SIGNAL_INFO
, NULL
,
9035 m_siginfo_data
.get (), 0, TYPE_LENGTH (type
));
9038 /* The inferior can be gone if the user types "print exit(0)"
9039 (and perhaps other times). */
9040 if (target_has_execution
)
9041 /* NB: The register write goes through to the target. */
9042 regcache
->restore (registers ());
9046 /* How the current thread stopped before the inferior function call was
9048 struct thread_suspend_state m_thread_suspend
;
9050 /* The registers before the inferior function call was executed. */
9051 std::unique_ptr
<readonly_detached_regcache
> m_registers
;
9053 /* Format of SIGINFO_DATA or NULL if it is not present. */
9054 struct gdbarch
*m_siginfo_gdbarch
= nullptr;
9056 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
9057 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
9058 content would be invalid. */
9059 gdb::unique_xmalloc_ptr
<gdb_byte
> m_siginfo_data
;
9062 infcall_suspend_state_up
9063 save_infcall_suspend_state ()
9065 struct thread_info
*tp
= inferior_thread ();
9066 struct regcache
*regcache
= get_current_regcache ();
9067 struct gdbarch
*gdbarch
= regcache
->arch ();
9069 infcall_suspend_state_up inf_state
9070 (new struct infcall_suspend_state (gdbarch
, tp
, regcache
));
9072 /* Having saved the current state, adjust the thread state, discarding
9073 any stop signal information. The stop signal is not useful when
9074 starting an inferior function call, and run_inferior_call will not use
9075 the signal due to its `proceed' call with GDB_SIGNAL_0. */
9076 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
9081 /* Restore inferior session state to INF_STATE. */
9084 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
9086 struct thread_info
*tp
= inferior_thread ();
9087 struct regcache
*regcache
= get_current_regcache ();
9088 struct gdbarch
*gdbarch
= regcache
->arch ();
9090 inf_state
->restore (gdbarch
, tp
, regcache
);
9091 discard_infcall_suspend_state (inf_state
);
9095 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
9100 readonly_detached_regcache
*
9101 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
9103 return inf_state
->registers ();
9106 /* infcall_control_state contains state regarding gdb's control of the
9107 inferior itself like stepping control. It also contains session state like
9108 the user's currently selected frame. */
9110 struct infcall_control_state
9112 struct thread_control_state thread_control
;
9113 struct inferior_control_state inferior_control
;
9116 enum stop_stack_kind stop_stack_dummy
= STOP_NONE
;
9117 int stopped_by_random_signal
= 0;
9119 /* ID if the selected frame when the inferior function call was made. */
9120 struct frame_id selected_frame_id
{};
9123 /* Save all of the information associated with the inferior<==>gdb
9126 infcall_control_state_up
9127 save_infcall_control_state ()
9129 infcall_control_state_up
inf_status (new struct infcall_control_state
);
9130 struct thread_info
*tp
= inferior_thread ();
9131 struct inferior
*inf
= current_inferior ();
9133 inf_status
->thread_control
= tp
->control
;
9134 inf_status
->inferior_control
= inf
->control
;
9136 tp
->control
.step_resume_breakpoint
= NULL
;
9137 tp
->control
.exception_resume_breakpoint
= NULL
;
9139 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
9140 chain. If caller's caller is walking the chain, they'll be happier if we
9141 hand them back the original chain when restore_infcall_control_state is
9143 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
9146 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
9147 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
9149 inf_status
->selected_frame_id
= get_frame_id (get_selected_frame (NULL
));
9155 restore_selected_frame (const frame_id
&fid
)
9157 frame_info
*frame
= frame_find_by_id (fid
);
9159 /* If inf_status->selected_frame_id is NULL, there was no previously
9163 warning (_("Unable to restore previously selected frame."));
9167 select_frame (frame
);
9170 /* Restore inferior session state to INF_STATUS. */
9173 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
9175 struct thread_info
*tp
= inferior_thread ();
9176 struct inferior
*inf
= current_inferior ();
9178 if (tp
->control
.step_resume_breakpoint
)
9179 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
9181 if (tp
->control
.exception_resume_breakpoint
)
9182 tp
->control
.exception_resume_breakpoint
->disposition
9183 = disp_del_at_next_stop
;
9185 /* Handle the bpstat_copy of the chain. */
9186 bpstat_clear (&tp
->control
.stop_bpstat
);
9188 tp
->control
= inf_status
->thread_control
;
9189 inf
->control
= inf_status
->inferior_control
;
9192 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
9193 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
9195 if (target_has_stack
)
9197 /* The point of the try/catch is that if the stack is clobbered,
9198 walking the stack might encounter a garbage pointer and
9199 error() trying to dereference it. */
9202 restore_selected_frame (inf_status
->selected_frame_id
);
9204 catch (const gdb_exception_error
&ex
)
9206 exception_fprintf (gdb_stderr
, ex
,
9207 "Unable to restore previously selected frame:\n");
9208 /* Error in restoring the selected frame. Select the
9210 select_frame (get_current_frame ());
9218 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
9220 if (inf_status
->thread_control
.step_resume_breakpoint
)
9221 inf_status
->thread_control
.step_resume_breakpoint
->disposition
9222 = disp_del_at_next_stop
;
9224 if (inf_status
->thread_control
.exception_resume_breakpoint
)
9225 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
9226 = disp_del_at_next_stop
;
9228 /* See save_infcall_control_state for info on stop_bpstat. */
9229 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
9237 clear_exit_convenience_vars (void)
9239 clear_internalvar (lookup_internalvar ("_exitsignal"));
9240 clear_internalvar (lookup_internalvar ("_exitcode"));
9244 /* User interface for reverse debugging:
9245 Set exec-direction / show exec-direction commands
9246 (returns error unless target implements to_set_exec_direction method). */
9248 enum exec_direction_kind execution_direction
= EXEC_FORWARD
;
9249 static const char exec_forward
[] = "forward";
9250 static const char exec_reverse
[] = "reverse";
9251 static const char *exec_direction
= exec_forward
;
9252 static const char *const exec_direction_names
[] = {
9259 set_exec_direction_func (const char *args
, int from_tty
,
9260 struct cmd_list_element
*cmd
)
9262 if (target_can_execute_reverse
)
9264 if (!strcmp (exec_direction
, exec_forward
))
9265 execution_direction
= EXEC_FORWARD
;
9266 else if (!strcmp (exec_direction
, exec_reverse
))
9267 execution_direction
= EXEC_REVERSE
;
9271 exec_direction
= exec_forward
;
9272 error (_("Target does not support this operation."));
9277 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
9278 struct cmd_list_element
*cmd
, const char *value
)
9280 switch (execution_direction
) {
9282 fprintf_filtered (out
, _("Forward.\n"));
9285 fprintf_filtered (out
, _("Reverse.\n"));
9288 internal_error (__FILE__
, __LINE__
,
9289 _("bogus execution_direction value: %d"),
9290 (int) execution_direction
);
9295 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
9296 struct cmd_list_element
*c
, const char *value
)
9298 fprintf_filtered (file
, _("Resuming the execution of threads "
9299 "of all processes is %s.\n"), value
);
9302 /* Implementation of `siginfo' variable. */
9304 static const struct internalvar_funcs siginfo_funcs
=
9311 /* Callback for infrun's target events source. This is marked when a
9312 thread has a pending status to process. */
9315 infrun_async_inferior_event_handler (gdb_client_data data
)
9317 inferior_event_handler (INF_REG_EVENT
, NULL
);
9320 void _initialize_infrun ();
9322 _initialize_infrun ()
9324 struct cmd_list_element
*c
;
9326 /* Register extra event sources in the event loop. */
9327 infrun_async_inferior_event_token
9328 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
);
9330 add_info ("signals", info_signals_command
, _("\
9331 What debugger does when program gets various signals.\n\
9332 Specify a signal as argument to print info on that signal only."));
9333 add_info_alias ("handle", "signals", 0);
9335 c
= add_com ("handle", class_run
, handle_command
, _("\
9336 Specify how to handle signals.\n\
9337 Usage: handle SIGNAL [ACTIONS]\n\
9338 Args are signals and actions to apply to those signals.\n\
9339 If no actions are specified, the current settings for the specified signals\n\
9340 will be displayed instead.\n\
9342 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9343 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9344 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9345 The special arg \"all\" is recognized to mean all signals except those\n\
9346 used by the debugger, typically SIGTRAP and SIGINT.\n\
9348 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9349 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9350 Stop means reenter debugger if this signal happens (implies print).\n\
9351 Print means print a message if this signal happens.\n\
9352 Pass means let program see this signal; otherwise program doesn't know.\n\
9353 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9354 Pass and Stop may be combined.\n\
9356 Multiple signals may be specified. Signal numbers and signal names\n\
9357 may be interspersed with actions, with the actions being performed for\n\
9358 all signals cumulatively specified."));
9359 set_cmd_completer (c
, handle_completer
);
9362 stop_command
= add_cmd ("stop", class_obscure
,
9363 not_just_help_class_command
, _("\
9364 There is no `stop' command, but you can set a hook on `stop'.\n\
9365 This allows you to set a list of commands to be run each time execution\n\
9366 of the program stops."), &cmdlist
);
9368 add_setshow_zuinteger_cmd ("infrun", class_maintenance
, &debug_infrun
, _("\
9369 Set inferior debugging."), _("\
9370 Show inferior debugging."), _("\
9371 When non-zero, inferior specific debugging is enabled."),
9374 &setdebuglist
, &showdebuglist
);
9376 add_setshow_boolean_cmd ("displaced", class_maintenance
,
9377 &debug_displaced
, _("\
9378 Set displaced stepping debugging."), _("\
9379 Show displaced stepping debugging."), _("\
9380 When non-zero, displaced stepping specific debugging is enabled."),
9382 show_debug_displaced
,
9383 &setdebuglist
, &showdebuglist
);
9385 add_setshow_boolean_cmd ("non-stop", no_class
,
9387 Set whether gdb controls the inferior in non-stop mode."), _("\
9388 Show whether gdb controls the inferior in non-stop mode."), _("\
9389 When debugging a multi-threaded program and this setting is\n\
9390 off (the default, also called all-stop mode), when one thread stops\n\
9391 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9392 all other threads in the program while you interact with the thread of\n\
9393 interest. When you continue or step a thread, you can allow the other\n\
9394 threads to run, or have them remain stopped, but while you inspect any\n\
9395 thread's state, all threads stop.\n\
9397 In non-stop mode, when one thread stops, other threads can continue\n\
9398 to run freely. You'll be able to step each thread independently,\n\
9399 leave it stopped or free to run as needed."),
9405 for (size_t i
= 0; i
< GDB_SIGNAL_LAST
; i
++)
9408 signal_print
[i
] = 1;
9409 signal_program
[i
] = 1;
9410 signal_catch
[i
] = 0;
9413 /* Signals caused by debugger's own actions should not be given to
9414 the program afterwards.
9416 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9417 explicitly specifies that it should be delivered to the target
9418 program. Typically, that would occur when a user is debugging a
9419 target monitor on a simulator: the target monitor sets a
9420 breakpoint; the simulator encounters this breakpoint and halts
9421 the simulation handing control to GDB; GDB, noting that the stop
9422 address doesn't map to any known breakpoint, returns control back
9423 to the simulator; the simulator then delivers the hardware
9424 equivalent of a GDB_SIGNAL_TRAP to the program being
9426 signal_program
[GDB_SIGNAL_TRAP
] = 0;
9427 signal_program
[GDB_SIGNAL_INT
] = 0;
9429 /* Signals that are not errors should not normally enter the debugger. */
9430 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
9431 signal_print
[GDB_SIGNAL_ALRM
] = 0;
9432 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
9433 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
9434 signal_stop
[GDB_SIGNAL_PROF
] = 0;
9435 signal_print
[GDB_SIGNAL_PROF
] = 0;
9436 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
9437 signal_print
[GDB_SIGNAL_CHLD
] = 0;
9438 signal_stop
[GDB_SIGNAL_IO
] = 0;
9439 signal_print
[GDB_SIGNAL_IO
] = 0;
9440 signal_stop
[GDB_SIGNAL_POLL
] = 0;
9441 signal_print
[GDB_SIGNAL_POLL
] = 0;
9442 signal_stop
[GDB_SIGNAL_URG
] = 0;
9443 signal_print
[GDB_SIGNAL_URG
] = 0;
9444 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
9445 signal_print
[GDB_SIGNAL_WINCH
] = 0;
9446 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
9447 signal_print
[GDB_SIGNAL_PRIO
] = 0;
9449 /* These signals are used internally by user-level thread
9450 implementations. (See signal(5) on Solaris.) Like the above
9451 signals, a healthy program receives and handles them as part of
9452 its normal operation. */
9453 signal_stop
[GDB_SIGNAL_LWP
] = 0;
9454 signal_print
[GDB_SIGNAL_LWP
] = 0;
9455 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
9456 signal_print
[GDB_SIGNAL_WAITING
] = 0;
9457 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
9458 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
9459 signal_stop
[GDB_SIGNAL_LIBRT
] = 0;
9460 signal_print
[GDB_SIGNAL_LIBRT
] = 0;
9462 /* Update cached state. */
9463 signal_cache_update (-1);
9465 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
9466 &stop_on_solib_events
, _("\
9467 Set stopping for shared library events."), _("\
9468 Show stopping for shared library events."), _("\
9469 If nonzero, gdb will give control to the user when the dynamic linker\n\
9470 notifies gdb of shared library events. The most common event of interest\n\
9471 to the user would be loading/unloading of a new library."),
9472 set_stop_on_solib_events
,
9473 show_stop_on_solib_events
,
9474 &setlist
, &showlist
);
9476 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
9477 follow_fork_mode_kind_names
,
9478 &follow_fork_mode_string
, _("\
9479 Set debugger response to a program call of fork or vfork."), _("\
9480 Show debugger response to a program call of fork or vfork."), _("\
9481 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9482 parent - the original process is debugged after a fork\n\
9483 child - the new process is debugged after a fork\n\
9484 The unfollowed process will continue to run.\n\
9485 By default, the debugger will follow the parent process."),
9487 show_follow_fork_mode_string
,
9488 &setlist
, &showlist
);
9490 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
9491 follow_exec_mode_names
,
9492 &follow_exec_mode_string
, _("\
9493 Set debugger response to a program call of exec."), _("\
9494 Show debugger response to a program call of exec."), _("\
9495 An exec call replaces the program image of a process.\n\
9497 follow-exec-mode can be:\n\
9499 new - the debugger creates a new inferior and rebinds the process\n\
9500 to this new inferior. The program the process was running before\n\
9501 the exec call can be restarted afterwards by restarting the original\n\
9504 same - the debugger keeps the process bound to the same inferior.\n\
9505 The new executable image replaces the previous executable loaded in\n\
9506 the inferior. Restarting the inferior after the exec call restarts\n\
9507 the executable the process was running after the exec call.\n\
9509 By default, the debugger will use the same inferior."),
9511 show_follow_exec_mode_string
,
9512 &setlist
, &showlist
);
9514 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9515 scheduler_enums
, &scheduler_mode
, _("\
9516 Set mode for locking scheduler during execution."), _("\
9517 Show mode for locking scheduler during execution."), _("\
9518 off == no locking (threads may preempt at any time)\n\
9519 on == full locking (no thread except the current thread may run)\n\
9520 This applies to both normal execution and replay mode.\n\
9521 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9522 In this mode, other threads may run during other commands.\n\
9523 This applies to both normal execution and replay mode.\n\
9524 replay == scheduler locked in replay mode and unlocked during normal execution."),
9525 set_schedlock_func
, /* traps on target vector */
9526 show_scheduler_mode
,
9527 &setlist
, &showlist
);
9529 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9530 Set mode for resuming threads of all processes."), _("\
9531 Show mode for resuming threads of all processes."), _("\
9532 When on, execution commands (such as 'continue' or 'next') resume all\n\
9533 threads of all processes. When off (which is the default), execution\n\
9534 commands only resume the threads of the current process. The set of\n\
9535 threads that are resumed is further refined by the scheduler-locking\n\
9536 mode (see help set scheduler-locking)."),
9538 show_schedule_multiple
,
9539 &setlist
, &showlist
);
9541 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9542 Set mode of the step operation."), _("\
9543 Show mode of the step operation."), _("\
9544 When set, doing a step over a function without debug line information\n\
9545 will stop at the first instruction of that function. Otherwise, the\n\
9546 function is skipped and the step command stops at a different source line."),
9548 show_step_stop_if_no_debug
,
9549 &setlist
, &showlist
);
9551 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9552 &can_use_displaced_stepping
, _("\
9553 Set debugger's willingness to use displaced stepping."), _("\
9554 Show debugger's willingness to use displaced stepping."), _("\
9555 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9556 supported by the target architecture. If off, gdb will not use displaced\n\
9557 stepping to step over breakpoints, even if such is supported by the target\n\
9558 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9559 if the target architecture supports it and non-stop mode is active, but will not\n\
9560 use it in all-stop mode (see help set non-stop)."),
9562 show_can_use_displaced_stepping
,
9563 &setlist
, &showlist
);
9565 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9566 &exec_direction
, _("Set direction of execution.\n\
9567 Options are 'forward' or 'reverse'."),
9568 _("Show direction of execution (forward/reverse)."),
9569 _("Tells gdb whether to execute forward or backward."),
9570 set_exec_direction_func
, show_exec_direction_func
,
9571 &setlist
, &showlist
);
9573 /* Set/show detach-on-fork: user-settable mode. */
9575 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9576 Set whether gdb will detach the child of a fork."), _("\
9577 Show whether gdb will detach the child of a fork."), _("\
9578 Tells gdb whether to detach the child of a fork."),
9579 NULL
, NULL
, &setlist
, &showlist
);
9581 /* Set/show disable address space randomization mode. */
9583 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9584 &disable_randomization
, _("\
9585 Set disabling of debuggee's virtual address space randomization."), _("\
9586 Show disabling of debuggee's virtual address space randomization."), _("\
9587 When this mode is on (which is the default), randomization of the virtual\n\
9588 address space is disabled. Standalone programs run with the randomization\n\
9589 enabled by default on some platforms."),
9590 &set_disable_randomization
,
9591 &show_disable_randomization
,
9592 &setlist
, &showlist
);
9594 /* ptid initializations */
9595 inferior_ptid
= null_ptid
;
9596 target_last_wait_ptid
= minus_one_ptid
;
9598 gdb::observers::thread_ptid_changed
.attach (infrun_thread_ptid_changed
);
9599 gdb::observers::thread_stop_requested
.attach (infrun_thread_stop_requested
);
9600 gdb::observers::thread_exit
.attach (infrun_thread_thread_exit
);
9601 gdb::observers::inferior_exit
.attach (infrun_inferior_exit
);
9603 /* Explicitly create without lookup, since that tries to create a
9604 value with a void typed value, and when we get here, gdbarch
9605 isn't initialized yet. At this point, we're quite sure there
9606 isn't another convenience variable of the same name. */
9607 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9609 add_setshow_boolean_cmd ("observer", no_class
,
9610 &observer_mode_1
, _("\
9611 Set whether gdb controls the inferior in observer mode."), _("\
9612 Show whether gdb controls the inferior in observer mode."), _("\
9613 In observer mode, GDB can get data from the inferior, but not\n\
9614 affect its execution. Registers and memory may not be changed,\n\
9615 breakpoints may not be set, and the program cannot be interrupted\n\