1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2015 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 "cli/cli-script.h"
33 #include "gdbthread.h"
45 #include "dictionary.h"
47 #include "mi/mi-common.h"
48 #include "event-top.h"
50 #include "record-full.h"
51 #include "inline-frame.h"
53 #include "tracepoint.h"
54 #include "continuations.h"
59 #include "completer.h"
60 #include "target-descriptions.h"
61 #include "target-dcache.h"
64 #include "event-loop.h"
66 /* Prototypes for local functions */
68 static void signals_info (char *, int);
70 static void handle_command (char *, int);
72 static void sig_print_info (enum gdb_signal
);
74 static void sig_print_header (void);
76 static void resume_cleanups (void *);
78 static int hook_stop_stub (void *);
80 static int restore_selected_frame (void *);
82 static int follow_fork (void);
84 static int follow_fork_inferior (int follow_child
, int detach_fork
);
86 static void follow_inferior_reset_breakpoints (void);
88 static void set_schedlock_func (char *args
, int from_tty
,
89 struct cmd_list_element
*c
);
91 static int currently_stepping (struct thread_info
*tp
);
93 void _initialize_infrun (void);
95 void nullify_last_target_wait_ptid (void);
97 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
99 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
101 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
103 static int maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
);
105 /* Asynchronous signal handler registered as event loop source for
106 when we have pending events ready to be passed to the core. */
107 static struct async_event_handler
*infrun_async_inferior_event_token
;
109 /* Stores whether infrun_async was previously enabled or disabled.
110 Starts off as -1, indicating "never enabled/disabled". */
111 static int infrun_is_async
= -1;
116 infrun_async (int enable
)
118 if (infrun_is_async
!= enable
)
120 infrun_is_async
= enable
;
123 fprintf_unfiltered (gdb_stdlog
,
124 "infrun: infrun_async(%d)\n",
128 mark_async_event_handler (infrun_async_inferior_event_token
);
130 clear_async_event_handler (infrun_async_inferior_event_token
);
134 /* When set, stop the 'step' command if we enter a function which has
135 no line number information. The normal behavior is that we step
136 over such function. */
137 int step_stop_if_no_debug
= 0;
139 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
140 struct cmd_list_element
*c
, const char *value
)
142 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
145 /* In asynchronous mode, but simulating synchronous execution. */
147 int sync_execution
= 0;
149 /* proceed and normal_stop use this to notify the user when the
150 inferior stopped in a different thread than it had been running
153 static ptid_t previous_inferior_ptid
;
155 /* If set (default for legacy reasons), when following a fork, GDB
156 will detach from one of the fork branches, child or parent.
157 Exactly which branch is detached depends on 'set follow-fork-mode'
160 static int detach_fork
= 1;
162 int debug_displaced
= 0;
164 show_debug_displaced (struct ui_file
*file
, int from_tty
,
165 struct cmd_list_element
*c
, const char *value
)
167 fprintf_filtered (file
, _("Displace stepping debugging is %s.\n"), value
);
170 unsigned int debug_infrun
= 0;
172 show_debug_infrun (struct ui_file
*file
, int from_tty
,
173 struct cmd_list_element
*c
, const char *value
)
175 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
179 /* Support for disabling address space randomization. */
181 int disable_randomization
= 1;
184 show_disable_randomization (struct ui_file
*file
, int from_tty
,
185 struct cmd_list_element
*c
, const char *value
)
187 if (target_supports_disable_randomization ())
188 fprintf_filtered (file
,
189 _("Disabling randomization of debuggee's "
190 "virtual address space is %s.\n"),
193 fputs_filtered (_("Disabling randomization of debuggee's "
194 "virtual address space is unsupported on\n"
195 "this platform.\n"), file
);
199 set_disable_randomization (char *args
, int from_tty
,
200 struct cmd_list_element
*c
)
202 if (!target_supports_disable_randomization ())
203 error (_("Disabling randomization of debuggee's "
204 "virtual address space is unsupported on\n"
208 /* User interface for non-stop mode. */
211 static int non_stop_1
= 0;
214 set_non_stop (char *args
, int from_tty
,
215 struct cmd_list_element
*c
)
217 if (target_has_execution
)
219 non_stop_1
= non_stop
;
220 error (_("Cannot change this setting while the inferior is running."));
223 non_stop
= non_stop_1
;
227 show_non_stop (struct ui_file
*file
, int from_tty
,
228 struct cmd_list_element
*c
, const char *value
)
230 fprintf_filtered (file
,
231 _("Controlling the inferior in non-stop mode is %s.\n"),
235 /* "Observer mode" is somewhat like a more extreme version of
236 non-stop, in which all GDB operations that might affect the
237 target's execution have been disabled. */
239 int observer_mode
= 0;
240 static int observer_mode_1
= 0;
243 set_observer_mode (char *args
, int from_tty
,
244 struct cmd_list_element
*c
)
246 if (target_has_execution
)
248 observer_mode_1
= observer_mode
;
249 error (_("Cannot change this setting while the inferior is running."));
252 observer_mode
= observer_mode_1
;
254 may_write_registers
= !observer_mode
;
255 may_write_memory
= !observer_mode
;
256 may_insert_breakpoints
= !observer_mode
;
257 may_insert_tracepoints
= !observer_mode
;
258 /* We can insert fast tracepoints in or out of observer mode,
259 but enable them if we're going into this mode. */
261 may_insert_fast_tracepoints
= 1;
262 may_stop
= !observer_mode
;
263 update_target_permissions ();
265 /* Going *into* observer mode we must force non-stop, then
266 going out we leave it that way. */
269 pagination_enabled
= 0;
270 non_stop
= non_stop_1
= 1;
274 printf_filtered (_("Observer mode is now %s.\n"),
275 (observer_mode
? "on" : "off"));
279 show_observer_mode (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
, const char *value
)
282 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
285 /* This updates the value of observer mode based on changes in
286 permissions. Note that we are deliberately ignoring the values of
287 may-write-registers and may-write-memory, since the user may have
288 reason to enable these during a session, for instance to turn on a
289 debugging-related global. */
292 update_observer_mode (void)
296 newval
= (!may_insert_breakpoints
297 && !may_insert_tracepoints
298 && may_insert_fast_tracepoints
302 /* Let the user know if things change. */
303 if (newval
!= observer_mode
)
304 printf_filtered (_("Observer mode is now %s.\n"),
305 (newval
? "on" : "off"));
307 observer_mode
= observer_mode_1
= newval
;
310 /* Tables of how to react to signals; the user sets them. */
312 static unsigned char *signal_stop
;
313 static unsigned char *signal_print
;
314 static unsigned char *signal_program
;
316 /* Table of signals that are registered with "catch signal". A
317 non-zero entry indicates that the signal is caught by some "catch
318 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
320 static unsigned char *signal_catch
;
322 /* Table of signals that the target may silently handle.
323 This is automatically determined from the flags above,
324 and simply cached here. */
325 static unsigned char *signal_pass
;
327 #define SET_SIGS(nsigs,sigs,flags) \
329 int signum = (nsigs); \
330 while (signum-- > 0) \
331 if ((sigs)[signum]) \
332 (flags)[signum] = 1; \
335 #define UNSET_SIGS(nsigs,sigs,flags) \
337 int signum = (nsigs); \
338 while (signum-- > 0) \
339 if ((sigs)[signum]) \
340 (flags)[signum] = 0; \
343 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
344 this function is to avoid exporting `signal_program'. */
347 update_signals_program_target (void)
349 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
352 /* Value to pass to target_resume() to cause all threads to resume. */
354 #define RESUME_ALL minus_one_ptid
356 /* Command list pointer for the "stop" placeholder. */
358 static struct cmd_list_element
*stop_command
;
360 /* Nonzero if we want to give control to the user when we're notified
361 of shared library events by the dynamic linker. */
362 int stop_on_solib_events
;
364 /* Enable or disable optional shared library event breakpoints
365 as appropriate when the above flag is changed. */
368 set_stop_on_solib_events (char *args
, int from_tty
, struct cmd_list_element
*c
)
370 update_solib_breakpoints ();
374 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
375 struct cmd_list_element
*c
, const char *value
)
377 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
381 /* Nonzero means expecting a trace trap
382 and should stop the inferior and return silently when it happens. */
386 /* Nonzero after stop if current stack frame should be printed. */
388 static int stop_print_frame
;
390 /* This is a cached copy of the pid/waitstatus of the last event
391 returned by target_wait()/deprecated_target_wait_hook(). This
392 information is returned by get_last_target_status(). */
393 static ptid_t target_last_wait_ptid
;
394 static struct target_waitstatus target_last_waitstatus
;
396 static void context_switch (ptid_t ptid
);
398 void init_thread_stepping_state (struct thread_info
*tss
);
400 static const char follow_fork_mode_child
[] = "child";
401 static const char follow_fork_mode_parent
[] = "parent";
403 static const char *const follow_fork_mode_kind_names
[] = {
404 follow_fork_mode_child
,
405 follow_fork_mode_parent
,
409 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
411 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
412 struct cmd_list_element
*c
, const char *value
)
414 fprintf_filtered (file
,
415 _("Debugger response to a program "
416 "call of fork or vfork is \"%s\".\n"),
421 /* Handle changes to the inferior list based on the type of fork,
422 which process is being followed, and whether the other process
423 should be detached. On entry inferior_ptid must be the ptid of
424 the fork parent. At return inferior_ptid is the ptid of the
425 followed inferior. */
428 follow_fork_inferior (int follow_child
, int detach_fork
)
431 ptid_t parent_ptid
, child_ptid
;
433 has_vforked
= (inferior_thread ()->pending_follow
.kind
434 == TARGET_WAITKIND_VFORKED
);
435 parent_ptid
= inferior_ptid
;
436 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
439 && !non_stop
/* Non-stop always resumes both branches. */
440 && (!target_is_async_p () || sync_execution
)
441 && !(follow_child
|| detach_fork
|| sched_multi
))
443 /* The parent stays blocked inside the vfork syscall until the
444 child execs or exits. If we don't let the child run, then
445 the parent stays blocked. If we're telling the parent to run
446 in the foreground, the user will not be able to ctrl-c to get
447 back the terminal, effectively hanging the debug session. */
448 fprintf_filtered (gdb_stderr
, _("\
449 Can not resume the parent process over vfork in the foreground while\n\
450 holding the child stopped. Try \"set detach-on-fork\" or \
451 \"set schedule-multiple\".\n"));
452 /* FIXME output string > 80 columns. */
458 /* Detach new forked process? */
461 struct cleanup
*old_chain
;
463 /* Before detaching from the child, remove all breakpoints
464 from it. If we forked, then this has already been taken
465 care of by infrun.c. If we vforked however, any
466 breakpoint inserted in the parent is visible in the
467 child, even those added while stopped in a vfork
468 catchpoint. This will remove the breakpoints from the
469 parent also, but they'll be reinserted below. */
472 /* Keep breakpoints list in sync. */
473 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
476 if (info_verbose
|| debug_infrun
)
478 /* Ensure that we have a process ptid. */
479 ptid_t process_ptid
= pid_to_ptid (ptid_get_pid (child_ptid
));
481 target_terminal_ours_for_output ();
482 fprintf_filtered (gdb_stdlog
,
483 _("Detaching after %s from child %s.\n"),
484 has_vforked
? "vfork" : "fork",
485 target_pid_to_str (process_ptid
));
490 struct inferior
*parent_inf
, *child_inf
;
491 struct cleanup
*old_chain
;
493 /* Add process to GDB's tables. */
494 child_inf
= add_inferior (ptid_get_pid (child_ptid
));
496 parent_inf
= current_inferior ();
497 child_inf
->attach_flag
= parent_inf
->attach_flag
;
498 copy_terminal_info (child_inf
, parent_inf
);
499 child_inf
->gdbarch
= parent_inf
->gdbarch
;
500 copy_inferior_target_desc_info (child_inf
, parent_inf
);
502 old_chain
= save_inferior_ptid ();
503 save_current_program_space ();
505 inferior_ptid
= child_ptid
;
506 add_thread (inferior_ptid
);
507 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
509 /* If this is a vfork child, then the address-space is
510 shared with the parent. */
513 child_inf
->pspace
= parent_inf
->pspace
;
514 child_inf
->aspace
= parent_inf
->aspace
;
516 /* The parent will be frozen until the child is done
517 with the shared region. Keep track of the
519 child_inf
->vfork_parent
= parent_inf
;
520 child_inf
->pending_detach
= 0;
521 parent_inf
->vfork_child
= child_inf
;
522 parent_inf
->pending_detach
= 0;
526 child_inf
->aspace
= new_address_space ();
527 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
528 child_inf
->removable
= 1;
529 set_current_program_space (child_inf
->pspace
);
530 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
532 /* Let the shared library layer (e.g., solib-svr4) learn
533 about this new process, relocate the cloned exec, pull
534 in shared libraries, and install the solib event
535 breakpoint. If a "cloned-VM" event was propagated
536 better throughout the core, this wouldn't be
538 solib_create_inferior_hook (0);
541 do_cleanups (old_chain
);
546 struct inferior
*parent_inf
;
548 parent_inf
= current_inferior ();
550 /* If we detached from the child, then we have to be careful
551 to not insert breakpoints in the parent until the child
552 is done with the shared memory region. However, if we're
553 staying attached to the child, then we can and should
554 insert breakpoints, so that we can debug it. A
555 subsequent child exec or exit is enough to know when does
556 the child stops using the parent's address space. */
557 parent_inf
->waiting_for_vfork_done
= detach_fork
;
558 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
563 /* Follow the child. */
564 struct inferior
*parent_inf
, *child_inf
;
565 struct program_space
*parent_pspace
;
567 if (info_verbose
|| debug_infrun
)
569 target_terminal_ours_for_output ();
570 fprintf_filtered (gdb_stdlog
,
571 _("Attaching after %s %s to child %s.\n"),
572 target_pid_to_str (parent_ptid
),
573 has_vforked
? "vfork" : "fork",
574 target_pid_to_str (child_ptid
));
577 /* Add the new inferior first, so that the target_detach below
578 doesn't unpush the target. */
580 child_inf
= add_inferior (ptid_get_pid (child_ptid
));
582 parent_inf
= current_inferior ();
583 child_inf
->attach_flag
= parent_inf
->attach_flag
;
584 copy_terminal_info (child_inf
, parent_inf
);
585 child_inf
->gdbarch
= parent_inf
->gdbarch
;
586 copy_inferior_target_desc_info (child_inf
, parent_inf
);
588 parent_pspace
= parent_inf
->pspace
;
590 /* If we're vforking, we want to hold on to the parent until the
591 child exits or execs. At child exec or exit time we can
592 remove the old breakpoints from the parent and detach or
593 resume debugging it. Otherwise, detach the parent now; we'll
594 want to reuse it's program/address spaces, but we can't set
595 them to the child before removing breakpoints from the
596 parent, otherwise, the breakpoints module could decide to
597 remove breakpoints from the wrong process (since they'd be
598 assigned to the same address space). */
602 gdb_assert (child_inf
->vfork_parent
== NULL
);
603 gdb_assert (parent_inf
->vfork_child
== NULL
);
604 child_inf
->vfork_parent
= parent_inf
;
605 child_inf
->pending_detach
= 0;
606 parent_inf
->vfork_child
= child_inf
;
607 parent_inf
->pending_detach
= detach_fork
;
608 parent_inf
->waiting_for_vfork_done
= 0;
610 else if (detach_fork
)
612 if (info_verbose
|| debug_infrun
)
614 /* Ensure that we have a process ptid. */
615 ptid_t process_ptid
= pid_to_ptid (ptid_get_pid (child_ptid
));
617 target_terminal_ours_for_output ();
618 fprintf_filtered (gdb_stdlog
,
619 _("Detaching after fork from "
621 target_pid_to_str (process_ptid
));
624 target_detach (NULL
, 0);
627 /* Note that the detach above makes PARENT_INF dangling. */
629 /* Add the child thread to the appropriate lists, and switch to
630 this new thread, before cloning the program space, and
631 informing the solib layer about this new process. */
633 inferior_ptid
= child_ptid
;
634 add_thread (inferior_ptid
);
636 /* If this is a vfork child, then the address-space is shared
637 with the parent. If we detached from the parent, then we can
638 reuse the parent's program/address spaces. */
639 if (has_vforked
|| detach_fork
)
641 child_inf
->pspace
= parent_pspace
;
642 child_inf
->aspace
= child_inf
->pspace
->aspace
;
646 child_inf
->aspace
= new_address_space ();
647 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
648 child_inf
->removable
= 1;
649 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
650 set_current_program_space (child_inf
->pspace
);
651 clone_program_space (child_inf
->pspace
, parent_pspace
);
653 /* Let the shared library layer (e.g., solib-svr4) learn
654 about this new process, relocate the cloned exec, pull in
655 shared libraries, and install the solib event breakpoint.
656 If a "cloned-VM" event was propagated better throughout
657 the core, this wouldn't be required. */
658 solib_create_inferior_hook (0);
662 return target_follow_fork (follow_child
, detach_fork
);
665 /* Tell the target to follow the fork we're stopped at. Returns true
666 if the inferior should be resumed; false, if the target for some
667 reason decided it's best not to resume. */
672 int follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
673 int should_resume
= 1;
674 struct thread_info
*tp
;
676 /* Copy user stepping state to the new inferior thread. FIXME: the
677 followed fork child thread should have a copy of most of the
678 parent thread structure's run control related fields, not just these.
679 Initialized to avoid "may be used uninitialized" warnings from gcc. */
680 struct breakpoint
*step_resume_breakpoint
= NULL
;
681 struct breakpoint
*exception_resume_breakpoint
= NULL
;
682 CORE_ADDR step_range_start
= 0;
683 CORE_ADDR step_range_end
= 0;
684 struct frame_id step_frame_id
= { 0 };
685 struct interp
*command_interp
= NULL
;
690 struct target_waitstatus wait_status
;
692 /* Get the last target status returned by target_wait(). */
693 get_last_target_status (&wait_ptid
, &wait_status
);
695 /* If not stopped at a fork event, then there's nothing else to
697 if (wait_status
.kind
!= TARGET_WAITKIND_FORKED
698 && wait_status
.kind
!= TARGET_WAITKIND_VFORKED
)
701 /* Check if we switched over from WAIT_PTID, since the event was
703 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
704 && !ptid_equal (inferior_ptid
, wait_ptid
))
706 /* We did. Switch back to WAIT_PTID thread, to tell the
707 target to follow it (in either direction). We'll
708 afterwards refuse to resume, and inform the user what
710 switch_to_thread (wait_ptid
);
715 tp
= inferior_thread ();
717 /* If there were any forks/vforks that were caught and are now to be
718 followed, then do so now. */
719 switch (tp
->pending_follow
.kind
)
721 case TARGET_WAITKIND_FORKED
:
722 case TARGET_WAITKIND_VFORKED
:
724 ptid_t parent
, child
;
726 /* If the user did a next/step, etc, over a fork call,
727 preserve the stepping state in the fork child. */
728 if (follow_child
&& should_resume
)
730 step_resume_breakpoint
= clone_momentary_breakpoint
731 (tp
->control
.step_resume_breakpoint
);
732 step_range_start
= tp
->control
.step_range_start
;
733 step_range_end
= tp
->control
.step_range_end
;
734 step_frame_id
= tp
->control
.step_frame_id
;
735 exception_resume_breakpoint
736 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
737 command_interp
= tp
->control
.command_interp
;
739 /* For now, delete the parent's sr breakpoint, otherwise,
740 parent/child sr breakpoints are considered duplicates,
741 and the child version will not be installed. Remove
742 this when the breakpoints module becomes aware of
743 inferiors and address spaces. */
744 delete_step_resume_breakpoint (tp
);
745 tp
->control
.step_range_start
= 0;
746 tp
->control
.step_range_end
= 0;
747 tp
->control
.step_frame_id
= null_frame_id
;
748 delete_exception_resume_breakpoint (tp
);
749 tp
->control
.command_interp
= NULL
;
752 parent
= inferior_ptid
;
753 child
= tp
->pending_follow
.value
.related_pid
;
755 /* Set up inferior(s) as specified by the caller, and tell the
756 target to do whatever is necessary to follow either parent
758 if (follow_fork_inferior (follow_child
, detach_fork
))
760 /* Target refused to follow, or there's some other reason
761 we shouldn't resume. */
766 /* This pending follow fork event is now handled, one way
767 or another. The previous selected thread may be gone
768 from the lists by now, but if it is still around, need
769 to clear the pending follow request. */
770 tp
= find_thread_ptid (parent
);
772 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
774 /* This makes sure we don't try to apply the "Switched
775 over from WAIT_PID" logic above. */
776 nullify_last_target_wait_ptid ();
778 /* If we followed the child, switch to it... */
781 switch_to_thread (child
);
783 /* ... and preserve the stepping state, in case the
784 user was stepping over the fork call. */
787 tp
= inferior_thread ();
788 tp
->control
.step_resume_breakpoint
789 = step_resume_breakpoint
;
790 tp
->control
.step_range_start
= step_range_start
;
791 tp
->control
.step_range_end
= step_range_end
;
792 tp
->control
.step_frame_id
= step_frame_id
;
793 tp
->control
.exception_resume_breakpoint
794 = exception_resume_breakpoint
;
795 tp
->control
.command_interp
= command_interp
;
799 /* If we get here, it was because we're trying to
800 resume from a fork catchpoint, but, the user
801 has switched threads away from the thread that
802 forked. In that case, the resume command
803 issued is most likely not applicable to the
804 child, so just warn, and refuse to resume. */
805 warning (_("Not resuming: switched threads "
806 "before following fork child.\n"));
809 /* Reset breakpoints in the child as appropriate. */
810 follow_inferior_reset_breakpoints ();
813 switch_to_thread (parent
);
817 case TARGET_WAITKIND_SPURIOUS
:
818 /* Nothing to follow. */
821 internal_error (__FILE__
, __LINE__
,
822 "Unexpected pending_follow.kind %d\n",
823 tp
->pending_follow
.kind
);
827 return should_resume
;
831 follow_inferior_reset_breakpoints (void)
833 struct thread_info
*tp
= inferior_thread ();
835 /* Was there a step_resume breakpoint? (There was if the user
836 did a "next" at the fork() call.) If so, explicitly reset its
837 thread number. Cloned step_resume breakpoints are disabled on
838 creation, so enable it here now that it is associated with the
841 step_resumes are a form of bp that are made to be per-thread.
842 Since we created the step_resume bp when the parent process
843 was being debugged, and now are switching to the child process,
844 from the breakpoint package's viewpoint, that's a switch of
845 "threads". We must update the bp's notion of which thread
846 it is for, or it'll be ignored when it triggers. */
848 if (tp
->control
.step_resume_breakpoint
)
850 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
851 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
854 /* Treat exception_resume breakpoints like step_resume breakpoints. */
855 if (tp
->control
.exception_resume_breakpoint
)
857 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
858 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
861 /* Reinsert all breakpoints in the child. The user may have set
862 breakpoints after catching the fork, in which case those
863 were never set in the child, but only in the parent. This makes
864 sure the inserted breakpoints match the breakpoint list. */
866 breakpoint_re_set ();
867 insert_breakpoints ();
870 /* The child has exited or execed: resume threads of the parent the
871 user wanted to be executing. */
874 proceed_after_vfork_done (struct thread_info
*thread
,
877 int pid
= * (int *) arg
;
879 if (ptid_get_pid (thread
->ptid
) == pid
880 && is_running (thread
->ptid
)
881 && !is_executing (thread
->ptid
)
882 && !thread
->stop_requested
883 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
886 fprintf_unfiltered (gdb_stdlog
,
887 "infrun: resuming vfork parent thread %s\n",
888 target_pid_to_str (thread
->ptid
));
890 switch_to_thread (thread
->ptid
);
891 clear_proceed_status (0);
892 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
898 /* Called whenever we notice an exec or exit event, to handle
899 detaching or resuming a vfork parent. */
902 handle_vfork_child_exec_or_exit (int exec
)
904 struct inferior
*inf
= current_inferior ();
906 if (inf
->vfork_parent
)
908 int resume_parent
= -1;
910 /* This exec or exit marks the end of the shared memory region
911 between the parent and the child. If the user wanted to
912 detach from the parent, now is the time. */
914 if (inf
->vfork_parent
->pending_detach
)
916 struct thread_info
*tp
;
917 struct cleanup
*old_chain
;
918 struct program_space
*pspace
;
919 struct address_space
*aspace
;
921 /* follow-fork child, detach-on-fork on. */
923 inf
->vfork_parent
->pending_detach
= 0;
927 /* If we're handling a child exit, then inferior_ptid
928 points at the inferior's pid, not to a thread. */
929 old_chain
= save_inferior_ptid ();
930 save_current_program_space ();
931 save_current_inferior ();
934 old_chain
= save_current_space_and_thread ();
936 /* We're letting loose of the parent. */
937 tp
= any_live_thread_of_process (inf
->vfork_parent
->pid
);
938 switch_to_thread (tp
->ptid
);
940 /* We're about to detach from the parent, which implicitly
941 removes breakpoints from its address space. There's a
942 catch here: we want to reuse the spaces for the child,
943 but, parent/child are still sharing the pspace at this
944 point, although the exec in reality makes the kernel give
945 the child a fresh set of new pages. The problem here is
946 that the breakpoints module being unaware of this, would
947 likely chose the child process to write to the parent
948 address space. Swapping the child temporarily away from
949 the spaces has the desired effect. Yes, this is "sort
952 pspace
= inf
->pspace
;
953 aspace
= inf
->aspace
;
957 if (debug_infrun
|| info_verbose
)
959 target_terminal_ours_for_output ();
963 fprintf_filtered (gdb_stdlog
,
964 _("Detaching vfork parent process "
965 "%d after child exec.\n"),
966 inf
->vfork_parent
->pid
);
970 fprintf_filtered (gdb_stdlog
,
971 _("Detaching vfork parent process "
972 "%d after child exit.\n"),
973 inf
->vfork_parent
->pid
);
977 target_detach (NULL
, 0);
980 inf
->pspace
= pspace
;
981 inf
->aspace
= aspace
;
983 do_cleanups (old_chain
);
987 /* We're staying attached to the parent, so, really give the
988 child a new address space. */
989 inf
->pspace
= add_program_space (maybe_new_address_space ());
990 inf
->aspace
= inf
->pspace
->aspace
;
992 set_current_program_space (inf
->pspace
);
994 resume_parent
= inf
->vfork_parent
->pid
;
996 /* Break the bonds. */
997 inf
->vfork_parent
->vfork_child
= NULL
;
1001 struct cleanup
*old_chain
;
1002 struct program_space
*pspace
;
1004 /* If this is a vfork child exiting, then the pspace and
1005 aspaces were shared with the parent. Since we're
1006 reporting the process exit, we'll be mourning all that is
1007 found in the address space, and switching to null_ptid,
1008 preparing to start a new inferior. But, since we don't
1009 want to clobber the parent's address/program spaces, we
1010 go ahead and create a new one for this exiting
1013 /* Switch to null_ptid, so that clone_program_space doesn't want
1014 to read the selected frame of a dead process. */
1015 old_chain
= save_inferior_ptid ();
1016 inferior_ptid
= null_ptid
;
1018 /* This inferior is dead, so avoid giving the breakpoints
1019 module the option to write through to it (cloning a
1020 program space resets breakpoints). */
1023 pspace
= add_program_space (maybe_new_address_space ());
1024 set_current_program_space (pspace
);
1026 inf
->symfile_flags
= SYMFILE_NO_READ
;
1027 clone_program_space (pspace
, inf
->vfork_parent
->pspace
);
1028 inf
->pspace
= pspace
;
1029 inf
->aspace
= pspace
->aspace
;
1031 /* Put back inferior_ptid. We'll continue mourning this
1033 do_cleanups (old_chain
);
1035 resume_parent
= inf
->vfork_parent
->pid
;
1036 /* Break the bonds. */
1037 inf
->vfork_parent
->vfork_child
= NULL
;
1040 inf
->vfork_parent
= NULL
;
1042 gdb_assert (current_program_space
== inf
->pspace
);
1044 if (non_stop
&& resume_parent
!= -1)
1046 /* If the user wanted the parent to be running, let it go
1048 struct cleanup
*old_chain
= make_cleanup_restore_current_thread ();
1051 fprintf_unfiltered (gdb_stdlog
,
1052 "infrun: resuming vfork parent process %d\n",
1055 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1057 do_cleanups (old_chain
);
1062 /* Enum strings for "set|show follow-exec-mode". */
1064 static const char follow_exec_mode_new
[] = "new";
1065 static const char follow_exec_mode_same
[] = "same";
1066 static const char *const follow_exec_mode_names
[] =
1068 follow_exec_mode_new
,
1069 follow_exec_mode_same
,
1073 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1075 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1076 struct cmd_list_element
*c
, const char *value
)
1078 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1081 /* EXECD_PATHNAME is assumed to be non-NULL. */
1084 follow_exec (ptid_t ptid
, char *execd_pathname
)
1086 struct thread_info
*th
, *tmp
;
1087 struct inferior
*inf
= current_inferior ();
1088 int pid
= ptid_get_pid (ptid
);
1090 /* This is an exec event that we actually wish to pay attention to.
1091 Refresh our symbol table to the newly exec'd program, remove any
1092 momentary bp's, etc.
1094 If there are breakpoints, they aren't really inserted now,
1095 since the exec() transformed our inferior into a fresh set
1098 We want to preserve symbolic breakpoints on the list, since
1099 we have hopes that they can be reset after the new a.out's
1100 symbol table is read.
1102 However, any "raw" breakpoints must be removed from the list
1103 (e.g., the solib bp's), since their address is probably invalid
1106 And, we DON'T want to call delete_breakpoints() here, since
1107 that may write the bp's "shadow contents" (the instruction
1108 value that was overwritten witha TRAP instruction). Since
1109 we now have a new a.out, those shadow contents aren't valid. */
1111 mark_breakpoints_out ();
1113 /* The target reports the exec event to the main thread, even if
1114 some other thread does the exec, and even if the main thread was
1115 stopped or already gone. We may still have non-leader threads of
1116 the process on our list. E.g., on targets that don't have thread
1117 exit events (like remote); or on native Linux in non-stop mode if
1118 there were only two threads in the inferior and the non-leader
1119 one is the one that execs (and nothing forces an update of the
1120 thread list up to here). When debugging remotely, it's best to
1121 avoid extra traffic, when possible, so avoid syncing the thread
1122 list with the target, and instead go ahead and delete all threads
1123 of the process but one that reported the event. Note this must
1124 be done before calling update_breakpoints_after_exec, as
1125 otherwise clearing the threads' resources would reference stale
1126 thread breakpoints -- it may have been one of these threads that
1127 stepped across the exec. We could just clear their stepping
1128 states, but as long as we're iterating, might as well delete
1129 them. Deleting them now rather than at the next user-visible
1130 stop provides a nicer sequence of events for user and MI
1132 ALL_THREADS_SAFE (th
, tmp
)
1133 if (ptid_get_pid (th
->ptid
) == pid
&& !ptid_equal (th
->ptid
, ptid
))
1134 delete_thread (th
->ptid
);
1136 /* We also need to clear any left over stale state for the
1137 leader/event thread. E.g., if there was any step-resume
1138 breakpoint or similar, it's gone now. We cannot truly
1139 step-to-next statement through an exec(). */
1140 th
= inferior_thread ();
1141 th
->control
.step_resume_breakpoint
= NULL
;
1142 th
->control
.exception_resume_breakpoint
= NULL
;
1143 th
->control
.single_step_breakpoints
= NULL
;
1144 th
->control
.step_range_start
= 0;
1145 th
->control
.step_range_end
= 0;
1147 /* The user may have had the main thread held stopped in the
1148 previous image (e.g., schedlock on, or non-stop). Release
1150 th
->stop_requested
= 0;
1152 update_breakpoints_after_exec ();
1154 /* What is this a.out's name? */
1155 printf_unfiltered (_("%s is executing new program: %s\n"),
1156 target_pid_to_str (inferior_ptid
),
1159 /* We've followed the inferior through an exec. Therefore, the
1160 inferior has essentially been killed & reborn. */
1162 gdb_flush (gdb_stdout
);
1164 breakpoint_init_inferior (inf_execd
);
1166 if (*gdb_sysroot
!= '\0')
1168 char *name
= exec_file_find (execd_pathname
, NULL
);
1170 execd_pathname
= alloca (strlen (name
) + 1);
1171 strcpy (execd_pathname
, name
);
1175 /* Reset the shared library package. This ensures that we get a
1176 shlib event when the child reaches "_start", at which point the
1177 dld will have had a chance to initialize the child. */
1178 /* Also, loading a symbol file below may trigger symbol lookups, and
1179 we don't want those to be satisfied by the libraries of the
1180 previous incarnation of this process. */
1181 no_shared_libraries (NULL
, 0);
1183 if (follow_exec_mode_string
== follow_exec_mode_new
)
1185 struct program_space
*pspace
;
1187 /* The user wants to keep the old inferior and program spaces
1188 around. Create a new fresh one, and switch to it. */
1190 inf
= add_inferior (current_inferior ()->pid
);
1191 pspace
= add_program_space (maybe_new_address_space ());
1192 inf
->pspace
= pspace
;
1193 inf
->aspace
= pspace
->aspace
;
1195 exit_inferior_num_silent (current_inferior ()->num
);
1197 set_current_inferior (inf
);
1198 set_current_program_space (pspace
);
1202 /* The old description may no longer be fit for the new image.
1203 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1204 old description; we'll read a new one below. No need to do
1205 this on "follow-exec-mode new", as the old inferior stays
1206 around (its description is later cleared/refetched on
1208 target_clear_description ();
1211 gdb_assert (current_program_space
== inf
->pspace
);
1213 /* That a.out is now the one to use. */
1214 exec_file_attach (execd_pathname
, 0);
1216 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1217 (Position Independent Executable) main symbol file will get applied by
1218 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1219 the breakpoints with the zero displacement. */
1221 symbol_file_add (execd_pathname
,
1223 | SYMFILE_MAINLINE
| SYMFILE_DEFER_BP_RESET
),
1226 if ((inf
->symfile_flags
& SYMFILE_NO_READ
) == 0)
1227 set_initial_language ();
1229 /* If the target can specify a description, read it. Must do this
1230 after flipping to the new executable (because the target supplied
1231 description must be compatible with the executable's
1232 architecture, and the old executable may e.g., be 32-bit, while
1233 the new one 64-bit), and before anything involving memory or
1235 target_find_description ();
1237 solib_create_inferior_hook (0);
1239 jit_inferior_created_hook ();
1241 breakpoint_re_set ();
1243 /* Reinsert all breakpoints. (Those which were symbolic have
1244 been reset to the proper address in the new a.out, thanks
1245 to symbol_file_command...). */
1246 insert_breakpoints ();
1248 /* The next resume of this inferior should bring it to the shlib
1249 startup breakpoints. (If the user had also set bp's on
1250 "main" from the old (parent) process, then they'll auto-
1251 matically get reset there in the new process.). */
1254 /* The queue of threads that need to do a step-over operation to get
1255 past e.g., a breakpoint. What technique is used to step over the
1256 breakpoint/watchpoint does not matter -- all threads end up in the
1257 same queue, to maintain rough temporal order of execution, in order
1258 to avoid starvation, otherwise, we could e.g., find ourselves
1259 constantly stepping the same couple threads past their breakpoints
1260 over and over, if the single-step finish fast enough. */
1261 struct thread_info
*step_over_queue_head
;
1263 /* Bit flags indicating what the thread needs to step over. */
1267 /* Step over a breakpoint. */
1268 STEP_OVER_BREAKPOINT
= 1,
1270 /* Step past a non-continuable watchpoint, in order to let the
1271 instruction execute so we can evaluate the watchpoint
1273 STEP_OVER_WATCHPOINT
= 2
1276 /* Info about an instruction that is being stepped over. */
1278 struct step_over_info
1280 /* If we're stepping past a breakpoint, this is the address space
1281 and address of the instruction the breakpoint is set at. We'll
1282 skip inserting all breakpoints here. Valid iff ASPACE is
1284 struct address_space
*aspace
;
1287 /* The instruction being stepped over triggers a nonsteppable
1288 watchpoint. If true, we'll skip inserting watchpoints. */
1289 int nonsteppable_watchpoint_p
;
1292 /* The step-over info of the location that is being stepped over.
1294 Note that with async/breakpoint always-inserted mode, a user might
1295 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1296 being stepped over. As setting a new breakpoint inserts all
1297 breakpoints, we need to make sure the breakpoint being stepped over
1298 isn't inserted then. We do that by only clearing the step-over
1299 info when the step-over is actually finished (or aborted).
1301 Presently GDB can only step over one breakpoint at any given time.
1302 Given threads that can't run code in the same address space as the
1303 breakpoint's can't really miss the breakpoint, GDB could be taught
1304 to step-over at most one breakpoint per address space (so this info
1305 could move to the address space object if/when GDB is extended).
1306 The set of breakpoints being stepped over will normally be much
1307 smaller than the set of all breakpoints, so a flag in the
1308 breakpoint location structure would be wasteful. A separate list
1309 also saves complexity and run-time, as otherwise we'd have to go
1310 through all breakpoint locations clearing their flag whenever we
1311 start a new sequence. Similar considerations weigh against storing
1312 this info in the thread object. Plus, not all step overs actually
1313 have breakpoint locations -- e.g., stepping past a single-step
1314 breakpoint, or stepping to complete a non-continuable
1316 static struct step_over_info step_over_info
;
1318 /* Record the address of the breakpoint/instruction we're currently
1322 set_step_over_info (struct address_space
*aspace
, CORE_ADDR address
,
1323 int nonsteppable_watchpoint_p
)
1325 step_over_info
.aspace
= aspace
;
1326 step_over_info
.address
= address
;
1327 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1330 /* Called when we're not longer stepping over a breakpoint / an
1331 instruction, so all breakpoints are free to be (re)inserted. */
1334 clear_step_over_info (void)
1337 fprintf_unfiltered (gdb_stdlog
,
1338 "infrun: clear_step_over_info\n");
1339 step_over_info
.aspace
= NULL
;
1340 step_over_info
.address
= 0;
1341 step_over_info
.nonsteppable_watchpoint_p
= 0;
1347 stepping_past_instruction_at (struct address_space
*aspace
,
1350 return (step_over_info
.aspace
!= NULL
1351 && breakpoint_address_match (aspace
, address
,
1352 step_over_info
.aspace
,
1353 step_over_info
.address
));
1359 stepping_past_nonsteppable_watchpoint (void)
1361 return step_over_info
.nonsteppable_watchpoint_p
;
1364 /* Returns true if step-over info is valid. */
1367 step_over_info_valid_p (void)
1369 return (step_over_info
.aspace
!= NULL
1370 || stepping_past_nonsteppable_watchpoint ());
1374 /* Displaced stepping. */
1376 /* In non-stop debugging mode, we must take special care to manage
1377 breakpoints properly; in particular, the traditional strategy for
1378 stepping a thread past a breakpoint it has hit is unsuitable.
1379 'Displaced stepping' is a tactic for stepping one thread past a
1380 breakpoint it has hit while ensuring that other threads running
1381 concurrently will hit the breakpoint as they should.
1383 The traditional way to step a thread T off a breakpoint in a
1384 multi-threaded program in all-stop mode is as follows:
1386 a0) Initially, all threads are stopped, and breakpoints are not
1388 a1) We single-step T, leaving breakpoints uninserted.
1389 a2) We insert breakpoints, and resume all threads.
1391 In non-stop debugging, however, this strategy is unsuitable: we
1392 don't want to have to stop all threads in the system in order to
1393 continue or step T past a breakpoint. Instead, we use displaced
1396 n0) Initially, T is stopped, other threads are running, and
1397 breakpoints are inserted.
1398 n1) We copy the instruction "under" the breakpoint to a separate
1399 location, outside the main code stream, making any adjustments
1400 to the instruction, register, and memory state as directed by
1402 n2) We single-step T over the instruction at its new location.
1403 n3) We adjust the resulting register and memory state as directed
1404 by T's architecture. This includes resetting T's PC to point
1405 back into the main instruction stream.
1408 This approach depends on the following gdbarch methods:
1410 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1411 indicate where to copy the instruction, and how much space must
1412 be reserved there. We use these in step n1.
1414 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1415 address, and makes any necessary adjustments to the instruction,
1416 register contents, and memory. We use this in step n1.
1418 - gdbarch_displaced_step_fixup adjusts registers and memory after
1419 we have successfuly single-stepped the instruction, to yield the
1420 same effect the instruction would have had if we had executed it
1421 at its original address. We use this in step n3.
1423 - gdbarch_displaced_step_free_closure provides cleanup.
1425 The gdbarch_displaced_step_copy_insn and
1426 gdbarch_displaced_step_fixup functions must be written so that
1427 copying an instruction with gdbarch_displaced_step_copy_insn,
1428 single-stepping across the copied instruction, and then applying
1429 gdbarch_displaced_insn_fixup should have the same effects on the
1430 thread's memory and registers as stepping the instruction in place
1431 would have. Exactly which responsibilities fall to the copy and
1432 which fall to the fixup is up to the author of those functions.
1434 See the comments in gdbarch.sh for details.
1436 Note that displaced stepping and software single-step cannot
1437 currently be used in combination, although with some care I think
1438 they could be made to. Software single-step works by placing
1439 breakpoints on all possible subsequent instructions; if the
1440 displaced instruction is a PC-relative jump, those breakpoints
1441 could fall in very strange places --- on pages that aren't
1442 executable, or at addresses that are not proper instruction
1443 boundaries. (We do generally let other threads run while we wait
1444 to hit the software single-step breakpoint, and they might
1445 encounter such a corrupted instruction.) One way to work around
1446 this would be to have gdbarch_displaced_step_copy_insn fully
1447 simulate the effect of PC-relative instructions (and return NULL)
1448 on architectures that use software single-stepping.
1450 In non-stop mode, we can have independent and simultaneous step
1451 requests, so more than one thread may need to simultaneously step
1452 over a breakpoint. The current implementation assumes there is
1453 only one scratch space per process. In this case, we have to
1454 serialize access to the scratch space. If thread A wants to step
1455 over a breakpoint, but we are currently waiting for some other
1456 thread to complete a displaced step, we leave thread A stopped and
1457 place it in the displaced_step_request_queue. Whenever a displaced
1458 step finishes, we pick the next thread in the queue and start a new
1459 displaced step operation on it. See displaced_step_prepare and
1460 displaced_step_fixup for details. */
1462 /* Per-inferior displaced stepping state. */
1463 struct displaced_step_inferior_state
1465 /* Pointer to next in linked list. */
1466 struct displaced_step_inferior_state
*next
;
1468 /* The process this displaced step state refers to. */
1471 /* True if preparing a displaced step ever failed. If so, we won't
1472 try displaced stepping for this inferior again. */
1475 /* If this is not null_ptid, this is the thread carrying out a
1476 displaced single-step in process PID. This thread's state will
1477 require fixing up once it has completed its step. */
1480 /* The architecture the thread had when we stepped it. */
1481 struct gdbarch
*step_gdbarch
;
1483 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1484 for post-step cleanup. */
1485 struct displaced_step_closure
*step_closure
;
1487 /* The address of the original instruction, and the copy we
1489 CORE_ADDR step_original
, step_copy
;
1491 /* Saved contents of copy area. */
1492 gdb_byte
*step_saved_copy
;
1495 /* The list of states of processes involved in displaced stepping
1497 static struct displaced_step_inferior_state
*displaced_step_inferior_states
;
1499 /* Get the displaced stepping state of process PID. */
1501 static struct displaced_step_inferior_state
*
1502 get_displaced_stepping_state (int pid
)
1504 struct displaced_step_inferior_state
*state
;
1506 for (state
= displaced_step_inferior_states
;
1508 state
= state
->next
)
1509 if (state
->pid
== pid
)
1515 /* Returns true if any inferior has a thread doing a displaced
1519 displaced_step_in_progress_any_inferior (void)
1521 struct displaced_step_inferior_state
*state
;
1523 for (state
= displaced_step_inferior_states
;
1525 state
= state
->next
)
1526 if (!ptid_equal (state
->step_ptid
, null_ptid
))
1532 /* Return true if process PID has a thread doing a displaced step. */
1535 displaced_step_in_progress (int pid
)
1537 struct displaced_step_inferior_state
*displaced
;
1539 displaced
= get_displaced_stepping_state (pid
);
1540 if (displaced
!= NULL
&& !ptid_equal (displaced
->step_ptid
, null_ptid
))
1546 /* Add a new displaced stepping state for process PID to the displaced
1547 stepping state list, or return a pointer to an already existing
1548 entry, if it already exists. Never returns NULL. */
1550 static struct displaced_step_inferior_state
*
1551 add_displaced_stepping_state (int pid
)
1553 struct displaced_step_inferior_state
*state
;
1555 for (state
= displaced_step_inferior_states
;
1557 state
= state
->next
)
1558 if (state
->pid
== pid
)
1561 state
= xcalloc (1, sizeof (*state
));
1563 state
->next
= displaced_step_inferior_states
;
1564 displaced_step_inferior_states
= state
;
1569 /* If inferior is in displaced stepping, and ADDR equals to starting address
1570 of copy area, return corresponding displaced_step_closure. Otherwise,
1573 struct displaced_step_closure
*
1574 get_displaced_step_closure_by_addr (CORE_ADDR addr
)
1576 struct displaced_step_inferior_state
*displaced
1577 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
1579 /* If checking the mode of displaced instruction in copy area. */
1580 if (displaced
&& !ptid_equal (displaced
->step_ptid
, null_ptid
)
1581 && (displaced
->step_copy
== addr
))
1582 return displaced
->step_closure
;
1587 /* Remove the displaced stepping state of process PID. */
1590 remove_displaced_stepping_state (int pid
)
1592 struct displaced_step_inferior_state
*it
, **prev_next_p
;
1594 gdb_assert (pid
!= 0);
1596 it
= displaced_step_inferior_states
;
1597 prev_next_p
= &displaced_step_inferior_states
;
1602 *prev_next_p
= it
->next
;
1607 prev_next_p
= &it
->next
;
1613 infrun_inferior_exit (struct inferior
*inf
)
1615 remove_displaced_stepping_state (inf
->pid
);
1618 /* If ON, and the architecture supports it, GDB will use displaced
1619 stepping to step over breakpoints. If OFF, or if the architecture
1620 doesn't support it, GDB will instead use the traditional
1621 hold-and-step approach. If AUTO (which is the default), GDB will
1622 decide which technique to use to step over breakpoints depending on
1623 which of all-stop or non-stop mode is active --- displaced stepping
1624 in non-stop mode; hold-and-step in all-stop mode. */
1626 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1629 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1630 struct cmd_list_element
*c
,
1633 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1634 fprintf_filtered (file
,
1635 _("Debugger's willingness to use displaced stepping "
1636 "to step over breakpoints is %s (currently %s).\n"),
1637 value
, target_is_non_stop_p () ? "on" : "off");
1639 fprintf_filtered (file
,
1640 _("Debugger's willingness to use displaced stepping "
1641 "to step over breakpoints is %s.\n"), value
);
1644 /* Return non-zero if displaced stepping can/should be used to step
1645 over breakpoints of thread TP. */
1648 use_displaced_stepping (struct thread_info
*tp
)
1650 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
1651 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1652 struct displaced_step_inferior_state
*displaced_state
;
1654 displaced_state
= get_displaced_stepping_state (ptid_get_pid (tp
->ptid
));
1656 return (((can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1657 && target_is_non_stop_p ())
1658 || can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1659 && gdbarch_displaced_step_copy_insn_p (gdbarch
)
1660 && find_record_target () == NULL
1661 && (displaced_state
== NULL
1662 || !displaced_state
->failed_before
));
1665 /* Clean out any stray displaced stepping state. */
1667 displaced_step_clear (struct displaced_step_inferior_state
*displaced
)
1669 /* Indicate that there is no cleanup pending. */
1670 displaced
->step_ptid
= null_ptid
;
1672 if (displaced
->step_closure
)
1674 gdbarch_displaced_step_free_closure (displaced
->step_gdbarch
,
1675 displaced
->step_closure
);
1676 displaced
->step_closure
= NULL
;
1681 displaced_step_clear_cleanup (void *arg
)
1683 struct displaced_step_inferior_state
*state
= arg
;
1685 displaced_step_clear (state
);
1688 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1690 displaced_step_dump_bytes (struct ui_file
*file
,
1691 const gdb_byte
*buf
,
1696 for (i
= 0; i
< len
; i
++)
1697 fprintf_unfiltered (file
, "%02x ", buf
[i
]);
1698 fputs_unfiltered ("\n", file
);
1701 /* Prepare to single-step, using displaced stepping.
1703 Note that we cannot use displaced stepping when we have a signal to
1704 deliver. If we have a signal to deliver and an instruction to step
1705 over, then after the step, there will be no indication from the
1706 target whether the thread entered a signal handler or ignored the
1707 signal and stepped over the instruction successfully --- both cases
1708 result in a simple SIGTRAP. In the first case we mustn't do a
1709 fixup, and in the second case we must --- but we can't tell which.
1710 Comments in the code for 'random signals' in handle_inferior_event
1711 explain how we handle this case instead.
1713 Returns 1 if preparing was successful -- this thread is going to be
1714 stepped now; or 0 if displaced stepping this thread got queued. */
1716 displaced_step_prepare_throw (ptid_t ptid
)
1718 struct cleanup
*old_cleanups
, *ignore_cleanups
;
1719 struct thread_info
*tp
= find_thread_ptid (ptid
);
1720 struct regcache
*regcache
= get_thread_regcache (ptid
);
1721 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1722 CORE_ADDR original
, copy
;
1724 struct displaced_step_closure
*closure
;
1725 struct displaced_step_inferior_state
*displaced
;
1728 /* We should never reach this function if the architecture does not
1729 support displaced stepping. */
1730 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch
));
1732 /* Nor if the thread isn't meant to step over a breakpoint. */
1733 gdb_assert (tp
->control
.trap_expected
);
1735 /* Disable range stepping while executing in the scratch pad. We
1736 want a single-step even if executing the displaced instruction in
1737 the scratch buffer lands within the stepping range (e.g., a
1739 tp
->control
.may_range_step
= 0;
1741 /* We have to displaced step one thread at a time, as we only have
1742 access to a single scratch space per inferior. */
1744 displaced
= add_displaced_stepping_state (ptid_get_pid (ptid
));
1746 if (!ptid_equal (displaced
->step_ptid
, null_ptid
))
1748 /* Already waiting for a displaced step to finish. Defer this
1749 request and place in queue. */
1751 if (debug_displaced
)
1752 fprintf_unfiltered (gdb_stdlog
,
1753 "displaced: deferring step of %s\n",
1754 target_pid_to_str (ptid
));
1756 thread_step_over_chain_enqueue (tp
);
1761 if (debug_displaced
)
1762 fprintf_unfiltered (gdb_stdlog
,
1763 "displaced: stepping %s now\n",
1764 target_pid_to_str (ptid
));
1767 displaced_step_clear (displaced
);
1769 old_cleanups
= save_inferior_ptid ();
1770 inferior_ptid
= ptid
;
1772 original
= regcache_read_pc (regcache
);
1774 copy
= gdbarch_displaced_step_location (gdbarch
);
1775 len
= gdbarch_max_insn_length (gdbarch
);
1777 /* Save the original contents of the copy area. */
1778 displaced
->step_saved_copy
= xmalloc (len
);
1779 ignore_cleanups
= make_cleanup (free_current_contents
,
1780 &displaced
->step_saved_copy
);
1781 status
= target_read_memory (copy
, displaced
->step_saved_copy
, len
);
1783 throw_error (MEMORY_ERROR
,
1784 _("Error accessing memory address %s (%s) for "
1785 "displaced-stepping scratch space."),
1786 paddress (gdbarch
, copy
), safe_strerror (status
));
1787 if (debug_displaced
)
1789 fprintf_unfiltered (gdb_stdlog
, "displaced: saved %s: ",
1790 paddress (gdbarch
, copy
));
1791 displaced_step_dump_bytes (gdb_stdlog
,
1792 displaced
->step_saved_copy
,
1796 closure
= gdbarch_displaced_step_copy_insn (gdbarch
,
1797 original
, copy
, regcache
);
1799 /* We don't support the fully-simulated case at present. */
1800 gdb_assert (closure
);
1802 /* Save the information we need to fix things up if the step
1804 displaced
->step_ptid
= ptid
;
1805 displaced
->step_gdbarch
= gdbarch
;
1806 displaced
->step_closure
= closure
;
1807 displaced
->step_original
= original
;
1808 displaced
->step_copy
= copy
;
1810 make_cleanup (displaced_step_clear_cleanup
, displaced
);
1812 /* Resume execution at the copy. */
1813 regcache_write_pc (regcache
, copy
);
1815 discard_cleanups (ignore_cleanups
);
1817 do_cleanups (old_cleanups
);
1819 if (debug_displaced
)
1820 fprintf_unfiltered (gdb_stdlog
, "displaced: displaced pc to %s\n",
1821 paddress (gdbarch
, copy
));
1826 /* Wrapper for displaced_step_prepare_throw that disabled further
1827 attempts at displaced stepping if we get a memory error. */
1830 displaced_step_prepare (ptid_t ptid
)
1836 prepared
= displaced_step_prepare_throw (ptid
);
1838 CATCH (ex
, RETURN_MASK_ERROR
)
1840 struct displaced_step_inferior_state
*displaced_state
;
1842 if (ex
.error
!= MEMORY_ERROR
)
1843 throw_exception (ex
);
1847 fprintf_unfiltered (gdb_stdlog
,
1848 "infrun: disabling displaced stepping: %s\n",
1852 /* Be verbose if "set displaced-stepping" is "on", silent if
1854 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1856 warning (_("disabling displaced stepping: %s\n"),
1860 /* Disable further displaced stepping attempts. */
1862 = get_displaced_stepping_state (ptid_get_pid (ptid
));
1863 displaced_state
->failed_before
= 1;
1871 write_memory_ptid (ptid_t ptid
, CORE_ADDR memaddr
,
1872 const gdb_byte
*myaddr
, int len
)
1874 struct cleanup
*ptid_cleanup
= save_inferior_ptid ();
1876 inferior_ptid
= ptid
;
1877 write_memory (memaddr
, myaddr
, len
);
1878 do_cleanups (ptid_cleanup
);
1881 /* Restore the contents of the copy area for thread PTID. */
1884 displaced_step_restore (struct displaced_step_inferior_state
*displaced
,
1887 ULONGEST len
= gdbarch_max_insn_length (displaced
->step_gdbarch
);
1889 write_memory_ptid (ptid
, displaced
->step_copy
,
1890 displaced
->step_saved_copy
, len
);
1891 if (debug_displaced
)
1892 fprintf_unfiltered (gdb_stdlog
, "displaced: restored %s %s\n",
1893 target_pid_to_str (ptid
),
1894 paddress (displaced
->step_gdbarch
,
1895 displaced
->step_copy
));
1898 /* If we displaced stepped an instruction successfully, adjust
1899 registers and memory to yield the same effect the instruction would
1900 have had if we had executed it at its original address, and return
1901 1. If the instruction didn't complete, relocate the PC and return
1902 -1. If the thread wasn't displaced stepping, return 0. */
1905 displaced_step_fixup (ptid_t event_ptid
, enum gdb_signal signal
)
1907 struct cleanup
*old_cleanups
;
1908 struct displaced_step_inferior_state
*displaced
1909 = get_displaced_stepping_state (ptid_get_pid (event_ptid
));
1912 /* Was any thread of this process doing a displaced step? */
1913 if (displaced
== NULL
)
1916 /* Was this event for the pid we displaced? */
1917 if (ptid_equal (displaced
->step_ptid
, null_ptid
)
1918 || ! ptid_equal (displaced
->step_ptid
, event_ptid
))
1921 old_cleanups
= make_cleanup (displaced_step_clear_cleanup
, displaced
);
1923 displaced_step_restore (displaced
, displaced
->step_ptid
);
1925 /* Fixup may need to read memory/registers. Switch to the thread
1926 that we're fixing up. Also, target_stopped_by_watchpoint checks
1927 the current thread. */
1928 switch_to_thread (event_ptid
);
1930 /* Did the instruction complete successfully? */
1931 if (signal
== GDB_SIGNAL_TRAP
1932 && !(target_stopped_by_watchpoint ()
1933 && (gdbarch_have_nonsteppable_watchpoint (displaced
->step_gdbarch
)
1934 || target_have_steppable_watchpoint
)))
1936 /* Fix up the resulting state. */
1937 gdbarch_displaced_step_fixup (displaced
->step_gdbarch
,
1938 displaced
->step_closure
,
1939 displaced
->step_original
,
1940 displaced
->step_copy
,
1941 get_thread_regcache (displaced
->step_ptid
));
1946 /* Since the instruction didn't complete, all we can do is
1948 struct regcache
*regcache
= get_thread_regcache (event_ptid
);
1949 CORE_ADDR pc
= regcache_read_pc (regcache
);
1951 pc
= displaced
->step_original
+ (pc
- displaced
->step_copy
);
1952 regcache_write_pc (regcache
, pc
);
1956 do_cleanups (old_cleanups
);
1958 displaced
->step_ptid
= null_ptid
;
1963 /* Data to be passed around while handling an event. This data is
1964 discarded between events. */
1965 struct execution_control_state
1968 /* The thread that got the event, if this was a thread event; NULL
1970 struct thread_info
*event_thread
;
1972 struct target_waitstatus ws
;
1973 int stop_func_filled_in
;
1974 CORE_ADDR stop_func_start
;
1975 CORE_ADDR stop_func_end
;
1976 const char *stop_func_name
;
1979 /* True if the event thread hit the single-step breakpoint of
1980 another thread. Thus the event doesn't cause a stop, the thread
1981 needs to be single-stepped past the single-step breakpoint before
1982 we can switch back to the original stepping thread. */
1983 int hit_singlestep_breakpoint
;
1986 /* Clear ECS and set it to point at TP. */
1989 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
1991 memset (ecs
, 0, sizeof (*ecs
));
1992 ecs
->event_thread
= tp
;
1993 ecs
->ptid
= tp
->ptid
;
1996 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
1997 static void prepare_to_wait (struct execution_control_state
*ecs
);
1998 static int keep_going_stepped_thread (struct thread_info
*tp
);
1999 static int thread_still_needs_step_over (struct thread_info
*tp
);
2000 static void stop_all_threads (void);
2002 /* Are there any pending step-over requests? If so, run all we can
2003 now and return true. Otherwise, return false. */
2006 start_step_over (void)
2008 struct thread_info
*tp
, *next
;
2010 /* Don't start a new step-over if we already have an in-line
2011 step-over operation ongoing. */
2012 if (step_over_info_valid_p ())
2015 for (tp
= step_over_queue_head
; tp
!= NULL
; tp
= next
)
2017 struct execution_control_state ecss
;
2018 struct execution_control_state
*ecs
= &ecss
;
2019 enum step_over_what step_what
;
2020 int must_be_in_line
;
2022 next
= thread_step_over_chain_next (tp
);
2024 /* If this inferior already has a displaced step in process,
2025 don't start a new one. */
2026 if (displaced_step_in_progress (ptid_get_pid (tp
->ptid
)))
2029 step_what
= thread_still_needs_step_over (tp
);
2030 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
2031 || ((step_what
& STEP_OVER_BREAKPOINT
)
2032 && !use_displaced_stepping (tp
)));
2034 /* We currently stop all threads of all processes to step-over
2035 in-line. If we need to start a new in-line step-over, let
2036 any pending displaced steps finish first. */
2037 if (must_be_in_line
&& displaced_step_in_progress_any_inferior ())
2040 thread_step_over_chain_remove (tp
);
2042 if (step_over_queue_head
== NULL
)
2045 fprintf_unfiltered (gdb_stdlog
,
2046 "infrun: step-over queue now empty\n");
2049 if (tp
->control
.trap_expected
2053 internal_error (__FILE__
, __LINE__
,
2054 "[%s] has inconsistent state: "
2055 "trap_expected=%d, resumed=%d, executing=%d\n",
2056 target_pid_to_str (tp
->ptid
),
2057 tp
->control
.trap_expected
,
2063 fprintf_unfiltered (gdb_stdlog
,
2064 "infrun: resuming [%s] for step-over\n",
2065 target_pid_to_str (tp
->ptid
));
2067 /* keep_going_pass_signal skips the step-over if the breakpoint
2068 is no longer inserted. In all-stop, we want to keep looking
2069 for a thread that needs a step-over instead of resuming TP,
2070 because we wouldn't be able to resume anything else until the
2071 target stops again. In non-stop, the resume always resumes
2072 only TP, so it's OK to let the thread resume freely. */
2073 if (!target_is_non_stop_p () && !step_what
)
2076 switch_to_thread (tp
->ptid
);
2077 reset_ecs (ecs
, tp
);
2078 keep_going_pass_signal (ecs
);
2080 if (!ecs
->wait_some_more
)
2081 error (_("Command aborted."));
2083 gdb_assert (tp
->resumed
);
2085 /* If we started a new in-line step-over, we're done. */
2086 if (step_over_info_valid_p ())
2088 gdb_assert (tp
->control
.trap_expected
);
2092 if (!target_is_non_stop_p ())
2094 /* On all-stop, shouldn't have resumed unless we needed a
2096 gdb_assert (tp
->control
.trap_expected
2097 || tp
->step_after_step_resume_breakpoint
);
2099 /* With remote targets (at least), in all-stop, we can't
2100 issue any further remote commands until the program stops
2105 /* Either the thread no longer needed a step-over, or a new
2106 displaced stepping sequence started. Even in the latter
2107 case, continue looking. Maybe we can also start another
2108 displaced step on a thread of other process. */
2114 /* Update global variables holding ptids to hold NEW_PTID if they were
2115 holding OLD_PTID. */
2117 infrun_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
2119 struct displaced_step_request
*it
;
2120 struct displaced_step_inferior_state
*displaced
;
2122 if (ptid_equal (inferior_ptid
, old_ptid
))
2123 inferior_ptid
= new_ptid
;
2125 for (displaced
= displaced_step_inferior_states
;
2127 displaced
= displaced
->next
)
2129 if (ptid_equal (displaced
->step_ptid
, old_ptid
))
2130 displaced
->step_ptid
= new_ptid
;
2137 /* Things to clean up if we QUIT out of resume (). */
2139 resume_cleanups (void *ignore
)
2141 if (!ptid_equal (inferior_ptid
, null_ptid
))
2142 delete_single_step_breakpoints (inferior_thread ());
2147 static const char schedlock_off
[] = "off";
2148 static const char schedlock_on
[] = "on";
2149 static const char schedlock_step
[] = "step";
2150 static const char *const scheduler_enums
[] = {
2156 static const char *scheduler_mode
= schedlock_off
;
2158 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2159 struct cmd_list_element
*c
, const char *value
)
2161 fprintf_filtered (file
,
2162 _("Mode for locking scheduler "
2163 "during execution is \"%s\".\n"),
2168 set_schedlock_func (char *args
, int from_tty
, struct cmd_list_element
*c
)
2170 if (!target_can_lock_scheduler
)
2172 scheduler_mode
= schedlock_off
;
2173 error (_("Target '%s' cannot support this command."), target_shortname
);
2177 /* True if execution commands resume all threads of all processes by
2178 default; otherwise, resume only threads of the current inferior
2180 int sched_multi
= 0;
2182 /* Try to setup for software single stepping over the specified location.
2183 Return 1 if target_resume() should use hardware single step.
2185 GDBARCH the current gdbarch.
2186 PC the location to step over. */
2189 maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2193 if (execution_direction
== EXEC_FORWARD
2194 && gdbarch_software_single_step_p (gdbarch
)
2195 && gdbarch_software_single_step (gdbarch
, get_current_frame ()))
2205 user_visible_resume_ptid (int step
)
2211 /* With non-stop mode on, threads are always handled
2213 resume_ptid
= inferior_ptid
;
2215 else if ((scheduler_mode
== schedlock_on
)
2216 || (scheduler_mode
== schedlock_step
&& step
))
2218 /* User-settable 'scheduler' mode requires solo thread
2220 resume_ptid
= inferior_ptid
;
2222 else if (!sched_multi
&& target_supports_multi_process ())
2224 /* Resume all threads of the current process (and none of other
2226 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
2230 /* Resume all threads of all processes. */
2231 resume_ptid
= RESUME_ALL
;
2237 /* Return a ptid representing the set of threads that we will resume,
2238 in the perspective of the target, assuming run control handling
2239 does not require leaving some threads stopped (e.g., stepping past
2240 breakpoint). USER_STEP indicates whether we're about to start the
2241 target for a stepping command. */
2244 internal_resume_ptid (int user_step
)
2246 /* In non-stop, we always control threads individually. Note that
2247 the target may always work in non-stop mode even with "set
2248 non-stop off", in which case user_visible_resume_ptid could
2249 return a wildcard ptid. */
2250 if (target_is_non_stop_p ())
2251 return inferior_ptid
;
2253 return user_visible_resume_ptid (user_step
);
2256 /* Wrapper for target_resume, that handles infrun-specific
2260 do_target_resume (ptid_t resume_ptid
, int step
, enum gdb_signal sig
)
2262 struct thread_info
*tp
= inferior_thread ();
2264 /* Install inferior's terminal modes. */
2265 target_terminal_inferior ();
2267 /* Avoid confusing the next resume, if the next stop/resume
2268 happens to apply to another thread. */
2269 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2271 /* Advise target which signals may be handled silently.
2273 If we have removed breakpoints because we are stepping over one
2274 in-line (in any thread), we need to receive all signals to avoid
2275 accidentally skipping a breakpoint during execution of a signal
2278 Likewise if we're displaced stepping, otherwise a trap for a
2279 breakpoint in a signal handler might be confused with the
2280 displaced step finishing. We don't make the displaced_step_fixup
2281 step distinguish the cases instead, because:
2283 - a backtrace while stopped in the signal handler would show the
2284 scratch pad as frame older than the signal handler, instead of
2285 the real mainline code.
2287 - when the thread is later resumed, the signal handler would
2288 return to the scratch pad area, which would no longer be
2290 if (step_over_info_valid_p ()
2291 || displaced_step_in_progress (ptid_get_pid (tp
->ptid
)))
2292 target_pass_signals (0, NULL
);
2294 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
2296 target_resume (resume_ptid
, step
, sig
);
2299 /* Resume the inferior, but allow a QUIT. This is useful if the user
2300 wants to interrupt some lengthy single-stepping operation
2301 (for child processes, the SIGINT goes to the inferior, and so
2302 we get a SIGINT random_signal, but for remote debugging and perhaps
2303 other targets, that's not true).
2305 SIG is the signal to give the inferior (zero for none). */
2307 resume (enum gdb_signal sig
)
2309 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
2310 struct regcache
*regcache
= get_current_regcache ();
2311 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2312 struct thread_info
*tp
= inferior_thread ();
2313 CORE_ADDR pc
= regcache_read_pc (regcache
);
2314 struct address_space
*aspace
= get_regcache_aspace (regcache
);
2316 /* This represents the user's step vs continue request. When
2317 deciding whether "set scheduler-locking step" applies, it's the
2318 user's intention that counts. */
2319 const int user_step
= tp
->control
.stepping_command
;
2320 /* This represents what we'll actually request the target to do.
2321 This can decay from a step to a continue, if e.g., we need to
2322 implement single-stepping with breakpoints (software
2326 gdb_assert (!thread_is_in_step_over_chain (tp
));
2330 if (tp
->suspend
.waitstatus_pending_p
)
2336 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2337 fprintf_unfiltered (gdb_stdlog
,
2338 "infrun: resume: thread %s has pending wait status %s "
2339 "(currently_stepping=%d).\n",
2340 target_pid_to_str (tp
->ptid
), statstr
,
2341 currently_stepping (tp
));
2347 /* FIXME: What should we do if we are supposed to resume this
2348 thread with a signal? Maybe we should maintain a queue of
2349 pending signals to deliver. */
2350 if (sig
!= GDB_SIGNAL_0
)
2352 warning (_("Couldn't deliver signal %s to %s.\n"),
2353 gdb_signal_to_name (sig
), target_pid_to_str (tp
->ptid
));
2356 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2357 discard_cleanups (old_cleanups
);
2359 if (target_can_async_p ())
2364 tp
->stepped_breakpoint
= 0;
2366 /* Depends on stepped_breakpoint. */
2367 step
= currently_stepping (tp
);
2369 if (current_inferior ()->waiting_for_vfork_done
)
2371 /* Don't try to single-step a vfork parent that is waiting for
2372 the child to get out of the shared memory region (by exec'ing
2373 or exiting). This is particularly important on software
2374 single-step archs, as the child process would trip on the
2375 software single step breakpoint inserted for the parent
2376 process. Since the parent will not actually execute any
2377 instruction until the child is out of the shared region (such
2378 are vfork's semantics), it is safe to simply continue it.
2379 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2380 the parent, and tell it to `keep_going', which automatically
2381 re-sets it stepping. */
2383 fprintf_unfiltered (gdb_stdlog
,
2384 "infrun: resume : clear step\n");
2389 fprintf_unfiltered (gdb_stdlog
,
2390 "infrun: resume (step=%d, signal=%s), "
2391 "trap_expected=%d, current thread [%s] at %s\n",
2392 step
, gdb_signal_to_symbol_string (sig
),
2393 tp
->control
.trap_expected
,
2394 target_pid_to_str (inferior_ptid
),
2395 paddress (gdbarch
, pc
));
2397 /* Normally, by the time we reach `resume', the breakpoints are either
2398 removed or inserted, as appropriate. The exception is if we're sitting
2399 at a permanent breakpoint; we need to step over it, but permanent
2400 breakpoints can't be removed. So we have to test for it here. */
2401 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2403 if (sig
!= GDB_SIGNAL_0
)
2405 /* We have a signal to pass to the inferior. The resume
2406 may, or may not take us to the signal handler. If this
2407 is a step, we'll need to stop in the signal handler, if
2408 there's one, (if the target supports stepping into
2409 handlers), or in the next mainline instruction, if
2410 there's no handler. If this is a continue, we need to be
2411 sure to run the handler with all breakpoints inserted.
2412 In all cases, set a breakpoint at the current address
2413 (where the handler returns to), and once that breakpoint
2414 is hit, resume skipping the permanent breakpoint. If
2415 that breakpoint isn't hit, then we've stepped into the
2416 signal handler (or hit some other event). We'll delete
2417 the step-resume breakpoint then. */
2420 fprintf_unfiltered (gdb_stdlog
,
2421 "infrun: resume: skipping permanent breakpoint, "
2422 "deliver signal first\n");
2424 clear_step_over_info ();
2425 tp
->control
.trap_expected
= 0;
2427 if (tp
->control
.step_resume_breakpoint
== NULL
)
2429 /* Set a "high-priority" step-resume, as we don't want
2430 user breakpoints at PC to trigger (again) when this
2432 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2433 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2435 tp
->step_after_step_resume_breakpoint
= step
;
2438 insert_breakpoints ();
2442 /* There's no signal to pass, we can go ahead and skip the
2443 permanent breakpoint manually. */
2445 fprintf_unfiltered (gdb_stdlog
,
2446 "infrun: resume: skipping permanent breakpoint\n");
2447 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2448 /* Update pc to reflect the new address from which we will
2449 execute instructions. */
2450 pc
= regcache_read_pc (regcache
);
2454 /* We've already advanced the PC, so the stepping part
2455 is done. Now we need to arrange for a trap to be
2456 reported to handle_inferior_event. Set a breakpoint
2457 at the current PC, and run to it. Don't update
2458 prev_pc, because if we end in
2459 switch_back_to_stepped_thread, we want the "expected
2460 thread advanced also" branch to be taken. IOW, we
2461 don't want this thread to step further from PC
2463 gdb_assert (!step_over_info_valid_p ());
2464 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2465 insert_breakpoints ();
2467 resume_ptid
= internal_resume_ptid (user_step
);
2468 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
2469 discard_cleanups (old_cleanups
);
2476 /* If we have a breakpoint to step over, make sure to do a single
2477 step only. Same if we have software watchpoints. */
2478 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2479 tp
->control
.may_range_step
= 0;
2481 /* If enabled, step over breakpoints by executing a copy of the
2482 instruction at a different address.
2484 We can't use displaced stepping when we have a signal to deliver;
2485 the comments for displaced_step_prepare explain why. The
2486 comments in the handle_inferior event for dealing with 'random
2487 signals' explain what we do instead.
2489 We can't use displaced stepping when we are waiting for vfork_done
2490 event, displaced stepping breaks the vfork child similarly as single
2491 step software breakpoint. */
2492 if (tp
->control
.trap_expected
2493 && use_displaced_stepping (tp
)
2494 && !step_over_info_valid_p ()
2495 && sig
== GDB_SIGNAL_0
2496 && !current_inferior ()->waiting_for_vfork_done
)
2498 int prepared
= displaced_step_prepare (inferior_ptid
);
2503 fprintf_unfiltered (gdb_stdlog
,
2504 "Got placed in step-over queue\n");
2506 tp
->control
.trap_expected
= 0;
2507 discard_cleanups (old_cleanups
);
2510 else if (prepared
< 0)
2512 /* Fallback to stepping over the breakpoint in-line. */
2514 if (target_is_non_stop_p ())
2515 stop_all_threads ();
2517 set_step_over_info (get_regcache_aspace (regcache
),
2518 regcache_read_pc (regcache
), 0);
2520 step
= maybe_software_singlestep (gdbarch
, pc
);
2522 insert_breakpoints ();
2524 else if (prepared
> 0)
2526 struct displaced_step_inferior_state
*displaced
;
2528 /* Update pc to reflect the new address from which we will
2529 execute instructions due to displaced stepping. */
2530 pc
= regcache_read_pc (get_thread_regcache (inferior_ptid
));
2532 displaced
= get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
2533 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
,
2534 displaced
->step_closure
);
2538 /* Do we need to do it the hard way, w/temp breakpoints? */
2540 step
= maybe_software_singlestep (gdbarch
, pc
);
2542 /* Currently, our software single-step implementation leads to different
2543 results than hardware single-stepping in one situation: when stepping
2544 into delivering a signal which has an associated signal handler,
2545 hardware single-step will stop at the first instruction of the handler,
2546 while software single-step will simply skip execution of the handler.
2548 For now, this difference in behavior is accepted since there is no
2549 easy way to actually implement single-stepping into a signal handler
2550 without kernel support.
2552 However, there is one scenario where this difference leads to follow-on
2553 problems: if we're stepping off a breakpoint by removing all breakpoints
2554 and then single-stepping. In this case, the software single-step
2555 behavior means that even if there is a *breakpoint* in the signal
2556 handler, GDB still would not stop.
2558 Fortunately, we can at least fix this particular issue. We detect
2559 here the case where we are about to deliver a signal while software
2560 single-stepping with breakpoints removed. In this situation, we
2561 revert the decisions to remove all breakpoints and insert single-
2562 step breakpoints, and instead we install a step-resume breakpoint
2563 at the current address, deliver the signal without stepping, and
2564 once we arrive back at the step-resume breakpoint, actually step
2565 over the breakpoint we originally wanted to step over. */
2566 if (thread_has_single_step_breakpoints_set (tp
)
2567 && sig
!= GDB_SIGNAL_0
2568 && step_over_info_valid_p ())
2570 /* If we have nested signals or a pending signal is delivered
2571 immediately after a handler returns, might might already have
2572 a step-resume breakpoint set on the earlier handler. We cannot
2573 set another step-resume breakpoint; just continue on until the
2574 original breakpoint is hit. */
2575 if (tp
->control
.step_resume_breakpoint
== NULL
)
2577 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2578 tp
->step_after_step_resume_breakpoint
= 1;
2581 delete_single_step_breakpoints (tp
);
2583 clear_step_over_info ();
2584 tp
->control
.trap_expected
= 0;
2586 insert_breakpoints ();
2589 /* If STEP is set, it's a request to use hardware stepping
2590 facilities. But in that case, we should never
2591 use singlestep breakpoint. */
2592 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2594 /* Decide the set of threads to ask the target to resume. */
2595 if ((step
|| thread_has_single_step_breakpoints_set (tp
))
2596 && tp
->control
.trap_expected
)
2598 /* We're allowing a thread to run past a breakpoint it has
2599 hit, by single-stepping the thread with the breakpoint
2600 removed. In which case, we need to single-step only this
2601 thread, and keep others stopped, as they can miss this
2602 breakpoint if allowed to run. */
2603 resume_ptid
= inferior_ptid
;
2606 resume_ptid
= internal_resume_ptid (user_step
);
2608 if (execution_direction
!= EXEC_REVERSE
2609 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2611 /* There are two cases where we currently need to step a
2612 breakpoint instruction when we have a signal to deliver:
2614 - See handle_signal_stop where we handle random signals that
2615 could take out us out of the stepping range. Normally, in
2616 that case we end up continuing (instead of stepping) over the
2617 signal handler with a breakpoint at PC, but there are cases
2618 where we should _always_ single-step, even if we have a
2619 step-resume breakpoint, like when a software watchpoint is
2620 set. Assuming single-stepping and delivering a signal at the
2621 same time would takes us to the signal handler, then we could
2622 have removed the breakpoint at PC to step over it. However,
2623 some hardware step targets (like e.g., Mac OS) can't step
2624 into signal handlers, and for those, we need to leave the
2625 breakpoint at PC inserted, as otherwise if the handler
2626 recurses and executes PC again, it'll miss the breakpoint.
2627 So we leave the breakpoint inserted anyway, but we need to
2628 record that we tried to step a breakpoint instruction, so
2629 that adjust_pc_after_break doesn't end up confused.
2631 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2632 in one thread after another thread that was stepping had been
2633 momentarily paused for a step-over. When we re-resume the
2634 stepping thread, it may be resumed from that address with a
2635 breakpoint that hasn't trapped yet. Seen with
2636 gdb.threads/non-stop-fair-events.exp, on targets that don't
2637 do displaced stepping. */
2640 fprintf_unfiltered (gdb_stdlog
,
2641 "infrun: resume: [%s] stepped breakpoint\n",
2642 target_pid_to_str (tp
->ptid
));
2644 tp
->stepped_breakpoint
= 1;
2646 /* Most targets can step a breakpoint instruction, thus
2647 executing it normally. But if this one cannot, just
2648 continue and we will hit it anyway. */
2649 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2654 && tp
->control
.trap_expected
2655 && use_displaced_stepping (tp
)
2656 && !step_over_info_valid_p ())
2658 struct regcache
*resume_regcache
= get_thread_regcache (tp
->ptid
);
2659 struct gdbarch
*resume_gdbarch
= get_regcache_arch (resume_regcache
);
2660 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2663 fprintf_unfiltered (gdb_stdlog
, "displaced: run %s: ",
2664 paddress (resume_gdbarch
, actual_pc
));
2665 read_memory (actual_pc
, buf
, sizeof (buf
));
2666 displaced_step_dump_bytes (gdb_stdlog
, buf
, sizeof (buf
));
2669 if (tp
->control
.may_range_step
)
2671 /* If we're resuming a thread with the PC out of the step
2672 range, then we're doing some nested/finer run control
2673 operation, like stepping the thread out of the dynamic
2674 linker or the displaced stepping scratch pad. We
2675 shouldn't have allowed a range step then. */
2676 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2679 do_target_resume (resume_ptid
, step
, sig
);
2681 discard_cleanups (old_cleanups
);
2686 /* Clear out all variables saying what to do when inferior is continued.
2687 First do this, then set the ones you want, then call `proceed'. */
2690 clear_proceed_status_thread (struct thread_info
*tp
)
2693 fprintf_unfiltered (gdb_stdlog
,
2694 "infrun: clear_proceed_status_thread (%s)\n",
2695 target_pid_to_str (tp
->ptid
));
2697 /* If we're starting a new sequence, then the previous finished
2698 single-step is no longer relevant. */
2699 if (tp
->suspend
.waitstatus_pending_p
)
2701 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
2704 fprintf_unfiltered (gdb_stdlog
,
2705 "infrun: clear_proceed_status: pending "
2706 "event of %s was a finished step. "
2708 target_pid_to_str (tp
->ptid
));
2710 tp
->suspend
.waitstatus_pending_p
= 0;
2711 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
2713 else if (debug_infrun
)
2717 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2718 fprintf_unfiltered (gdb_stdlog
,
2719 "infrun: clear_proceed_status_thread: thread %s "
2720 "has pending wait status %s "
2721 "(currently_stepping=%d).\n",
2722 target_pid_to_str (tp
->ptid
), statstr
,
2723 currently_stepping (tp
));
2728 /* If this signal should not be seen by program, give it zero.
2729 Used for debugging signals. */
2730 if (!signal_pass_state (tp
->suspend
.stop_signal
))
2731 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2733 tp
->control
.trap_expected
= 0;
2734 tp
->control
.step_range_start
= 0;
2735 tp
->control
.step_range_end
= 0;
2736 tp
->control
.may_range_step
= 0;
2737 tp
->control
.step_frame_id
= null_frame_id
;
2738 tp
->control
.step_stack_frame_id
= null_frame_id
;
2739 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2740 tp
->control
.step_start_function
= NULL
;
2741 tp
->stop_requested
= 0;
2743 tp
->control
.stop_step
= 0;
2745 tp
->control
.proceed_to_finish
= 0;
2747 tp
->control
.command_interp
= NULL
;
2748 tp
->control
.stepping_command
= 0;
2750 /* Discard any remaining commands or status from previous stop. */
2751 bpstat_clear (&tp
->control
.stop_bpstat
);
2755 clear_proceed_status (int step
)
2759 struct thread_info
*tp
;
2762 resume_ptid
= user_visible_resume_ptid (step
);
2764 /* In all-stop mode, delete the per-thread status of all threads
2765 we're about to resume, implicitly and explicitly. */
2766 ALL_NON_EXITED_THREADS (tp
)
2768 if (!ptid_match (tp
->ptid
, resume_ptid
))
2770 clear_proceed_status_thread (tp
);
2774 if (!ptid_equal (inferior_ptid
, null_ptid
))
2776 struct inferior
*inferior
;
2780 /* If in non-stop mode, only delete the per-thread status of
2781 the current thread. */
2782 clear_proceed_status_thread (inferior_thread ());
2785 inferior
= current_inferior ();
2786 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2789 stop_after_trap
= 0;
2791 observer_notify_about_to_proceed ();
2794 /* Returns true if TP is still stopped at a breakpoint that needs
2795 stepping-over in order to make progress. If the breakpoint is gone
2796 meanwhile, we can skip the whole step-over dance. */
2799 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2801 if (tp
->stepping_over_breakpoint
)
2803 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
2805 if (breakpoint_here_p (get_regcache_aspace (regcache
),
2806 regcache_read_pc (regcache
))
2807 == ordinary_breakpoint_here
)
2810 tp
->stepping_over_breakpoint
= 0;
2816 /* Check whether thread TP still needs to start a step-over in order
2817 to make progress when resumed. Returns an bitwise or of enum
2818 step_over_what bits, indicating what needs to be stepped over. */
2821 thread_still_needs_step_over (struct thread_info
*tp
)
2823 struct inferior
*inf
= find_inferior_ptid (tp
->ptid
);
2826 if (thread_still_needs_step_over_bp (tp
))
2827 what
|= STEP_OVER_BREAKPOINT
;
2829 if (tp
->stepping_over_watchpoint
2830 && !target_have_steppable_watchpoint
)
2831 what
|= STEP_OVER_WATCHPOINT
;
2836 /* Returns true if scheduler locking applies. STEP indicates whether
2837 we're about to do a step/next-like command to a thread. */
2840 schedlock_applies (struct thread_info
*tp
)
2842 return (scheduler_mode
== schedlock_on
2843 || (scheduler_mode
== schedlock_step
2844 && tp
->control
.stepping_command
));
2847 /* Basic routine for continuing the program in various fashions.
2849 ADDR is the address to resume at, or -1 for resume where stopped.
2850 SIGGNAL is the signal to give it, or 0 for none,
2851 or -1 for act according to how it stopped.
2852 STEP is nonzero if should trap after one instruction.
2853 -1 means return after that and print nothing.
2854 You should probably set various step_... variables
2855 before calling here, if you are stepping.
2857 You should call clear_proceed_status before calling proceed. */
2860 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
2862 struct regcache
*regcache
;
2863 struct gdbarch
*gdbarch
;
2864 struct thread_info
*tp
;
2866 struct address_space
*aspace
;
2868 struct execution_control_state ecss
;
2869 struct execution_control_state
*ecs
= &ecss
;
2870 struct cleanup
*old_chain
;
2873 /* If we're stopped at a fork/vfork, follow the branch set by the
2874 "set follow-fork-mode" command; otherwise, we'll just proceed
2875 resuming the current thread. */
2876 if (!follow_fork ())
2878 /* The target for some reason decided not to resume. */
2880 if (target_can_async_p ())
2881 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
2885 /* We'll update this if & when we switch to a new thread. */
2886 previous_inferior_ptid
= inferior_ptid
;
2888 regcache
= get_current_regcache ();
2889 gdbarch
= get_regcache_arch (regcache
);
2890 aspace
= get_regcache_aspace (regcache
);
2891 pc
= regcache_read_pc (regcache
);
2892 tp
= inferior_thread ();
2894 /* Fill in with reasonable starting values. */
2895 init_thread_stepping_state (tp
);
2897 gdb_assert (!thread_is_in_step_over_chain (tp
));
2899 if (addr
== (CORE_ADDR
) -1)
2902 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
2903 && execution_direction
!= EXEC_REVERSE
)
2904 /* There is a breakpoint at the address we will resume at,
2905 step one instruction before inserting breakpoints so that
2906 we do not stop right away (and report a second hit at this
2909 Note, we don't do this in reverse, because we won't
2910 actually be executing the breakpoint insn anyway.
2911 We'll be (un-)executing the previous instruction. */
2912 tp
->stepping_over_breakpoint
= 1;
2913 else if (gdbarch_single_step_through_delay_p (gdbarch
)
2914 && gdbarch_single_step_through_delay (gdbarch
,
2915 get_current_frame ()))
2916 /* We stepped onto an instruction that needs to be stepped
2917 again before re-inserting the breakpoint, do so. */
2918 tp
->stepping_over_breakpoint
= 1;
2922 regcache_write_pc (regcache
, addr
);
2925 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
2926 tp
->suspend
.stop_signal
= siggnal
;
2928 /* Record the interpreter that issued the execution command that
2929 caused this thread to resume. If the top level interpreter is
2930 MI/async, and the execution command was a CLI command
2931 (next/step/etc.), we'll want to print stop event output to the MI
2932 console channel (the stepped-to line, etc.), as if the user
2933 entered the execution command on a real GDB console. */
2934 tp
->control
.command_interp
= command_interp ();
2936 resume_ptid
= user_visible_resume_ptid (tp
->control
.stepping_command
);
2938 /* If an exception is thrown from this point on, make sure to
2939 propagate GDB's knowledge of the executing state to the
2940 frontend/user running state. */
2941 old_chain
= make_cleanup (finish_thread_state_cleanup
, &resume_ptid
);
2943 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
2944 threads (e.g., we might need to set threads stepping over
2945 breakpoints first), from the user/frontend's point of view, all
2946 threads in RESUME_PTID are now running. Unless we're calling an
2947 inferior function, as in that case we pretend the inferior
2948 doesn't run at all. */
2949 if (!tp
->control
.in_infcall
)
2950 set_running (resume_ptid
, 1);
2953 fprintf_unfiltered (gdb_stdlog
,
2954 "infrun: proceed (addr=%s, signal=%s)\n",
2955 paddress (gdbarch
, addr
),
2956 gdb_signal_to_symbol_string (siggnal
));
2958 annotate_starting ();
2960 /* Make sure that output from GDB appears before output from the
2962 gdb_flush (gdb_stdout
);
2964 /* In a multi-threaded task we may select another thread and
2965 then continue or step.
2967 But if a thread that we're resuming had stopped at a breakpoint,
2968 it will immediately cause another breakpoint stop without any
2969 execution (i.e. it will report a breakpoint hit incorrectly). So
2970 we must step over it first.
2972 Look for threads other than the current (TP) that reported a
2973 breakpoint hit and haven't been resumed yet since. */
2975 /* If scheduler locking applies, we can avoid iterating over all
2977 if (!non_stop
&& !schedlock_applies (tp
))
2979 struct thread_info
*current
= tp
;
2981 ALL_NON_EXITED_THREADS (tp
)
2983 /* Ignore the current thread here. It's handled
2988 /* Ignore threads of processes we're not resuming. */
2989 if (!ptid_match (tp
->ptid
, resume_ptid
))
2992 if (!thread_still_needs_step_over (tp
))
2995 gdb_assert (!thread_is_in_step_over_chain (tp
));
2998 fprintf_unfiltered (gdb_stdlog
,
2999 "infrun: need to step-over [%s] first\n",
3000 target_pid_to_str (tp
->ptid
));
3002 thread_step_over_chain_enqueue (tp
);
3008 /* Enqueue the current thread last, so that we move all other
3009 threads over their breakpoints first. */
3010 if (tp
->stepping_over_breakpoint
)
3011 thread_step_over_chain_enqueue (tp
);
3013 /* If the thread isn't started, we'll still need to set its prev_pc,
3014 so that switch_back_to_stepped_thread knows the thread hasn't
3015 advanced. Must do this before resuming any thread, as in
3016 all-stop/remote, once we resume we can't send any other packet
3017 until the target stops again. */
3018 tp
->prev_pc
= regcache_read_pc (regcache
);
3020 started
= start_step_over ();
3022 if (step_over_info_valid_p ())
3024 /* Either this thread started a new in-line step over, or some
3025 other thread was already doing one. In either case, don't
3026 resume anything else until the step-over is finished. */
3028 else if (started
&& !target_is_non_stop_p ())
3030 /* A new displaced stepping sequence was started. In all-stop,
3031 we can't talk to the target anymore until it next stops. */
3033 else if (!non_stop
&& target_is_non_stop_p ())
3035 /* In all-stop, but the target is always in non-stop mode.
3036 Start all other threads that are implicitly resumed too. */
3037 ALL_NON_EXITED_THREADS (tp
)
3039 /* Ignore threads of processes we're not resuming. */
3040 if (!ptid_match (tp
->ptid
, resume_ptid
))
3046 fprintf_unfiltered (gdb_stdlog
,
3047 "infrun: proceed: [%s] resumed\n",
3048 target_pid_to_str (tp
->ptid
));
3049 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
3053 if (thread_is_in_step_over_chain (tp
))
3056 fprintf_unfiltered (gdb_stdlog
,
3057 "infrun: proceed: [%s] needs step-over\n",
3058 target_pid_to_str (tp
->ptid
));
3063 fprintf_unfiltered (gdb_stdlog
,
3064 "infrun: proceed: resuming %s\n",
3065 target_pid_to_str (tp
->ptid
));
3067 reset_ecs (ecs
, tp
);
3068 switch_to_thread (tp
->ptid
);
3069 keep_going_pass_signal (ecs
);
3070 if (!ecs
->wait_some_more
)
3071 error ("Command aborted.");
3074 else if (!tp
->resumed
&& !thread_is_in_step_over_chain (tp
))
3076 /* The thread wasn't started, and isn't queued, run it now. */
3077 reset_ecs (ecs
, tp
);
3078 switch_to_thread (tp
->ptid
);
3079 keep_going_pass_signal (ecs
);
3080 if (!ecs
->wait_some_more
)
3081 error ("Command aborted.");
3084 discard_cleanups (old_chain
);
3086 /* Wait for it to stop (if not standalone)
3087 and in any case decode why it stopped, and act accordingly. */
3088 /* Do this only if we are not using the event loop, or if the target
3089 does not support asynchronous execution. */
3090 if (!target_can_async_p ())
3092 wait_for_inferior ();
3098 /* Start remote-debugging of a machine over a serial link. */
3101 start_remote (int from_tty
)
3103 struct inferior
*inferior
;
3105 inferior
= current_inferior ();
3106 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3108 /* Always go on waiting for the target, regardless of the mode. */
3109 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3110 indicate to wait_for_inferior that a target should timeout if
3111 nothing is returned (instead of just blocking). Because of this,
3112 targets expecting an immediate response need to, internally, set
3113 things up so that the target_wait() is forced to eventually
3115 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3116 differentiate to its caller what the state of the target is after
3117 the initial open has been performed. Here we're assuming that
3118 the target has stopped. It should be possible to eventually have
3119 target_open() return to the caller an indication that the target
3120 is currently running and GDB state should be set to the same as
3121 for an async run. */
3122 wait_for_inferior ();
3124 /* Now that the inferior has stopped, do any bookkeeping like
3125 loading shared libraries. We want to do this before normal_stop,
3126 so that the displayed frame is up to date. */
3127 post_create_inferior (¤t_target
, from_tty
);
3132 /* Initialize static vars when a new inferior begins. */
3135 init_wait_for_inferior (void)
3137 /* These are meaningless until the first time through wait_for_inferior. */
3139 breakpoint_init_inferior (inf_starting
);
3141 clear_proceed_status (0);
3143 target_last_wait_ptid
= minus_one_ptid
;
3145 previous_inferior_ptid
= inferior_ptid
;
3147 /* Discard any skipped inlined frames. */
3148 clear_inline_frame_state (minus_one_ptid
);
3153 static void handle_inferior_event (struct execution_control_state
*ecs
);
3155 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3156 struct execution_control_state
*ecs
);
3157 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3158 struct execution_control_state
*ecs
);
3159 static void handle_signal_stop (struct execution_control_state
*ecs
);
3160 static void check_exception_resume (struct execution_control_state
*,
3161 struct frame_info
*);
3163 static void end_stepping_range (struct execution_control_state
*ecs
);
3164 static void stop_waiting (struct execution_control_state
*ecs
);
3165 static void keep_going (struct execution_control_state
*ecs
);
3166 static void process_event_stop_test (struct execution_control_state
*ecs
);
3167 static int switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3169 /* Callback for iterate over threads. If the thread is stopped, but
3170 the user/frontend doesn't know about that yet, go through
3171 normal_stop, as if the thread had just stopped now. ARG points at
3172 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
3173 ptid_is_pid(PTID) is true, applies to all threads of the process
3174 pointed at by PTID. Otherwise, apply only to the thread pointed by
3178 infrun_thread_stop_requested_callback (struct thread_info
*info
, void *arg
)
3180 ptid_t ptid
= * (ptid_t
*) arg
;
3182 if ((ptid_equal (info
->ptid
, ptid
)
3183 || ptid_equal (minus_one_ptid
, ptid
)
3184 || (ptid_is_pid (ptid
)
3185 && ptid_get_pid (ptid
) == ptid_get_pid (info
->ptid
)))
3186 && is_running (info
->ptid
)
3187 && !is_executing (info
->ptid
))
3189 struct cleanup
*old_chain
;
3190 struct execution_control_state ecss
;
3191 struct execution_control_state
*ecs
= &ecss
;
3193 memset (ecs
, 0, sizeof (*ecs
));
3195 old_chain
= make_cleanup_restore_current_thread ();
3197 overlay_cache_invalid
= 1;
3198 /* Flush target cache before starting to handle each event.
3199 Target was running and cache could be stale. This is just a
3200 heuristic. Running threads may modify target memory, but we
3201 don't get any event. */
3202 target_dcache_invalidate ();
3204 /* Go through handle_inferior_event/normal_stop, so we always
3205 have consistent output as if the stop event had been
3207 ecs
->ptid
= info
->ptid
;
3208 ecs
->event_thread
= find_thread_ptid (info
->ptid
);
3209 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
3210 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
3212 handle_inferior_event (ecs
);
3214 if (!ecs
->wait_some_more
)
3216 struct thread_info
*tp
;
3220 /* Finish off the continuations. */
3221 tp
= inferior_thread ();
3222 do_all_intermediate_continuations_thread (tp
, 1);
3223 do_all_continuations_thread (tp
, 1);
3226 do_cleanups (old_chain
);
3232 /* This function is attached as a "thread_stop_requested" observer.
3233 Cleanup local state that assumed the PTID was to be resumed, and
3234 report the stop to the frontend. */
3237 infrun_thread_stop_requested (ptid_t ptid
)
3239 struct thread_info
*tp
;
3241 /* PTID was requested to stop. Remove matching threads from the
3242 step-over queue, so we don't try to resume them
3244 ALL_NON_EXITED_THREADS (tp
)
3245 if (ptid_match (tp
->ptid
, ptid
))
3247 if (thread_is_in_step_over_chain (tp
))
3248 thread_step_over_chain_remove (tp
);
3251 iterate_over_threads (infrun_thread_stop_requested_callback
, &ptid
);
3255 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3257 if (ptid_equal (target_last_wait_ptid
, tp
->ptid
))
3258 nullify_last_target_wait_ptid ();
3261 /* Delete the step resume, single-step and longjmp/exception resume
3262 breakpoints of TP. */
3265 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3267 delete_step_resume_breakpoint (tp
);
3268 delete_exception_resume_breakpoint (tp
);
3269 delete_single_step_breakpoints (tp
);
3272 /* If the target still has execution, call FUNC for each thread that
3273 just stopped. In all-stop, that's all the non-exited threads; in
3274 non-stop, that's the current thread, only. */
3276 typedef void (*for_each_just_stopped_thread_callback_func
)
3277 (struct thread_info
*tp
);
3280 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3282 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
3285 if (target_is_non_stop_p ())
3287 /* If in non-stop mode, only the current thread stopped. */
3288 func (inferior_thread ());
3292 struct thread_info
*tp
;
3294 /* In all-stop mode, all threads have stopped. */
3295 ALL_NON_EXITED_THREADS (tp
)
3302 /* Delete the step resume and longjmp/exception resume breakpoints of
3303 the threads that just stopped. */
3306 delete_just_stopped_threads_infrun_breakpoints (void)
3308 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3311 /* Delete the single-step breakpoints of the threads that just
3315 delete_just_stopped_threads_single_step_breakpoints (void)
3317 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3320 /* A cleanup wrapper. */
3323 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg
)
3325 delete_just_stopped_threads_infrun_breakpoints ();
3328 /* Pretty print the results of target_wait, for debugging purposes. */
3331 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3332 const struct target_waitstatus
*ws
)
3334 char *status_string
= target_waitstatus_to_string (ws
);
3335 struct ui_file
*tmp_stream
= mem_fileopen ();
3338 /* The text is split over several lines because it was getting too long.
3339 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3340 output as a unit; we want only one timestamp printed if debug_timestamp
3343 fprintf_unfiltered (tmp_stream
,
3344 "infrun: target_wait (%d.%ld.%ld",
3345 ptid_get_pid (waiton_ptid
),
3346 ptid_get_lwp (waiton_ptid
),
3347 ptid_get_tid (waiton_ptid
));
3348 if (ptid_get_pid (waiton_ptid
) != -1)
3349 fprintf_unfiltered (tmp_stream
,
3350 " [%s]", target_pid_to_str (waiton_ptid
));
3351 fprintf_unfiltered (tmp_stream
, ", status) =\n");
3352 fprintf_unfiltered (tmp_stream
,
3353 "infrun: %d.%ld.%ld [%s],\n",
3354 ptid_get_pid (result_ptid
),
3355 ptid_get_lwp (result_ptid
),
3356 ptid_get_tid (result_ptid
),
3357 target_pid_to_str (result_ptid
));
3358 fprintf_unfiltered (tmp_stream
,
3362 text
= ui_file_xstrdup (tmp_stream
, NULL
);
3364 /* This uses %s in part to handle %'s in the text, but also to avoid
3365 a gcc error: the format attribute requires a string literal. */
3366 fprintf_unfiltered (gdb_stdlog
, "%s", text
);
3368 xfree (status_string
);
3370 ui_file_delete (tmp_stream
);
3373 /* Select a thread at random, out of those which are resumed and have
3376 static struct thread_info
*
3377 random_pending_event_thread (ptid_t waiton_ptid
)
3379 struct thread_info
*event_tp
;
3381 int random_selector
;
3383 /* First see how many events we have. Count only resumed threads
3384 that have an event pending. */
3385 ALL_NON_EXITED_THREADS (event_tp
)
3386 if (ptid_match (event_tp
->ptid
, waiton_ptid
)
3387 && event_tp
->resumed
3388 && event_tp
->suspend
.waitstatus_pending_p
)
3391 if (num_events
== 0)
3394 /* Now randomly pick a thread out of those that have had events. */
3395 random_selector
= (int)
3396 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
3398 if (debug_infrun
&& num_events
> 1)
3399 fprintf_unfiltered (gdb_stdlog
,
3400 "infrun: Found %d events, selecting #%d\n",
3401 num_events
, random_selector
);
3403 /* Select the Nth thread that has had an event. */
3404 ALL_NON_EXITED_THREADS (event_tp
)
3405 if (ptid_match (event_tp
->ptid
, waiton_ptid
)
3406 && event_tp
->resumed
3407 && event_tp
->suspend
.waitstatus_pending_p
)
3408 if (random_selector
-- == 0)
3414 /* Wrapper for target_wait that first checks whether threads have
3415 pending statuses to report before actually asking the target for
3419 do_target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3422 struct thread_info
*tp
;
3424 /* First check if there is a resumed thread with a wait status
3426 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
3428 tp
= random_pending_event_thread (ptid
);
3433 fprintf_unfiltered (gdb_stdlog
,
3434 "infrun: Waiting for specific thread %s.\n",
3435 target_pid_to_str (ptid
));
3437 /* We have a specific thread to check. */
3438 tp
= find_thread_ptid (ptid
);
3439 gdb_assert (tp
!= NULL
);
3440 if (!tp
->suspend
.waitstatus_pending_p
)
3445 && (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3446 || tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
3448 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
3449 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3453 pc
= regcache_read_pc (regcache
);
3455 if (pc
!= tp
->suspend
.stop_pc
)
3458 fprintf_unfiltered (gdb_stdlog
,
3459 "infrun: PC of %s changed. was=%s, now=%s\n",
3460 target_pid_to_str (tp
->ptid
),
3461 paddress (gdbarch
, tp
->prev_pc
),
3462 paddress (gdbarch
, pc
));
3465 else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
3468 fprintf_unfiltered (gdb_stdlog
,
3469 "infrun: previous breakpoint of %s, at %s gone\n",
3470 target_pid_to_str (tp
->ptid
),
3471 paddress (gdbarch
, pc
));
3479 fprintf_unfiltered (gdb_stdlog
,
3480 "infrun: pending event of %s cancelled.\n",
3481 target_pid_to_str (tp
->ptid
));
3483 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_SPURIOUS
;
3484 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3494 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
3495 fprintf_unfiltered (gdb_stdlog
,
3496 "infrun: Using pending wait status %s for %s.\n",
3498 target_pid_to_str (tp
->ptid
));
3502 /* Now that we've selected our final event LWP, un-adjust its PC
3503 if it was a software breakpoint (and the target doesn't
3504 always adjust the PC itself). */
3505 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3506 && !target_supports_stopped_by_sw_breakpoint ())
3508 struct regcache
*regcache
;
3509 struct gdbarch
*gdbarch
;
3512 regcache
= get_thread_regcache (tp
->ptid
);
3513 gdbarch
= get_regcache_arch (regcache
);
3515 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3520 pc
= regcache_read_pc (regcache
);
3521 regcache_write_pc (regcache
, pc
+ decr_pc
);
3525 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3526 *status
= tp
->suspend
.waitstatus
;
3527 tp
->suspend
.waitstatus_pending_p
= 0;
3529 /* Wake up the event loop again, until all pending events are
3531 if (target_is_async_p ())
3532 mark_async_event_handler (infrun_async_inferior_event_token
);
3536 /* But if we don't find one, we'll have to wait. */
3538 if (deprecated_target_wait_hook
)
3539 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3541 event_ptid
= target_wait (ptid
, status
, options
);
3546 /* Prepare and stabilize the inferior for detaching it. E.g.,
3547 detaching while a thread is displaced stepping is a recipe for
3548 crashing it, as nothing would readjust the PC out of the scratch
3552 prepare_for_detach (void)
3554 struct inferior
*inf
= current_inferior ();
3555 ptid_t pid_ptid
= pid_to_ptid (inf
->pid
);
3556 struct cleanup
*old_chain_1
;
3557 struct displaced_step_inferior_state
*displaced
;
3559 displaced
= get_displaced_stepping_state (inf
->pid
);
3561 /* Is any thread of this process displaced stepping? If not,
3562 there's nothing else to do. */
3563 if (displaced
== NULL
|| ptid_equal (displaced
->step_ptid
, null_ptid
))
3567 fprintf_unfiltered (gdb_stdlog
,
3568 "displaced-stepping in-process while detaching");
3570 old_chain_1
= make_cleanup_restore_integer (&inf
->detaching
);
3573 while (!ptid_equal (displaced
->step_ptid
, null_ptid
))
3575 struct cleanup
*old_chain_2
;
3576 struct execution_control_state ecss
;
3577 struct execution_control_state
*ecs
;
3580 memset (ecs
, 0, sizeof (*ecs
));
3582 overlay_cache_invalid
= 1;
3583 /* Flush target cache before starting to handle each event.
3584 Target was running and cache could be stale. This is just a
3585 heuristic. Running threads may modify target memory, but we
3586 don't get any event. */
3587 target_dcache_invalidate ();
3589 ecs
->ptid
= do_target_wait (pid_ptid
, &ecs
->ws
, 0);
3592 print_target_wait_results (pid_ptid
, ecs
->ptid
, &ecs
->ws
);
3594 /* If an error happens while handling the event, propagate GDB's
3595 knowledge of the executing state to the frontend/user running
3597 old_chain_2
= make_cleanup (finish_thread_state_cleanup
,
3600 /* Now figure out what to do with the result of the result. */
3601 handle_inferior_event (ecs
);
3603 /* No error, don't finish the state yet. */
3604 discard_cleanups (old_chain_2
);
3606 /* Breakpoints and watchpoints are not installed on the target
3607 at this point, and signals are passed directly to the
3608 inferior, so this must mean the process is gone. */
3609 if (!ecs
->wait_some_more
)
3611 discard_cleanups (old_chain_1
);
3612 error (_("Program exited while detaching"));
3616 discard_cleanups (old_chain_1
);
3619 /* Wait for control to return from inferior to debugger.
3621 If inferior gets a signal, we may decide to start it up again
3622 instead of returning. That is why there is a loop in this function.
3623 When this function actually returns it means the inferior
3624 should be left stopped and GDB should read more commands. */
3627 wait_for_inferior (void)
3629 struct cleanup
*old_cleanups
;
3630 struct cleanup
*thread_state_chain
;
3634 (gdb_stdlog
, "infrun: wait_for_inferior ()\n");
3637 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
,
3640 /* If an error happens while handling the event, propagate GDB's
3641 knowledge of the executing state to the frontend/user running
3643 thread_state_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3647 struct execution_control_state ecss
;
3648 struct execution_control_state
*ecs
= &ecss
;
3649 ptid_t waiton_ptid
= minus_one_ptid
;
3651 memset (ecs
, 0, sizeof (*ecs
));
3653 overlay_cache_invalid
= 1;
3655 /* Flush target cache before starting to handle each event.
3656 Target was running and cache could be stale. This is just a
3657 heuristic. Running threads may modify target memory, but we
3658 don't get any event. */
3659 target_dcache_invalidate ();
3661 ecs
->ptid
= do_target_wait (waiton_ptid
, &ecs
->ws
, 0);
3664 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3666 /* Now figure out what to do with the result of the result. */
3667 handle_inferior_event (ecs
);
3669 if (!ecs
->wait_some_more
)
3673 /* No error, don't finish the state yet. */
3674 discard_cleanups (thread_state_chain
);
3676 do_cleanups (old_cleanups
);
3679 /* Cleanup that reinstalls the readline callback handler, if the
3680 target is running in the background. If while handling the target
3681 event something triggered a secondary prompt, like e.g., a
3682 pagination prompt, we'll have removed the callback handler (see
3683 gdb_readline_wrapper_line). Need to do this as we go back to the
3684 event loop, ready to process further input. Note this has no
3685 effect if the handler hasn't actually been removed, because calling
3686 rl_callback_handler_install resets the line buffer, thus losing
3690 reinstall_readline_callback_handler_cleanup (void *arg
)
3692 if (!interpreter_async
)
3694 /* We're not going back to the top level event loop yet. Don't
3695 install the readline callback, as it'd prep the terminal,
3696 readline-style (raw, noecho) (e.g., --batch). We'll install
3697 it the next time the prompt is displayed, when we're ready
3702 if (async_command_editing_p
&& !sync_execution
)
3703 gdb_rl_callback_handler_reinstall ();
3706 /* Asynchronous version of wait_for_inferior. It is called by the
3707 event loop whenever a change of state is detected on the file
3708 descriptor corresponding to the target. It can be called more than
3709 once to complete a single execution command. In such cases we need
3710 to keep the state in a global variable ECSS. If it is the last time
3711 that this function is called for a single execution command, then
3712 report to the user that the inferior has stopped, and do the
3713 necessary cleanups. */
3716 fetch_inferior_event (void *client_data
)
3718 struct execution_control_state ecss
;
3719 struct execution_control_state
*ecs
= &ecss
;
3720 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3721 struct cleanup
*ts_old_chain
;
3722 int was_sync
= sync_execution
;
3724 ptid_t waiton_ptid
= minus_one_ptid
;
3726 memset (ecs
, 0, sizeof (*ecs
));
3728 /* End up with readline processing input, if necessary. */
3729 make_cleanup (reinstall_readline_callback_handler_cleanup
, NULL
);
3731 /* We're handling a live event, so make sure we're doing live
3732 debugging. If we're looking at traceframes while the target is
3733 running, we're going to need to get back to that mode after
3734 handling the event. */
3737 make_cleanup_restore_current_traceframe ();
3738 set_current_traceframe (-1);
3742 /* In non-stop mode, the user/frontend should not notice a thread
3743 switch due to internal events. Make sure we reverse to the
3744 user selected thread and frame after handling the event and
3745 running any breakpoint commands. */
3746 make_cleanup_restore_current_thread ();
3748 overlay_cache_invalid
= 1;
3749 /* Flush target cache before starting to handle each event. Target
3750 was running and cache could be stale. This is just a heuristic.
3751 Running threads may modify target memory, but we don't get any
3753 target_dcache_invalidate ();
3755 make_cleanup_restore_integer (&execution_direction
);
3756 execution_direction
= target_execution_direction ();
3758 ecs
->ptid
= do_target_wait (waiton_ptid
, &ecs
->ws
, TARGET_WNOHANG
);
3761 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3763 /* If an error happens while handling the event, propagate GDB's
3764 knowledge of the executing state to the frontend/user running
3766 if (!target_is_non_stop_p ())
3767 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3769 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &ecs
->ptid
);
3771 /* Get executed before make_cleanup_restore_current_thread above to apply
3772 still for the thread which has thrown the exception. */
3773 make_bpstat_clear_actions_cleanup ();
3775 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
, NULL
);
3777 /* Now figure out what to do with the result of the result. */
3778 handle_inferior_event (ecs
);
3780 if (!ecs
->wait_some_more
)
3782 struct inferior
*inf
= find_inferior_ptid (ecs
->ptid
);
3784 delete_just_stopped_threads_infrun_breakpoints ();
3786 /* We may not find an inferior if this was a process exit. */
3787 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
3790 if (target_has_execution
3791 && ecs
->ws
.kind
!= TARGET_WAITKIND_NO_RESUMED
3792 && ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
3793 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
3794 && ecs
->event_thread
->step_multi
3795 && ecs
->event_thread
->control
.stop_step
)
3796 inferior_event_handler (INF_EXEC_CONTINUE
, NULL
);
3799 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
3804 /* No error, don't finish the thread states yet. */
3805 discard_cleanups (ts_old_chain
);
3807 /* Revert thread and frame. */
3808 do_cleanups (old_chain
);
3810 /* If the inferior was in sync execution mode, and now isn't,
3811 restore the prompt (a synchronous execution command has finished,
3812 and we're ready for input). */
3813 if (interpreter_async
&& was_sync
&& !sync_execution
)
3814 observer_notify_sync_execution_done ();
3818 && exec_done_display_p
3819 && (ptid_equal (inferior_ptid
, null_ptid
)
3820 || !is_running (inferior_ptid
)))
3821 printf_unfiltered (_("completed.\n"));
3824 /* Record the frame and location we're currently stepping through. */
3826 set_step_info (struct frame_info
*frame
, struct symtab_and_line sal
)
3828 struct thread_info
*tp
= inferior_thread ();
3830 tp
->control
.step_frame_id
= get_frame_id (frame
);
3831 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
3833 tp
->current_symtab
= sal
.symtab
;
3834 tp
->current_line
= sal
.line
;
3837 /* Clear context switchable stepping state. */
3840 init_thread_stepping_state (struct thread_info
*tss
)
3842 tss
->stepped_breakpoint
= 0;
3843 tss
->stepping_over_breakpoint
= 0;
3844 tss
->stepping_over_watchpoint
= 0;
3845 tss
->step_after_step_resume_breakpoint
= 0;
3848 /* Set the cached copy of the last ptid/waitstatus. */
3851 set_last_target_status (ptid_t ptid
, struct target_waitstatus status
)
3853 target_last_wait_ptid
= ptid
;
3854 target_last_waitstatus
= status
;
3857 /* Return the cached copy of the last pid/waitstatus returned by
3858 target_wait()/deprecated_target_wait_hook(). The data is actually
3859 cached by handle_inferior_event(), which gets called immediately
3860 after target_wait()/deprecated_target_wait_hook(). */
3863 get_last_target_status (ptid_t
*ptidp
, struct target_waitstatus
*status
)
3865 *ptidp
= target_last_wait_ptid
;
3866 *status
= target_last_waitstatus
;
3870 nullify_last_target_wait_ptid (void)
3872 target_last_wait_ptid
= minus_one_ptid
;
3875 /* Switch thread contexts. */
3878 context_switch (ptid_t ptid
)
3880 if (debug_infrun
&& !ptid_equal (ptid
, inferior_ptid
))
3882 fprintf_unfiltered (gdb_stdlog
, "infrun: Switching context from %s ",
3883 target_pid_to_str (inferior_ptid
));
3884 fprintf_unfiltered (gdb_stdlog
, "to %s\n",
3885 target_pid_to_str (ptid
));
3888 switch_to_thread (ptid
);
3891 /* If the target can't tell whether we've hit breakpoints
3892 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
3893 check whether that could have been caused by a breakpoint. If so,
3894 adjust the PC, per gdbarch_decr_pc_after_break. */
3897 adjust_pc_after_break (struct thread_info
*thread
,
3898 struct target_waitstatus
*ws
)
3900 struct regcache
*regcache
;
3901 struct gdbarch
*gdbarch
;
3902 struct address_space
*aspace
;
3903 CORE_ADDR breakpoint_pc
, decr_pc
;
3905 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
3906 we aren't, just return.
3908 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3909 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
3910 implemented by software breakpoints should be handled through the normal
3913 NOTE drow/2004-01-31: On some targets, breakpoints may generate
3914 different signals (SIGILL or SIGEMT for instance), but it is less
3915 clear where the PC is pointing afterwards. It may not match
3916 gdbarch_decr_pc_after_break. I don't know any specific target that
3917 generates these signals at breakpoints (the code has been in GDB since at
3918 least 1992) so I can not guess how to handle them here.
3920 In earlier versions of GDB, a target with
3921 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3922 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
3923 target with both of these set in GDB history, and it seems unlikely to be
3924 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
3926 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
3929 if (ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
3932 /* In reverse execution, when a breakpoint is hit, the instruction
3933 under it has already been de-executed. The reported PC always
3934 points at the breakpoint address, so adjusting it further would
3935 be wrong. E.g., consider this case on a decr_pc_after_break == 1
3938 B1 0x08000000 : INSN1
3939 B2 0x08000001 : INSN2
3941 PC -> 0x08000003 : INSN4
3943 Say you're stopped at 0x08000003 as above. Reverse continuing
3944 from that point should hit B2 as below. Reading the PC when the
3945 SIGTRAP is reported should read 0x08000001 and INSN2 should have
3946 been de-executed already.
3948 B1 0x08000000 : INSN1
3949 B2 PC -> 0x08000001 : INSN2
3953 We can't apply the same logic as for forward execution, because
3954 we would wrongly adjust the PC to 0x08000000, since there's a
3955 breakpoint at PC - 1. We'd then report a hit on B1, although
3956 INSN1 hadn't been de-executed yet. Doing nothing is the correct
3958 if (execution_direction
== EXEC_REVERSE
)
3961 /* If the target can tell whether the thread hit a SW breakpoint,
3962 trust it. Targets that can tell also adjust the PC
3964 if (target_supports_stopped_by_sw_breakpoint ())
3967 /* Note that relying on whether a breakpoint is planted in memory to
3968 determine this can fail. E.g,. the breakpoint could have been
3969 removed since. Or the thread could have been told to step an
3970 instruction the size of a breakpoint instruction, and only
3971 _after_ was a breakpoint inserted at its address. */
3973 /* If this target does not decrement the PC after breakpoints, then
3974 we have nothing to do. */
3975 regcache
= get_thread_regcache (thread
->ptid
);
3976 gdbarch
= get_regcache_arch (regcache
);
3978 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3982 aspace
= get_regcache_aspace (regcache
);
3984 /* Find the location where (if we've hit a breakpoint) the
3985 breakpoint would be. */
3986 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
3988 /* If the target can't tell whether a software breakpoint triggered,
3989 fallback to figuring it out based on breakpoints we think were
3990 inserted in the target, and on whether the thread was stepped or
3993 /* Check whether there actually is a software breakpoint inserted at
3996 If in non-stop mode, a race condition is possible where we've
3997 removed a breakpoint, but stop events for that breakpoint were
3998 already queued and arrive later. To suppress those spurious
3999 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4000 and retire them after a number of stop events are reported. Note
4001 this is an heuristic and can thus get confused. The real fix is
4002 to get the "stopped by SW BP and needs adjustment" info out of
4003 the target/kernel (and thus never reach here; see above). */
4004 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4005 || (target_is_non_stop_p ()
4006 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4008 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
4010 if (record_full_is_used ())
4011 record_full_gdb_operation_disable_set ();
4013 /* When using hardware single-step, a SIGTRAP is reported for both
4014 a completed single-step and a software breakpoint. Need to
4015 differentiate between the two, as the latter needs adjusting
4016 but the former does not.
4018 The SIGTRAP can be due to a completed hardware single-step only if
4019 - we didn't insert software single-step breakpoints
4020 - this thread is currently being stepped
4022 If any of these events did not occur, we must have stopped due
4023 to hitting a software breakpoint, and have to back up to the
4026 As a special case, we could have hardware single-stepped a
4027 software breakpoint. In this case (prev_pc == breakpoint_pc),
4028 we also need to back up to the breakpoint address. */
4030 if (thread_has_single_step_breakpoints_set (thread
)
4031 || !currently_stepping (thread
)
4032 || (thread
->stepped_breakpoint
4033 && thread
->prev_pc
== breakpoint_pc
))
4034 regcache_write_pc (regcache
, breakpoint_pc
);
4036 do_cleanups (old_cleanups
);
4041 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4043 for (frame
= get_prev_frame (frame
);
4045 frame
= get_prev_frame (frame
))
4047 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4049 if (get_frame_type (frame
) != INLINE_FRAME
)
4056 /* Auxiliary function that handles syscall entry/return events.
4057 It returns 1 if the inferior should keep going (and GDB
4058 should ignore the event), or 0 if the event deserves to be
4062 handle_syscall_event (struct execution_control_state
*ecs
)
4064 struct regcache
*regcache
;
4067 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4068 context_switch (ecs
->ptid
);
4070 regcache
= get_thread_regcache (ecs
->ptid
);
4071 syscall_number
= ecs
->ws
.value
.syscall_number
;
4072 stop_pc
= regcache_read_pc (regcache
);
4074 if (catch_syscall_enabled () > 0
4075 && catching_syscall_number (syscall_number
) > 0)
4078 fprintf_unfiltered (gdb_stdlog
, "infrun: syscall number = '%d'\n",
4081 ecs
->event_thread
->control
.stop_bpstat
4082 = bpstat_stop_status (get_regcache_aspace (regcache
),
4083 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4085 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4087 /* Catchpoint hit. */
4092 /* If no catchpoint triggered for this, then keep going. */
4097 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4100 fill_in_stop_func (struct gdbarch
*gdbarch
,
4101 struct execution_control_state
*ecs
)
4103 if (!ecs
->stop_func_filled_in
)
4105 /* Don't care about return value; stop_func_start and stop_func_name
4106 will both be 0 if it doesn't work. */
4107 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
4108 &ecs
->stop_func_start
, &ecs
->stop_func_end
);
4109 ecs
->stop_func_start
4110 += gdbarch_deprecated_function_start_offset (gdbarch
);
4112 if (gdbarch_skip_entrypoint_p (gdbarch
))
4113 ecs
->stop_func_start
= gdbarch_skip_entrypoint (gdbarch
,
4114 ecs
->stop_func_start
);
4116 ecs
->stop_func_filled_in
= 1;
4121 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
4123 static enum stop_kind
4124 get_inferior_stop_soon (ptid_t ptid
)
4126 struct inferior
*inf
= find_inferior_ptid (ptid
);
4128 gdb_assert (inf
!= NULL
);
4129 return inf
->control
.stop_soon
;
4132 /* Wait for one event. Store the resulting waitstatus in WS, and
4133 return the event ptid. */
4136 wait_one (struct target_waitstatus
*ws
)
4139 ptid_t wait_ptid
= minus_one_ptid
;
4141 overlay_cache_invalid
= 1;
4143 /* Flush target cache before starting to handle each event.
4144 Target was running and cache could be stale. This is just a
4145 heuristic. Running threads may modify target memory, but we
4146 don't get any event. */
4147 target_dcache_invalidate ();
4149 if (deprecated_target_wait_hook
)
4150 event_ptid
= deprecated_target_wait_hook (wait_ptid
, ws
, 0);
4152 event_ptid
= target_wait (wait_ptid
, ws
, 0);
4155 print_target_wait_results (wait_ptid
, event_ptid
, ws
);
4160 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4161 instead of the current thread. */
4162 #define THREAD_STOPPED_BY(REASON) \
4164 thread_stopped_by_ ## REASON (ptid_t ptid) \
4166 struct cleanup *old_chain; \
4169 old_chain = save_inferior_ptid (); \
4170 inferior_ptid = ptid; \
4172 res = target_stopped_by_ ## REASON (); \
4174 do_cleanups (old_chain); \
4179 /* Generate thread_stopped_by_watchpoint. */
4180 THREAD_STOPPED_BY (watchpoint
)
4181 /* Generate thread_stopped_by_sw_breakpoint. */
4182 THREAD_STOPPED_BY (sw_breakpoint
)
4183 /* Generate thread_stopped_by_hw_breakpoint. */
4184 THREAD_STOPPED_BY (hw_breakpoint
)
4186 /* Cleanups that switches to the PTID pointed at by PTID_P. */
4189 switch_to_thread_cleanup (void *ptid_p
)
4191 ptid_t ptid
= *(ptid_t
*) ptid_p
;
4193 switch_to_thread (ptid
);
4196 /* Save the thread's event and stop reason to process it later. */
4199 save_waitstatus (struct thread_info
*tp
, struct target_waitstatus
*ws
)
4201 struct regcache
*regcache
;
4202 struct address_space
*aspace
;
4208 statstr
= target_waitstatus_to_string (ws
);
4209 fprintf_unfiltered (gdb_stdlog
,
4210 "infrun: saving status %s for %d.%ld.%ld\n",
4212 ptid_get_pid (tp
->ptid
),
4213 ptid_get_lwp (tp
->ptid
),
4214 ptid_get_tid (tp
->ptid
));
4218 /* Record for later. */
4219 tp
->suspend
.waitstatus
= *ws
;
4220 tp
->suspend
.waitstatus_pending_p
= 1;
4222 regcache
= get_thread_regcache (tp
->ptid
);
4223 aspace
= get_regcache_aspace (regcache
);
4225 if (ws
->kind
== TARGET_WAITKIND_STOPPED
4226 && ws
->value
.sig
== GDB_SIGNAL_TRAP
)
4228 CORE_ADDR pc
= regcache_read_pc (regcache
);
4230 adjust_pc_after_break (tp
, &tp
->suspend
.waitstatus
);
4232 if (thread_stopped_by_watchpoint (tp
->ptid
))
4234 tp
->suspend
.stop_reason
4235 = TARGET_STOPPED_BY_WATCHPOINT
;
4237 else if (target_supports_stopped_by_sw_breakpoint ()
4238 && thread_stopped_by_sw_breakpoint (tp
->ptid
))
4240 tp
->suspend
.stop_reason
4241 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4243 else if (target_supports_stopped_by_hw_breakpoint ()
4244 && thread_stopped_by_hw_breakpoint (tp
->ptid
))
4246 tp
->suspend
.stop_reason
4247 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4249 else if (!target_supports_stopped_by_hw_breakpoint ()
4250 && hardware_breakpoint_inserted_here_p (aspace
,
4253 tp
->suspend
.stop_reason
4254 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4256 else if (!target_supports_stopped_by_sw_breakpoint ()
4257 && software_breakpoint_inserted_here_p (aspace
,
4260 tp
->suspend
.stop_reason
4261 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4263 else if (!thread_has_single_step_breakpoints_set (tp
)
4264 && currently_stepping (tp
))
4266 tp
->suspend
.stop_reason
4267 = TARGET_STOPPED_BY_SINGLE_STEP
;
4272 /* Stop all threads. */
4275 stop_all_threads (void)
4277 /* We may need multiple passes to discover all threads. */
4281 struct cleanup
*old_chain
;
4283 gdb_assert (target_is_non_stop_p ());
4286 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads\n");
4288 entry_ptid
= inferior_ptid
;
4289 old_chain
= make_cleanup (switch_to_thread_cleanup
, &entry_ptid
);
4291 /* Request threads to stop, and then wait for the stops. Because
4292 threads we already know about can spawn more threads while we're
4293 trying to stop them, and we only learn about new threads when we
4294 update the thread list, do this in a loop, and keep iterating
4295 until two passes find no threads that need to be stopped. */
4296 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4299 fprintf_unfiltered (gdb_stdlog
,
4300 "infrun: stop_all_threads, pass=%d, "
4301 "iterations=%d\n", pass
, iterations
);
4305 struct target_waitstatus ws
;
4307 struct thread_info
*t
;
4309 update_thread_list ();
4311 /* Go through all threads looking for threads that we need
4312 to tell the target to stop. */
4313 ALL_NON_EXITED_THREADS (t
)
4317 /* If already stopping, don't request a stop again.
4318 We just haven't seen the notification yet. */
4319 if (!t
->stop_requested
)
4322 fprintf_unfiltered (gdb_stdlog
,
4323 "infrun: %s executing, "
4325 target_pid_to_str (t
->ptid
));
4326 target_stop (t
->ptid
);
4327 t
->stop_requested
= 1;
4332 fprintf_unfiltered (gdb_stdlog
,
4333 "infrun: %s executing, "
4334 "already stopping\n",
4335 target_pid_to_str (t
->ptid
));
4338 if (t
->stop_requested
)
4344 fprintf_unfiltered (gdb_stdlog
,
4345 "infrun: %s not executing\n",
4346 target_pid_to_str (t
->ptid
));
4348 /* The thread may be not executing, but still be
4349 resumed with a pending status to process. */
4357 /* If we find new threads on the second iteration, restart
4358 over. We want to see two iterations in a row with all
4363 event_ptid
= wait_one (&ws
);
4364 if (ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4366 /* All resumed threads exited. */
4368 else if (ws
.kind
== TARGET_WAITKIND_EXITED
4369 || ws
.kind
== TARGET_WAITKIND_SIGNALLED
)
4373 ptid_t ptid
= pid_to_ptid (ws
.value
.integer
);
4375 fprintf_unfiltered (gdb_stdlog
,
4376 "infrun: %s exited while "
4377 "stopping threads\n",
4378 target_pid_to_str (ptid
));
4383 t
= find_thread_ptid (event_ptid
);
4385 t
= add_thread (event_ptid
);
4387 t
->stop_requested
= 0;
4390 t
->control
.may_range_step
= 0;
4392 if (ws
.kind
== TARGET_WAITKIND_STOPPED
4393 && ws
.value
.sig
== GDB_SIGNAL_0
)
4395 /* We caught the event that we intended to catch, so
4396 there's no event pending. */
4397 t
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
4398 t
->suspend
.waitstatus_pending_p
= 0;
4400 if (displaced_step_fixup (t
->ptid
, GDB_SIGNAL_0
) < 0)
4402 /* Add it back to the step-over queue. */
4405 fprintf_unfiltered (gdb_stdlog
,
4406 "infrun: displaced-step of %s "
4407 "canceled: adding back to the "
4408 "step-over queue\n",
4409 target_pid_to_str (t
->ptid
));
4411 t
->control
.trap_expected
= 0;
4412 thread_step_over_chain_enqueue (t
);
4417 enum gdb_signal sig
;
4418 struct regcache
*regcache
;
4419 struct address_space
*aspace
;
4425 statstr
= target_waitstatus_to_string (&ws
);
4426 fprintf_unfiltered (gdb_stdlog
,
4427 "infrun: target_wait %s, saving "
4428 "status for %d.%ld.%ld\n",
4430 ptid_get_pid (t
->ptid
),
4431 ptid_get_lwp (t
->ptid
),
4432 ptid_get_tid (t
->ptid
));
4436 /* Record for later. */
4437 save_waitstatus (t
, &ws
);
4439 sig
= (ws
.kind
== TARGET_WAITKIND_STOPPED
4440 ? ws
.value
.sig
: GDB_SIGNAL_0
);
4442 if (displaced_step_fixup (t
->ptid
, sig
) < 0)
4444 /* Add it back to the step-over queue. */
4445 t
->control
.trap_expected
= 0;
4446 thread_step_over_chain_enqueue (t
);
4449 regcache
= get_thread_regcache (t
->ptid
);
4450 t
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4454 fprintf_unfiltered (gdb_stdlog
,
4455 "infrun: saved stop_pc=%s for %s "
4456 "(currently_stepping=%d)\n",
4457 paddress (target_gdbarch (),
4458 t
->suspend
.stop_pc
),
4459 target_pid_to_str (t
->ptid
),
4460 currently_stepping (t
));
4467 do_cleanups (old_chain
);
4470 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads done\n");
4473 /* Given an execution control state that has been freshly filled in by
4474 an event from the inferior, figure out what it means and take
4477 The alternatives are:
4479 1) stop_waiting and return; to really stop and return to the
4482 2) keep_going and return; to wait for the next event (set
4483 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4487 handle_inferior_event_1 (struct execution_control_state
*ecs
)
4489 enum stop_kind stop_soon
;
4491 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
4493 /* We had an event in the inferior, but we are not interested in
4494 handling it at this level. The lower layers have already
4495 done what needs to be done, if anything.
4497 One of the possible circumstances for this is when the
4498 inferior produces output for the console. The inferior has
4499 not stopped, and we are ignoring the event. Another possible
4500 circumstance is any event which the lower level knows will be
4501 reported multiple times without an intervening resume. */
4503 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_IGNORE\n");
4504 prepare_to_wait (ecs
);
4508 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
4509 && target_can_async_p () && !sync_execution
)
4511 /* There were no unwaited-for children left in the target, but,
4512 we're not synchronously waiting for events either. Just
4513 ignore. Otherwise, if we were running a synchronous
4514 execution command, we need to cancel it and give the user
4515 back the terminal. */
4517 fprintf_unfiltered (gdb_stdlog
,
4518 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
4519 prepare_to_wait (ecs
);
4523 /* Cache the last pid/waitstatus. */
4524 set_last_target_status (ecs
->ptid
, ecs
->ws
);
4526 /* Always clear state belonging to the previous time we stopped. */
4527 stop_stack_dummy
= STOP_NONE
;
4529 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4531 /* No unwaited-for children left. IOW, all resumed children
4534 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4536 stop_print_frame
= 0;
4541 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
4542 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
4544 ecs
->event_thread
= find_thread_ptid (ecs
->ptid
);
4545 /* If it's a new thread, add it to the thread database. */
4546 if (ecs
->event_thread
== NULL
)
4547 ecs
->event_thread
= add_thread (ecs
->ptid
);
4549 /* Disable range stepping. If the next step request could use a
4550 range, this will be end up re-enabled then. */
4551 ecs
->event_thread
->control
.may_range_step
= 0;
4554 /* Dependent on valid ECS->EVENT_THREAD. */
4555 adjust_pc_after_break (ecs
->event_thread
, &ecs
->ws
);
4557 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4558 reinit_frame_cache ();
4560 breakpoint_retire_moribund ();
4562 /* First, distinguish signals caused by the debugger from signals
4563 that have to do with the program's own actions. Note that
4564 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4565 on the operating system version. Here we detect when a SIGILL or
4566 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4567 something similar for SIGSEGV, since a SIGSEGV will be generated
4568 when we're trying to execute a breakpoint instruction on a
4569 non-executable stack. This happens for call dummy breakpoints
4570 for architectures like SPARC that place call dummies on the
4572 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
4573 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
4574 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
4575 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
4577 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4579 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
),
4580 regcache_read_pc (regcache
)))
4583 fprintf_unfiltered (gdb_stdlog
,
4584 "infrun: Treating signal as SIGTRAP\n");
4585 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
4589 /* Mark the non-executing threads accordingly. In all-stop, all
4590 threads of all processes are stopped when we get any event
4591 reported. In non-stop mode, only the event thread stops. */
4595 if (!target_is_non_stop_p ())
4596 mark_ptid
= minus_one_ptid
;
4597 else if (ecs
->ws
.kind
== TARGET_WAITKIND_SIGNALLED
4598 || ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4600 /* If we're handling a process exit in non-stop mode, even
4601 though threads haven't been deleted yet, one would think
4602 that there is nothing to do, as threads of the dead process
4603 will be soon deleted, and threads of any other process were
4604 left running. However, on some targets, threads survive a
4605 process exit event. E.g., for the "checkpoint" command,
4606 when the current checkpoint/fork exits, linux-fork.c
4607 automatically switches to another fork from within
4608 target_mourn_inferior, by associating the same
4609 inferior/thread to another fork. We haven't mourned yet at
4610 this point, but we must mark any threads left in the
4611 process as not-executing so that finish_thread_state marks
4612 them stopped (in the user's perspective) if/when we present
4613 the stop to the user. */
4614 mark_ptid
= pid_to_ptid (ptid_get_pid (ecs
->ptid
));
4617 mark_ptid
= ecs
->ptid
;
4619 set_executing (mark_ptid
, 0);
4621 /* Likewise the resumed flag. */
4622 set_resumed (mark_ptid
, 0);
4625 switch (ecs
->ws
.kind
)
4627 case TARGET_WAITKIND_LOADED
:
4629 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_LOADED\n");
4630 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4631 context_switch (ecs
->ptid
);
4632 /* Ignore gracefully during startup of the inferior, as it might
4633 be the shell which has just loaded some objects, otherwise
4634 add the symbols for the newly loaded objects. Also ignore at
4635 the beginning of an attach or remote session; we will query
4636 the full list of libraries once the connection is
4639 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
4640 if (stop_soon
== NO_STOP_QUIETLY
)
4642 struct regcache
*regcache
;
4644 regcache
= get_thread_regcache (ecs
->ptid
);
4646 handle_solib_event ();
4648 ecs
->event_thread
->control
.stop_bpstat
4649 = bpstat_stop_status (get_regcache_aspace (regcache
),
4650 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4652 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4654 /* A catchpoint triggered. */
4655 process_event_stop_test (ecs
);
4659 /* If requested, stop when the dynamic linker notifies
4660 gdb of events. This allows the user to get control
4661 and place breakpoints in initializer routines for
4662 dynamically loaded objects (among other things). */
4663 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4664 if (stop_on_solib_events
)
4666 /* Make sure we print "Stopped due to solib-event" in
4668 stop_print_frame
= 1;
4675 /* If we are skipping through a shell, or through shared library
4676 loading that we aren't interested in, resume the program. If
4677 we're running the program normally, also resume. */
4678 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
4680 /* Loading of shared libraries might have changed breakpoint
4681 addresses. Make sure new breakpoints are inserted. */
4682 if (stop_soon
== NO_STOP_QUIETLY
)
4683 insert_breakpoints ();
4684 resume (GDB_SIGNAL_0
);
4685 prepare_to_wait (ecs
);
4689 /* But stop if we're attaching or setting up a remote
4691 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
4692 || stop_soon
== STOP_QUIETLY_REMOTE
)
4695 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
4700 internal_error (__FILE__
, __LINE__
,
4701 _("unhandled stop_soon: %d"), (int) stop_soon
);
4703 case TARGET_WAITKIND_SPURIOUS
:
4705 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_SPURIOUS\n");
4706 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4707 context_switch (ecs
->ptid
);
4708 resume (GDB_SIGNAL_0
);
4709 prepare_to_wait (ecs
);
4712 case TARGET_WAITKIND_EXITED
:
4713 case TARGET_WAITKIND_SIGNALLED
:
4716 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4717 fprintf_unfiltered (gdb_stdlog
,
4718 "infrun: TARGET_WAITKIND_EXITED\n");
4720 fprintf_unfiltered (gdb_stdlog
,
4721 "infrun: TARGET_WAITKIND_SIGNALLED\n");
4724 inferior_ptid
= ecs
->ptid
;
4725 set_current_inferior (find_inferior_ptid (ecs
->ptid
));
4726 set_current_program_space (current_inferior ()->pspace
);
4727 handle_vfork_child_exec_or_exit (0);
4728 target_terminal_ours (); /* Must do this before mourn anyway. */
4730 /* Clearing any previous state of convenience variables. */
4731 clear_exit_convenience_vars ();
4733 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4735 /* Record the exit code in the convenience variable $_exitcode, so
4736 that the user can inspect this again later. */
4737 set_internalvar_integer (lookup_internalvar ("_exitcode"),
4738 (LONGEST
) ecs
->ws
.value
.integer
);
4740 /* Also record this in the inferior itself. */
4741 current_inferior ()->has_exit_code
= 1;
4742 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
4744 /* Support the --return-child-result option. */
4745 return_child_result_value
= ecs
->ws
.value
.integer
;
4747 observer_notify_exited (ecs
->ws
.value
.integer
);
4751 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4752 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4754 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
4756 /* Set the value of the internal variable $_exitsignal,
4757 which holds the signal uncaught by the inferior. */
4758 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
4759 gdbarch_gdb_signal_to_target (gdbarch
,
4760 ecs
->ws
.value
.sig
));
4764 /* We don't have access to the target's method used for
4765 converting between signal numbers (GDB's internal
4766 representation <-> target's representation).
4767 Therefore, we cannot do a good job at displaying this
4768 information to the user. It's better to just warn
4769 her about it (if infrun debugging is enabled), and
4772 fprintf_filtered (gdb_stdlog
, _("\
4773 Cannot fill $_exitsignal with the correct signal number.\n"));
4776 observer_notify_signal_exited (ecs
->ws
.value
.sig
);
4779 gdb_flush (gdb_stdout
);
4780 target_mourn_inferior ();
4781 stop_print_frame
= 0;
4785 /* The following are the only cases in which we keep going;
4786 the above cases end in a continue or goto. */
4787 case TARGET_WAITKIND_FORKED
:
4788 case TARGET_WAITKIND_VFORKED
:
4791 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
4792 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_FORKED\n");
4794 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_VFORKED\n");
4797 /* Check whether the inferior is displaced stepping. */
4799 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4800 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4801 struct displaced_step_inferior_state
*displaced
4802 = get_displaced_stepping_state (ptid_get_pid (ecs
->ptid
));
4804 /* If checking displaced stepping is supported, and thread
4805 ecs->ptid is displaced stepping. */
4806 if (displaced
&& ptid_equal (displaced
->step_ptid
, ecs
->ptid
))
4808 struct inferior
*parent_inf
4809 = find_inferior_ptid (ecs
->ptid
);
4810 struct regcache
*child_regcache
;
4811 CORE_ADDR parent_pc
;
4813 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
4814 indicating that the displaced stepping of syscall instruction
4815 has been done. Perform cleanup for parent process here. Note
4816 that this operation also cleans up the child process for vfork,
4817 because their pages are shared. */
4818 displaced_step_fixup (ecs
->ptid
, GDB_SIGNAL_TRAP
);
4819 /* Start a new step-over in another thread if there's one
4823 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
4825 /* Restore scratch pad for child process. */
4826 displaced_step_restore (displaced
, ecs
->ws
.value
.related_pid
);
4829 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
4830 the child's PC is also within the scratchpad. Set the child's PC
4831 to the parent's PC value, which has already been fixed up.
4832 FIXME: we use the parent's aspace here, although we're touching
4833 the child, because the child hasn't been added to the inferior
4834 list yet at this point. */
4837 = get_thread_arch_aspace_regcache (ecs
->ws
.value
.related_pid
,
4839 parent_inf
->aspace
);
4840 /* Read PC value of parent process. */
4841 parent_pc
= regcache_read_pc (regcache
);
4843 if (debug_displaced
)
4844 fprintf_unfiltered (gdb_stdlog
,
4845 "displaced: write child pc from %s to %s\n",
4847 regcache_read_pc (child_regcache
)),
4848 paddress (gdbarch
, parent_pc
));
4850 regcache_write_pc (child_regcache
, parent_pc
);
4854 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4855 context_switch (ecs
->ptid
);
4857 /* Immediately detach breakpoints from the child before there's
4858 any chance of letting the user delete breakpoints from the
4859 breakpoint lists. If we don't do this early, it's easy to
4860 leave left over traps in the child, vis: "break foo; catch
4861 fork; c; <fork>; del; c; <child calls foo>". We only follow
4862 the fork on the last `continue', and by that time the
4863 breakpoint at "foo" is long gone from the breakpoint table.
4864 If we vforked, then we don't need to unpatch here, since both
4865 parent and child are sharing the same memory pages; we'll
4866 need to unpatch at follow/detach time instead to be certain
4867 that new breakpoints added between catchpoint hit time and
4868 vfork follow are detached. */
4869 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
4871 /* This won't actually modify the breakpoint list, but will
4872 physically remove the breakpoints from the child. */
4873 detach_breakpoints (ecs
->ws
.value
.related_pid
);
4876 delete_just_stopped_threads_single_step_breakpoints ();
4878 /* In case the event is caught by a catchpoint, remember that
4879 the event is to be followed at the next resume of the thread,
4880 and not immediately. */
4881 ecs
->event_thread
->pending_follow
= ecs
->ws
;
4883 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4885 ecs
->event_thread
->control
.stop_bpstat
4886 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4887 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4889 /* If no catchpoint triggered for this, then keep going. Note
4890 that we're interested in knowing the bpstat actually causes a
4891 stop, not just if it may explain the signal. Software
4892 watchpoints, for example, always appear in the bpstat. */
4893 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4899 = (follow_fork_mode_string
== follow_fork_mode_child
);
4901 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4903 should_resume
= follow_fork ();
4906 child
= ecs
->ws
.value
.related_pid
;
4908 /* In non-stop mode, also resume the other branch. */
4909 if (!detach_fork
&& (non_stop
4910 || (sched_multi
&& target_is_non_stop_p ())))
4913 switch_to_thread (parent
);
4915 switch_to_thread (child
);
4917 ecs
->event_thread
= inferior_thread ();
4918 ecs
->ptid
= inferior_ptid
;
4923 switch_to_thread (child
);
4925 switch_to_thread (parent
);
4927 ecs
->event_thread
= inferior_thread ();
4928 ecs
->ptid
= inferior_ptid
;
4936 process_event_stop_test (ecs
);
4939 case TARGET_WAITKIND_VFORK_DONE
:
4940 /* Done with the shared memory region. Re-insert breakpoints in
4941 the parent, and keep going. */
4944 fprintf_unfiltered (gdb_stdlog
,
4945 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
4947 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4948 context_switch (ecs
->ptid
);
4950 current_inferior ()->waiting_for_vfork_done
= 0;
4951 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
4952 /* This also takes care of reinserting breakpoints in the
4953 previously locked inferior. */
4957 case TARGET_WAITKIND_EXECD
:
4959 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_EXECD\n");
4961 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4962 context_switch (ecs
->ptid
);
4964 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4966 /* Do whatever is necessary to the parent branch of the vfork. */
4967 handle_vfork_child_exec_or_exit (1);
4969 /* This causes the eventpoints and symbol table to be reset.
4970 Must do this now, before trying to determine whether to
4972 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
4974 ecs
->event_thread
->control
.stop_bpstat
4975 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4976 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4978 /* Note that this may be referenced from inside
4979 bpstat_stop_status above, through inferior_has_execd. */
4980 xfree (ecs
->ws
.value
.execd_pathname
);
4981 ecs
->ws
.value
.execd_pathname
= NULL
;
4983 /* If no catchpoint triggered for this, then keep going. */
4984 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4986 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4990 process_event_stop_test (ecs
);
4993 /* Be careful not to try to gather much state about a thread
4994 that's in a syscall. It's frequently a losing proposition. */
4995 case TARGET_WAITKIND_SYSCALL_ENTRY
:
4997 fprintf_unfiltered (gdb_stdlog
,
4998 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
4999 /* Getting the current syscall number. */
5000 if (handle_syscall_event (ecs
) == 0)
5001 process_event_stop_test (ecs
);
5004 /* Before examining the threads further, step this thread to
5005 get it entirely out of the syscall. (We get notice of the
5006 event when the thread is just on the verge of exiting a
5007 syscall. Stepping one instruction seems to get it back
5009 case TARGET_WAITKIND_SYSCALL_RETURN
:
5011 fprintf_unfiltered (gdb_stdlog
,
5012 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5013 if (handle_syscall_event (ecs
) == 0)
5014 process_event_stop_test (ecs
);
5017 case TARGET_WAITKIND_STOPPED
:
5019 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_STOPPED\n");
5020 ecs
->event_thread
->suspend
.stop_signal
= ecs
->ws
.value
.sig
;
5021 handle_signal_stop (ecs
);
5024 case TARGET_WAITKIND_NO_HISTORY
:
5026 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5027 /* Reverse execution: target ran out of history info. */
5029 delete_just_stopped_threads_single_step_breakpoints ();
5030 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5031 observer_notify_no_history ();
5037 /* A wrapper around handle_inferior_event_1, which also makes sure
5038 that all temporary struct value objects that were created during
5039 the handling of the event get deleted at the end. */
5042 handle_inferior_event (struct execution_control_state
*ecs
)
5044 struct value
*mark
= value_mark ();
5046 handle_inferior_event_1 (ecs
);
5047 /* Purge all temporary values created during the event handling,
5048 as it could be a long time before we return to the command level
5049 where such values would otherwise be purged. */
5050 value_free_to_mark (mark
);
5053 /* Restart threads back to what they were trying to do back when we
5054 paused them for an in-line step-over. The EVENT_THREAD thread is
5058 restart_threads (struct thread_info
*event_thread
)
5060 struct thread_info
*tp
;
5061 struct thread_info
*step_over
= NULL
;
5063 /* In case the instruction just stepped spawned a new thread. */
5064 update_thread_list ();
5066 ALL_NON_EXITED_THREADS (tp
)
5068 if (tp
== event_thread
)
5071 fprintf_unfiltered (gdb_stdlog
,
5072 "infrun: restart threads: "
5073 "[%s] is event thread\n",
5074 target_pid_to_str (tp
->ptid
));
5078 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5081 fprintf_unfiltered (gdb_stdlog
,
5082 "infrun: restart threads: "
5083 "[%s] not meant to be running\n",
5084 target_pid_to_str (tp
->ptid
));
5091 fprintf_unfiltered (gdb_stdlog
,
5092 "infrun: restart threads: [%s] resumed\n",
5093 target_pid_to_str (tp
->ptid
));
5094 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
5098 if (thread_is_in_step_over_chain (tp
))
5101 fprintf_unfiltered (gdb_stdlog
,
5102 "infrun: restart threads: "
5103 "[%s] needs step-over\n",
5104 target_pid_to_str (tp
->ptid
));
5105 gdb_assert (!tp
->resumed
);
5110 if (tp
->suspend
.waitstatus_pending_p
)
5113 fprintf_unfiltered (gdb_stdlog
,
5114 "infrun: restart threads: "
5115 "[%s] has pending status\n",
5116 target_pid_to_str (tp
->ptid
));
5121 /* If some thread needs to start a step-over at this point, it
5122 should still be in the step-over queue, and thus skipped
5124 if (thread_still_needs_step_over (tp
))
5126 internal_error (__FILE__
, __LINE__
,
5127 "thread [%s] needs a step-over, but not in "
5128 "step-over queue\n",
5129 target_pid_to_str (tp
->ptid
));
5132 if (currently_stepping (tp
))
5135 fprintf_unfiltered (gdb_stdlog
,
5136 "infrun: restart threads: [%s] was stepping\n",
5137 target_pid_to_str (tp
->ptid
));
5138 keep_going_stepped_thread (tp
);
5142 struct execution_control_state ecss
;
5143 struct execution_control_state
*ecs
= &ecss
;
5146 fprintf_unfiltered (gdb_stdlog
,
5147 "infrun: restart threads: [%s] continuing\n",
5148 target_pid_to_str (tp
->ptid
));
5149 reset_ecs (ecs
, tp
);
5150 switch_to_thread (tp
->ptid
);
5151 keep_going_pass_signal (ecs
);
5156 /* Callback for iterate_over_threads. Find a resumed thread that has
5157 a pending waitstatus. */
5160 resumed_thread_with_pending_status (struct thread_info
*tp
,
5164 && tp
->suspend
.waitstatus_pending_p
);
5167 /* Called when we get an event that may finish an in-line or
5168 out-of-line (displaced stepping) step-over started previously.
5169 Return true if the event is processed and we should go back to the
5170 event loop; false if the caller should continue processing the
5174 finish_step_over (struct execution_control_state
*ecs
)
5176 int had_step_over_info
;
5178 displaced_step_fixup (ecs
->ptid
,
5179 ecs
->event_thread
->suspend
.stop_signal
);
5181 had_step_over_info
= step_over_info_valid_p ();
5183 if (had_step_over_info
)
5185 /* If we're stepping over a breakpoint with all threads locked,
5186 then only the thread that was stepped should be reporting
5188 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5190 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5191 clear_step_over_info ();
5194 if (!target_is_non_stop_p ())
5197 /* Start a new step-over in another thread if there's one that
5201 /* If we were stepping over a breakpoint before, and haven't started
5202 a new in-line step-over sequence, then restart all other threads
5203 (except the event thread). We can't do this in all-stop, as then
5204 e.g., we wouldn't be able to issue any other remote packet until
5205 these other threads stop. */
5206 if (had_step_over_info
&& !step_over_info_valid_p ())
5208 struct thread_info
*pending
;
5210 /* If we only have threads with pending statuses, the restart
5211 below won't restart any thread and so nothing re-inserts the
5212 breakpoint we just stepped over. But we need it inserted
5213 when we later process the pending events, otherwise if
5214 another thread has a pending event for this breakpoint too,
5215 we'd discard its event (because the breakpoint that
5216 originally caused the event was no longer inserted). */
5217 context_switch (ecs
->ptid
);
5218 insert_breakpoints ();
5220 restart_threads (ecs
->event_thread
);
5222 /* If we have events pending, go through handle_inferior_event
5223 again, picking up a pending event at random. This avoids
5224 thread starvation. */
5226 /* But not if we just stepped over a watchpoint in order to let
5227 the instruction execute so we can evaluate its expression.
5228 The set of watchpoints that triggered is recorded in the
5229 breakpoint objects themselves (see bp->watchpoint_triggered).
5230 If we processed another event first, that other event could
5231 clobber this info. */
5232 if (ecs
->event_thread
->stepping_over_watchpoint
)
5235 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5237 if (pending
!= NULL
)
5239 struct thread_info
*tp
= ecs
->event_thread
;
5240 struct regcache
*regcache
;
5244 fprintf_unfiltered (gdb_stdlog
,
5245 "infrun: found resumed threads with "
5246 "pending events, saving status\n");
5249 gdb_assert (pending
!= tp
);
5251 /* Record the event thread's event for later. */
5252 save_waitstatus (tp
, &ecs
->ws
);
5253 /* This was cleared early, by handle_inferior_event. Set it
5254 so this pending event is considered by
5258 gdb_assert (!tp
->executing
);
5260 regcache
= get_thread_regcache (tp
->ptid
);
5261 tp
->suspend
.stop_pc
= regcache_read_pc (regcache
);
5265 fprintf_unfiltered (gdb_stdlog
,
5266 "infrun: saved stop_pc=%s for %s "
5267 "(currently_stepping=%d)\n",
5268 paddress (target_gdbarch (),
5269 tp
->suspend
.stop_pc
),
5270 target_pid_to_str (tp
->ptid
),
5271 currently_stepping (tp
));
5274 /* This in-line step-over finished; clear this so we won't
5275 start a new one. This is what handle_signal_stop would
5276 do, if we returned false. */
5277 tp
->stepping_over_breakpoint
= 0;
5279 /* Wake up the event loop again. */
5280 mark_async_event_handler (infrun_async_inferior_event_token
);
5282 prepare_to_wait (ecs
);
5290 /* Come here when the program has stopped with a signal. */
5293 handle_signal_stop (struct execution_control_state
*ecs
)
5295 struct frame_info
*frame
;
5296 struct gdbarch
*gdbarch
;
5297 int stopped_by_watchpoint
;
5298 enum stop_kind stop_soon
;
5301 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5303 /* Do we need to clean up the state of a thread that has
5304 completed a displaced single-step? (Doing so usually affects
5305 the PC, so do it here, before we set stop_pc.) */
5306 if (finish_step_over (ecs
))
5309 /* If we either finished a single-step or hit a breakpoint, but
5310 the user wanted this thread to be stopped, pretend we got a
5311 SIG0 (generic unsignaled stop). */
5312 if (ecs
->event_thread
->stop_requested
5313 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5314 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5316 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5320 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
5321 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5322 struct cleanup
*old_chain
= save_inferior_ptid ();
5324 inferior_ptid
= ecs
->ptid
;
5326 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_pc = %s\n",
5327 paddress (gdbarch
, stop_pc
));
5328 if (target_stopped_by_watchpoint ())
5332 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped by watchpoint\n");
5334 if (target_stopped_data_address (¤t_target
, &addr
))
5335 fprintf_unfiltered (gdb_stdlog
,
5336 "infrun: stopped data address = %s\n",
5337 paddress (gdbarch
, addr
));
5339 fprintf_unfiltered (gdb_stdlog
,
5340 "infrun: (no data address available)\n");
5343 do_cleanups (old_chain
);
5346 /* This is originated from start_remote(), start_inferior() and
5347 shared libraries hook functions. */
5348 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
5349 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5351 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5352 context_switch (ecs
->ptid
);
5354 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
5355 stop_print_frame
= 1;
5360 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5363 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5364 context_switch (ecs
->ptid
);
5366 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped\n");
5367 stop_print_frame
= 0;
5372 /* This originates from attach_command(). We need to overwrite
5373 the stop_signal here, because some kernels don't ignore a
5374 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5375 See more comments in inferior.h. On the other hand, if we
5376 get a non-SIGSTOP, report it to the user - assume the backend
5377 will handle the SIGSTOP if it should show up later.
5379 Also consider that the attach is complete when we see a
5380 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5381 target extended-remote report it instead of a SIGSTOP
5382 (e.g. gdbserver). We already rely on SIGTRAP being our
5383 signal, so this is no exception.
5385 Also consider that the attach is complete when we see a
5386 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5387 the target to stop all threads of the inferior, in case the
5388 low level attach operation doesn't stop them implicitly. If
5389 they weren't stopped implicitly, then the stub will report a
5390 GDB_SIGNAL_0, meaning: stopped for no particular reason
5391 other than GDB's request. */
5392 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5393 && (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_STOP
5394 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5395 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_0
))
5397 stop_print_frame
= 1;
5399 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5403 /* See if something interesting happened to the non-current thread. If
5404 so, then switch to that thread. */
5405 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5408 fprintf_unfiltered (gdb_stdlog
, "infrun: context switch\n");
5410 context_switch (ecs
->ptid
);
5412 if (deprecated_context_hook
)
5413 deprecated_context_hook (pid_to_thread_id (ecs
->ptid
));
5416 /* At this point, get hold of the now-current thread's frame. */
5417 frame
= get_current_frame ();
5418 gdbarch
= get_frame_arch (frame
);
5420 /* Pull the single step breakpoints out of the target. */
5421 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5423 struct regcache
*regcache
;
5424 struct address_space
*aspace
;
5427 regcache
= get_thread_regcache (ecs
->ptid
);
5428 aspace
= get_regcache_aspace (regcache
);
5429 pc
= regcache_read_pc (regcache
);
5431 /* However, before doing so, if this single-step breakpoint was
5432 actually for another thread, set this thread up for moving
5434 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
5437 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
5441 fprintf_unfiltered (gdb_stdlog
,
5442 "infrun: [%s] hit another thread's "
5443 "single-step breakpoint\n",
5444 target_pid_to_str (ecs
->ptid
));
5446 ecs
->hit_singlestep_breakpoint
= 1;
5453 fprintf_unfiltered (gdb_stdlog
,
5454 "infrun: [%s] hit its "
5455 "single-step breakpoint\n",
5456 target_pid_to_str (ecs
->ptid
));
5460 delete_just_stopped_threads_single_step_breakpoints ();
5462 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5463 && ecs
->event_thread
->control
.trap_expected
5464 && ecs
->event_thread
->stepping_over_watchpoint
)
5465 stopped_by_watchpoint
= 0;
5467 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
5469 /* If necessary, step over this watchpoint. We'll be back to display
5471 if (stopped_by_watchpoint
5472 && (target_have_steppable_watchpoint
5473 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
5475 /* At this point, we are stopped at an instruction which has
5476 attempted to write to a piece of memory under control of
5477 a watchpoint. The instruction hasn't actually executed
5478 yet. If we were to evaluate the watchpoint expression
5479 now, we would get the old value, and therefore no change
5480 would seem to have occurred.
5482 In order to make watchpoints work `right', we really need
5483 to complete the memory write, and then evaluate the
5484 watchpoint expression. We do this by single-stepping the
5487 It may not be necessary to disable the watchpoint to step over
5488 it. For example, the PA can (with some kernel cooperation)
5489 single step over a watchpoint without disabling the watchpoint.
5491 It is far more common to need to disable a watchpoint to step
5492 the inferior over it. If we have non-steppable watchpoints,
5493 we must disable the current watchpoint; it's simplest to
5494 disable all watchpoints.
5496 Any breakpoint at PC must also be stepped over -- if there's
5497 one, it will have already triggered before the watchpoint
5498 triggered, and we either already reported it to the user, or
5499 it didn't cause a stop and we called keep_going. In either
5500 case, if there was a breakpoint at PC, we must be trying to
5502 ecs
->event_thread
->stepping_over_watchpoint
= 1;
5507 ecs
->event_thread
->stepping_over_breakpoint
= 0;
5508 ecs
->event_thread
->stepping_over_watchpoint
= 0;
5509 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
5510 ecs
->event_thread
->control
.stop_step
= 0;
5511 stop_print_frame
= 1;
5512 stopped_by_random_signal
= 0;
5514 /* Hide inlined functions starting here, unless we just performed stepi or
5515 nexti. After stepi and nexti, always show the innermost frame (not any
5516 inline function call sites). */
5517 if (ecs
->event_thread
->control
.step_range_end
!= 1)
5519 struct address_space
*aspace
=
5520 get_regcache_aspace (get_thread_regcache (ecs
->ptid
));
5522 /* skip_inline_frames is expensive, so we avoid it if we can
5523 determine that the address is one where functions cannot have
5524 been inlined. This improves performance with inferiors that
5525 load a lot of shared libraries, because the solib event
5526 breakpoint is defined as the address of a function (i.e. not
5527 inline). Note that we have to check the previous PC as well
5528 as the current one to catch cases when we have just
5529 single-stepped off a breakpoint prior to reinstating it.
5530 Note that we're assuming that the code we single-step to is
5531 not inline, but that's not definitive: there's nothing
5532 preventing the event breakpoint function from containing
5533 inlined code, and the single-step ending up there. If the
5534 user had set a breakpoint on that inlined code, the missing
5535 skip_inline_frames call would break things. Fortunately
5536 that's an extremely unlikely scenario. */
5537 if (!pc_at_non_inline_function (aspace
, stop_pc
, &ecs
->ws
)
5538 && !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5539 && ecs
->event_thread
->control
.trap_expected
5540 && pc_at_non_inline_function (aspace
,
5541 ecs
->event_thread
->prev_pc
,
5544 skip_inline_frames (ecs
->ptid
);
5546 /* Re-fetch current thread's frame in case that invalidated
5548 frame
= get_current_frame ();
5549 gdbarch
= get_frame_arch (frame
);
5553 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5554 && ecs
->event_thread
->control
.trap_expected
5555 && gdbarch_single_step_through_delay_p (gdbarch
)
5556 && currently_stepping (ecs
->event_thread
))
5558 /* We're trying to step off a breakpoint. Turns out that we're
5559 also on an instruction that needs to be stepped multiple
5560 times before it's been fully executing. E.g., architectures
5561 with a delay slot. It needs to be stepped twice, once for
5562 the instruction and once for the delay slot. */
5563 int step_through_delay
5564 = gdbarch_single_step_through_delay (gdbarch
, frame
);
5566 if (debug_infrun
&& step_through_delay
)
5567 fprintf_unfiltered (gdb_stdlog
, "infrun: step through delay\n");
5568 if (ecs
->event_thread
->control
.step_range_end
== 0
5569 && step_through_delay
)
5571 /* The user issued a continue when stopped at a breakpoint.
5572 Set up for another trap and get out of here. */
5573 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5577 else if (step_through_delay
)
5579 /* The user issued a step when stopped at a breakpoint.
5580 Maybe we should stop, maybe we should not - the delay
5581 slot *might* correspond to a line of source. In any
5582 case, don't decide that here, just set
5583 ecs->stepping_over_breakpoint, making sure we
5584 single-step again before breakpoints are re-inserted. */
5585 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5589 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5590 handles this event. */
5591 ecs
->event_thread
->control
.stop_bpstat
5592 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5593 stop_pc
, ecs
->ptid
, &ecs
->ws
);
5595 /* Following in case break condition called a
5597 stop_print_frame
= 1;
5599 /* This is where we handle "moribund" watchpoints. Unlike
5600 software breakpoints traps, hardware watchpoint traps are
5601 always distinguishable from random traps. If no high-level
5602 watchpoint is associated with the reported stop data address
5603 anymore, then the bpstat does not explain the signal ---
5604 simply make sure to ignore it if `stopped_by_watchpoint' is
5608 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5609 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
5611 && stopped_by_watchpoint
)
5612 fprintf_unfiltered (gdb_stdlog
,
5613 "infrun: no user watchpoint explains "
5614 "watchpoint SIGTRAP, ignoring\n");
5616 /* NOTE: cagney/2003-03-29: These checks for a random signal
5617 at one stage in the past included checks for an inferior
5618 function call's call dummy's return breakpoint. The original
5619 comment, that went with the test, read:
5621 ``End of a stack dummy. Some systems (e.g. Sony news) give
5622 another signal besides SIGTRAP, so check here as well as
5625 If someone ever tries to get call dummys on a
5626 non-executable stack to work (where the target would stop
5627 with something like a SIGSEGV), then those tests might need
5628 to be re-instated. Given, however, that the tests were only
5629 enabled when momentary breakpoints were not being used, I
5630 suspect that it won't be the case.
5632 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5633 be necessary for call dummies on a non-executable stack on
5636 /* See if the breakpoints module can explain the signal. */
5638 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
5639 ecs
->event_thread
->suspend
.stop_signal
);
5641 /* Maybe this was a trap for a software breakpoint that has since
5643 if (random_signal
&& target_stopped_by_sw_breakpoint ())
5645 if (program_breakpoint_here_p (gdbarch
, stop_pc
))
5647 struct regcache
*regcache
;
5650 /* Re-adjust PC to what the program would see if GDB was not
5652 regcache
= get_thread_regcache (ecs
->event_thread
->ptid
);
5653 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
5656 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
5658 if (record_full_is_used ())
5659 record_full_gdb_operation_disable_set ();
5661 regcache_write_pc (regcache
, stop_pc
+ decr_pc
);
5663 do_cleanups (old_cleanups
);
5668 /* A delayed software breakpoint event. Ignore the trap. */
5670 fprintf_unfiltered (gdb_stdlog
,
5671 "infrun: delayed software breakpoint "
5672 "trap, ignoring\n");
5677 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
5678 has since been removed. */
5679 if (random_signal
&& target_stopped_by_hw_breakpoint ())
5681 /* A delayed hardware breakpoint event. Ignore the trap. */
5683 fprintf_unfiltered (gdb_stdlog
,
5684 "infrun: delayed hardware breakpoint/watchpoint "
5685 "trap, ignoring\n");
5689 /* If not, perhaps stepping/nexting can. */
5691 random_signal
= !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5692 && currently_stepping (ecs
->event_thread
));
5694 /* Perhaps the thread hit a single-step breakpoint of _another_
5695 thread. Single-step breakpoints are transparent to the
5696 breakpoints module. */
5698 random_signal
= !ecs
->hit_singlestep_breakpoint
;
5700 /* No? Perhaps we got a moribund watchpoint. */
5702 random_signal
= !stopped_by_watchpoint
;
5704 /* For the program's own signals, act according to
5705 the signal handling tables. */
5709 /* Signal not for debugging purposes. */
5710 struct inferior
*inf
= find_inferior_ptid (ecs
->ptid
);
5711 enum gdb_signal stop_signal
= ecs
->event_thread
->suspend
.stop_signal
;
5714 fprintf_unfiltered (gdb_stdlog
, "infrun: random signal (%s)\n",
5715 gdb_signal_to_symbol_string (stop_signal
));
5717 stopped_by_random_signal
= 1;
5719 /* Always stop on signals if we're either just gaining control
5720 of the program, or the user explicitly requested this thread
5721 to remain stopped. */
5722 if (stop_soon
!= NO_STOP_QUIETLY
5723 || ecs
->event_thread
->stop_requested
5725 && signal_stop_state (ecs
->event_thread
->suspend
.stop_signal
)))
5731 /* Notify observers the signal has "handle print" set. Note we
5732 returned early above if stopping; normal_stop handles the
5733 printing in that case. */
5734 if (signal_print
[ecs
->event_thread
->suspend
.stop_signal
])
5736 /* The signal table tells us to print about this signal. */
5737 target_terminal_ours_for_output ();
5738 observer_notify_signal_received (ecs
->event_thread
->suspend
.stop_signal
);
5739 target_terminal_inferior ();
5742 /* Clear the signal if it should not be passed. */
5743 if (signal_program
[ecs
->event_thread
->suspend
.stop_signal
] == 0)
5744 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5746 if (ecs
->event_thread
->prev_pc
== stop_pc
5747 && ecs
->event_thread
->control
.trap_expected
5748 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
5752 /* We were just starting a new sequence, attempting to
5753 single-step off of a breakpoint and expecting a SIGTRAP.
5754 Instead this signal arrives. This signal will take us out
5755 of the stepping range so GDB needs to remember to, when
5756 the signal handler returns, resume stepping off that
5758 /* To simplify things, "continue" is forced to use the same
5759 code paths as single-step - set a breakpoint at the
5760 signal return address and then, once hit, step off that
5763 fprintf_unfiltered (gdb_stdlog
,
5764 "infrun: signal arrived while stepping over "
5767 was_in_line
= step_over_info_valid_p ();
5768 clear_step_over_info ();
5769 insert_hp_step_resume_breakpoint_at_frame (frame
);
5770 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
5771 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5772 ecs
->event_thread
->control
.trap_expected
= 0;
5774 if (target_is_non_stop_p ())
5776 /* Either "set non-stop" is "on", or the target is
5777 always in non-stop mode. In this case, we have a bit
5778 more work to do. Resume the current thread, and if
5779 we had paused all threads, restart them while the
5780 signal handler runs. */
5785 restart_threads (ecs
->event_thread
);
5787 else if (debug_infrun
)
5789 fprintf_unfiltered (gdb_stdlog
,
5790 "infrun: no need to restart threads\n");
5795 /* If we were nexting/stepping some other thread, switch to
5796 it, so that we don't continue it, losing control. */
5797 if (!switch_back_to_stepped_thread (ecs
))
5802 if (ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
5803 && (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
5804 || ecs
->event_thread
->control
.step_range_end
== 1)
5805 && frame_id_eq (get_stack_frame_id (frame
),
5806 ecs
->event_thread
->control
.step_stack_frame_id
)
5807 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
5809 /* The inferior is about to take a signal that will take it
5810 out of the single step range. Set a breakpoint at the
5811 current PC (which is presumably where the signal handler
5812 will eventually return) and then allow the inferior to
5815 Note that this is only needed for a signal delivered
5816 while in the single-step range. Nested signals aren't a
5817 problem as they eventually all return. */
5819 fprintf_unfiltered (gdb_stdlog
,
5820 "infrun: signal may take us out of "
5821 "single-step range\n");
5823 clear_step_over_info ();
5824 insert_hp_step_resume_breakpoint_at_frame (frame
);
5825 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
5826 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5827 ecs
->event_thread
->control
.trap_expected
= 0;
5832 /* Note: step_resume_breakpoint may be non-NULL. This occures
5833 when either there's a nested signal, or when there's a
5834 pending signal enabled just as the signal handler returns
5835 (leaving the inferior at the step-resume-breakpoint without
5836 actually executing it). Either way continue until the
5837 breakpoint is really hit. */
5839 if (!switch_back_to_stepped_thread (ecs
))
5842 fprintf_unfiltered (gdb_stdlog
,
5843 "infrun: random signal, keep going\n");
5850 process_event_stop_test (ecs
);
5853 /* Come here when we've got some debug event / signal we can explain
5854 (IOW, not a random signal), and test whether it should cause a
5855 stop, or whether we should resume the inferior (transparently).
5856 E.g., could be a breakpoint whose condition evaluates false; we
5857 could be still stepping within the line; etc. */
5860 process_event_stop_test (struct execution_control_state
*ecs
)
5862 struct symtab_and_line stop_pc_sal
;
5863 struct frame_info
*frame
;
5864 struct gdbarch
*gdbarch
;
5865 CORE_ADDR jmp_buf_pc
;
5866 struct bpstat_what what
;
5868 /* Handle cases caused by hitting a breakpoint. */
5870 frame
= get_current_frame ();
5871 gdbarch
= get_frame_arch (frame
);
5873 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
5875 if (what
.call_dummy
)
5877 stop_stack_dummy
= what
.call_dummy
;
5880 /* If we hit an internal event that triggers symbol changes, the
5881 current frame will be invalidated within bpstat_what (e.g., if we
5882 hit an internal solib event). Re-fetch it. */
5883 frame
= get_current_frame ();
5884 gdbarch
= get_frame_arch (frame
);
5886 switch (what
.main_action
)
5888 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
5889 /* If we hit the breakpoint at longjmp while stepping, we
5890 install a momentary breakpoint at the target of the
5894 fprintf_unfiltered (gdb_stdlog
,
5895 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
5897 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5899 if (what
.is_longjmp
)
5901 struct value
*arg_value
;
5903 /* If we set the longjmp breakpoint via a SystemTap probe,
5904 then use it to extract the arguments. The destination PC
5905 is the third argument to the probe. */
5906 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
5909 jmp_buf_pc
= value_as_address (arg_value
);
5910 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
5912 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
5913 || !gdbarch_get_longjmp_target (gdbarch
,
5914 frame
, &jmp_buf_pc
))
5917 fprintf_unfiltered (gdb_stdlog
,
5918 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
5919 "(!gdbarch_get_longjmp_target)\n");
5924 /* Insert a breakpoint at resume address. */
5925 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
5928 check_exception_resume (ecs
, frame
);
5932 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
5934 struct frame_info
*init_frame
;
5936 /* There are several cases to consider.
5938 1. The initiating frame no longer exists. In this case we
5939 must stop, because the exception or longjmp has gone too
5942 2. The initiating frame exists, and is the same as the
5943 current frame. We stop, because the exception or longjmp
5946 3. The initiating frame exists and is different from the
5947 current frame. This means the exception or longjmp has
5948 been caught beneath the initiating frame, so keep going.
5950 4. longjmp breakpoint has been placed just to protect
5951 against stale dummy frames and user is not interested in
5952 stopping around longjmps. */
5955 fprintf_unfiltered (gdb_stdlog
,
5956 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
5958 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
5960 delete_exception_resume_breakpoint (ecs
->event_thread
);
5962 if (what
.is_longjmp
)
5964 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
5966 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
5974 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
5978 struct frame_id current_id
5979 = get_frame_id (get_current_frame ());
5980 if (frame_id_eq (current_id
,
5981 ecs
->event_thread
->initiating_frame
))
5983 /* Case 2. Fall through. */
5993 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
5995 delete_step_resume_breakpoint (ecs
->event_thread
);
5997 end_stepping_range (ecs
);
6001 case BPSTAT_WHAT_SINGLE
:
6003 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_SINGLE\n");
6004 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6005 /* Still need to check other stuff, at least the case where we
6006 are stepping and step out of the right range. */
6009 case BPSTAT_WHAT_STEP_RESUME
:
6011 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6013 delete_step_resume_breakpoint (ecs
->event_thread
);
6014 if (ecs
->event_thread
->control
.proceed_to_finish
6015 && execution_direction
== EXEC_REVERSE
)
6017 struct thread_info
*tp
= ecs
->event_thread
;
6019 /* We are finishing a function in reverse, and just hit the
6020 step-resume breakpoint at the start address of the
6021 function, and we're almost there -- just need to back up
6022 by one more single-step, which should take us back to the
6024 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6028 fill_in_stop_func (gdbarch
, ecs
);
6029 if (stop_pc
== ecs
->stop_func_start
6030 && execution_direction
== EXEC_REVERSE
)
6032 /* We are stepping over a function call in reverse, and just
6033 hit the step-resume breakpoint at the start address of
6034 the function. Go back to single-stepping, which should
6035 take us back to the function call. */
6036 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6042 case BPSTAT_WHAT_STOP_NOISY
:
6044 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6045 stop_print_frame
= 1;
6047 /* Assume the thread stopped for a breapoint. We'll still check
6048 whether a/the breakpoint is there when the thread is next
6050 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6055 case BPSTAT_WHAT_STOP_SILENT
:
6057 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6058 stop_print_frame
= 0;
6060 /* Assume the thread stopped for a breapoint. We'll still check
6061 whether a/the breakpoint is there when the thread is next
6063 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6067 case BPSTAT_WHAT_HP_STEP_RESUME
:
6069 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6071 delete_step_resume_breakpoint (ecs
->event_thread
);
6072 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6074 /* Back when the step-resume breakpoint was inserted, we
6075 were trying to single-step off a breakpoint. Go back to
6077 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6078 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6084 case BPSTAT_WHAT_KEEP_CHECKING
:
6088 /* If we stepped a permanent breakpoint and we had a high priority
6089 step-resume breakpoint for the address we stepped, but we didn't
6090 hit it, then we must have stepped into the signal handler. The
6091 step-resume was only necessary to catch the case of _not_
6092 stepping into the handler, so delete it, and fall through to
6093 checking whether the step finished. */
6094 if (ecs
->event_thread
->stepped_breakpoint
)
6096 struct breakpoint
*sr_bp
6097 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6100 && sr_bp
->loc
->permanent
6101 && sr_bp
->type
== bp_hp_step_resume
6102 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6105 fprintf_unfiltered (gdb_stdlog
,
6106 "infrun: stepped permanent breakpoint, stopped in "
6108 delete_step_resume_breakpoint (ecs
->event_thread
);
6109 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6113 /* We come here if we hit a breakpoint but should not stop for it.
6114 Possibly we also were stepping and should stop for that. So fall
6115 through and test for stepping. But, if not stepping, do not
6118 /* In all-stop mode, if we're currently stepping but have stopped in
6119 some other thread, we need to switch back to the stepped thread. */
6120 if (switch_back_to_stepped_thread (ecs
))
6123 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6126 fprintf_unfiltered (gdb_stdlog
,
6127 "infrun: step-resume breakpoint is inserted\n");
6129 /* Having a step-resume breakpoint overrides anything
6130 else having to do with stepping commands until
6131 that breakpoint is reached. */
6136 if (ecs
->event_thread
->control
.step_range_end
== 0)
6139 fprintf_unfiltered (gdb_stdlog
, "infrun: no stepping, continue\n");
6140 /* Likewise if we aren't even stepping. */
6145 /* Re-fetch current thread's frame in case the code above caused
6146 the frame cache to be re-initialized, making our FRAME variable
6147 a dangling pointer. */
6148 frame
= get_current_frame ();
6149 gdbarch
= get_frame_arch (frame
);
6150 fill_in_stop_func (gdbarch
, ecs
);
6152 /* If stepping through a line, keep going if still within it.
6154 Note that step_range_end is the address of the first instruction
6155 beyond the step range, and NOT the address of the last instruction
6158 Note also that during reverse execution, we may be stepping
6159 through a function epilogue and therefore must detect when
6160 the current-frame changes in the middle of a line. */
6162 if (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
6163 && (execution_direction
!= EXEC_REVERSE
6164 || frame_id_eq (get_frame_id (frame
),
6165 ecs
->event_thread
->control
.step_frame_id
)))
6169 (gdb_stdlog
, "infrun: stepping inside range [%s-%s]\n",
6170 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6171 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6173 /* Tentatively re-enable range stepping; `resume' disables it if
6174 necessary (e.g., if we're stepping over a breakpoint or we
6175 have software watchpoints). */
6176 ecs
->event_thread
->control
.may_range_step
= 1;
6178 /* When stepping backward, stop at beginning of line range
6179 (unless it's the function entry point, in which case
6180 keep going back to the call point). */
6181 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6182 && stop_pc
!= ecs
->stop_func_start
6183 && execution_direction
== EXEC_REVERSE
)
6184 end_stepping_range (ecs
);
6191 /* We stepped out of the stepping range. */
6193 /* If we are stepping at the source level and entered the runtime
6194 loader dynamic symbol resolution code...
6196 EXEC_FORWARD: we keep on single stepping until we exit the run
6197 time loader code and reach the callee's address.
6199 EXEC_REVERSE: we've already executed the callee (backward), and
6200 the runtime loader code is handled just like any other
6201 undebuggable function call. Now we need only keep stepping
6202 backward through the trampoline code, and that's handled further
6203 down, so there is nothing for us to do here. */
6205 if (execution_direction
!= EXEC_REVERSE
6206 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6207 && in_solib_dynsym_resolve_code (stop_pc
))
6209 CORE_ADDR pc_after_resolver
=
6210 gdbarch_skip_solib_resolver (gdbarch
, stop_pc
);
6213 fprintf_unfiltered (gdb_stdlog
,
6214 "infrun: stepped into dynsym resolve code\n");
6216 if (pc_after_resolver
)
6218 /* Set up a step-resume breakpoint at the address
6219 indicated by SKIP_SOLIB_RESOLVER. */
6220 struct symtab_and_line sr_sal
;
6223 sr_sal
.pc
= pc_after_resolver
;
6224 sr_sal
.pspace
= get_frame_program_space (frame
);
6226 insert_step_resume_breakpoint_at_sal (gdbarch
,
6227 sr_sal
, null_frame_id
);
6234 if (ecs
->event_thread
->control
.step_range_end
!= 1
6235 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6236 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6237 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6240 fprintf_unfiltered (gdb_stdlog
,
6241 "infrun: stepped into signal trampoline\n");
6242 /* The inferior, while doing a "step" or "next", has ended up in
6243 a signal trampoline (either by a signal being delivered or by
6244 the signal handler returning). Just single-step until the
6245 inferior leaves the trampoline (either by calling the handler
6251 /* If we're in the return path from a shared library trampoline,
6252 we want to proceed through the trampoline when stepping. */
6253 /* macro/2012-04-25: This needs to come before the subroutine
6254 call check below as on some targets return trampolines look
6255 like subroutine calls (MIPS16 return thunks). */
6256 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6257 stop_pc
, ecs
->stop_func_name
)
6258 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6260 /* Determine where this trampoline returns. */
6261 CORE_ADDR real_stop_pc
;
6263 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6266 fprintf_unfiltered (gdb_stdlog
,
6267 "infrun: stepped into solib return tramp\n");
6269 /* Only proceed through if we know where it's going. */
6272 /* And put the step-breakpoint there and go until there. */
6273 struct symtab_and_line sr_sal
;
6275 init_sal (&sr_sal
); /* initialize to zeroes */
6276 sr_sal
.pc
= real_stop_pc
;
6277 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6278 sr_sal
.pspace
= get_frame_program_space (frame
);
6280 /* Do not specify what the fp should be when we stop since
6281 on some machines the prologue is where the new fp value
6283 insert_step_resume_breakpoint_at_sal (gdbarch
,
6284 sr_sal
, null_frame_id
);
6286 /* Restart without fiddling with the step ranges or
6293 /* Check for subroutine calls. The check for the current frame
6294 equalling the step ID is not necessary - the check of the
6295 previous frame's ID is sufficient - but it is a common case and
6296 cheaper than checking the previous frame's ID.
6298 NOTE: frame_id_eq will never report two invalid frame IDs as
6299 being equal, so to get into this block, both the current and
6300 previous frame must have valid frame IDs. */
6301 /* The outer_frame_id check is a heuristic to detect stepping
6302 through startup code. If we step over an instruction which
6303 sets the stack pointer from an invalid value to a valid value,
6304 we may detect that as a subroutine call from the mythical
6305 "outermost" function. This could be fixed by marking
6306 outermost frames as !stack_p,code_p,special_p. Then the
6307 initial outermost frame, before sp was valid, would
6308 have code_addr == &_start. See the comment in frame_id_eq
6310 if (!frame_id_eq (get_stack_frame_id (frame
),
6311 ecs
->event_thread
->control
.step_stack_frame_id
)
6312 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6313 ecs
->event_thread
->control
.step_stack_frame_id
)
6314 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6316 || (ecs
->event_thread
->control
.step_start_function
6317 != find_pc_function (stop_pc
)))))
6319 CORE_ADDR real_stop_pc
;
6322 fprintf_unfiltered (gdb_stdlog
, "infrun: stepped into subroutine\n");
6324 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6326 /* I presume that step_over_calls is only 0 when we're
6327 supposed to be stepping at the assembly language level
6328 ("stepi"). Just stop. */
6329 /* And this works the same backward as frontward. MVS */
6330 end_stepping_range (ecs
);
6334 /* Reverse stepping through solib trampolines. */
6336 if (execution_direction
== EXEC_REVERSE
6337 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6338 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6339 || (ecs
->stop_func_start
== 0
6340 && in_solib_dynsym_resolve_code (stop_pc
))))
6342 /* Any solib trampoline code can be handled in reverse
6343 by simply continuing to single-step. We have already
6344 executed the solib function (backwards), and a few
6345 steps will take us back through the trampoline to the
6351 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6353 /* We're doing a "next".
6355 Normal (forward) execution: set a breakpoint at the
6356 callee's return address (the address at which the caller
6359 Reverse (backward) execution. set the step-resume
6360 breakpoint at the start of the function that we just
6361 stepped into (backwards), and continue to there. When we
6362 get there, we'll need to single-step back to the caller. */
6364 if (execution_direction
== EXEC_REVERSE
)
6366 /* If we're already at the start of the function, we've either
6367 just stepped backward into a single instruction function,
6368 or stepped back out of a signal handler to the first instruction
6369 of the function. Just keep going, which will single-step back
6371 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6373 struct symtab_and_line sr_sal
;
6375 /* Normal function call return (static or dynamic). */
6377 sr_sal
.pc
= ecs
->stop_func_start
;
6378 sr_sal
.pspace
= get_frame_program_space (frame
);
6379 insert_step_resume_breakpoint_at_sal (gdbarch
,
6380 sr_sal
, null_frame_id
);
6384 insert_step_resume_breakpoint_at_caller (frame
);
6390 /* If we are in a function call trampoline (a stub between the
6391 calling routine and the real function), locate the real
6392 function. That's what tells us (a) whether we want to step
6393 into it at all, and (b) what prologue we want to run to the
6394 end of, if we do step into it. */
6395 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6396 if (real_stop_pc
== 0)
6397 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6398 if (real_stop_pc
!= 0)
6399 ecs
->stop_func_start
= real_stop_pc
;
6401 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6403 struct symtab_and_line sr_sal
;
6406 sr_sal
.pc
= ecs
->stop_func_start
;
6407 sr_sal
.pspace
= get_frame_program_space (frame
);
6409 insert_step_resume_breakpoint_at_sal (gdbarch
,
6410 sr_sal
, null_frame_id
);
6415 /* If we have line number information for the function we are
6416 thinking of stepping into and the function isn't on the skip
6419 If there are several symtabs at that PC (e.g. with include
6420 files), just want to know whether *any* of them have line
6421 numbers. find_pc_line handles this. */
6423 struct symtab_and_line tmp_sal
;
6425 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6426 if (tmp_sal
.line
!= 0
6427 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6430 if (execution_direction
== EXEC_REVERSE
)
6431 handle_step_into_function_backward (gdbarch
, ecs
);
6433 handle_step_into_function (gdbarch
, ecs
);
6438 /* If we have no line number and the step-stop-if-no-debug is
6439 set, we stop the step so that the user has a chance to switch
6440 in assembly mode. */
6441 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6442 && step_stop_if_no_debug
)
6444 end_stepping_range (ecs
);
6448 if (execution_direction
== EXEC_REVERSE
)
6450 /* If we're already at the start of the function, we've either just
6451 stepped backward into a single instruction function without line
6452 number info, or stepped back out of a signal handler to the first
6453 instruction of the function without line number info. Just keep
6454 going, which will single-step back to the caller. */
6455 if (ecs
->stop_func_start
!= stop_pc
)
6457 /* Set a breakpoint at callee's start address.
6458 From there we can step once and be back in the caller. */
6459 struct symtab_and_line sr_sal
;
6462 sr_sal
.pc
= ecs
->stop_func_start
;
6463 sr_sal
.pspace
= get_frame_program_space (frame
);
6464 insert_step_resume_breakpoint_at_sal (gdbarch
,
6465 sr_sal
, null_frame_id
);
6469 /* Set a breakpoint at callee's return address (the address
6470 at which the caller will resume). */
6471 insert_step_resume_breakpoint_at_caller (frame
);
6477 /* Reverse stepping through solib trampolines. */
6479 if (execution_direction
== EXEC_REVERSE
6480 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6482 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6483 || (ecs
->stop_func_start
== 0
6484 && in_solib_dynsym_resolve_code (stop_pc
)))
6486 /* Any solib trampoline code can be handled in reverse
6487 by simply continuing to single-step. We have already
6488 executed the solib function (backwards), and a few
6489 steps will take us back through the trampoline to the
6494 else if (in_solib_dynsym_resolve_code (stop_pc
))
6496 /* Stepped backward into the solib dynsym resolver.
6497 Set a breakpoint at its start and continue, then
6498 one more step will take us out. */
6499 struct symtab_and_line sr_sal
;
6502 sr_sal
.pc
= ecs
->stop_func_start
;
6503 sr_sal
.pspace
= get_frame_program_space (frame
);
6504 insert_step_resume_breakpoint_at_sal (gdbarch
,
6505 sr_sal
, null_frame_id
);
6511 stop_pc_sal
= find_pc_line (stop_pc
, 0);
6513 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6514 the trampoline processing logic, however, there are some trampolines
6515 that have no names, so we should do trampoline handling first. */
6516 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6517 && ecs
->stop_func_name
== NULL
6518 && stop_pc_sal
.line
== 0)
6521 fprintf_unfiltered (gdb_stdlog
,
6522 "infrun: stepped into undebuggable function\n");
6524 /* The inferior just stepped into, or returned to, an
6525 undebuggable function (where there is no debugging information
6526 and no line number corresponding to the address where the
6527 inferior stopped). Since we want to skip this kind of code,
6528 we keep going until the inferior returns from this
6529 function - unless the user has asked us not to (via
6530 set step-mode) or we no longer know how to get back
6531 to the call site. */
6532 if (step_stop_if_no_debug
6533 || !frame_id_p (frame_unwind_caller_id (frame
)))
6535 /* If we have no line number and the step-stop-if-no-debug
6536 is set, we stop the step so that the user has a chance to
6537 switch in assembly mode. */
6538 end_stepping_range (ecs
);
6543 /* Set a breakpoint at callee's return address (the address
6544 at which the caller will resume). */
6545 insert_step_resume_breakpoint_at_caller (frame
);
6551 if (ecs
->event_thread
->control
.step_range_end
== 1)
6553 /* It is stepi or nexti. We always want to stop stepping after
6556 fprintf_unfiltered (gdb_stdlog
, "infrun: stepi/nexti\n");
6557 end_stepping_range (ecs
);
6561 if (stop_pc_sal
.line
== 0)
6563 /* We have no line number information. That means to stop
6564 stepping (does this always happen right after one instruction,
6565 when we do "s" in a function with no line numbers,
6566 or can this happen as a result of a return or longjmp?). */
6568 fprintf_unfiltered (gdb_stdlog
, "infrun: no line number info\n");
6569 end_stepping_range (ecs
);
6573 /* Look for "calls" to inlined functions, part one. If the inline
6574 frame machinery detected some skipped call sites, we have entered
6575 a new inline function. */
6577 if (frame_id_eq (get_frame_id (get_current_frame ()),
6578 ecs
->event_thread
->control
.step_frame_id
)
6579 && inline_skipped_frames (ecs
->ptid
))
6581 struct symtab_and_line call_sal
;
6584 fprintf_unfiltered (gdb_stdlog
,
6585 "infrun: stepped into inlined function\n");
6587 find_frame_sal (get_current_frame (), &call_sal
);
6589 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
6591 /* For "step", we're going to stop. But if the call site
6592 for this inlined function is on the same source line as
6593 we were previously stepping, go down into the function
6594 first. Otherwise stop at the call site. */
6596 if (call_sal
.line
== ecs
->event_thread
->current_line
6597 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
6598 step_into_inline_frame (ecs
->ptid
);
6600 end_stepping_range (ecs
);
6605 /* For "next", we should stop at the call site if it is on a
6606 different source line. Otherwise continue through the
6607 inlined function. */
6608 if (call_sal
.line
== ecs
->event_thread
->current_line
6609 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
6612 end_stepping_range (ecs
);
6617 /* Look for "calls" to inlined functions, part two. If we are still
6618 in the same real function we were stepping through, but we have
6619 to go further up to find the exact frame ID, we are stepping
6620 through a more inlined call beyond its call site. */
6622 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6623 && !frame_id_eq (get_frame_id (get_current_frame ()),
6624 ecs
->event_thread
->control
.step_frame_id
)
6625 && stepped_in_from (get_current_frame (),
6626 ecs
->event_thread
->control
.step_frame_id
))
6629 fprintf_unfiltered (gdb_stdlog
,
6630 "infrun: stepping through inlined function\n");
6632 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6635 end_stepping_range (ecs
);
6639 if ((stop_pc
== stop_pc_sal
.pc
)
6640 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
6641 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
6643 /* We are at the start of a different line. So stop. Note that
6644 we don't stop if we step into the middle of a different line.
6645 That is said to make things like for (;;) statements work
6648 fprintf_unfiltered (gdb_stdlog
,
6649 "infrun: stepped to a different line\n");
6650 end_stepping_range (ecs
);
6654 /* We aren't done stepping.
6656 Optimize by setting the stepping range to the line.
6657 (We might not be in the original line, but if we entered a
6658 new line in mid-statement, we continue stepping. This makes
6659 things like for(;;) statements work better.) */
6661 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
6662 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
6663 ecs
->event_thread
->control
.may_range_step
= 1;
6664 set_step_info (frame
, stop_pc_sal
);
6667 fprintf_unfiltered (gdb_stdlog
, "infrun: keep going\n");
6671 /* In all-stop mode, if we're currently stepping but have stopped in
6672 some other thread, we may need to switch back to the stepped
6673 thread. Returns true we set the inferior running, false if we left
6674 it stopped (and the event needs further processing). */
6677 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
6679 if (!target_is_non_stop_p ())
6681 struct thread_info
*tp
;
6682 struct thread_info
*stepping_thread
;
6684 /* If any thread is blocked on some internal breakpoint, and we
6685 simply need to step over that breakpoint to get it going
6686 again, do that first. */
6688 /* However, if we see an event for the stepping thread, then we
6689 know all other threads have been moved past their breakpoints
6690 already. Let the caller check whether the step is finished,
6691 etc., before deciding to move it past a breakpoint. */
6692 if (ecs
->event_thread
->control
.step_range_end
!= 0)
6695 /* Check if the current thread is blocked on an incomplete
6696 step-over, interrupted by a random signal. */
6697 if (ecs
->event_thread
->control
.trap_expected
6698 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
6702 fprintf_unfiltered (gdb_stdlog
,
6703 "infrun: need to finish step-over of [%s]\n",
6704 target_pid_to_str (ecs
->event_thread
->ptid
));
6710 /* Check if the current thread is blocked by a single-step
6711 breakpoint of another thread. */
6712 if (ecs
->hit_singlestep_breakpoint
)
6716 fprintf_unfiltered (gdb_stdlog
,
6717 "infrun: need to step [%s] over single-step "
6719 target_pid_to_str (ecs
->ptid
));
6725 /* If this thread needs yet another step-over (e.g., stepping
6726 through a delay slot), do it first before moving on to
6728 if (thread_still_needs_step_over (ecs
->event_thread
))
6732 fprintf_unfiltered (gdb_stdlog
,
6733 "infrun: thread [%s] still needs step-over\n",
6734 target_pid_to_str (ecs
->event_thread
->ptid
));
6740 /* If scheduler locking applies even if not stepping, there's no
6741 need to walk over threads. Above we've checked whether the
6742 current thread is stepping. If some other thread not the
6743 event thread is stepping, then it must be that scheduler
6744 locking is not in effect. */
6745 if (schedlock_applies (ecs
->event_thread
))
6748 /* Otherwise, we no longer expect a trap in the current thread.
6749 Clear the trap_expected flag before switching back -- this is
6750 what keep_going does as well, if we call it. */
6751 ecs
->event_thread
->control
.trap_expected
= 0;
6753 /* Likewise, clear the signal if it should not be passed. */
6754 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
6755 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6757 /* Do all pending step-overs before actually proceeding with
6759 if (start_step_over ())
6761 prepare_to_wait (ecs
);
6765 /* Look for the stepping/nexting thread. */
6766 stepping_thread
= NULL
;
6768 ALL_NON_EXITED_THREADS (tp
)
6770 /* Ignore threads of processes the caller is not
6773 && ptid_get_pid (tp
->ptid
) != ptid_get_pid (ecs
->ptid
))
6776 /* When stepping over a breakpoint, we lock all threads
6777 except the one that needs to move past the breakpoint.
6778 If a non-event thread has this set, the "incomplete
6779 step-over" check above should have caught it earlier. */
6780 if (tp
->control
.trap_expected
)
6782 internal_error (__FILE__
, __LINE__
,
6783 "[%s] has inconsistent state: "
6784 "trap_expected=%d\n",
6785 target_pid_to_str (tp
->ptid
),
6786 tp
->control
.trap_expected
);
6789 /* Did we find the stepping thread? */
6790 if (tp
->control
.step_range_end
)
6792 /* Yep. There should only one though. */
6793 gdb_assert (stepping_thread
== NULL
);
6795 /* The event thread is handled at the top, before we
6797 gdb_assert (tp
!= ecs
->event_thread
);
6799 /* If some thread other than the event thread is
6800 stepping, then scheduler locking can't be in effect,
6801 otherwise we wouldn't have resumed the current event
6802 thread in the first place. */
6803 gdb_assert (!schedlock_applies (tp
));
6805 stepping_thread
= tp
;
6809 if (stepping_thread
!= NULL
)
6812 fprintf_unfiltered (gdb_stdlog
,
6813 "infrun: switching back to stepped thread\n");
6815 if (keep_going_stepped_thread (stepping_thread
))
6817 prepare_to_wait (ecs
);
6826 /* Set a previously stepped thread back to stepping. Returns true on
6827 success, false if the resume is not possible (e.g., the thread
6831 keep_going_stepped_thread (struct thread_info
*tp
)
6833 struct frame_info
*frame
;
6834 struct gdbarch
*gdbarch
;
6835 struct execution_control_state ecss
;
6836 struct execution_control_state
*ecs
= &ecss
;
6838 /* If the stepping thread exited, then don't try to switch back and
6839 resume it, which could fail in several different ways depending
6840 on the target. Instead, just keep going.
6842 We can find a stepping dead thread in the thread list in two
6845 - The target supports thread exit events, and when the target
6846 tries to delete the thread from the thread list, inferior_ptid
6847 pointed at the exiting thread. In such case, calling
6848 delete_thread does not really remove the thread from the list;
6849 instead, the thread is left listed, with 'exited' state.
6851 - The target's debug interface does not support thread exit
6852 events, and so we have no idea whatsoever if the previously
6853 stepping thread is still alive. For that reason, we need to
6854 synchronously query the target now. */
6856 if (is_exited (tp
->ptid
)
6857 || !target_thread_alive (tp
->ptid
))
6860 fprintf_unfiltered (gdb_stdlog
,
6861 "infrun: not resuming previously "
6862 "stepped thread, it has vanished\n");
6864 delete_thread (tp
->ptid
);
6869 fprintf_unfiltered (gdb_stdlog
,
6870 "infrun: resuming previously stepped thread\n");
6872 reset_ecs (ecs
, tp
);
6873 switch_to_thread (tp
->ptid
);
6875 stop_pc
= regcache_read_pc (get_thread_regcache (tp
->ptid
));
6876 frame
= get_current_frame ();
6877 gdbarch
= get_frame_arch (frame
);
6879 /* If the PC of the thread we were trying to single-step has
6880 changed, then that thread has trapped or been signaled, but the
6881 event has not been reported to GDB yet. Re-poll the target
6882 looking for this particular thread's event (i.e. temporarily
6883 enable schedlock) by:
6885 - setting a break at the current PC
6886 - resuming that particular thread, only (by setting trap
6889 This prevents us continuously moving the single-step breakpoint
6890 forward, one instruction at a time, overstepping. */
6892 if (stop_pc
!= tp
->prev_pc
)
6897 fprintf_unfiltered (gdb_stdlog
,
6898 "infrun: expected thread advanced also (%s -> %s)\n",
6899 paddress (target_gdbarch (), tp
->prev_pc
),
6900 paddress (target_gdbarch (), stop_pc
));
6902 /* Clear the info of the previous step-over, as it's no longer
6903 valid (if the thread was trying to step over a breakpoint, it
6904 has already succeeded). It's what keep_going would do too,
6905 if we called it. Do this before trying to insert the sss
6906 breakpoint, otherwise if we were previously trying to step
6907 over this exact address in another thread, the breakpoint is
6909 clear_step_over_info ();
6910 tp
->control
.trap_expected
= 0;
6912 insert_single_step_breakpoint (get_frame_arch (frame
),
6913 get_frame_address_space (frame
),
6917 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
6918 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
6923 fprintf_unfiltered (gdb_stdlog
,
6924 "infrun: expected thread still hasn't advanced\n");
6926 keep_going_pass_signal (ecs
);
6931 /* Is thread TP in the middle of (software or hardware)
6932 single-stepping? (Note the result of this function must never be
6933 passed directly as target_resume's STEP parameter.) */
6936 currently_stepping (struct thread_info
*tp
)
6938 return ((tp
->control
.step_range_end
6939 && tp
->control
.step_resume_breakpoint
== NULL
)
6940 || tp
->control
.trap_expected
6941 || tp
->stepped_breakpoint
6942 || bpstat_should_step ());
6945 /* Inferior has stepped into a subroutine call with source code that
6946 we should not step over. Do step to the first line of code in
6950 handle_step_into_function (struct gdbarch
*gdbarch
,
6951 struct execution_control_state
*ecs
)
6953 struct compunit_symtab
*cust
;
6954 struct symtab_and_line stop_func_sal
, sr_sal
;
6956 fill_in_stop_func (gdbarch
, ecs
);
6958 cust
= find_pc_compunit_symtab (stop_pc
);
6959 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
6960 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
6961 ecs
->stop_func_start
);
6963 stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6964 /* Use the step_resume_break to step until the end of the prologue,
6965 even if that involves jumps (as it seems to on the vax under
6967 /* If the prologue ends in the middle of a source line, continue to
6968 the end of that source line (if it is still within the function).
6969 Otherwise, just go to end of prologue. */
6970 if (stop_func_sal
.end
6971 && stop_func_sal
.pc
!= ecs
->stop_func_start
6972 && stop_func_sal
.end
< ecs
->stop_func_end
)
6973 ecs
->stop_func_start
= stop_func_sal
.end
;
6975 /* Architectures which require breakpoint adjustment might not be able
6976 to place a breakpoint at the computed address. If so, the test
6977 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
6978 ecs->stop_func_start to an address at which a breakpoint may be
6979 legitimately placed.
6981 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
6982 made, GDB will enter an infinite loop when stepping through
6983 optimized code consisting of VLIW instructions which contain
6984 subinstructions corresponding to different source lines. On
6985 FR-V, it's not permitted to place a breakpoint on any but the
6986 first subinstruction of a VLIW instruction. When a breakpoint is
6987 set, GDB will adjust the breakpoint address to the beginning of
6988 the VLIW instruction. Thus, we need to make the corresponding
6989 adjustment here when computing the stop address. */
6991 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
6993 ecs
->stop_func_start
6994 = gdbarch_adjust_breakpoint_address (gdbarch
,
6995 ecs
->stop_func_start
);
6998 if (ecs
->stop_func_start
== stop_pc
)
7000 /* We are already there: stop now. */
7001 end_stepping_range (ecs
);
7006 /* Put the step-breakpoint there and go until there. */
7007 init_sal (&sr_sal
); /* initialize to zeroes */
7008 sr_sal
.pc
= ecs
->stop_func_start
;
7009 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7010 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7012 /* Do not specify what the fp should be when we stop since on
7013 some machines the prologue is where the new fp value is
7015 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7017 /* And make sure stepping stops right away then. */
7018 ecs
->event_thread
->control
.step_range_end
7019 = ecs
->event_thread
->control
.step_range_start
;
7024 /* Inferior has stepped backward into a subroutine call with source
7025 code that we should not step over. Do step to the beginning of the
7026 last line of code in it. */
7029 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7030 struct execution_control_state
*ecs
)
7032 struct compunit_symtab
*cust
;
7033 struct symtab_and_line stop_func_sal
;
7035 fill_in_stop_func (gdbarch
, ecs
);
7037 cust
= find_pc_compunit_symtab (stop_pc
);
7038 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7039 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
7040 ecs
->stop_func_start
);
7042 stop_func_sal
= find_pc_line (stop_pc
, 0);
7044 /* OK, we're just going to keep stepping here. */
7045 if (stop_func_sal
.pc
== stop_pc
)
7047 /* We're there already. Just stop stepping now. */
7048 end_stepping_range (ecs
);
7052 /* Else just reset the step range and keep going.
7053 No step-resume breakpoint, they don't work for
7054 epilogues, which can have multiple entry paths. */
7055 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7056 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7062 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7063 This is used to both functions and to skip over code. */
7066 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7067 struct symtab_and_line sr_sal
,
7068 struct frame_id sr_id
,
7069 enum bptype sr_type
)
7071 /* There should never be more than one step-resume or longjmp-resume
7072 breakpoint per thread, so we should never be setting a new
7073 step_resume_breakpoint when one is already active. */
7074 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7075 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7078 fprintf_unfiltered (gdb_stdlog
,
7079 "infrun: inserting step-resume breakpoint at %s\n",
7080 paddress (gdbarch
, sr_sal
.pc
));
7082 inferior_thread ()->control
.step_resume_breakpoint
7083 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
);
7087 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7088 struct symtab_and_line sr_sal
,
7089 struct frame_id sr_id
)
7091 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7096 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7097 This is used to skip a potential signal handler.
7099 This is called with the interrupted function's frame. The signal
7100 handler, when it returns, will resume the interrupted function at
7104 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7106 struct symtab_and_line sr_sal
;
7107 struct gdbarch
*gdbarch
;
7109 gdb_assert (return_frame
!= NULL
);
7110 init_sal (&sr_sal
); /* initialize to zeros */
7112 gdbarch
= get_frame_arch (return_frame
);
7113 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7114 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7115 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7117 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7118 get_stack_frame_id (return_frame
),
7122 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7123 is used to skip a function after stepping into it (for "next" or if
7124 the called function has no debugging information).
7126 The current function has almost always been reached by single
7127 stepping a call or return instruction. NEXT_FRAME belongs to the
7128 current function, and the breakpoint will be set at the caller's
7131 This is a separate function rather than reusing
7132 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7133 get_prev_frame, which may stop prematurely (see the implementation
7134 of frame_unwind_caller_id for an example). */
7137 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7139 struct symtab_and_line sr_sal
;
7140 struct gdbarch
*gdbarch
;
7142 /* We shouldn't have gotten here if we don't know where the call site
7144 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7146 init_sal (&sr_sal
); /* initialize to zeros */
7148 gdbarch
= frame_unwind_caller_arch (next_frame
);
7149 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7150 frame_unwind_caller_pc (next_frame
));
7151 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7152 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7154 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7155 frame_unwind_caller_id (next_frame
));
7158 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7159 new breakpoint at the target of a jmp_buf. The handling of
7160 longjmp-resume uses the same mechanisms used for handling
7161 "step-resume" breakpoints. */
7164 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7166 /* There should never be more than one longjmp-resume breakpoint per
7167 thread, so we should never be setting a new
7168 longjmp_resume_breakpoint when one is already active. */
7169 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7172 fprintf_unfiltered (gdb_stdlog
,
7173 "infrun: inserting longjmp-resume breakpoint at %s\n",
7174 paddress (gdbarch
, pc
));
7176 inferior_thread ()->control
.exception_resume_breakpoint
=
7177 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
);
7180 /* Insert an exception resume breakpoint. TP is the thread throwing
7181 the exception. The block B is the block of the unwinder debug hook
7182 function. FRAME is the frame corresponding to the call to this
7183 function. SYM is the symbol of the function argument holding the
7184 target PC of the exception. */
7187 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7188 const struct block
*b
,
7189 struct frame_info
*frame
,
7194 struct symbol
*vsym
;
7195 struct value
*value
;
7197 struct breakpoint
*bp
;
7199 vsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
), b
, VAR_DOMAIN
,
7201 value
= read_var_value (vsym
, frame
);
7202 /* If the value was optimized out, revert to the old behavior. */
7203 if (! value_optimized_out (value
))
7205 handler
= value_as_address (value
);
7208 fprintf_unfiltered (gdb_stdlog
,
7209 "infrun: exception resume at %lx\n",
7210 (unsigned long) handler
);
7212 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7213 handler
, bp_exception_resume
);
7215 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7218 bp
->thread
= tp
->num
;
7219 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7222 CATCH (e
, RETURN_MASK_ERROR
)
7224 /* We want to ignore errors here. */
7229 /* A helper for check_exception_resume that sets an
7230 exception-breakpoint based on a SystemTap probe. */
7233 insert_exception_resume_from_probe (struct thread_info
*tp
,
7234 const struct bound_probe
*probe
,
7235 struct frame_info
*frame
)
7237 struct value
*arg_value
;
7239 struct breakpoint
*bp
;
7241 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7245 handler
= value_as_address (arg_value
);
7248 fprintf_unfiltered (gdb_stdlog
,
7249 "infrun: exception resume at %s\n",
7250 paddress (get_objfile_arch (probe
->objfile
),
7253 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7254 handler
, bp_exception_resume
);
7255 bp
->thread
= tp
->num
;
7256 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7259 /* This is called when an exception has been intercepted. Check to
7260 see whether the exception's destination is of interest, and if so,
7261 set an exception resume breakpoint there. */
7264 check_exception_resume (struct execution_control_state
*ecs
,
7265 struct frame_info
*frame
)
7267 struct bound_probe probe
;
7268 struct symbol
*func
;
7270 /* First see if this exception unwinding breakpoint was set via a
7271 SystemTap probe point. If so, the probe has two arguments: the
7272 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7273 set a breakpoint there. */
7274 probe
= find_probe_by_pc (get_frame_pc (frame
));
7277 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7281 func
= get_frame_function (frame
);
7287 const struct block
*b
;
7288 struct block_iterator iter
;
7292 /* The exception breakpoint is a thread-specific breakpoint on
7293 the unwinder's debug hook, declared as:
7295 void _Unwind_DebugHook (void *cfa, void *handler);
7297 The CFA argument indicates the frame to which control is
7298 about to be transferred. HANDLER is the destination PC.
7300 We ignore the CFA and set a temporary breakpoint at HANDLER.
7301 This is not extremely efficient but it avoids issues in gdb
7302 with computing the DWARF CFA, and it also works even in weird
7303 cases such as throwing an exception from inside a signal
7306 b
= SYMBOL_BLOCK_VALUE (func
);
7307 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7309 if (!SYMBOL_IS_ARGUMENT (sym
))
7316 insert_exception_resume_breakpoint (ecs
->event_thread
,
7322 CATCH (e
, RETURN_MASK_ERROR
)
7329 stop_waiting (struct execution_control_state
*ecs
)
7332 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_waiting\n");
7334 clear_step_over_info ();
7336 /* Let callers know we don't want to wait for the inferior anymore. */
7337 ecs
->wait_some_more
= 0;
7339 /* If all-stop, but the target is always in non-stop mode, stop all
7340 threads now that we're presenting the stop to the user. */
7341 if (!non_stop
&& target_is_non_stop_p ())
7342 stop_all_threads ();
7345 /* Like keep_going, but passes the signal to the inferior, even if the
7346 signal is set to nopass. */
7349 keep_going_pass_signal (struct execution_control_state
*ecs
)
7351 /* Make sure normal_stop is called if we get a QUIT handled before
7353 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
7355 gdb_assert (ptid_equal (ecs
->event_thread
->ptid
, inferior_ptid
));
7356 gdb_assert (!ecs
->event_thread
->resumed
);
7358 /* Save the pc before execution, to compare with pc after stop. */
7359 ecs
->event_thread
->prev_pc
7360 = regcache_read_pc (get_thread_regcache (ecs
->ptid
));
7362 if (ecs
->event_thread
->control
.trap_expected
)
7364 struct thread_info
*tp
= ecs
->event_thread
;
7367 fprintf_unfiltered (gdb_stdlog
,
7368 "infrun: %s has trap_expected set, "
7369 "resuming to collect trap\n",
7370 target_pid_to_str (tp
->ptid
));
7372 /* We haven't yet gotten our trap, and either: intercepted a
7373 non-signal event (e.g., a fork); or took a signal which we
7374 are supposed to pass through to the inferior. Simply
7376 discard_cleanups (old_cleanups
);
7377 resume (ecs
->event_thread
->suspend
.stop_signal
);
7379 else if (step_over_info_valid_p ())
7381 /* Another thread is stepping over a breakpoint in-line. If
7382 this thread needs a step-over too, queue the request. In
7383 either case, this resume must be deferred for later. */
7384 struct thread_info
*tp
= ecs
->event_thread
;
7386 if (ecs
->hit_singlestep_breakpoint
7387 || thread_still_needs_step_over (tp
))
7390 fprintf_unfiltered (gdb_stdlog
,
7391 "infrun: step-over already in progress: "
7392 "step-over for %s deferred\n",
7393 target_pid_to_str (tp
->ptid
));
7394 thread_step_over_chain_enqueue (tp
);
7399 fprintf_unfiltered (gdb_stdlog
,
7400 "infrun: step-over in progress: "
7401 "resume of %s deferred\n",
7402 target_pid_to_str (tp
->ptid
));
7405 discard_cleanups (old_cleanups
);
7409 struct regcache
*regcache
= get_current_regcache ();
7412 enum step_over_what step_what
;
7414 /* Either the trap was not expected, but we are continuing
7415 anyway (if we got a signal, the user asked it be passed to
7418 We got our expected trap, but decided we should resume from
7421 We're going to run this baby now!
7423 Note that insert_breakpoints won't try to re-insert
7424 already inserted breakpoints. Therefore, we don't
7425 care if breakpoints were already inserted, or not. */
7427 /* If we need to step over a breakpoint, and we're not using
7428 displaced stepping to do so, insert all breakpoints
7429 (watchpoints, etc.) but the one we're stepping over, step one
7430 instruction, and then re-insert the breakpoint when that step
7433 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
7435 remove_bp
= (ecs
->hit_singlestep_breakpoint
7436 || (step_what
& STEP_OVER_BREAKPOINT
));
7437 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
7439 /* We can't use displaced stepping if we need to step past a
7440 watchpoint. The instruction copied to the scratch pad would
7441 still trigger the watchpoint. */
7443 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
7445 set_step_over_info (get_regcache_aspace (regcache
),
7446 regcache_read_pc (regcache
), remove_wps
);
7448 else if (remove_wps
)
7449 set_step_over_info (NULL
, 0, remove_wps
);
7451 /* If we now need to do an in-line step-over, we need to stop
7452 all other threads. Note this must be done before
7453 insert_breakpoints below, because that removes the breakpoint
7454 we're about to step over, otherwise other threads could miss
7456 if (step_over_info_valid_p () && target_is_non_stop_p ())
7457 stop_all_threads ();
7459 /* Stop stepping if inserting breakpoints fails. */
7462 insert_breakpoints ();
7464 CATCH (e
, RETURN_MASK_ERROR
)
7466 exception_print (gdb_stderr
, e
);
7468 discard_cleanups (old_cleanups
);
7473 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
7475 discard_cleanups (old_cleanups
);
7476 resume (ecs
->event_thread
->suspend
.stop_signal
);
7479 prepare_to_wait (ecs
);
7482 /* Called when we should continue running the inferior, because the
7483 current event doesn't cause a user visible stop. This does the
7484 resuming part; waiting for the next event is done elsewhere. */
7487 keep_going (struct execution_control_state
*ecs
)
7489 if (ecs
->event_thread
->control
.trap_expected
7490 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
7491 ecs
->event_thread
->control
.trap_expected
= 0;
7493 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7494 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7495 keep_going_pass_signal (ecs
);
7498 /* This function normally comes after a resume, before
7499 handle_inferior_event exits. It takes care of any last bits of
7500 housekeeping, and sets the all-important wait_some_more flag. */
7503 prepare_to_wait (struct execution_control_state
*ecs
)
7506 fprintf_unfiltered (gdb_stdlog
, "infrun: prepare_to_wait\n");
7508 /* This is the old end of the while loop. Let everybody know we
7509 want to wait for the inferior some more and get called again
7511 ecs
->wait_some_more
= 1;
7514 /* We are done with the step range of a step/next/si/ni command.
7515 Called once for each n of a "step n" operation. */
7518 end_stepping_range (struct execution_control_state
*ecs
)
7520 ecs
->event_thread
->control
.stop_step
= 1;
7524 /* Several print_*_reason functions to print why the inferior has stopped.
7525 We always print something when the inferior exits, or receives a signal.
7526 The rest of the cases are dealt with later on in normal_stop and
7527 print_it_typical. Ideally there should be a call to one of these
7528 print_*_reason functions functions from handle_inferior_event each time
7529 stop_waiting is called.
7531 Note that we don't call these directly, instead we delegate that to
7532 the interpreters, through observers. Interpreters then call these
7533 with whatever uiout is right. */
7536 print_end_stepping_range_reason (struct ui_out
*uiout
)
7538 /* For CLI-like interpreters, print nothing. */
7540 if (ui_out_is_mi_like_p (uiout
))
7542 ui_out_field_string (uiout
, "reason",
7543 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
7548 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7550 annotate_signalled ();
7551 if (ui_out_is_mi_like_p (uiout
))
7553 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
7554 ui_out_text (uiout
, "\nProgram terminated with signal ");
7555 annotate_signal_name ();
7556 ui_out_field_string (uiout
, "signal-name",
7557 gdb_signal_to_name (siggnal
));
7558 annotate_signal_name_end ();
7559 ui_out_text (uiout
, ", ");
7560 annotate_signal_string ();
7561 ui_out_field_string (uiout
, "signal-meaning",
7562 gdb_signal_to_string (siggnal
));
7563 annotate_signal_string_end ();
7564 ui_out_text (uiout
, ".\n");
7565 ui_out_text (uiout
, "The program no longer exists.\n");
7569 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
7571 struct inferior
*inf
= current_inferior ();
7572 const char *pidstr
= target_pid_to_str (pid_to_ptid (inf
->pid
));
7574 annotate_exited (exitstatus
);
7577 if (ui_out_is_mi_like_p (uiout
))
7578 ui_out_field_string (uiout
, "reason",
7579 async_reason_lookup (EXEC_ASYNC_EXITED
));
7580 ui_out_text (uiout
, "[Inferior ");
7581 ui_out_text (uiout
, plongest (inf
->num
));
7582 ui_out_text (uiout
, " (");
7583 ui_out_text (uiout
, pidstr
);
7584 ui_out_text (uiout
, ") exited with code ");
7585 ui_out_field_fmt (uiout
, "exit-code", "0%o", (unsigned int) exitstatus
);
7586 ui_out_text (uiout
, "]\n");
7590 if (ui_out_is_mi_like_p (uiout
))
7592 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
7593 ui_out_text (uiout
, "[Inferior ");
7594 ui_out_text (uiout
, plongest (inf
->num
));
7595 ui_out_text (uiout
, " (");
7596 ui_out_text (uiout
, pidstr
);
7597 ui_out_text (uiout
, ") exited normally]\n");
7602 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7606 if (siggnal
== GDB_SIGNAL_0
&& !ui_out_is_mi_like_p (uiout
))
7608 struct thread_info
*t
= inferior_thread ();
7610 ui_out_text (uiout
, "\n[");
7611 ui_out_field_string (uiout
, "thread-name",
7612 target_pid_to_str (t
->ptid
));
7613 ui_out_field_fmt (uiout
, "thread-id", "] #%d", t
->num
);
7614 ui_out_text (uiout
, " stopped");
7618 ui_out_text (uiout
, "\nProgram received signal ");
7619 annotate_signal_name ();
7620 if (ui_out_is_mi_like_p (uiout
))
7622 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
7623 ui_out_field_string (uiout
, "signal-name",
7624 gdb_signal_to_name (siggnal
));
7625 annotate_signal_name_end ();
7626 ui_out_text (uiout
, ", ");
7627 annotate_signal_string ();
7628 ui_out_field_string (uiout
, "signal-meaning",
7629 gdb_signal_to_string (siggnal
));
7630 annotate_signal_string_end ();
7632 ui_out_text (uiout
, ".\n");
7636 print_no_history_reason (struct ui_out
*uiout
)
7638 ui_out_text (uiout
, "\nNo more reverse-execution history.\n");
7641 /* Print current location without a level number, if we have changed
7642 functions or hit a breakpoint. Print source line if we have one.
7643 bpstat_print contains the logic deciding in detail what to print,
7644 based on the event(s) that just occurred. */
7647 print_stop_event (struct target_waitstatus
*ws
)
7650 enum print_what source_flag
;
7651 int do_frame_printing
= 1;
7652 struct thread_info
*tp
= inferior_thread ();
7654 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
7658 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
7659 should) carry around the function and does (or should) use
7660 that when doing a frame comparison. */
7661 if (tp
->control
.stop_step
7662 && frame_id_eq (tp
->control
.step_frame_id
,
7663 get_frame_id (get_current_frame ()))
7664 && tp
->control
.step_start_function
== find_pc_function (stop_pc
))
7666 /* Finished step, just print source line. */
7667 source_flag
= SRC_LINE
;
7671 /* Print location and source line. */
7672 source_flag
= SRC_AND_LOC
;
7675 case PRINT_SRC_AND_LOC
:
7676 /* Print location and source line. */
7677 source_flag
= SRC_AND_LOC
;
7679 case PRINT_SRC_ONLY
:
7680 source_flag
= SRC_LINE
;
7683 /* Something bogus. */
7684 source_flag
= SRC_LINE
;
7685 do_frame_printing
= 0;
7688 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
7691 /* The behavior of this routine with respect to the source
7693 SRC_LINE: Print only source line
7694 LOCATION: Print only location
7695 SRC_AND_LOC: Print location and source line. */
7696 if (do_frame_printing
)
7697 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
7699 /* Display the auto-display expressions. */
7703 /* Here to return control to GDB when the inferior stops for real.
7704 Print appropriate messages, remove breakpoints, give terminal our modes.
7706 STOP_PRINT_FRAME nonzero means print the executing frame
7707 (pc, function, args, file, line number and line text).
7708 BREAKPOINTS_FAILED nonzero means stop was due to error
7709 attempting to insert breakpoints. */
7714 struct target_waitstatus last
;
7716 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
7719 get_last_target_status (&last_ptid
, &last
);
7721 /* If an exception is thrown from this point on, make sure to
7722 propagate GDB's knowledge of the executing state to the
7723 frontend/user running state. A QUIT is an easy exception to see
7724 here, so do this before any filtered output. */
7726 make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
7727 else if (last
.kind
== TARGET_WAITKIND_SIGNALLED
7728 || last
.kind
== TARGET_WAITKIND_EXITED
)
7730 /* On some targets, we may still have live threads in the
7731 inferior when we get a process exit event. E.g., for
7732 "checkpoint", when the current checkpoint/fork exits,
7733 linux-fork.c automatically switches to another fork from
7734 within target_mourn_inferior. */
7735 if (!ptid_equal (inferior_ptid
, null_ptid
))
7737 pid_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
7738 make_cleanup (finish_thread_state_cleanup
, &pid_ptid
);
7741 else if (last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
7742 make_cleanup (finish_thread_state_cleanup
, &inferior_ptid
);
7744 /* As we're presenting a stop, and potentially removing breakpoints,
7745 update the thread list so we can tell whether there are threads
7746 running on the target. With target remote, for example, we can
7747 only learn about new threads when we explicitly update the thread
7748 list. Do this before notifying the interpreters about signal
7749 stops, end of stepping ranges, etc., so that the "new thread"
7750 output is emitted before e.g., "Program received signal FOO",
7751 instead of after. */
7752 update_thread_list ();
7754 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
7755 observer_notify_signal_received (inferior_thread ()->suspend
.stop_signal
);
7757 /* As with the notification of thread events, we want to delay
7758 notifying the user that we've switched thread context until
7759 the inferior actually stops.
7761 There's no point in saying anything if the inferior has exited.
7762 Note that SIGNALLED here means "exited with a signal", not
7763 "received a signal".
7765 Also skip saying anything in non-stop mode. In that mode, as we
7766 don't want GDB to switch threads behind the user's back, to avoid
7767 races where the user is typing a command to apply to thread x,
7768 but GDB switches to thread y before the user finishes entering
7769 the command, fetch_inferior_event installs a cleanup to restore
7770 the current thread back to the thread the user had selected right
7771 after this event is handled, so we're not really switching, only
7772 informing of a stop. */
7774 && !ptid_equal (previous_inferior_ptid
, inferior_ptid
)
7775 && target_has_execution
7776 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
7777 && last
.kind
!= TARGET_WAITKIND_EXITED
7778 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
7780 target_terminal_ours_for_output ();
7781 printf_filtered (_("[Switching to %s]\n"),
7782 target_pid_to_str (inferior_ptid
));
7783 annotate_thread_changed ();
7784 previous_inferior_ptid
= inferior_ptid
;
7787 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
7789 gdb_assert (sync_execution
|| !target_can_async_p ());
7791 target_terminal_ours_for_output ();
7792 printf_filtered (_("No unwaited-for children left.\n"));
7795 /* Note: this depends on the update_thread_list call above. */
7796 if (!breakpoints_should_be_inserted_now () && target_has_execution
)
7798 if (remove_breakpoints ())
7800 target_terminal_ours_for_output ();
7801 printf_filtered (_("Cannot remove breakpoints because "
7802 "program is no longer writable.\nFurther "
7803 "execution is probably impossible.\n"));
7807 /* If an auto-display called a function and that got a signal,
7808 delete that auto-display to avoid an infinite recursion. */
7810 if (stopped_by_random_signal
)
7811 disable_current_display ();
7813 /* Notify observers if we finished a "step"-like command, etc. */
7814 if (target_has_execution
7815 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
7816 && last
.kind
!= TARGET_WAITKIND_EXITED
7817 && inferior_thread ()->control
.stop_step
)
7819 /* But not if in the middle of doing a "step n" operation for
7821 if (inferior_thread ()->step_multi
)
7824 observer_notify_end_stepping_range ();
7827 target_terminal_ours ();
7828 async_enable_stdin ();
7830 /* Set the current source location. This will also happen if we
7831 display the frame below, but the current SAL will be incorrect
7832 during a user hook-stop function. */
7833 if (has_stack_frames () && !stop_stack_dummy
)
7834 set_current_sal_from_frame (get_current_frame ());
7836 /* Let the user/frontend see the threads as stopped, but defer to
7837 call_function_by_hand if the thread finished an infcall
7838 successfully. We may be e.g., evaluating a breakpoint condition.
7839 In that case, the thread had state THREAD_RUNNING before the
7840 infcall, and shall remain marked running, all without informing
7841 the user/frontend about state transition changes. */
7842 if (target_has_execution
7843 && inferior_thread ()->control
.in_infcall
7844 && stop_stack_dummy
== STOP_STACK_DUMMY
)
7845 discard_cleanups (old_chain
);
7847 do_cleanups (old_chain
);
7849 /* Look up the hook_stop and run it (CLI internally handles problem
7850 of stop_command's pre-hook not existing). */
7852 catch_errors (hook_stop_stub
, stop_command
,
7853 "Error while running hook_stop:\n", RETURN_MASK_ALL
);
7855 if (!has_stack_frames ())
7858 if (last
.kind
== TARGET_WAITKIND_SIGNALLED
7859 || last
.kind
== TARGET_WAITKIND_EXITED
)
7862 /* Select innermost stack frame - i.e., current frame is frame 0,
7863 and current location is based on that.
7864 Don't do this on return from a stack dummy routine,
7865 or if the program has exited. */
7867 if (!stop_stack_dummy
)
7869 select_frame (get_current_frame ());
7871 /* If --batch-silent is enabled then there's no need to print the current
7872 source location, and to try risks causing an error message about
7873 missing source files. */
7874 if (stop_print_frame
&& !batch_silent
)
7875 print_stop_event (&last
);
7878 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
7880 /* Pop the empty frame that contains the stack dummy.
7881 This also restores inferior state prior to the call
7882 (struct infcall_suspend_state). */
7883 struct frame_info
*frame
= get_current_frame ();
7885 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
7887 /* frame_pop() calls reinit_frame_cache as the last thing it
7888 does which means there's currently no selected frame. We
7889 don't need to re-establish a selected frame if the dummy call
7890 returns normally, that will be done by
7891 restore_infcall_control_state. However, we do have to handle
7892 the case where the dummy call is returning after being
7893 stopped (e.g. the dummy call previously hit a breakpoint).
7894 We can't know which case we have so just always re-establish
7895 a selected frame here. */
7896 select_frame (get_current_frame ());
7900 annotate_stopped ();
7902 /* Suppress the stop observer if we're in the middle of:
7904 - a step n (n > 1), as there still more steps to be done.
7906 - a "finish" command, as the observer will be called in
7907 finish_command_continuation, so it can include the inferior
7908 function's return value.
7910 - calling an inferior function, as we pretend we inferior didn't
7911 run at all. The return value of the call is handled by the
7912 expression evaluator, through call_function_by_hand. */
7914 if (!target_has_execution
7915 || last
.kind
== TARGET_WAITKIND_SIGNALLED
7916 || last
.kind
== TARGET_WAITKIND_EXITED
7917 || last
.kind
== TARGET_WAITKIND_NO_RESUMED
7918 || (!(inferior_thread ()->step_multi
7919 && inferior_thread ()->control
.stop_step
)
7920 && !(inferior_thread ()->control
.stop_bpstat
7921 && inferior_thread ()->control
.proceed_to_finish
)
7922 && !inferior_thread ()->control
.in_infcall
))
7924 if (!ptid_equal (inferior_ptid
, null_ptid
))
7925 observer_notify_normal_stop (inferior_thread ()->control
.stop_bpstat
,
7928 observer_notify_normal_stop (NULL
, stop_print_frame
);
7931 if (target_has_execution
)
7933 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
7934 && last
.kind
!= TARGET_WAITKIND_EXITED
)
7935 /* Delete the breakpoint we stopped at, if it wants to be deleted.
7936 Delete any breakpoint that is to be deleted at the next stop. */
7937 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
7940 /* Try to get rid of automatically added inferiors that are no
7941 longer needed. Keeping those around slows down things linearly.
7942 Note that this never removes the current inferior. */
7947 hook_stop_stub (void *cmd
)
7949 execute_cmd_pre_hook ((struct cmd_list_element
*) cmd
);
7954 signal_stop_state (int signo
)
7956 return signal_stop
[signo
];
7960 signal_print_state (int signo
)
7962 return signal_print
[signo
];
7966 signal_pass_state (int signo
)
7968 return signal_program
[signo
];
7972 signal_cache_update (int signo
)
7976 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
7977 signal_cache_update (signo
);
7982 signal_pass
[signo
] = (signal_stop
[signo
] == 0
7983 && signal_print
[signo
] == 0
7984 && signal_program
[signo
] == 1
7985 && signal_catch
[signo
] == 0);
7989 signal_stop_update (int signo
, int state
)
7991 int ret
= signal_stop
[signo
];
7993 signal_stop
[signo
] = state
;
7994 signal_cache_update (signo
);
7999 signal_print_update (int signo
, int state
)
8001 int ret
= signal_print
[signo
];
8003 signal_print
[signo
] = state
;
8004 signal_cache_update (signo
);
8009 signal_pass_update (int signo
, int state
)
8011 int ret
= signal_program
[signo
];
8013 signal_program
[signo
] = state
;
8014 signal_cache_update (signo
);
8018 /* Update the global 'signal_catch' from INFO and notify the
8022 signal_catch_update (const unsigned int *info
)
8026 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8027 signal_catch
[i
] = info
[i
] > 0;
8028 signal_cache_update (-1);
8029 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
8033 sig_print_header (void)
8035 printf_filtered (_("Signal Stop\tPrint\tPass "
8036 "to program\tDescription\n"));
8040 sig_print_info (enum gdb_signal oursig
)
8042 const char *name
= gdb_signal_to_name (oursig
);
8043 int name_padding
= 13 - strlen (name
);
8045 if (name_padding
<= 0)
8048 printf_filtered ("%s", name
);
8049 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8050 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8051 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8052 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8053 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8056 /* Specify how various signals in the inferior should be handled. */
8059 handle_command (char *args
, int from_tty
)
8062 int digits
, wordlen
;
8063 int sigfirst
, signum
, siglast
;
8064 enum gdb_signal oursig
;
8067 unsigned char *sigs
;
8068 struct cleanup
*old_chain
;
8072 error_no_arg (_("signal to handle"));
8075 /* Allocate and zero an array of flags for which signals to handle. */
8077 nsigs
= (int) GDB_SIGNAL_LAST
;
8078 sigs
= (unsigned char *) alloca (nsigs
);
8079 memset (sigs
, 0, nsigs
);
8081 /* Break the command line up into args. */
8083 argv
= gdb_buildargv (args
);
8084 old_chain
= make_cleanup_freeargv (argv
);
8086 /* Walk through the args, looking for signal oursigs, signal names, and
8087 actions. Signal numbers and signal names may be interspersed with
8088 actions, with the actions being performed for all signals cumulatively
8089 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8091 while (*argv
!= NULL
)
8093 wordlen
= strlen (*argv
);
8094 for (digits
= 0; isdigit ((*argv
)[digits
]); digits
++)
8098 sigfirst
= siglast
= -1;
8100 if (wordlen
>= 1 && !strncmp (*argv
, "all", wordlen
))
8102 /* Apply action to all signals except those used by the
8103 debugger. Silently skip those. */
8106 siglast
= nsigs
- 1;
8108 else if (wordlen
>= 1 && !strncmp (*argv
, "stop", wordlen
))
8110 SET_SIGS (nsigs
, sigs
, signal_stop
);
8111 SET_SIGS (nsigs
, sigs
, signal_print
);
8113 else if (wordlen
>= 1 && !strncmp (*argv
, "ignore", wordlen
))
8115 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8117 else if (wordlen
>= 2 && !strncmp (*argv
, "print", wordlen
))
8119 SET_SIGS (nsigs
, sigs
, signal_print
);
8121 else if (wordlen
>= 2 && !strncmp (*argv
, "pass", wordlen
))
8123 SET_SIGS (nsigs
, sigs
, signal_program
);
8125 else if (wordlen
>= 3 && !strncmp (*argv
, "nostop", wordlen
))
8127 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8129 else if (wordlen
>= 3 && !strncmp (*argv
, "noignore", wordlen
))
8131 SET_SIGS (nsigs
, sigs
, signal_program
);
8133 else if (wordlen
>= 4 && !strncmp (*argv
, "noprint", wordlen
))
8135 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8136 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8138 else if (wordlen
>= 4 && !strncmp (*argv
, "nopass", wordlen
))
8140 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8142 else if (digits
> 0)
8144 /* It is numeric. The numeric signal refers to our own
8145 internal signal numbering from target.h, not to host/target
8146 signal number. This is a feature; users really should be
8147 using symbolic names anyway, and the common ones like
8148 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8150 sigfirst
= siglast
= (int)
8151 gdb_signal_from_command (atoi (*argv
));
8152 if ((*argv
)[digits
] == '-')
8155 gdb_signal_from_command (atoi ((*argv
) + digits
+ 1));
8157 if (sigfirst
> siglast
)
8159 /* Bet he didn't figure we'd think of this case... */
8167 oursig
= gdb_signal_from_name (*argv
);
8168 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8170 sigfirst
= siglast
= (int) oursig
;
8174 /* Not a number and not a recognized flag word => complain. */
8175 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv
);
8179 /* If any signal numbers or symbol names were found, set flags for
8180 which signals to apply actions to. */
8182 for (signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8184 switch ((enum gdb_signal
) signum
)
8186 case GDB_SIGNAL_TRAP
:
8187 case GDB_SIGNAL_INT
:
8188 if (!allsigs
&& !sigs
[signum
])
8190 if (query (_("%s is used by the debugger.\n\
8191 Are you sure you want to change it? "),
8192 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8198 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8199 gdb_flush (gdb_stdout
);
8204 case GDB_SIGNAL_DEFAULT
:
8205 case GDB_SIGNAL_UNKNOWN
:
8206 /* Make sure that "all" doesn't print these. */
8217 for (signum
= 0; signum
< nsigs
; signum
++)
8220 signal_cache_update (-1);
8221 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
8222 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
8226 /* Show the results. */
8227 sig_print_header ();
8228 for (; signum
< nsigs
; signum
++)
8230 sig_print_info ((enum gdb_signal
) signum
);
8236 do_cleanups (old_chain
);
8239 /* Complete the "handle" command. */
8241 static VEC (char_ptr
) *
8242 handle_completer (struct cmd_list_element
*ignore
,
8243 const char *text
, const char *word
)
8245 VEC (char_ptr
) *vec_signals
, *vec_keywords
, *return_val
;
8246 static const char * const keywords
[] =
8260 vec_signals
= signal_completer (ignore
, text
, word
);
8261 vec_keywords
= complete_on_enum (keywords
, word
, word
);
8263 return_val
= VEC_merge (char_ptr
, vec_signals
, vec_keywords
);
8264 VEC_free (char_ptr
, vec_signals
);
8265 VEC_free (char_ptr
, vec_keywords
);
8270 gdb_signal_from_command (int num
)
8272 if (num
>= 1 && num
<= 15)
8273 return (enum gdb_signal
) num
;
8274 error (_("Only signals 1-15 are valid as numeric signals.\n\
8275 Use \"info signals\" for a list of symbolic signals."));
8278 /* Print current contents of the tables set by the handle command.
8279 It is possible we should just be printing signals actually used
8280 by the current target (but for things to work right when switching
8281 targets, all signals should be in the signal tables). */
8284 signals_info (char *signum_exp
, int from_tty
)
8286 enum gdb_signal oursig
;
8288 sig_print_header ();
8292 /* First see if this is a symbol name. */
8293 oursig
= gdb_signal_from_name (signum_exp
);
8294 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8296 /* No, try numeric. */
8298 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8300 sig_print_info (oursig
);
8304 printf_filtered ("\n");
8305 /* These ugly casts brought to you by the native VAX compiler. */
8306 for (oursig
= GDB_SIGNAL_FIRST
;
8307 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8308 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8312 if (oursig
!= GDB_SIGNAL_UNKNOWN
8313 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8314 sig_print_info (oursig
);
8317 printf_filtered (_("\nUse the \"handle\" command "
8318 "to change these tables.\n"));
8321 /* Check if it makes sense to read $_siginfo from the current thread
8322 at this point. If not, throw an error. */
8325 validate_siginfo_access (void)
8327 /* No current inferior, no siginfo. */
8328 if (ptid_equal (inferior_ptid
, null_ptid
))
8329 error (_("No thread selected."));
8331 /* Don't try to read from a dead thread. */
8332 if (is_exited (inferior_ptid
))
8333 error (_("The current thread has terminated"));
8335 /* ... or from a spinning thread. */
8336 if (is_running (inferior_ptid
))
8337 error (_("Selected thread is running."));
8340 /* The $_siginfo convenience variable is a bit special. We don't know
8341 for sure the type of the value until we actually have a chance to
8342 fetch the data. The type can change depending on gdbarch, so it is
8343 also dependent on which thread you have selected.
8345 1. making $_siginfo be an internalvar that creates a new value on
8348 2. making the value of $_siginfo be an lval_computed value. */
8350 /* This function implements the lval_computed support for reading a
8354 siginfo_value_read (struct value
*v
)
8356 LONGEST transferred
;
8358 validate_siginfo_access ();
8361 target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
,
8363 value_contents_all_raw (v
),
8365 TYPE_LENGTH (value_type (v
)));
8367 if (transferred
!= TYPE_LENGTH (value_type (v
)))
8368 error (_("Unable to read siginfo"));
8371 /* This function implements the lval_computed support for writing a
8375 siginfo_value_write (struct value
*v
, struct value
*fromval
)
8377 LONGEST transferred
;
8379 validate_siginfo_access ();
8381 transferred
= target_write (¤t_target
,
8382 TARGET_OBJECT_SIGNAL_INFO
,
8384 value_contents_all_raw (fromval
),
8386 TYPE_LENGTH (value_type (fromval
)));
8388 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
8389 error (_("Unable to write siginfo"));
8392 static const struct lval_funcs siginfo_value_funcs
=
8398 /* Return a new value with the correct type for the siginfo object of
8399 the current thread using architecture GDBARCH. Return a void value
8400 if there's no object available. */
8402 static struct value
*
8403 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
8406 if (target_has_stack
8407 && !ptid_equal (inferior_ptid
, null_ptid
)
8408 && gdbarch_get_siginfo_type_p (gdbarch
))
8410 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8412 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
8415 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
8419 /* infcall_suspend_state contains state about the program itself like its
8420 registers and any signal it received when it last stopped.
8421 This state must be restored regardless of how the inferior function call
8422 ends (either successfully, or after it hits a breakpoint or signal)
8423 if the program is to properly continue where it left off. */
8425 struct infcall_suspend_state
8427 struct thread_suspend_state thread_suspend
;
8431 struct regcache
*registers
;
8433 /* Format of SIGINFO_DATA or NULL if it is not present. */
8434 struct gdbarch
*siginfo_gdbarch
;
8436 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8437 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8438 content would be invalid. */
8439 gdb_byte
*siginfo_data
;
8442 struct infcall_suspend_state
*
8443 save_infcall_suspend_state (void)
8445 struct infcall_suspend_state
*inf_state
;
8446 struct thread_info
*tp
= inferior_thread ();
8447 struct regcache
*regcache
= get_current_regcache ();
8448 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
8449 gdb_byte
*siginfo_data
= NULL
;
8451 if (gdbarch_get_siginfo_type_p (gdbarch
))
8453 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8454 size_t len
= TYPE_LENGTH (type
);
8455 struct cleanup
*back_to
;
8457 siginfo_data
= xmalloc (len
);
8458 back_to
= make_cleanup (xfree
, siginfo_data
);
8460 if (target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8461 siginfo_data
, 0, len
) == len
)
8462 discard_cleanups (back_to
);
8465 /* Errors ignored. */
8466 do_cleanups (back_to
);
8467 siginfo_data
= NULL
;
8471 inf_state
= XCNEW (struct infcall_suspend_state
);
8475 inf_state
->siginfo_gdbarch
= gdbarch
;
8476 inf_state
->siginfo_data
= siginfo_data
;
8479 inf_state
->thread_suspend
= tp
->suspend
;
8481 /* run_inferior_call will not use the signal due to its `proceed' call with
8482 GDB_SIGNAL_0 anyway. */
8483 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
8485 inf_state
->stop_pc
= stop_pc
;
8487 inf_state
->registers
= regcache_dup (regcache
);
8492 /* Restore inferior session state to INF_STATE. */
8495 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8497 struct thread_info
*tp
= inferior_thread ();
8498 struct regcache
*regcache
= get_current_regcache ();
8499 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
8501 tp
->suspend
= inf_state
->thread_suspend
;
8503 stop_pc
= inf_state
->stop_pc
;
8505 if (inf_state
->siginfo_gdbarch
== gdbarch
)
8507 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8509 /* Errors ignored. */
8510 target_write (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8511 inf_state
->siginfo_data
, 0, TYPE_LENGTH (type
));
8514 /* The inferior can be gone if the user types "print exit(0)"
8515 (and perhaps other times). */
8516 if (target_has_execution
)
8517 /* NB: The register write goes through to the target. */
8518 regcache_cpy (regcache
, inf_state
->registers
);
8520 discard_infcall_suspend_state (inf_state
);
8524 do_restore_infcall_suspend_state_cleanup (void *state
)
8526 restore_infcall_suspend_state (state
);
8530 make_cleanup_restore_infcall_suspend_state
8531 (struct infcall_suspend_state
*inf_state
)
8533 return make_cleanup (do_restore_infcall_suspend_state_cleanup
, inf_state
);
8537 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8539 regcache_xfree (inf_state
->registers
);
8540 xfree (inf_state
->siginfo_data
);
8545 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
8547 return inf_state
->registers
;
8550 /* infcall_control_state contains state regarding gdb's control of the
8551 inferior itself like stepping control. It also contains session state like
8552 the user's currently selected frame. */
8554 struct infcall_control_state
8556 struct thread_control_state thread_control
;
8557 struct inferior_control_state inferior_control
;
8560 enum stop_stack_kind stop_stack_dummy
;
8561 int stopped_by_random_signal
;
8562 int stop_after_trap
;
8564 /* ID if the selected frame when the inferior function call was made. */
8565 struct frame_id selected_frame_id
;
8568 /* Save all of the information associated with the inferior<==>gdb
8571 struct infcall_control_state
*
8572 save_infcall_control_state (void)
8574 struct infcall_control_state
*inf_status
= xmalloc (sizeof (*inf_status
));
8575 struct thread_info
*tp
= inferior_thread ();
8576 struct inferior
*inf
= current_inferior ();
8578 inf_status
->thread_control
= tp
->control
;
8579 inf_status
->inferior_control
= inf
->control
;
8581 tp
->control
.step_resume_breakpoint
= NULL
;
8582 tp
->control
.exception_resume_breakpoint
= NULL
;
8584 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8585 chain. If caller's caller is walking the chain, they'll be happier if we
8586 hand them back the original chain when restore_infcall_control_state is
8588 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
8591 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
8592 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
8593 inf_status
->stop_after_trap
= stop_after_trap
;
8595 inf_status
->selected_frame_id
= get_frame_id (get_selected_frame (NULL
));
8601 restore_selected_frame (void *args
)
8603 struct frame_id
*fid
= (struct frame_id
*) args
;
8604 struct frame_info
*frame
;
8606 frame
= frame_find_by_id (*fid
);
8608 /* If inf_status->selected_frame_id is NULL, there was no previously
8612 warning (_("Unable to restore previously selected frame."));
8616 select_frame (frame
);
8621 /* Restore inferior session state to INF_STATUS. */
8624 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
8626 struct thread_info
*tp
= inferior_thread ();
8627 struct inferior
*inf
= current_inferior ();
8629 if (tp
->control
.step_resume_breakpoint
)
8630 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
8632 if (tp
->control
.exception_resume_breakpoint
)
8633 tp
->control
.exception_resume_breakpoint
->disposition
8634 = disp_del_at_next_stop
;
8636 /* Handle the bpstat_copy of the chain. */
8637 bpstat_clear (&tp
->control
.stop_bpstat
);
8639 tp
->control
= inf_status
->thread_control
;
8640 inf
->control
= inf_status
->inferior_control
;
8643 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
8644 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
8645 stop_after_trap
= inf_status
->stop_after_trap
;
8647 if (target_has_stack
)
8649 /* The point of catch_errors is that if the stack is clobbered,
8650 walking the stack might encounter a garbage pointer and
8651 error() trying to dereference it. */
8653 (restore_selected_frame
, &inf_status
->selected_frame_id
,
8654 "Unable to restore previously selected frame:\n",
8655 RETURN_MASK_ERROR
) == 0)
8656 /* Error in restoring the selected frame. Select the innermost
8658 select_frame (get_current_frame ());
8665 do_restore_infcall_control_state_cleanup (void *sts
)
8667 restore_infcall_control_state (sts
);
8671 make_cleanup_restore_infcall_control_state
8672 (struct infcall_control_state
*inf_status
)
8674 return make_cleanup (do_restore_infcall_control_state_cleanup
, inf_status
);
8678 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
8680 if (inf_status
->thread_control
.step_resume_breakpoint
)
8681 inf_status
->thread_control
.step_resume_breakpoint
->disposition
8682 = disp_del_at_next_stop
;
8684 if (inf_status
->thread_control
.exception_resume_breakpoint
)
8685 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
8686 = disp_del_at_next_stop
;
8688 /* See save_infcall_control_state for info on stop_bpstat. */
8689 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
8694 /* restore_inferior_ptid() will be used by the cleanup machinery
8695 to restore the inferior_ptid value saved in a call to
8696 save_inferior_ptid(). */
8699 restore_inferior_ptid (void *arg
)
8701 ptid_t
*saved_ptid_ptr
= arg
;
8703 inferior_ptid
= *saved_ptid_ptr
;
8707 /* Save the value of inferior_ptid so that it may be restored by a
8708 later call to do_cleanups(). Returns the struct cleanup pointer
8709 needed for later doing the cleanup. */
8712 save_inferior_ptid (void)
8714 ptid_t
*saved_ptid_ptr
;
8716 saved_ptid_ptr
= xmalloc (sizeof (ptid_t
));
8717 *saved_ptid_ptr
= inferior_ptid
;
8718 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
8724 clear_exit_convenience_vars (void)
8726 clear_internalvar (lookup_internalvar ("_exitsignal"));
8727 clear_internalvar (lookup_internalvar ("_exitcode"));
8731 /* User interface for reverse debugging:
8732 Set exec-direction / show exec-direction commands
8733 (returns error unless target implements to_set_exec_direction method). */
8735 int execution_direction
= EXEC_FORWARD
;
8736 static const char exec_forward
[] = "forward";
8737 static const char exec_reverse
[] = "reverse";
8738 static const char *exec_direction
= exec_forward
;
8739 static const char *const exec_direction_names
[] = {
8746 set_exec_direction_func (char *args
, int from_tty
,
8747 struct cmd_list_element
*cmd
)
8749 if (target_can_execute_reverse
)
8751 if (!strcmp (exec_direction
, exec_forward
))
8752 execution_direction
= EXEC_FORWARD
;
8753 else if (!strcmp (exec_direction
, exec_reverse
))
8754 execution_direction
= EXEC_REVERSE
;
8758 exec_direction
= exec_forward
;
8759 error (_("Target does not support this operation."));
8764 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
8765 struct cmd_list_element
*cmd
, const char *value
)
8767 switch (execution_direction
) {
8769 fprintf_filtered (out
, _("Forward.\n"));
8772 fprintf_filtered (out
, _("Reverse.\n"));
8775 internal_error (__FILE__
, __LINE__
,
8776 _("bogus execution_direction value: %d"),
8777 (int) execution_direction
);
8782 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
8783 struct cmd_list_element
*c
, const char *value
)
8785 fprintf_filtered (file
, _("Resuming the execution of threads "
8786 "of all processes is %s.\n"), value
);
8789 /* Implementation of `siginfo' variable. */
8791 static const struct internalvar_funcs siginfo_funcs
=
8798 /* Callback for infrun's target events source. This is marked when a
8799 thread has a pending status to process. */
8802 infrun_async_inferior_event_handler (gdb_client_data data
)
8804 /* If the target is closed while this event source is marked, we
8805 will reach here without execution, or a target to call
8806 target_wait on, which is an error. Instead of tracking whether
8807 the target has been popped already, or whether we do have threads
8808 with pending statutes, simply ignore the event. */
8809 if (!target_is_async_p ())
8812 inferior_event_handler (INF_REG_EVENT
, NULL
);
8816 _initialize_infrun (void)
8820 struct cmd_list_element
*c
;
8822 /* Register extra event sources in the event loop. */
8823 infrun_async_inferior_event_token
8824 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
);
8826 add_info ("signals", signals_info
, _("\
8827 What debugger does when program gets various signals.\n\
8828 Specify a signal as argument to print info on that signal only."));
8829 add_info_alias ("handle", "signals", 0);
8831 c
= add_com ("handle", class_run
, handle_command
, _("\
8832 Specify how to handle signals.\n\
8833 Usage: handle SIGNAL [ACTIONS]\n\
8834 Args are signals and actions to apply to those signals.\n\
8835 If no actions are specified, the current settings for the specified signals\n\
8836 will be displayed instead.\n\
8838 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
8839 from 1-15 are allowed for compatibility with old versions of GDB.\n\
8840 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
8841 The special arg \"all\" is recognized to mean all signals except those\n\
8842 used by the debugger, typically SIGTRAP and SIGINT.\n\
8844 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
8845 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
8846 Stop means reenter debugger if this signal happens (implies print).\n\
8847 Print means print a message if this signal happens.\n\
8848 Pass means let program see this signal; otherwise program doesn't know.\n\
8849 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
8850 Pass and Stop may be combined.\n\
8852 Multiple signals may be specified. Signal numbers and signal names\n\
8853 may be interspersed with actions, with the actions being performed for\n\
8854 all signals cumulatively specified."));
8855 set_cmd_completer (c
, handle_completer
);
8858 stop_command
= add_cmd ("stop", class_obscure
,
8859 not_just_help_class_command
, _("\
8860 There is no `stop' command, but you can set a hook on `stop'.\n\
8861 This allows you to set a list of commands to be run each time execution\n\
8862 of the program stops."), &cmdlist
);
8864 add_setshow_zuinteger_cmd ("infrun", class_maintenance
, &debug_infrun
, _("\
8865 Set inferior debugging."), _("\
8866 Show inferior debugging."), _("\
8867 When non-zero, inferior specific debugging is enabled."),
8870 &setdebuglist
, &showdebuglist
);
8872 add_setshow_boolean_cmd ("displaced", class_maintenance
,
8873 &debug_displaced
, _("\
8874 Set displaced stepping debugging."), _("\
8875 Show displaced stepping debugging."), _("\
8876 When non-zero, displaced stepping specific debugging is enabled."),
8878 show_debug_displaced
,
8879 &setdebuglist
, &showdebuglist
);
8881 add_setshow_boolean_cmd ("non-stop", no_class
,
8883 Set whether gdb controls the inferior in non-stop mode."), _("\
8884 Show whether gdb controls the inferior in non-stop mode."), _("\
8885 When debugging a multi-threaded program and this setting is\n\
8886 off (the default, also called all-stop mode), when one thread stops\n\
8887 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
8888 all other threads in the program while you interact with the thread of\n\
8889 interest. When you continue or step a thread, you can allow the other\n\
8890 threads to run, or have them remain stopped, but while you inspect any\n\
8891 thread's state, all threads stop.\n\
8893 In non-stop mode, when one thread stops, other threads can continue\n\
8894 to run freely. You'll be able to step each thread independently,\n\
8895 leave it stopped or free to run as needed."),
8901 numsigs
= (int) GDB_SIGNAL_LAST
;
8902 signal_stop
= (unsigned char *) xmalloc (sizeof (signal_stop
[0]) * numsigs
);
8903 signal_print
= (unsigned char *)
8904 xmalloc (sizeof (signal_print
[0]) * numsigs
);
8905 signal_program
= (unsigned char *)
8906 xmalloc (sizeof (signal_program
[0]) * numsigs
);
8907 signal_catch
= (unsigned char *)
8908 xmalloc (sizeof (signal_catch
[0]) * numsigs
);
8909 signal_pass
= (unsigned char *)
8910 xmalloc (sizeof (signal_pass
[0]) * numsigs
);
8911 for (i
= 0; i
< numsigs
; i
++)
8914 signal_print
[i
] = 1;
8915 signal_program
[i
] = 1;
8916 signal_catch
[i
] = 0;
8919 /* Signals caused by debugger's own actions should not be given to
8920 the program afterwards.
8922 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
8923 explicitly specifies that it should be delivered to the target
8924 program. Typically, that would occur when a user is debugging a
8925 target monitor on a simulator: the target monitor sets a
8926 breakpoint; the simulator encounters this breakpoint and halts
8927 the simulation handing control to GDB; GDB, noting that the stop
8928 address doesn't map to any known breakpoint, returns control back
8929 to the simulator; the simulator then delivers the hardware
8930 equivalent of a GDB_SIGNAL_TRAP to the program being
8932 signal_program
[GDB_SIGNAL_TRAP
] = 0;
8933 signal_program
[GDB_SIGNAL_INT
] = 0;
8935 /* Signals that are not errors should not normally enter the debugger. */
8936 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
8937 signal_print
[GDB_SIGNAL_ALRM
] = 0;
8938 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
8939 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
8940 signal_stop
[GDB_SIGNAL_PROF
] = 0;
8941 signal_print
[GDB_SIGNAL_PROF
] = 0;
8942 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
8943 signal_print
[GDB_SIGNAL_CHLD
] = 0;
8944 signal_stop
[GDB_SIGNAL_IO
] = 0;
8945 signal_print
[GDB_SIGNAL_IO
] = 0;
8946 signal_stop
[GDB_SIGNAL_POLL
] = 0;
8947 signal_print
[GDB_SIGNAL_POLL
] = 0;
8948 signal_stop
[GDB_SIGNAL_URG
] = 0;
8949 signal_print
[GDB_SIGNAL_URG
] = 0;
8950 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
8951 signal_print
[GDB_SIGNAL_WINCH
] = 0;
8952 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
8953 signal_print
[GDB_SIGNAL_PRIO
] = 0;
8955 /* These signals are used internally by user-level thread
8956 implementations. (See signal(5) on Solaris.) Like the above
8957 signals, a healthy program receives and handles them as part of
8958 its normal operation. */
8959 signal_stop
[GDB_SIGNAL_LWP
] = 0;
8960 signal_print
[GDB_SIGNAL_LWP
] = 0;
8961 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
8962 signal_print
[GDB_SIGNAL_WAITING
] = 0;
8963 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
8964 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
8966 /* Update cached state. */
8967 signal_cache_update (-1);
8969 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
8970 &stop_on_solib_events
, _("\
8971 Set stopping for shared library events."), _("\
8972 Show stopping for shared library events."), _("\
8973 If nonzero, gdb will give control to the user when the dynamic linker\n\
8974 notifies gdb of shared library events. The most common event of interest\n\
8975 to the user would be loading/unloading of a new library."),
8976 set_stop_on_solib_events
,
8977 show_stop_on_solib_events
,
8978 &setlist
, &showlist
);
8980 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
8981 follow_fork_mode_kind_names
,
8982 &follow_fork_mode_string
, _("\
8983 Set debugger response to a program call of fork or vfork."), _("\
8984 Show debugger response to a program call of fork or vfork."), _("\
8985 A fork or vfork creates a new process. follow-fork-mode can be:\n\
8986 parent - the original process is debugged after a fork\n\
8987 child - the new process is debugged after a fork\n\
8988 The unfollowed process will continue to run.\n\
8989 By default, the debugger will follow the parent process."),
8991 show_follow_fork_mode_string
,
8992 &setlist
, &showlist
);
8994 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
8995 follow_exec_mode_names
,
8996 &follow_exec_mode_string
, _("\
8997 Set debugger response to a program call of exec."), _("\
8998 Show debugger response to a program call of exec."), _("\
8999 An exec call replaces the program image of a process.\n\
9001 follow-exec-mode can be:\n\
9003 new - the debugger creates a new inferior and rebinds the process\n\
9004 to this new inferior. The program the process was running before\n\
9005 the exec call can be restarted afterwards by restarting the original\n\
9008 same - the debugger keeps the process bound to the same inferior.\n\
9009 The new executable image replaces the previous executable loaded in\n\
9010 the inferior. Restarting the inferior after the exec call restarts\n\
9011 the executable the process was running after the exec call.\n\
9013 By default, the debugger will use the same inferior."),
9015 show_follow_exec_mode_string
,
9016 &setlist
, &showlist
);
9018 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9019 scheduler_enums
, &scheduler_mode
, _("\
9020 Set mode for locking scheduler during execution."), _("\
9021 Show mode for locking scheduler during execution."), _("\
9022 off == no locking (threads may preempt at any time)\n\
9023 on == full locking (no thread except the current thread may run)\n\
9024 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9025 In this mode, other threads may run during other commands."),
9026 set_schedlock_func
, /* traps on target vector */
9027 show_scheduler_mode
,
9028 &setlist
, &showlist
);
9030 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9031 Set mode for resuming threads of all processes."), _("\
9032 Show mode for resuming threads of all processes."), _("\
9033 When on, execution commands (such as 'continue' or 'next') resume all\n\
9034 threads of all processes. When off (which is the default), execution\n\
9035 commands only resume the threads of the current process. The set of\n\
9036 threads that are resumed is further refined by the scheduler-locking\n\
9037 mode (see help set scheduler-locking)."),
9039 show_schedule_multiple
,
9040 &setlist
, &showlist
);
9042 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9043 Set mode of the step operation."), _("\
9044 Show mode of the step operation."), _("\
9045 When set, doing a step over a function without debug line information\n\
9046 will stop at the first instruction of that function. Otherwise, the\n\
9047 function is skipped and the step command stops at a different source line."),
9049 show_step_stop_if_no_debug
,
9050 &setlist
, &showlist
);
9052 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9053 &can_use_displaced_stepping
, _("\
9054 Set debugger's willingness to use displaced stepping."), _("\
9055 Show debugger's willingness to use displaced stepping."), _("\
9056 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9057 supported by the target architecture. If off, gdb will not use displaced\n\
9058 stepping to step over breakpoints, even if such is supported by the target\n\
9059 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9060 if the target architecture supports it and non-stop mode is active, but will not\n\
9061 use it in all-stop mode (see help set non-stop)."),
9063 show_can_use_displaced_stepping
,
9064 &setlist
, &showlist
);
9066 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9067 &exec_direction
, _("Set direction of execution.\n\
9068 Options are 'forward' or 'reverse'."),
9069 _("Show direction of execution (forward/reverse)."),
9070 _("Tells gdb whether to execute forward or backward."),
9071 set_exec_direction_func
, show_exec_direction_func
,
9072 &setlist
, &showlist
);
9074 /* Set/show detach-on-fork: user-settable mode. */
9076 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9077 Set whether gdb will detach the child of a fork."), _("\
9078 Show whether gdb will detach the child of a fork."), _("\
9079 Tells gdb whether to detach the child of a fork."),
9080 NULL
, NULL
, &setlist
, &showlist
);
9082 /* Set/show disable address space randomization mode. */
9084 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9085 &disable_randomization
, _("\
9086 Set disabling of debuggee's virtual address space randomization."), _("\
9087 Show disabling of debuggee's virtual address space randomization."), _("\
9088 When this mode is on (which is the default), randomization of the virtual\n\
9089 address space is disabled. Standalone programs run with the randomization\n\
9090 enabled by default on some platforms."),
9091 &set_disable_randomization
,
9092 &show_disable_randomization
,
9093 &setlist
, &showlist
);
9095 /* ptid initializations */
9096 inferior_ptid
= null_ptid
;
9097 target_last_wait_ptid
= minus_one_ptid
;
9099 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed
);
9100 observer_attach_thread_stop_requested (infrun_thread_stop_requested
);
9101 observer_attach_thread_exit (infrun_thread_thread_exit
);
9102 observer_attach_inferior_exit (infrun_inferior_exit
);
9104 /* Explicitly create without lookup, since that tries to create a
9105 value with a void typed value, and when we get here, gdbarch
9106 isn't initialized yet. At this point, we're quite sure there
9107 isn't another convenience variable of the same name. */
9108 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9110 add_setshow_boolean_cmd ("observer", no_class
,
9111 &observer_mode_1
, _("\
9112 Set whether gdb controls the inferior in observer mode."), _("\
9113 Show whether gdb controls the inferior in observer mode."), _("\
9114 In observer mode, GDB can get data from the inferior, but not\n\
9115 affect its execution. Registers and memory may not be changed,\n\
9116 breakpoints may not be set, and the program cannot be interrupted\n\