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"
65 #include "thread-fsm.h"
67 /* Prototypes for local functions */
69 static void signals_info (char *, int);
71 static void handle_command (char *, int);
73 static void sig_print_info (enum gdb_signal
);
75 static void sig_print_header (void);
77 static void resume_cleanups (void *);
79 static int hook_stop_stub (void *);
81 static int restore_selected_frame (void *);
83 static int follow_fork (void);
85 static int follow_fork_inferior (int follow_child
, int detach_fork
);
87 static void follow_inferior_reset_breakpoints (void);
89 static void set_schedlock_func (char *args
, int from_tty
,
90 struct cmd_list_element
*c
);
92 static int currently_stepping (struct thread_info
*tp
);
94 void _initialize_infrun (void);
96 void nullify_last_target_wait_ptid (void);
98 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
100 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
102 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
104 static int maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
);
106 /* Asynchronous signal handler registered as event loop source for
107 when we have pending events ready to be passed to the core. */
108 static struct async_event_handler
*infrun_async_inferior_event_token
;
110 /* Stores whether infrun_async was previously enabled or disabled.
111 Starts off as -1, indicating "never enabled/disabled". */
112 static int infrun_is_async
= -1;
117 infrun_async (int enable
)
119 if (infrun_is_async
!= enable
)
121 infrun_is_async
= enable
;
124 fprintf_unfiltered (gdb_stdlog
,
125 "infrun: infrun_async(%d)\n",
129 mark_async_event_handler (infrun_async_inferior_event_token
);
131 clear_async_event_handler (infrun_async_inferior_event_token
);
138 mark_infrun_async_event_handler (void)
140 mark_async_event_handler (infrun_async_inferior_event_token
);
143 /* When set, stop the 'step' command if we enter a function which has
144 no line number information. The normal behavior is that we step
145 over such function. */
146 int step_stop_if_no_debug
= 0;
148 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
149 struct cmd_list_element
*c
, const char *value
)
151 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
154 /* In asynchronous mode, but simulating synchronous execution. */
156 int sync_execution
= 0;
158 /* proceed and normal_stop use this to notify the user when the
159 inferior stopped in a different thread than it had been running
162 static ptid_t previous_inferior_ptid
;
164 /* If set (default for legacy reasons), when following a fork, GDB
165 will detach from one of the fork branches, child or parent.
166 Exactly which branch is detached depends on 'set follow-fork-mode'
169 static int detach_fork
= 1;
171 int debug_displaced
= 0;
173 show_debug_displaced (struct ui_file
*file
, int from_tty
,
174 struct cmd_list_element
*c
, const char *value
)
176 fprintf_filtered (file
, _("Displace stepping debugging is %s.\n"), value
);
179 unsigned int debug_infrun
= 0;
181 show_debug_infrun (struct ui_file
*file
, int from_tty
,
182 struct cmd_list_element
*c
, const char *value
)
184 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
188 /* Support for disabling address space randomization. */
190 int disable_randomization
= 1;
193 show_disable_randomization (struct ui_file
*file
, int from_tty
,
194 struct cmd_list_element
*c
, const char *value
)
196 if (target_supports_disable_randomization ())
197 fprintf_filtered (file
,
198 _("Disabling randomization of debuggee's "
199 "virtual address space is %s.\n"),
202 fputs_filtered (_("Disabling randomization of debuggee's "
203 "virtual address space is unsupported on\n"
204 "this platform.\n"), file
);
208 set_disable_randomization (char *args
, int from_tty
,
209 struct cmd_list_element
*c
)
211 if (!target_supports_disable_randomization ())
212 error (_("Disabling randomization of debuggee's "
213 "virtual address space is unsupported on\n"
217 /* User interface for non-stop mode. */
220 static int non_stop_1
= 0;
223 set_non_stop (char *args
, int from_tty
,
224 struct cmd_list_element
*c
)
226 if (target_has_execution
)
228 non_stop_1
= non_stop
;
229 error (_("Cannot change this setting while the inferior is running."));
232 non_stop
= non_stop_1
;
236 show_non_stop (struct ui_file
*file
, int from_tty
,
237 struct cmd_list_element
*c
, const char *value
)
239 fprintf_filtered (file
,
240 _("Controlling the inferior in non-stop mode is %s.\n"),
244 /* "Observer mode" is somewhat like a more extreme version of
245 non-stop, in which all GDB operations that might affect the
246 target's execution have been disabled. */
248 int observer_mode
= 0;
249 static int observer_mode_1
= 0;
252 set_observer_mode (char *args
, int from_tty
,
253 struct cmd_list_element
*c
)
255 if (target_has_execution
)
257 observer_mode_1
= observer_mode
;
258 error (_("Cannot change this setting while the inferior is running."));
261 observer_mode
= observer_mode_1
;
263 may_write_registers
= !observer_mode
;
264 may_write_memory
= !observer_mode
;
265 may_insert_breakpoints
= !observer_mode
;
266 may_insert_tracepoints
= !observer_mode
;
267 /* We can insert fast tracepoints in or out of observer mode,
268 but enable them if we're going into this mode. */
270 may_insert_fast_tracepoints
= 1;
271 may_stop
= !observer_mode
;
272 update_target_permissions ();
274 /* Going *into* observer mode we must force non-stop, then
275 going out we leave it that way. */
278 pagination_enabled
= 0;
279 non_stop
= non_stop_1
= 1;
283 printf_filtered (_("Observer mode is now %s.\n"),
284 (observer_mode
? "on" : "off"));
288 show_observer_mode (struct ui_file
*file
, int from_tty
,
289 struct cmd_list_element
*c
, const char *value
)
291 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
294 /* This updates the value of observer mode based on changes in
295 permissions. Note that we are deliberately ignoring the values of
296 may-write-registers and may-write-memory, since the user may have
297 reason to enable these during a session, for instance to turn on a
298 debugging-related global. */
301 update_observer_mode (void)
305 newval
= (!may_insert_breakpoints
306 && !may_insert_tracepoints
307 && may_insert_fast_tracepoints
311 /* Let the user know if things change. */
312 if (newval
!= observer_mode
)
313 printf_filtered (_("Observer mode is now %s.\n"),
314 (newval
? "on" : "off"));
316 observer_mode
= observer_mode_1
= newval
;
319 /* Tables of how to react to signals; the user sets them. */
321 static unsigned char *signal_stop
;
322 static unsigned char *signal_print
;
323 static unsigned char *signal_program
;
325 /* Table of signals that are registered with "catch signal". A
326 non-zero entry indicates that the signal is caught by some "catch
327 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
329 static unsigned char *signal_catch
;
331 /* Table of signals that the target may silently handle.
332 This is automatically determined from the flags above,
333 and simply cached here. */
334 static unsigned char *signal_pass
;
336 #define SET_SIGS(nsigs,sigs,flags) \
338 int signum = (nsigs); \
339 while (signum-- > 0) \
340 if ((sigs)[signum]) \
341 (flags)[signum] = 1; \
344 #define UNSET_SIGS(nsigs,sigs,flags) \
346 int signum = (nsigs); \
347 while (signum-- > 0) \
348 if ((sigs)[signum]) \
349 (flags)[signum] = 0; \
352 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
353 this function is to avoid exporting `signal_program'. */
356 update_signals_program_target (void)
358 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
361 /* Value to pass to target_resume() to cause all threads to resume. */
363 #define RESUME_ALL minus_one_ptid
365 /* Command list pointer for the "stop" placeholder. */
367 static struct cmd_list_element
*stop_command
;
369 /* Nonzero if we want to give control to the user when we're notified
370 of shared library events by the dynamic linker. */
371 int stop_on_solib_events
;
373 /* Enable or disable optional shared library event breakpoints
374 as appropriate when the above flag is changed. */
377 set_stop_on_solib_events (char *args
, int from_tty
, struct cmd_list_element
*c
)
379 update_solib_breakpoints ();
383 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
384 struct cmd_list_element
*c
, const char *value
)
386 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
390 /* Nonzero means expecting a trace trap
391 and should stop the inferior and return silently when it happens. */
395 /* Nonzero after stop if current stack frame should be printed. */
397 static int stop_print_frame
;
399 /* This is a cached copy of the pid/waitstatus of the last event
400 returned by target_wait()/deprecated_target_wait_hook(). This
401 information is returned by get_last_target_status(). */
402 static ptid_t target_last_wait_ptid
;
403 static struct target_waitstatus target_last_waitstatus
;
405 static void context_switch (ptid_t ptid
);
407 void init_thread_stepping_state (struct thread_info
*tss
);
409 static const char follow_fork_mode_child
[] = "child";
410 static const char follow_fork_mode_parent
[] = "parent";
412 static const char *const follow_fork_mode_kind_names
[] = {
413 follow_fork_mode_child
,
414 follow_fork_mode_parent
,
418 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
420 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
421 struct cmd_list_element
*c
, const char *value
)
423 fprintf_filtered (file
,
424 _("Debugger response to a program "
425 "call of fork or vfork is \"%s\".\n"),
430 /* Handle changes to the inferior list based on the type of fork,
431 which process is being followed, and whether the other process
432 should be detached. On entry inferior_ptid must be the ptid of
433 the fork parent. At return inferior_ptid is the ptid of the
434 followed inferior. */
437 follow_fork_inferior (int follow_child
, int detach_fork
)
440 ptid_t parent_ptid
, child_ptid
;
442 has_vforked
= (inferior_thread ()->pending_follow
.kind
443 == TARGET_WAITKIND_VFORKED
);
444 parent_ptid
= inferior_ptid
;
445 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
448 && !non_stop
/* Non-stop always resumes both branches. */
449 && (!target_is_async_p () || sync_execution
)
450 && !(follow_child
|| detach_fork
|| sched_multi
))
452 /* The parent stays blocked inside the vfork syscall until the
453 child execs or exits. If we don't let the child run, then
454 the parent stays blocked. If we're telling the parent to run
455 in the foreground, the user will not be able to ctrl-c to get
456 back the terminal, effectively hanging the debug session. */
457 fprintf_filtered (gdb_stderr
, _("\
458 Can not resume the parent process over vfork in the foreground while\n\
459 holding the child stopped. Try \"set detach-on-fork\" or \
460 \"set schedule-multiple\".\n"));
461 /* FIXME output string > 80 columns. */
467 /* Detach new forked process? */
470 struct cleanup
*old_chain
;
472 /* Before detaching from the child, remove all breakpoints
473 from it. If we forked, then this has already been taken
474 care of by infrun.c. If we vforked however, any
475 breakpoint inserted in the parent is visible in the
476 child, even those added while stopped in a vfork
477 catchpoint. This will remove the breakpoints from the
478 parent also, but they'll be reinserted below. */
481 /* Keep breakpoints list in sync. */
482 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
485 if (info_verbose
|| debug_infrun
)
487 /* Ensure that we have a process ptid. */
488 ptid_t process_ptid
= pid_to_ptid (ptid_get_pid (child_ptid
));
490 target_terminal_ours_for_output ();
491 fprintf_filtered (gdb_stdlog
,
492 _("Detaching after %s from child %s.\n"),
493 has_vforked
? "vfork" : "fork",
494 target_pid_to_str (process_ptid
));
499 struct inferior
*parent_inf
, *child_inf
;
500 struct cleanup
*old_chain
;
502 /* Add process to GDB's tables. */
503 child_inf
= add_inferior (ptid_get_pid (child_ptid
));
505 parent_inf
= current_inferior ();
506 child_inf
->attach_flag
= parent_inf
->attach_flag
;
507 copy_terminal_info (child_inf
, parent_inf
);
508 child_inf
->gdbarch
= parent_inf
->gdbarch
;
509 copy_inferior_target_desc_info (child_inf
, parent_inf
);
511 old_chain
= save_inferior_ptid ();
512 save_current_program_space ();
514 inferior_ptid
= child_ptid
;
515 add_thread (inferior_ptid
);
516 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
518 /* If this is a vfork child, then the address-space is
519 shared with the parent. */
522 child_inf
->pspace
= parent_inf
->pspace
;
523 child_inf
->aspace
= parent_inf
->aspace
;
525 /* The parent will be frozen until the child is done
526 with the shared region. Keep track of the
528 child_inf
->vfork_parent
= parent_inf
;
529 child_inf
->pending_detach
= 0;
530 parent_inf
->vfork_child
= child_inf
;
531 parent_inf
->pending_detach
= 0;
535 child_inf
->aspace
= new_address_space ();
536 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
537 child_inf
->removable
= 1;
538 set_current_program_space (child_inf
->pspace
);
539 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
541 /* Let the shared library layer (e.g., solib-svr4) learn
542 about this new process, relocate the cloned exec, pull
543 in shared libraries, and install the solib event
544 breakpoint. If a "cloned-VM" event was propagated
545 better throughout the core, this wouldn't be
547 solib_create_inferior_hook (0);
550 do_cleanups (old_chain
);
555 struct inferior
*parent_inf
;
557 parent_inf
= current_inferior ();
559 /* If we detached from the child, then we have to be careful
560 to not insert breakpoints in the parent until the child
561 is done with the shared memory region. However, if we're
562 staying attached to the child, then we can and should
563 insert breakpoints, so that we can debug it. A
564 subsequent child exec or exit is enough to know when does
565 the child stops using the parent's address space. */
566 parent_inf
->waiting_for_vfork_done
= detach_fork
;
567 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
572 /* Follow the child. */
573 struct inferior
*parent_inf
, *child_inf
;
574 struct program_space
*parent_pspace
;
576 if (info_verbose
|| debug_infrun
)
578 target_terminal_ours_for_output ();
579 fprintf_filtered (gdb_stdlog
,
580 _("Attaching after %s %s to child %s.\n"),
581 target_pid_to_str (parent_ptid
),
582 has_vforked
? "vfork" : "fork",
583 target_pid_to_str (child_ptid
));
586 /* Add the new inferior first, so that the target_detach below
587 doesn't unpush the target. */
589 child_inf
= add_inferior (ptid_get_pid (child_ptid
));
591 parent_inf
= current_inferior ();
592 child_inf
->attach_flag
= parent_inf
->attach_flag
;
593 copy_terminal_info (child_inf
, parent_inf
);
594 child_inf
->gdbarch
= parent_inf
->gdbarch
;
595 copy_inferior_target_desc_info (child_inf
, parent_inf
);
597 parent_pspace
= parent_inf
->pspace
;
599 /* If we're vforking, we want to hold on to the parent until the
600 child exits or execs. At child exec or exit time we can
601 remove the old breakpoints from the parent and detach or
602 resume debugging it. Otherwise, detach the parent now; we'll
603 want to reuse it's program/address spaces, but we can't set
604 them to the child before removing breakpoints from the
605 parent, otherwise, the breakpoints module could decide to
606 remove breakpoints from the wrong process (since they'd be
607 assigned to the same address space). */
611 gdb_assert (child_inf
->vfork_parent
== NULL
);
612 gdb_assert (parent_inf
->vfork_child
== NULL
);
613 child_inf
->vfork_parent
= parent_inf
;
614 child_inf
->pending_detach
= 0;
615 parent_inf
->vfork_child
= child_inf
;
616 parent_inf
->pending_detach
= detach_fork
;
617 parent_inf
->waiting_for_vfork_done
= 0;
619 else if (detach_fork
)
621 if (info_verbose
|| debug_infrun
)
623 /* Ensure that we have a process ptid. */
624 ptid_t process_ptid
= pid_to_ptid (ptid_get_pid (child_ptid
));
626 target_terminal_ours_for_output ();
627 fprintf_filtered (gdb_stdlog
,
628 _("Detaching after fork from "
630 target_pid_to_str (process_ptid
));
633 target_detach (NULL
, 0);
636 /* Note that the detach above makes PARENT_INF dangling. */
638 /* Add the child thread to the appropriate lists, and switch to
639 this new thread, before cloning the program space, and
640 informing the solib layer about this new process. */
642 inferior_ptid
= child_ptid
;
643 add_thread (inferior_ptid
);
645 /* If this is a vfork child, then the address-space is shared
646 with the parent. If we detached from the parent, then we can
647 reuse the parent's program/address spaces. */
648 if (has_vforked
|| detach_fork
)
650 child_inf
->pspace
= parent_pspace
;
651 child_inf
->aspace
= child_inf
->pspace
->aspace
;
655 child_inf
->aspace
= new_address_space ();
656 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
657 child_inf
->removable
= 1;
658 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
659 set_current_program_space (child_inf
->pspace
);
660 clone_program_space (child_inf
->pspace
, parent_pspace
);
662 /* Let the shared library layer (e.g., solib-svr4) learn
663 about this new process, relocate the cloned exec, pull in
664 shared libraries, and install the solib event breakpoint.
665 If a "cloned-VM" event was propagated better throughout
666 the core, this wouldn't be required. */
667 solib_create_inferior_hook (0);
671 return target_follow_fork (follow_child
, detach_fork
);
674 /* Tell the target to follow the fork we're stopped at. Returns true
675 if the inferior should be resumed; false, if the target for some
676 reason decided it's best not to resume. */
681 int follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
682 int should_resume
= 1;
683 struct thread_info
*tp
;
685 /* Copy user stepping state to the new inferior thread. FIXME: the
686 followed fork child thread should have a copy of most of the
687 parent thread structure's run control related fields, not just these.
688 Initialized to avoid "may be used uninitialized" warnings from gcc. */
689 struct breakpoint
*step_resume_breakpoint
= NULL
;
690 struct breakpoint
*exception_resume_breakpoint
= NULL
;
691 CORE_ADDR step_range_start
= 0;
692 CORE_ADDR step_range_end
= 0;
693 struct frame_id step_frame_id
= { 0 };
694 struct interp
*command_interp
= NULL
;
699 struct target_waitstatus wait_status
;
701 /* Get the last target status returned by target_wait(). */
702 get_last_target_status (&wait_ptid
, &wait_status
);
704 /* If not stopped at a fork event, then there's nothing else to
706 if (wait_status
.kind
!= TARGET_WAITKIND_FORKED
707 && wait_status
.kind
!= TARGET_WAITKIND_VFORKED
)
710 /* Check if we switched over from WAIT_PTID, since the event was
712 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
713 && !ptid_equal (inferior_ptid
, wait_ptid
))
715 /* We did. Switch back to WAIT_PTID thread, to tell the
716 target to follow it (in either direction). We'll
717 afterwards refuse to resume, and inform the user what
719 switch_to_thread (wait_ptid
);
724 tp
= inferior_thread ();
726 /* If there were any forks/vforks that were caught and are now to be
727 followed, then do so now. */
728 switch (tp
->pending_follow
.kind
)
730 case TARGET_WAITKIND_FORKED
:
731 case TARGET_WAITKIND_VFORKED
:
733 ptid_t parent
, child
;
735 /* If the user did a next/step, etc, over a fork call,
736 preserve the stepping state in the fork child. */
737 if (follow_child
&& should_resume
)
739 step_resume_breakpoint
= clone_momentary_breakpoint
740 (tp
->control
.step_resume_breakpoint
);
741 step_range_start
= tp
->control
.step_range_start
;
742 step_range_end
= tp
->control
.step_range_end
;
743 step_frame_id
= tp
->control
.step_frame_id
;
744 exception_resume_breakpoint
745 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
746 command_interp
= tp
->control
.command_interp
;
748 /* For now, delete the parent's sr breakpoint, otherwise,
749 parent/child sr breakpoints are considered duplicates,
750 and the child version will not be installed. Remove
751 this when the breakpoints module becomes aware of
752 inferiors and address spaces. */
753 delete_step_resume_breakpoint (tp
);
754 tp
->control
.step_range_start
= 0;
755 tp
->control
.step_range_end
= 0;
756 tp
->control
.step_frame_id
= null_frame_id
;
757 delete_exception_resume_breakpoint (tp
);
758 tp
->control
.command_interp
= NULL
;
761 parent
= inferior_ptid
;
762 child
= tp
->pending_follow
.value
.related_pid
;
764 /* Set up inferior(s) as specified by the caller, and tell the
765 target to do whatever is necessary to follow either parent
767 if (follow_fork_inferior (follow_child
, detach_fork
))
769 /* Target refused to follow, or there's some other reason
770 we shouldn't resume. */
775 /* This pending follow fork event is now handled, one way
776 or another. The previous selected thread may be gone
777 from the lists by now, but if it is still around, need
778 to clear the pending follow request. */
779 tp
= find_thread_ptid (parent
);
781 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
783 /* This makes sure we don't try to apply the "Switched
784 over from WAIT_PID" logic above. */
785 nullify_last_target_wait_ptid ();
787 /* If we followed the child, switch to it... */
790 switch_to_thread (child
);
792 /* ... and preserve the stepping state, in case the
793 user was stepping over the fork call. */
796 tp
= inferior_thread ();
797 tp
->control
.step_resume_breakpoint
798 = step_resume_breakpoint
;
799 tp
->control
.step_range_start
= step_range_start
;
800 tp
->control
.step_range_end
= step_range_end
;
801 tp
->control
.step_frame_id
= step_frame_id
;
802 tp
->control
.exception_resume_breakpoint
803 = exception_resume_breakpoint
;
804 tp
->control
.command_interp
= command_interp
;
808 /* If we get here, it was because we're trying to
809 resume from a fork catchpoint, but, the user
810 has switched threads away from the thread that
811 forked. In that case, the resume command
812 issued is most likely not applicable to the
813 child, so just warn, and refuse to resume. */
814 warning (_("Not resuming: switched threads "
815 "before following fork child."));
818 /* Reset breakpoints in the child as appropriate. */
819 follow_inferior_reset_breakpoints ();
822 switch_to_thread (parent
);
826 case TARGET_WAITKIND_SPURIOUS
:
827 /* Nothing to follow. */
830 internal_error (__FILE__
, __LINE__
,
831 "Unexpected pending_follow.kind %d\n",
832 tp
->pending_follow
.kind
);
836 return should_resume
;
840 follow_inferior_reset_breakpoints (void)
842 struct thread_info
*tp
= inferior_thread ();
844 /* Was there a step_resume breakpoint? (There was if the user
845 did a "next" at the fork() call.) If so, explicitly reset its
846 thread number. Cloned step_resume breakpoints are disabled on
847 creation, so enable it here now that it is associated with the
850 step_resumes are a form of bp that are made to be per-thread.
851 Since we created the step_resume bp when the parent process
852 was being debugged, and now are switching to the child process,
853 from the breakpoint package's viewpoint, that's a switch of
854 "threads". We must update the bp's notion of which thread
855 it is for, or it'll be ignored when it triggers. */
857 if (tp
->control
.step_resume_breakpoint
)
859 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
860 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
863 /* Treat exception_resume breakpoints like step_resume breakpoints. */
864 if (tp
->control
.exception_resume_breakpoint
)
866 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
867 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
870 /* Reinsert all breakpoints in the child. The user may have set
871 breakpoints after catching the fork, in which case those
872 were never set in the child, but only in the parent. This makes
873 sure the inserted breakpoints match the breakpoint list. */
875 breakpoint_re_set ();
876 insert_breakpoints ();
879 /* The child has exited or execed: resume threads of the parent the
880 user wanted to be executing. */
883 proceed_after_vfork_done (struct thread_info
*thread
,
886 int pid
= * (int *) arg
;
888 if (ptid_get_pid (thread
->ptid
) == pid
889 && is_running (thread
->ptid
)
890 && !is_executing (thread
->ptid
)
891 && !thread
->stop_requested
892 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
895 fprintf_unfiltered (gdb_stdlog
,
896 "infrun: resuming vfork parent thread %s\n",
897 target_pid_to_str (thread
->ptid
));
899 switch_to_thread (thread
->ptid
);
900 clear_proceed_status (0);
901 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
907 /* Called whenever we notice an exec or exit event, to handle
908 detaching or resuming a vfork parent. */
911 handle_vfork_child_exec_or_exit (int exec
)
913 struct inferior
*inf
= current_inferior ();
915 if (inf
->vfork_parent
)
917 int resume_parent
= -1;
919 /* This exec or exit marks the end of the shared memory region
920 between the parent and the child. If the user wanted to
921 detach from the parent, now is the time. */
923 if (inf
->vfork_parent
->pending_detach
)
925 struct thread_info
*tp
;
926 struct cleanup
*old_chain
;
927 struct program_space
*pspace
;
928 struct address_space
*aspace
;
930 /* follow-fork child, detach-on-fork on. */
932 inf
->vfork_parent
->pending_detach
= 0;
936 /* If we're handling a child exit, then inferior_ptid
937 points at the inferior's pid, not to a thread. */
938 old_chain
= save_inferior_ptid ();
939 save_current_program_space ();
940 save_current_inferior ();
943 old_chain
= save_current_space_and_thread ();
945 /* We're letting loose of the parent. */
946 tp
= any_live_thread_of_process (inf
->vfork_parent
->pid
);
947 switch_to_thread (tp
->ptid
);
949 /* We're about to detach from the parent, which implicitly
950 removes breakpoints from its address space. There's a
951 catch here: we want to reuse the spaces for the child,
952 but, parent/child are still sharing the pspace at this
953 point, although the exec in reality makes the kernel give
954 the child a fresh set of new pages. The problem here is
955 that the breakpoints module being unaware of this, would
956 likely chose the child process to write to the parent
957 address space. Swapping the child temporarily away from
958 the spaces has the desired effect. Yes, this is "sort
961 pspace
= inf
->pspace
;
962 aspace
= inf
->aspace
;
966 if (debug_infrun
|| info_verbose
)
968 target_terminal_ours_for_output ();
972 fprintf_filtered (gdb_stdlog
,
973 _("Detaching vfork parent process "
974 "%d after child exec.\n"),
975 inf
->vfork_parent
->pid
);
979 fprintf_filtered (gdb_stdlog
,
980 _("Detaching vfork parent process "
981 "%d after child exit.\n"),
982 inf
->vfork_parent
->pid
);
986 target_detach (NULL
, 0);
989 inf
->pspace
= pspace
;
990 inf
->aspace
= aspace
;
992 do_cleanups (old_chain
);
996 /* We're staying attached to the parent, so, really give the
997 child a new address space. */
998 inf
->pspace
= add_program_space (maybe_new_address_space ());
999 inf
->aspace
= inf
->pspace
->aspace
;
1001 set_current_program_space (inf
->pspace
);
1003 resume_parent
= inf
->vfork_parent
->pid
;
1005 /* Break the bonds. */
1006 inf
->vfork_parent
->vfork_child
= NULL
;
1010 struct cleanup
*old_chain
;
1011 struct program_space
*pspace
;
1013 /* If this is a vfork child exiting, then the pspace and
1014 aspaces were shared with the parent. Since we're
1015 reporting the process exit, we'll be mourning all that is
1016 found in the address space, and switching to null_ptid,
1017 preparing to start a new inferior. But, since we don't
1018 want to clobber the parent's address/program spaces, we
1019 go ahead and create a new one for this exiting
1022 /* Switch to null_ptid, so that clone_program_space doesn't want
1023 to read the selected frame of a dead process. */
1024 old_chain
= save_inferior_ptid ();
1025 inferior_ptid
= null_ptid
;
1027 /* This inferior is dead, so avoid giving the breakpoints
1028 module the option to write through to it (cloning a
1029 program space resets breakpoints). */
1032 pspace
= add_program_space (maybe_new_address_space ());
1033 set_current_program_space (pspace
);
1035 inf
->symfile_flags
= SYMFILE_NO_READ
;
1036 clone_program_space (pspace
, inf
->vfork_parent
->pspace
);
1037 inf
->pspace
= pspace
;
1038 inf
->aspace
= pspace
->aspace
;
1040 /* Put back inferior_ptid. We'll continue mourning this
1042 do_cleanups (old_chain
);
1044 resume_parent
= inf
->vfork_parent
->pid
;
1045 /* Break the bonds. */
1046 inf
->vfork_parent
->vfork_child
= NULL
;
1049 inf
->vfork_parent
= NULL
;
1051 gdb_assert (current_program_space
== inf
->pspace
);
1053 if (non_stop
&& resume_parent
!= -1)
1055 /* If the user wanted the parent to be running, let it go
1057 struct cleanup
*old_chain
= make_cleanup_restore_current_thread ();
1060 fprintf_unfiltered (gdb_stdlog
,
1061 "infrun: resuming vfork parent process %d\n",
1064 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1066 do_cleanups (old_chain
);
1071 /* Enum strings for "set|show follow-exec-mode". */
1073 static const char follow_exec_mode_new
[] = "new";
1074 static const char follow_exec_mode_same
[] = "same";
1075 static const char *const follow_exec_mode_names
[] =
1077 follow_exec_mode_new
,
1078 follow_exec_mode_same
,
1082 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1084 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1085 struct cmd_list_element
*c
, const char *value
)
1087 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1090 /* EXECD_PATHNAME is assumed to be non-NULL. */
1093 follow_exec (ptid_t ptid
, char *execd_pathname
)
1095 struct thread_info
*th
, *tmp
;
1096 struct inferior
*inf
= current_inferior ();
1097 int pid
= ptid_get_pid (ptid
);
1099 /* This is an exec event that we actually wish to pay attention to.
1100 Refresh our symbol table to the newly exec'd program, remove any
1101 momentary bp's, etc.
1103 If there are breakpoints, they aren't really inserted now,
1104 since the exec() transformed our inferior into a fresh set
1107 We want to preserve symbolic breakpoints on the list, since
1108 we have hopes that they can be reset after the new a.out's
1109 symbol table is read.
1111 However, any "raw" breakpoints must be removed from the list
1112 (e.g., the solib bp's), since their address is probably invalid
1115 And, we DON'T want to call delete_breakpoints() here, since
1116 that may write the bp's "shadow contents" (the instruction
1117 value that was overwritten witha TRAP instruction). Since
1118 we now have a new a.out, those shadow contents aren't valid. */
1120 mark_breakpoints_out ();
1122 /* The target reports the exec event to the main thread, even if
1123 some other thread does the exec, and even if the main thread was
1124 stopped or already gone. We may still have non-leader threads of
1125 the process on our list. E.g., on targets that don't have thread
1126 exit events (like remote); or on native Linux in non-stop mode if
1127 there were only two threads in the inferior and the non-leader
1128 one is the one that execs (and nothing forces an update of the
1129 thread list up to here). When debugging remotely, it's best to
1130 avoid extra traffic, when possible, so avoid syncing the thread
1131 list with the target, and instead go ahead and delete all threads
1132 of the process but one that reported the event. Note this must
1133 be done before calling update_breakpoints_after_exec, as
1134 otherwise clearing the threads' resources would reference stale
1135 thread breakpoints -- it may have been one of these threads that
1136 stepped across the exec. We could just clear their stepping
1137 states, but as long as we're iterating, might as well delete
1138 them. Deleting them now rather than at the next user-visible
1139 stop provides a nicer sequence of events for user and MI
1141 ALL_THREADS_SAFE (th
, tmp
)
1142 if (ptid_get_pid (th
->ptid
) == pid
&& !ptid_equal (th
->ptid
, ptid
))
1143 delete_thread (th
->ptid
);
1145 /* We also need to clear any left over stale state for the
1146 leader/event thread. E.g., if there was any step-resume
1147 breakpoint or similar, it's gone now. We cannot truly
1148 step-to-next statement through an exec(). */
1149 th
= inferior_thread ();
1150 th
->control
.step_resume_breakpoint
= NULL
;
1151 th
->control
.exception_resume_breakpoint
= NULL
;
1152 th
->control
.single_step_breakpoints
= NULL
;
1153 th
->control
.step_range_start
= 0;
1154 th
->control
.step_range_end
= 0;
1156 /* The user may have had the main thread held stopped in the
1157 previous image (e.g., schedlock on, or non-stop). Release
1159 th
->stop_requested
= 0;
1161 update_breakpoints_after_exec ();
1163 /* What is this a.out's name? */
1164 printf_unfiltered (_("%s is executing new program: %s\n"),
1165 target_pid_to_str (inferior_ptid
),
1168 /* We've followed the inferior through an exec. Therefore, the
1169 inferior has essentially been killed & reborn. */
1171 gdb_flush (gdb_stdout
);
1173 breakpoint_init_inferior (inf_execd
);
1175 if (*gdb_sysroot
!= '\0')
1177 char *name
= exec_file_find (execd_pathname
, NULL
);
1179 execd_pathname
= alloca (strlen (name
) + 1);
1180 strcpy (execd_pathname
, name
);
1184 /* Reset the shared library package. This ensures that we get a
1185 shlib event when the child reaches "_start", at which point the
1186 dld will have had a chance to initialize the child. */
1187 /* Also, loading a symbol file below may trigger symbol lookups, and
1188 we don't want those to be satisfied by the libraries of the
1189 previous incarnation of this process. */
1190 no_shared_libraries (NULL
, 0);
1192 if (follow_exec_mode_string
== follow_exec_mode_new
)
1194 struct program_space
*pspace
;
1196 /* The user wants to keep the old inferior and program spaces
1197 around. Create a new fresh one, and switch to it. */
1199 /* Do exit processing for the original inferior before adding
1200 the new inferior so we don't have two active inferiors with
1201 the same ptid, which can confuse find_inferior_ptid. */
1202 exit_inferior_num_silent (current_inferior ()->num
);
1204 inf
= add_inferior (pid
);
1205 pspace
= add_program_space (maybe_new_address_space ());
1206 inf
->pspace
= pspace
;
1207 inf
->aspace
= pspace
->aspace
;
1210 set_current_inferior (inf
);
1211 set_current_program_space (pspace
);
1215 /* The old description may no longer be fit for the new image.
1216 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1217 old description; we'll read a new one below. No need to do
1218 this on "follow-exec-mode new", as the old inferior stays
1219 around (its description is later cleared/refetched on
1221 target_clear_description ();
1224 gdb_assert (current_program_space
== inf
->pspace
);
1226 /* That a.out is now the one to use. */
1227 exec_file_attach (execd_pathname
, 0);
1229 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1230 (Position Independent Executable) main symbol file will get applied by
1231 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1232 the breakpoints with the zero displacement. */
1234 symbol_file_add (execd_pathname
,
1236 | SYMFILE_MAINLINE
| SYMFILE_DEFER_BP_RESET
),
1239 if ((inf
->symfile_flags
& SYMFILE_NO_READ
) == 0)
1240 set_initial_language ();
1242 /* If the target can specify a description, read it. Must do this
1243 after flipping to the new executable (because the target supplied
1244 description must be compatible with the executable's
1245 architecture, and the old executable may e.g., be 32-bit, while
1246 the new one 64-bit), and before anything involving memory or
1248 target_find_description ();
1250 solib_create_inferior_hook (0);
1252 jit_inferior_created_hook ();
1254 breakpoint_re_set ();
1256 /* Reinsert all breakpoints. (Those which were symbolic have
1257 been reset to the proper address in the new a.out, thanks
1258 to symbol_file_command...). */
1259 insert_breakpoints ();
1261 /* The next resume of this inferior should bring it to the shlib
1262 startup breakpoints. (If the user had also set bp's on
1263 "main" from the old (parent) process, then they'll auto-
1264 matically get reset there in the new process.). */
1267 /* The queue of threads that need to do a step-over operation to get
1268 past e.g., a breakpoint. What technique is used to step over the
1269 breakpoint/watchpoint does not matter -- all threads end up in the
1270 same queue, to maintain rough temporal order of execution, in order
1271 to avoid starvation, otherwise, we could e.g., find ourselves
1272 constantly stepping the same couple threads past their breakpoints
1273 over and over, if the single-step finish fast enough. */
1274 struct thread_info
*step_over_queue_head
;
1276 /* Bit flags indicating what the thread needs to step over. */
1280 /* Step over a breakpoint. */
1281 STEP_OVER_BREAKPOINT
= 1,
1283 /* Step past a non-continuable watchpoint, in order to let the
1284 instruction execute so we can evaluate the watchpoint
1286 STEP_OVER_WATCHPOINT
= 2
1289 /* Info about an instruction that is being stepped over. */
1291 struct step_over_info
1293 /* If we're stepping past a breakpoint, this is the address space
1294 and address of the instruction the breakpoint is set at. We'll
1295 skip inserting all breakpoints here. Valid iff ASPACE is
1297 struct address_space
*aspace
;
1300 /* The instruction being stepped over triggers a nonsteppable
1301 watchpoint. If true, we'll skip inserting watchpoints. */
1302 int nonsteppable_watchpoint_p
;
1305 /* The step-over info of the location that is being stepped over.
1307 Note that with async/breakpoint always-inserted mode, a user might
1308 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1309 being stepped over. As setting a new breakpoint inserts all
1310 breakpoints, we need to make sure the breakpoint being stepped over
1311 isn't inserted then. We do that by only clearing the step-over
1312 info when the step-over is actually finished (or aborted).
1314 Presently GDB can only step over one breakpoint at any given time.
1315 Given threads that can't run code in the same address space as the
1316 breakpoint's can't really miss the breakpoint, GDB could be taught
1317 to step-over at most one breakpoint per address space (so this info
1318 could move to the address space object if/when GDB is extended).
1319 The set of breakpoints being stepped over will normally be much
1320 smaller than the set of all breakpoints, so a flag in the
1321 breakpoint location structure would be wasteful. A separate list
1322 also saves complexity and run-time, as otherwise we'd have to go
1323 through all breakpoint locations clearing their flag whenever we
1324 start a new sequence. Similar considerations weigh against storing
1325 this info in the thread object. Plus, not all step overs actually
1326 have breakpoint locations -- e.g., stepping past a single-step
1327 breakpoint, or stepping to complete a non-continuable
1329 static struct step_over_info step_over_info
;
1331 /* Record the address of the breakpoint/instruction we're currently
1335 set_step_over_info (struct address_space
*aspace
, CORE_ADDR address
,
1336 int nonsteppable_watchpoint_p
)
1338 step_over_info
.aspace
= aspace
;
1339 step_over_info
.address
= address
;
1340 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1343 /* Called when we're not longer stepping over a breakpoint / an
1344 instruction, so all breakpoints are free to be (re)inserted. */
1347 clear_step_over_info (void)
1350 fprintf_unfiltered (gdb_stdlog
,
1351 "infrun: clear_step_over_info\n");
1352 step_over_info
.aspace
= NULL
;
1353 step_over_info
.address
= 0;
1354 step_over_info
.nonsteppable_watchpoint_p
= 0;
1360 stepping_past_instruction_at (struct address_space
*aspace
,
1363 return (step_over_info
.aspace
!= NULL
1364 && breakpoint_address_match (aspace
, address
,
1365 step_over_info
.aspace
,
1366 step_over_info
.address
));
1372 stepping_past_nonsteppable_watchpoint (void)
1374 return step_over_info
.nonsteppable_watchpoint_p
;
1377 /* Returns true if step-over info is valid. */
1380 step_over_info_valid_p (void)
1382 return (step_over_info
.aspace
!= NULL
1383 || stepping_past_nonsteppable_watchpoint ());
1387 /* Displaced stepping. */
1389 /* In non-stop debugging mode, we must take special care to manage
1390 breakpoints properly; in particular, the traditional strategy for
1391 stepping a thread past a breakpoint it has hit is unsuitable.
1392 'Displaced stepping' is a tactic for stepping one thread past a
1393 breakpoint it has hit while ensuring that other threads running
1394 concurrently will hit the breakpoint as they should.
1396 The traditional way to step a thread T off a breakpoint in a
1397 multi-threaded program in all-stop mode is as follows:
1399 a0) Initially, all threads are stopped, and breakpoints are not
1401 a1) We single-step T, leaving breakpoints uninserted.
1402 a2) We insert breakpoints, and resume all threads.
1404 In non-stop debugging, however, this strategy is unsuitable: we
1405 don't want to have to stop all threads in the system in order to
1406 continue or step T past a breakpoint. Instead, we use displaced
1409 n0) Initially, T is stopped, other threads are running, and
1410 breakpoints are inserted.
1411 n1) We copy the instruction "under" the breakpoint to a separate
1412 location, outside the main code stream, making any adjustments
1413 to the instruction, register, and memory state as directed by
1415 n2) We single-step T over the instruction at its new location.
1416 n3) We adjust the resulting register and memory state as directed
1417 by T's architecture. This includes resetting T's PC to point
1418 back into the main instruction stream.
1421 This approach depends on the following gdbarch methods:
1423 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1424 indicate where to copy the instruction, and how much space must
1425 be reserved there. We use these in step n1.
1427 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1428 address, and makes any necessary adjustments to the instruction,
1429 register contents, and memory. We use this in step n1.
1431 - gdbarch_displaced_step_fixup adjusts registers and memory after
1432 we have successfuly single-stepped the instruction, to yield the
1433 same effect the instruction would have had if we had executed it
1434 at its original address. We use this in step n3.
1436 - gdbarch_displaced_step_free_closure provides cleanup.
1438 The gdbarch_displaced_step_copy_insn and
1439 gdbarch_displaced_step_fixup functions must be written so that
1440 copying an instruction with gdbarch_displaced_step_copy_insn,
1441 single-stepping across the copied instruction, and then applying
1442 gdbarch_displaced_insn_fixup should have the same effects on the
1443 thread's memory and registers as stepping the instruction in place
1444 would have. Exactly which responsibilities fall to the copy and
1445 which fall to the fixup is up to the author of those functions.
1447 See the comments in gdbarch.sh for details.
1449 Note that displaced stepping and software single-step cannot
1450 currently be used in combination, although with some care I think
1451 they could be made to. Software single-step works by placing
1452 breakpoints on all possible subsequent instructions; if the
1453 displaced instruction is a PC-relative jump, those breakpoints
1454 could fall in very strange places --- on pages that aren't
1455 executable, or at addresses that are not proper instruction
1456 boundaries. (We do generally let other threads run while we wait
1457 to hit the software single-step breakpoint, and they might
1458 encounter such a corrupted instruction.) One way to work around
1459 this would be to have gdbarch_displaced_step_copy_insn fully
1460 simulate the effect of PC-relative instructions (and return NULL)
1461 on architectures that use software single-stepping.
1463 In non-stop mode, we can have independent and simultaneous step
1464 requests, so more than one thread may need to simultaneously step
1465 over a breakpoint. The current implementation assumes there is
1466 only one scratch space per process. In this case, we have to
1467 serialize access to the scratch space. If thread A wants to step
1468 over a breakpoint, but we are currently waiting for some other
1469 thread to complete a displaced step, we leave thread A stopped and
1470 place it in the displaced_step_request_queue. Whenever a displaced
1471 step finishes, we pick the next thread in the queue and start a new
1472 displaced step operation on it. See displaced_step_prepare and
1473 displaced_step_fixup for details. */
1475 /* Per-inferior displaced stepping state. */
1476 struct displaced_step_inferior_state
1478 /* Pointer to next in linked list. */
1479 struct displaced_step_inferior_state
*next
;
1481 /* The process this displaced step state refers to. */
1484 /* True if preparing a displaced step ever failed. If so, we won't
1485 try displaced stepping for this inferior again. */
1488 /* If this is not null_ptid, this is the thread carrying out a
1489 displaced single-step in process PID. This thread's state will
1490 require fixing up once it has completed its step. */
1493 /* The architecture the thread had when we stepped it. */
1494 struct gdbarch
*step_gdbarch
;
1496 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1497 for post-step cleanup. */
1498 struct displaced_step_closure
*step_closure
;
1500 /* The address of the original instruction, and the copy we
1502 CORE_ADDR step_original
, step_copy
;
1504 /* Saved contents of copy area. */
1505 gdb_byte
*step_saved_copy
;
1508 /* The list of states of processes involved in displaced stepping
1510 static struct displaced_step_inferior_state
*displaced_step_inferior_states
;
1512 /* Get the displaced stepping state of process PID. */
1514 static struct displaced_step_inferior_state
*
1515 get_displaced_stepping_state (int pid
)
1517 struct displaced_step_inferior_state
*state
;
1519 for (state
= displaced_step_inferior_states
;
1521 state
= state
->next
)
1522 if (state
->pid
== pid
)
1528 /* Returns true if any inferior has a thread doing a displaced
1532 displaced_step_in_progress_any_inferior (void)
1534 struct displaced_step_inferior_state
*state
;
1536 for (state
= displaced_step_inferior_states
;
1538 state
= state
->next
)
1539 if (!ptid_equal (state
->step_ptid
, null_ptid
))
1545 /* Return true if process PID has a thread doing a displaced step. */
1548 displaced_step_in_progress (int pid
)
1550 struct displaced_step_inferior_state
*displaced
;
1552 displaced
= get_displaced_stepping_state (pid
);
1553 if (displaced
!= NULL
&& !ptid_equal (displaced
->step_ptid
, null_ptid
))
1559 /* Add a new displaced stepping state for process PID to the displaced
1560 stepping state list, or return a pointer to an already existing
1561 entry, if it already exists. Never returns NULL. */
1563 static struct displaced_step_inferior_state
*
1564 add_displaced_stepping_state (int pid
)
1566 struct displaced_step_inferior_state
*state
;
1568 for (state
= displaced_step_inferior_states
;
1570 state
= state
->next
)
1571 if (state
->pid
== pid
)
1574 state
= XCNEW (struct displaced_step_inferior_state
);
1576 state
->next
= displaced_step_inferior_states
;
1577 displaced_step_inferior_states
= state
;
1582 /* If inferior is in displaced stepping, and ADDR equals to starting address
1583 of copy area, return corresponding displaced_step_closure. Otherwise,
1586 struct displaced_step_closure
*
1587 get_displaced_step_closure_by_addr (CORE_ADDR addr
)
1589 struct displaced_step_inferior_state
*displaced
1590 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
1592 /* If checking the mode of displaced instruction in copy area. */
1593 if (displaced
&& !ptid_equal (displaced
->step_ptid
, null_ptid
)
1594 && (displaced
->step_copy
== addr
))
1595 return displaced
->step_closure
;
1600 /* Remove the displaced stepping state of process PID. */
1603 remove_displaced_stepping_state (int pid
)
1605 struct displaced_step_inferior_state
*it
, **prev_next_p
;
1607 gdb_assert (pid
!= 0);
1609 it
= displaced_step_inferior_states
;
1610 prev_next_p
= &displaced_step_inferior_states
;
1615 *prev_next_p
= it
->next
;
1620 prev_next_p
= &it
->next
;
1626 infrun_inferior_exit (struct inferior
*inf
)
1628 remove_displaced_stepping_state (inf
->pid
);
1631 /* If ON, and the architecture supports it, GDB will use displaced
1632 stepping to step over breakpoints. If OFF, or if the architecture
1633 doesn't support it, GDB will instead use the traditional
1634 hold-and-step approach. If AUTO (which is the default), GDB will
1635 decide which technique to use to step over breakpoints depending on
1636 which of all-stop or non-stop mode is active --- displaced stepping
1637 in non-stop mode; hold-and-step in all-stop mode. */
1639 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1642 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1643 struct cmd_list_element
*c
,
1646 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1647 fprintf_filtered (file
,
1648 _("Debugger's willingness to use displaced stepping "
1649 "to step over breakpoints is %s (currently %s).\n"),
1650 value
, target_is_non_stop_p () ? "on" : "off");
1652 fprintf_filtered (file
,
1653 _("Debugger's willingness to use displaced stepping "
1654 "to step over breakpoints is %s.\n"), value
);
1657 /* Return non-zero if displaced stepping can/should be used to step
1658 over breakpoints of thread TP. */
1661 use_displaced_stepping (struct thread_info
*tp
)
1663 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
1664 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1665 struct displaced_step_inferior_state
*displaced_state
;
1667 displaced_state
= get_displaced_stepping_state (ptid_get_pid (tp
->ptid
));
1669 return (((can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1670 && target_is_non_stop_p ())
1671 || can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1672 && gdbarch_displaced_step_copy_insn_p (gdbarch
)
1673 && find_record_target () == NULL
1674 && (displaced_state
== NULL
1675 || !displaced_state
->failed_before
));
1678 /* Clean out any stray displaced stepping state. */
1680 displaced_step_clear (struct displaced_step_inferior_state
*displaced
)
1682 /* Indicate that there is no cleanup pending. */
1683 displaced
->step_ptid
= null_ptid
;
1685 if (displaced
->step_closure
)
1687 gdbarch_displaced_step_free_closure (displaced
->step_gdbarch
,
1688 displaced
->step_closure
);
1689 displaced
->step_closure
= NULL
;
1694 displaced_step_clear_cleanup (void *arg
)
1696 struct displaced_step_inferior_state
*state
= arg
;
1698 displaced_step_clear (state
);
1701 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1703 displaced_step_dump_bytes (struct ui_file
*file
,
1704 const gdb_byte
*buf
,
1709 for (i
= 0; i
< len
; i
++)
1710 fprintf_unfiltered (file
, "%02x ", buf
[i
]);
1711 fputs_unfiltered ("\n", file
);
1714 /* Prepare to single-step, using displaced stepping.
1716 Note that we cannot use displaced stepping when we have a signal to
1717 deliver. If we have a signal to deliver and an instruction to step
1718 over, then after the step, there will be no indication from the
1719 target whether the thread entered a signal handler or ignored the
1720 signal and stepped over the instruction successfully --- both cases
1721 result in a simple SIGTRAP. In the first case we mustn't do a
1722 fixup, and in the second case we must --- but we can't tell which.
1723 Comments in the code for 'random signals' in handle_inferior_event
1724 explain how we handle this case instead.
1726 Returns 1 if preparing was successful -- this thread is going to be
1727 stepped now; 0 if displaced stepping this thread got queued; or -1
1728 if this instruction can't be displaced stepped. */
1731 displaced_step_prepare_throw (ptid_t ptid
)
1733 struct cleanup
*old_cleanups
, *ignore_cleanups
;
1734 struct thread_info
*tp
= find_thread_ptid (ptid
);
1735 struct regcache
*regcache
= get_thread_regcache (ptid
);
1736 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1737 CORE_ADDR original
, copy
;
1739 struct displaced_step_closure
*closure
;
1740 struct displaced_step_inferior_state
*displaced
;
1743 /* We should never reach this function if the architecture does not
1744 support displaced stepping. */
1745 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch
));
1747 /* Nor if the thread isn't meant to step over a breakpoint. */
1748 gdb_assert (tp
->control
.trap_expected
);
1750 /* Disable range stepping while executing in the scratch pad. We
1751 want a single-step even if executing the displaced instruction in
1752 the scratch buffer lands within the stepping range (e.g., a
1754 tp
->control
.may_range_step
= 0;
1756 /* We have to displaced step one thread at a time, as we only have
1757 access to a single scratch space per inferior. */
1759 displaced
= add_displaced_stepping_state (ptid_get_pid (ptid
));
1761 if (!ptid_equal (displaced
->step_ptid
, null_ptid
))
1763 /* Already waiting for a displaced step to finish. Defer this
1764 request and place in queue. */
1766 if (debug_displaced
)
1767 fprintf_unfiltered (gdb_stdlog
,
1768 "displaced: deferring step of %s\n",
1769 target_pid_to_str (ptid
));
1771 thread_step_over_chain_enqueue (tp
);
1776 if (debug_displaced
)
1777 fprintf_unfiltered (gdb_stdlog
,
1778 "displaced: stepping %s now\n",
1779 target_pid_to_str (ptid
));
1782 displaced_step_clear (displaced
);
1784 old_cleanups
= save_inferior_ptid ();
1785 inferior_ptid
= ptid
;
1787 original
= regcache_read_pc (regcache
);
1789 copy
= gdbarch_displaced_step_location (gdbarch
);
1790 len
= gdbarch_max_insn_length (gdbarch
);
1792 /* Save the original contents of the copy area. */
1793 displaced
->step_saved_copy
= xmalloc (len
);
1794 ignore_cleanups
= make_cleanup (free_current_contents
,
1795 &displaced
->step_saved_copy
);
1796 status
= target_read_memory (copy
, displaced
->step_saved_copy
, len
);
1798 throw_error (MEMORY_ERROR
,
1799 _("Error accessing memory address %s (%s) for "
1800 "displaced-stepping scratch space."),
1801 paddress (gdbarch
, copy
), safe_strerror (status
));
1802 if (debug_displaced
)
1804 fprintf_unfiltered (gdb_stdlog
, "displaced: saved %s: ",
1805 paddress (gdbarch
, copy
));
1806 displaced_step_dump_bytes (gdb_stdlog
,
1807 displaced
->step_saved_copy
,
1811 closure
= gdbarch_displaced_step_copy_insn (gdbarch
,
1812 original
, copy
, regcache
);
1813 if (closure
== NULL
)
1815 /* The architecture doesn't know how or want to displaced step
1816 this instruction or instruction sequence. Fallback to
1817 stepping over the breakpoint in-line. */
1818 do_cleanups (old_cleanups
);
1822 /* Save the information we need to fix things up if the step
1824 displaced
->step_ptid
= ptid
;
1825 displaced
->step_gdbarch
= gdbarch
;
1826 displaced
->step_closure
= closure
;
1827 displaced
->step_original
= original
;
1828 displaced
->step_copy
= copy
;
1830 make_cleanup (displaced_step_clear_cleanup
, displaced
);
1832 /* Resume execution at the copy. */
1833 regcache_write_pc (regcache
, copy
);
1835 discard_cleanups (ignore_cleanups
);
1837 do_cleanups (old_cleanups
);
1839 if (debug_displaced
)
1840 fprintf_unfiltered (gdb_stdlog
, "displaced: displaced pc to %s\n",
1841 paddress (gdbarch
, copy
));
1846 /* Wrapper for displaced_step_prepare_throw that disabled further
1847 attempts at displaced stepping if we get a memory error. */
1850 displaced_step_prepare (ptid_t ptid
)
1856 prepared
= displaced_step_prepare_throw (ptid
);
1858 CATCH (ex
, RETURN_MASK_ERROR
)
1860 struct displaced_step_inferior_state
*displaced_state
;
1862 if (ex
.error
!= MEMORY_ERROR
)
1863 throw_exception (ex
);
1867 fprintf_unfiltered (gdb_stdlog
,
1868 "infrun: disabling displaced stepping: %s\n",
1872 /* Be verbose if "set displaced-stepping" is "on", silent if
1874 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1876 warning (_("disabling displaced stepping: %s"),
1880 /* Disable further displaced stepping attempts. */
1882 = get_displaced_stepping_state (ptid_get_pid (ptid
));
1883 displaced_state
->failed_before
= 1;
1891 write_memory_ptid (ptid_t ptid
, CORE_ADDR memaddr
,
1892 const gdb_byte
*myaddr
, int len
)
1894 struct cleanup
*ptid_cleanup
= save_inferior_ptid ();
1896 inferior_ptid
= ptid
;
1897 write_memory (memaddr
, myaddr
, len
);
1898 do_cleanups (ptid_cleanup
);
1901 /* Restore the contents of the copy area for thread PTID. */
1904 displaced_step_restore (struct displaced_step_inferior_state
*displaced
,
1907 ULONGEST len
= gdbarch_max_insn_length (displaced
->step_gdbarch
);
1909 write_memory_ptid (ptid
, displaced
->step_copy
,
1910 displaced
->step_saved_copy
, len
);
1911 if (debug_displaced
)
1912 fprintf_unfiltered (gdb_stdlog
, "displaced: restored %s %s\n",
1913 target_pid_to_str (ptid
),
1914 paddress (displaced
->step_gdbarch
,
1915 displaced
->step_copy
));
1918 /* If we displaced stepped an instruction successfully, adjust
1919 registers and memory to yield the same effect the instruction would
1920 have had if we had executed it at its original address, and return
1921 1. If the instruction didn't complete, relocate the PC and return
1922 -1. If the thread wasn't displaced stepping, return 0. */
1925 displaced_step_fixup (ptid_t event_ptid
, enum gdb_signal signal
)
1927 struct cleanup
*old_cleanups
;
1928 struct displaced_step_inferior_state
*displaced
1929 = get_displaced_stepping_state (ptid_get_pid (event_ptid
));
1932 /* Was any thread of this process doing a displaced step? */
1933 if (displaced
== NULL
)
1936 /* Was this event for the pid we displaced? */
1937 if (ptid_equal (displaced
->step_ptid
, null_ptid
)
1938 || ! ptid_equal (displaced
->step_ptid
, event_ptid
))
1941 old_cleanups
= make_cleanup (displaced_step_clear_cleanup
, displaced
);
1943 displaced_step_restore (displaced
, displaced
->step_ptid
);
1945 /* Fixup may need to read memory/registers. Switch to the thread
1946 that we're fixing up. Also, target_stopped_by_watchpoint checks
1947 the current thread. */
1948 switch_to_thread (event_ptid
);
1950 /* Did the instruction complete successfully? */
1951 if (signal
== GDB_SIGNAL_TRAP
1952 && !(target_stopped_by_watchpoint ()
1953 && (gdbarch_have_nonsteppable_watchpoint (displaced
->step_gdbarch
)
1954 || target_have_steppable_watchpoint
)))
1956 /* Fix up the resulting state. */
1957 gdbarch_displaced_step_fixup (displaced
->step_gdbarch
,
1958 displaced
->step_closure
,
1959 displaced
->step_original
,
1960 displaced
->step_copy
,
1961 get_thread_regcache (displaced
->step_ptid
));
1966 /* Since the instruction didn't complete, all we can do is
1968 struct regcache
*regcache
= get_thread_regcache (event_ptid
);
1969 CORE_ADDR pc
= regcache_read_pc (regcache
);
1971 pc
= displaced
->step_original
+ (pc
- displaced
->step_copy
);
1972 regcache_write_pc (regcache
, pc
);
1976 do_cleanups (old_cleanups
);
1978 displaced
->step_ptid
= null_ptid
;
1983 /* Data to be passed around while handling an event. This data is
1984 discarded between events. */
1985 struct execution_control_state
1988 /* The thread that got the event, if this was a thread event; NULL
1990 struct thread_info
*event_thread
;
1992 struct target_waitstatus ws
;
1993 int stop_func_filled_in
;
1994 CORE_ADDR stop_func_start
;
1995 CORE_ADDR stop_func_end
;
1996 const char *stop_func_name
;
1999 /* True if the event thread hit the single-step breakpoint of
2000 another thread. Thus the event doesn't cause a stop, the thread
2001 needs to be single-stepped past the single-step breakpoint before
2002 we can switch back to the original stepping thread. */
2003 int hit_singlestep_breakpoint
;
2006 /* Clear ECS and set it to point at TP. */
2009 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
2011 memset (ecs
, 0, sizeof (*ecs
));
2012 ecs
->event_thread
= tp
;
2013 ecs
->ptid
= tp
->ptid
;
2016 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
2017 static void prepare_to_wait (struct execution_control_state
*ecs
);
2018 static int keep_going_stepped_thread (struct thread_info
*tp
);
2019 static int thread_still_needs_step_over (struct thread_info
*tp
);
2020 static void stop_all_threads (void);
2022 /* Are there any pending step-over requests? If so, run all we can
2023 now and return true. Otherwise, return false. */
2026 start_step_over (void)
2028 struct thread_info
*tp
, *next
;
2030 /* Don't start a new step-over if we already have an in-line
2031 step-over operation ongoing. */
2032 if (step_over_info_valid_p ())
2035 for (tp
= step_over_queue_head
; tp
!= NULL
; tp
= next
)
2037 struct execution_control_state ecss
;
2038 struct execution_control_state
*ecs
= &ecss
;
2039 enum step_over_what step_what
;
2040 int must_be_in_line
;
2042 next
= thread_step_over_chain_next (tp
);
2044 /* If this inferior already has a displaced step in process,
2045 don't start a new one. */
2046 if (displaced_step_in_progress (ptid_get_pid (tp
->ptid
)))
2049 step_what
= thread_still_needs_step_over (tp
);
2050 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
2051 || ((step_what
& STEP_OVER_BREAKPOINT
)
2052 && !use_displaced_stepping (tp
)));
2054 /* We currently stop all threads of all processes to step-over
2055 in-line. If we need to start a new in-line step-over, let
2056 any pending displaced steps finish first. */
2057 if (must_be_in_line
&& displaced_step_in_progress_any_inferior ())
2060 thread_step_over_chain_remove (tp
);
2062 if (step_over_queue_head
== NULL
)
2065 fprintf_unfiltered (gdb_stdlog
,
2066 "infrun: step-over queue now empty\n");
2069 if (tp
->control
.trap_expected
2073 internal_error (__FILE__
, __LINE__
,
2074 "[%s] has inconsistent state: "
2075 "trap_expected=%d, resumed=%d, executing=%d\n",
2076 target_pid_to_str (tp
->ptid
),
2077 tp
->control
.trap_expected
,
2083 fprintf_unfiltered (gdb_stdlog
,
2084 "infrun: resuming [%s] for step-over\n",
2085 target_pid_to_str (tp
->ptid
));
2087 /* keep_going_pass_signal skips the step-over if the breakpoint
2088 is no longer inserted. In all-stop, we want to keep looking
2089 for a thread that needs a step-over instead of resuming TP,
2090 because we wouldn't be able to resume anything else until the
2091 target stops again. In non-stop, the resume always resumes
2092 only TP, so it's OK to let the thread resume freely. */
2093 if (!target_is_non_stop_p () && !step_what
)
2096 switch_to_thread (tp
->ptid
);
2097 reset_ecs (ecs
, tp
);
2098 keep_going_pass_signal (ecs
);
2100 if (!ecs
->wait_some_more
)
2101 error (_("Command aborted."));
2103 gdb_assert (tp
->resumed
);
2105 /* If we started a new in-line step-over, we're done. */
2106 if (step_over_info_valid_p ())
2108 gdb_assert (tp
->control
.trap_expected
);
2112 if (!target_is_non_stop_p ())
2114 /* On all-stop, shouldn't have resumed unless we needed a
2116 gdb_assert (tp
->control
.trap_expected
2117 || tp
->step_after_step_resume_breakpoint
);
2119 /* With remote targets (at least), in all-stop, we can't
2120 issue any further remote commands until the program stops
2125 /* Either the thread no longer needed a step-over, or a new
2126 displaced stepping sequence started. Even in the latter
2127 case, continue looking. Maybe we can also start another
2128 displaced step on a thread of other process. */
2134 /* Update global variables holding ptids to hold NEW_PTID if they were
2135 holding OLD_PTID. */
2137 infrun_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
2139 struct displaced_step_request
*it
;
2140 struct displaced_step_inferior_state
*displaced
;
2142 if (ptid_equal (inferior_ptid
, old_ptid
))
2143 inferior_ptid
= new_ptid
;
2145 for (displaced
= displaced_step_inferior_states
;
2147 displaced
= displaced
->next
)
2149 if (ptid_equal (displaced
->step_ptid
, old_ptid
))
2150 displaced
->step_ptid
= new_ptid
;
2157 /* Things to clean up if we QUIT out of resume (). */
2159 resume_cleanups (void *ignore
)
2161 if (!ptid_equal (inferior_ptid
, null_ptid
))
2162 delete_single_step_breakpoints (inferior_thread ());
2167 static const char schedlock_off
[] = "off";
2168 static const char schedlock_on
[] = "on";
2169 static const char schedlock_step
[] = "step";
2170 static const char *const scheduler_enums
[] = {
2176 static const char *scheduler_mode
= schedlock_off
;
2178 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2179 struct cmd_list_element
*c
, const char *value
)
2181 fprintf_filtered (file
,
2182 _("Mode for locking scheduler "
2183 "during execution is \"%s\".\n"),
2188 set_schedlock_func (char *args
, int from_tty
, struct cmd_list_element
*c
)
2190 if (!target_can_lock_scheduler
)
2192 scheduler_mode
= schedlock_off
;
2193 error (_("Target '%s' cannot support this command."), target_shortname
);
2197 /* True if execution commands resume all threads of all processes by
2198 default; otherwise, resume only threads of the current inferior
2200 int sched_multi
= 0;
2202 /* Try to setup for software single stepping over the specified location.
2203 Return 1 if target_resume() should use hardware single step.
2205 GDBARCH the current gdbarch.
2206 PC the location to step over. */
2209 maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2213 if (execution_direction
== EXEC_FORWARD
2214 && gdbarch_software_single_step_p (gdbarch
)
2215 && gdbarch_software_single_step (gdbarch
, get_current_frame ()))
2225 user_visible_resume_ptid (int step
)
2231 /* With non-stop mode on, threads are always handled
2233 resume_ptid
= inferior_ptid
;
2235 else if ((scheduler_mode
== schedlock_on
)
2236 || (scheduler_mode
== schedlock_step
&& step
))
2238 /* User-settable 'scheduler' mode requires solo thread
2240 resume_ptid
= inferior_ptid
;
2242 else if (!sched_multi
&& target_supports_multi_process ())
2244 /* Resume all threads of the current process (and none of other
2246 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
2250 /* Resume all threads of all processes. */
2251 resume_ptid
= RESUME_ALL
;
2257 /* Return a ptid representing the set of threads that we will resume,
2258 in the perspective of the target, assuming run control handling
2259 does not require leaving some threads stopped (e.g., stepping past
2260 breakpoint). USER_STEP indicates whether we're about to start the
2261 target for a stepping command. */
2264 internal_resume_ptid (int user_step
)
2266 /* In non-stop, we always control threads individually. Note that
2267 the target may always work in non-stop mode even with "set
2268 non-stop off", in which case user_visible_resume_ptid could
2269 return a wildcard ptid. */
2270 if (target_is_non_stop_p ())
2271 return inferior_ptid
;
2273 return user_visible_resume_ptid (user_step
);
2276 /* Wrapper for target_resume, that handles infrun-specific
2280 do_target_resume (ptid_t resume_ptid
, int step
, enum gdb_signal sig
)
2282 struct thread_info
*tp
= inferior_thread ();
2284 /* Install inferior's terminal modes. */
2285 target_terminal_inferior ();
2287 /* Avoid confusing the next resume, if the next stop/resume
2288 happens to apply to another thread. */
2289 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2291 /* Advise target which signals may be handled silently.
2293 If we have removed breakpoints because we are stepping over one
2294 in-line (in any thread), we need to receive all signals to avoid
2295 accidentally skipping a breakpoint during execution of a signal
2298 Likewise if we're displaced stepping, otherwise a trap for a
2299 breakpoint in a signal handler might be confused with the
2300 displaced step finishing. We don't make the displaced_step_fixup
2301 step distinguish the cases instead, because:
2303 - a backtrace while stopped in the signal handler would show the
2304 scratch pad as frame older than the signal handler, instead of
2305 the real mainline code.
2307 - when the thread is later resumed, the signal handler would
2308 return to the scratch pad area, which would no longer be
2310 if (step_over_info_valid_p ()
2311 || displaced_step_in_progress (ptid_get_pid (tp
->ptid
)))
2312 target_pass_signals (0, NULL
);
2314 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
2316 target_resume (resume_ptid
, step
, sig
);
2319 /* Resume the inferior, but allow a QUIT. This is useful if the user
2320 wants to interrupt some lengthy single-stepping operation
2321 (for child processes, the SIGINT goes to the inferior, and so
2322 we get a SIGINT random_signal, but for remote debugging and perhaps
2323 other targets, that's not true).
2325 SIG is the signal to give the inferior (zero for none). */
2327 resume (enum gdb_signal sig
)
2329 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
2330 struct regcache
*regcache
= get_current_regcache ();
2331 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2332 struct thread_info
*tp
= inferior_thread ();
2333 CORE_ADDR pc
= regcache_read_pc (regcache
);
2334 struct address_space
*aspace
= get_regcache_aspace (regcache
);
2336 /* This represents the user's step vs continue request. When
2337 deciding whether "set scheduler-locking step" applies, it's the
2338 user's intention that counts. */
2339 const int user_step
= tp
->control
.stepping_command
;
2340 /* This represents what we'll actually request the target to do.
2341 This can decay from a step to a continue, if e.g., we need to
2342 implement single-stepping with breakpoints (software
2346 gdb_assert (!thread_is_in_step_over_chain (tp
));
2350 if (tp
->suspend
.waitstatus_pending_p
)
2356 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2357 fprintf_unfiltered (gdb_stdlog
,
2358 "infrun: resume: thread %s has pending wait status %s "
2359 "(currently_stepping=%d).\n",
2360 target_pid_to_str (tp
->ptid
), statstr
,
2361 currently_stepping (tp
));
2367 /* FIXME: What should we do if we are supposed to resume this
2368 thread with a signal? Maybe we should maintain a queue of
2369 pending signals to deliver. */
2370 if (sig
!= GDB_SIGNAL_0
)
2372 warning (_("Couldn't deliver signal %s to %s."),
2373 gdb_signal_to_name (sig
), target_pid_to_str (tp
->ptid
));
2376 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2377 discard_cleanups (old_cleanups
);
2379 if (target_can_async_p ())
2384 tp
->stepped_breakpoint
= 0;
2386 /* Depends on stepped_breakpoint. */
2387 step
= currently_stepping (tp
);
2389 if (current_inferior ()->waiting_for_vfork_done
)
2391 /* Don't try to single-step a vfork parent that is waiting for
2392 the child to get out of the shared memory region (by exec'ing
2393 or exiting). This is particularly important on software
2394 single-step archs, as the child process would trip on the
2395 software single step breakpoint inserted for the parent
2396 process. Since the parent will not actually execute any
2397 instruction until the child is out of the shared region (such
2398 are vfork's semantics), it is safe to simply continue it.
2399 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2400 the parent, and tell it to `keep_going', which automatically
2401 re-sets it stepping. */
2403 fprintf_unfiltered (gdb_stdlog
,
2404 "infrun: resume : clear step\n");
2409 fprintf_unfiltered (gdb_stdlog
,
2410 "infrun: resume (step=%d, signal=%s), "
2411 "trap_expected=%d, current thread [%s] at %s\n",
2412 step
, gdb_signal_to_symbol_string (sig
),
2413 tp
->control
.trap_expected
,
2414 target_pid_to_str (inferior_ptid
),
2415 paddress (gdbarch
, pc
));
2417 /* Normally, by the time we reach `resume', the breakpoints are either
2418 removed or inserted, as appropriate. The exception is if we're sitting
2419 at a permanent breakpoint; we need to step over it, but permanent
2420 breakpoints can't be removed. So we have to test for it here. */
2421 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2423 if (sig
!= GDB_SIGNAL_0
)
2425 /* We have a signal to pass to the inferior. The resume
2426 may, or may not take us to the signal handler. If this
2427 is a step, we'll need to stop in the signal handler, if
2428 there's one, (if the target supports stepping into
2429 handlers), or in the next mainline instruction, if
2430 there's no handler. If this is a continue, we need to be
2431 sure to run the handler with all breakpoints inserted.
2432 In all cases, set a breakpoint at the current address
2433 (where the handler returns to), and once that breakpoint
2434 is hit, resume skipping the permanent breakpoint. If
2435 that breakpoint isn't hit, then we've stepped into the
2436 signal handler (or hit some other event). We'll delete
2437 the step-resume breakpoint then. */
2440 fprintf_unfiltered (gdb_stdlog
,
2441 "infrun: resume: skipping permanent breakpoint, "
2442 "deliver signal first\n");
2444 clear_step_over_info ();
2445 tp
->control
.trap_expected
= 0;
2447 if (tp
->control
.step_resume_breakpoint
== NULL
)
2449 /* Set a "high-priority" step-resume, as we don't want
2450 user breakpoints at PC to trigger (again) when this
2452 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2453 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2455 tp
->step_after_step_resume_breakpoint
= step
;
2458 insert_breakpoints ();
2462 /* There's no signal to pass, we can go ahead and skip the
2463 permanent breakpoint manually. */
2465 fprintf_unfiltered (gdb_stdlog
,
2466 "infrun: resume: skipping permanent breakpoint\n");
2467 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2468 /* Update pc to reflect the new address from which we will
2469 execute instructions. */
2470 pc
= regcache_read_pc (regcache
);
2474 /* We've already advanced the PC, so the stepping part
2475 is done. Now we need to arrange for a trap to be
2476 reported to handle_inferior_event. Set a breakpoint
2477 at the current PC, and run to it. Don't update
2478 prev_pc, because if we end in
2479 switch_back_to_stepped_thread, we want the "expected
2480 thread advanced also" branch to be taken. IOW, we
2481 don't want this thread to step further from PC
2483 gdb_assert (!step_over_info_valid_p ());
2484 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2485 insert_breakpoints ();
2487 resume_ptid
= internal_resume_ptid (user_step
);
2488 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
2489 discard_cleanups (old_cleanups
);
2496 /* If we have a breakpoint to step over, make sure to do a single
2497 step only. Same if we have software watchpoints. */
2498 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2499 tp
->control
.may_range_step
= 0;
2501 /* If enabled, step over breakpoints by executing a copy of the
2502 instruction at a different address.
2504 We can't use displaced stepping when we have a signal to deliver;
2505 the comments for displaced_step_prepare explain why. The
2506 comments in the handle_inferior event for dealing with 'random
2507 signals' explain what we do instead.
2509 We can't use displaced stepping when we are waiting for vfork_done
2510 event, displaced stepping breaks the vfork child similarly as single
2511 step software breakpoint. */
2512 if (tp
->control
.trap_expected
2513 && use_displaced_stepping (tp
)
2514 && !step_over_info_valid_p ()
2515 && sig
== GDB_SIGNAL_0
2516 && !current_inferior ()->waiting_for_vfork_done
)
2518 int prepared
= displaced_step_prepare (inferior_ptid
);
2523 fprintf_unfiltered (gdb_stdlog
,
2524 "Got placed in step-over queue\n");
2526 tp
->control
.trap_expected
= 0;
2527 discard_cleanups (old_cleanups
);
2530 else if (prepared
< 0)
2532 /* Fallback to stepping over the breakpoint in-line. */
2534 if (target_is_non_stop_p ())
2535 stop_all_threads ();
2537 set_step_over_info (get_regcache_aspace (regcache
),
2538 regcache_read_pc (regcache
), 0);
2540 step
= maybe_software_singlestep (gdbarch
, pc
);
2542 insert_breakpoints ();
2544 else if (prepared
> 0)
2546 struct displaced_step_inferior_state
*displaced
;
2548 /* Update pc to reflect the new address from which we will
2549 execute instructions due to displaced stepping. */
2550 pc
= regcache_read_pc (get_thread_regcache (inferior_ptid
));
2552 displaced
= get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
2553 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
,
2554 displaced
->step_closure
);
2558 /* Do we need to do it the hard way, w/temp breakpoints? */
2560 step
= maybe_software_singlestep (gdbarch
, pc
);
2562 /* Currently, our software single-step implementation leads to different
2563 results than hardware single-stepping in one situation: when stepping
2564 into delivering a signal which has an associated signal handler,
2565 hardware single-step will stop at the first instruction of the handler,
2566 while software single-step will simply skip execution of the handler.
2568 For now, this difference in behavior is accepted since there is no
2569 easy way to actually implement single-stepping into a signal handler
2570 without kernel support.
2572 However, there is one scenario where this difference leads to follow-on
2573 problems: if we're stepping off a breakpoint by removing all breakpoints
2574 and then single-stepping. In this case, the software single-step
2575 behavior means that even if there is a *breakpoint* in the signal
2576 handler, GDB still would not stop.
2578 Fortunately, we can at least fix this particular issue. We detect
2579 here the case where we are about to deliver a signal while software
2580 single-stepping with breakpoints removed. In this situation, we
2581 revert the decisions to remove all breakpoints and insert single-
2582 step breakpoints, and instead we install a step-resume breakpoint
2583 at the current address, deliver the signal without stepping, and
2584 once we arrive back at the step-resume breakpoint, actually step
2585 over the breakpoint we originally wanted to step over. */
2586 if (thread_has_single_step_breakpoints_set (tp
)
2587 && sig
!= GDB_SIGNAL_0
2588 && step_over_info_valid_p ())
2590 /* If we have nested signals or a pending signal is delivered
2591 immediately after a handler returns, might might already have
2592 a step-resume breakpoint set on the earlier handler. We cannot
2593 set another step-resume breakpoint; just continue on until the
2594 original breakpoint is hit. */
2595 if (tp
->control
.step_resume_breakpoint
== NULL
)
2597 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2598 tp
->step_after_step_resume_breakpoint
= 1;
2601 delete_single_step_breakpoints (tp
);
2603 clear_step_over_info ();
2604 tp
->control
.trap_expected
= 0;
2606 insert_breakpoints ();
2609 /* If STEP is set, it's a request to use hardware stepping
2610 facilities. But in that case, we should never
2611 use singlestep breakpoint. */
2612 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2614 /* Decide the set of threads to ask the target to resume. */
2615 if ((step
|| thread_has_single_step_breakpoints_set (tp
))
2616 && tp
->control
.trap_expected
)
2618 /* We're allowing a thread to run past a breakpoint it has
2619 hit, by single-stepping the thread with the breakpoint
2620 removed. In which case, we need to single-step only this
2621 thread, and keep others stopped, as they can miss this
2622 breakpoint if allowed to run. */
2623 resume_ptid
= inferior_ptid
;
2626 resume_ptid
= internal_resume_ptid (user_step
);
2628 if (execution_direction
!= EXEC_REVERSE
2629 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2631 /* There are two cases where we currently need to step a
2632 breakpoint instruction when we have a signal to deliver:
2634 - See handle_signal_stop where we handle random signals that
2635 could take out us out of the stepping range. Normally, in
2636 that case we end up continuing (instead of stepping) over the
2637 signal handler with a breakpoint at PC, but there are cases
2638 where we should _always_ single-step, even if we have a
2639 step-resume breakpoint, like when a software watchpoint is
2640 set. Assuming single-stepping and delivering a signal at the
2641 same time would takes us to the signal handler, then we could
2642 have removed the breakpoint at PC to step over it. However,
2643 some hardware step targets (like e.g., Mac OS) can't step
2644 into signal handlers, and for those, we need to leave the
2645 breakpoint at PC inserted, as otherwise if the handler
2646 recurses and executes PC again, it'll miss the breakpoint.
2647 So we leave the breakpoint inserted anyway, but we need to
2648 record that we tried to step a breakpoint instruction, so
2649 that adjust_pc_after_break doesn't end up confused.
2651 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2652 in one thread after another thread that was stepping had been
2653 momentarily paused for a step-over. When we re-resume the
2654 stepping thread, it may be resumed from that address with a
2655 breakpoint that hasn't trapped yet. Seen with
2656 gdb.threads/non-stop-fair-events.exp, on targets that don't
2657 do displaced stepping. */
2660 fprintf_unfiltered (gdb_stdlog
,
2661 "infrun: resume: [%s] stepped breakpoint\n",
2662 target_pid_to_str (tp
->ptid
));
2664 tp
->stepped_breakpoint
= 1;
2666 /* Most targets can step a breakpoint instruction, thus
2667 executing it normally. But if this one cannot, just
2668 continue and we will hit it anyway. */
2669 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2674 && tp
->control
.trap_expected
2675 && use_displaced_stepping (tp
)
2676 && !step_over_info_valid_p ())
2678 struct regcache
*resume_regcache
= get_thread_regcache (tp
->ptid
);
2679 struct gdbarch
*resume_gdbarch
= get_regcache_arch (resume_regcache
);
2680 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2683 fprintf_unfiltered (gdb_stdlog
, "displaced: run %s: ",
2684 paddress (resume_gdbarch
, actual_pc
));
2685 read_memory (actual_pc
, buf
, sizeof (buf
));
2686 displaced_step_dump_bytes (gdb_stdlog
, buf
, sizeof (buf
));
2689 if (tp
->control
.may_range_step
)
2691 /* If we're resuming a thread with the PC out of the step
2692 range, then we're doing some nested/finer run control
2693 operation, like stepping the thread out of the dynamic
2694 linker or the displaced stepping scratch pad. We
2695 shouldn't have allowed a range step then. */
2696 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2699 do_target_resume (resume_ptid
, step
, sig
);
2701 discard_cleanups (old_cleanups
);
2706 /* Clear out all variables saying what to do when inferior is continued.
2707 First do this, then set the ones you want, then call `proceed'. */
2710 clear_proceed_status_thread (struct thread_info
*tp
)
2713 fprintf_unfiltered (gdb_stdlog
,
2714 "infrun: clear_proceed_status_thread (%s)\n",
2715 target_pid_to_str (tp
->ptid
));
2717 /* If we're starting a new sequence, then the previous finished
2718 single-step is no longer relevant. */
2719 if (tp
->suspend
.waitstatus_pending_p
)
2721 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
2724 fprintf_unfiltered (gdb_stdlog
,
2725 "infrun: clear_proceed_status: pending "
2726 "event of %s was a finished step. "
2728 target_pid_to_str (tp
->ptid
));
2730 tp
->suspend
.waitstatus_pending_p
= 0;
2731 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
2733 else if (debug_infrun
)
2737 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2738 fprintf_unfiltered (gdb_stdlog
,
2739 "infrun: clear_proceed_status_thread: thread %s "
2740 "has pending wait status %s "
2741 "(currently_stepping=%d).\n",
2742 target_pid_to_str (tp
->ptid
), statstr
,
2743 currently_stepping (tp
));
2748 /* If this signal should not be seen by program, give it zero.
2749 Used for debugging signals. */
2750 if (!signal_pass_state (tp
->suspend
.stop_signal
))
2751 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2753 thread_fsm_delete (tp
->thread_fsm
);
2754 tp
->thread_fsm
= NULL
;
2756 tp
->control
.trap_expected
= 0;
2757 tp
->control
.step_range_start
= 0;
2758 tp
->control
.step_range_end
= 0;
2759 tp
->control
.may_range_step
= 0;
2760 tp
->control
.step_frame_id
= null_frame_id
;
2761 tp
->control
.step_stack_frame_id
= null_frame_id
;
2762 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2763 tp
->control
.step_start_function
= NULL
;
2764 tp
->stop_requested
= 0;
2766 tp
->control
.stop_step
= 0;
2768 tp
->control
.proceed_to_finish
= 0;
2770 tp
->control
.command_interp
= NULL
;
2771 tp
->control
.stepping_command
= 0;
2773 /* Discard any remaining commands or status from previous stop. */
2774 bpstat_clear (&tp
->control
.stop_bpstat
);
2778 clear_proceed_status (int step
)
2782 struct thread_info
*tp
;
2785 resume_ptid
= user_visible_resume_ptid (step
);
2787 /* In all-stop mode, delete the per-thread status of all threads
2788 we're about to resume, implicitly and explicitly. */
2789 ALL_NON_EXITED_THREADS (tp
)
2791 if (!ptid_match (tp
->ptid
, resume_ptid
))
2793 clear_proceed_status_thread (tp
);
2797 if (!ptid_equal (inferior_ptid
, null_ptid
))
2799 struct inferior
*inferior
;
2803 /* If in non-stop mode, only delete the per-thread status of
2804 the current thread. */
2805 clear_proceed_status_thread (inferior_thread ());
2808 inferior
= current_inferior ();
2809 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2812 stop_after_trap
= 0;
2814 observer_notify_about_to_proceed ();
2817 /* Returns true if TP is still stopped at a breakpoint that needs
2818 stepping-over in order to make progress. If the breakpoint is gone
2819 meanwhile, we can skip the whole step-over dance. */
2822 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2824 if (tp
->stepping_over_breakpoint
)
2826 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
2828 if (breakpoint_here_p (get_regcache_aspace (regcache
),
2829 regcache_read_pc (regcache
))
2830 == ordinary_breakpoint_here
)
2833 tp
->stepping_over_breakpoint
= 0;
2839 /* Check whether thread TP still needs to start a step-over in order
2840 to make progress when resumed. Returns an bitwise or of enum
2841 step_over_what bits, indicating what needs to be stepped over. */
2844 thread_still_needs_step_over (struct thread_info
*tp
)
2846 struct inferior
*inf
= find_inferior_ptid (tp
->ptid
);
2849 if (thread_still_needs_step_over_bp (tp
))
2850 what
|= STEP_OVER_BREAKPOINT
;
2852 if (tp
->stepping_over_watchpoint
2853 && !target_have_steppable_watchpoint
)
2854 what
|= STEP_OVER_WATCHPOINT
;
2859 /* Returns true if scheduler locking applies. STEP indicates whether
2860 we're about to do a step/next-like command to a thread. */
2863 schedlock_applies (struct thread_info
*tp
)
2865 return (scheduler_mode
== schedlock_on
2866 || (scheduler_mode
== schedlock_step
2867 && tp
->control
.stepping_command
));
2870 /* Basic routine for continuing the program in various fashions.
2872 ADDR is the address to resume at, or -1 for resume where stopped.
2873 SIGGNAL is the signal to give it, or 0 for none,
2874 or -1 for act according to how it stopped.
2875 STEP is nonzero if should trap after one instruction.
2876 -1 means return after that and print nothing.
2877 You should probably set various step_... variables
2878 before calling here, if you are stepping.
2880 You should call clear_proceed_status before calling proceed. */
2883 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
2885 struct regcache
*regcache
;
2886 struct gdbarch
*gdbarch
;
2887 struct thread_info
*tp
;
2889 struct address_space
*aspace
;
2891 struct execution_control_state ecss
;
2892 struct execution_control_state
*ecs
= &ecss
;
2893 struct cleanup
*old_chain
;
2896 /* If we're stopped at a fork/vfork, follow the branch set by the
2897 "set follow-fork-mode" command; otherwise, we'll just proceed
2898 resuming the current thread. */
2899 if (!follow_fork ())
2901 /* The target for some reason decided not to resume. */
2903 if (target_can_async_p ())
2904 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
2908 /* We'll update this if & when we switch to a new thread. */
2909 previous_inferior_ptid
= inferior_ptid
;
2911 regcache
= get_current_regcache ();
2912 gdbarch
= get_regcache_arch (regcache
);
2913 aspace
= get_regcache_aspace (regcache
);
2914 pc
= regcache_read_pc (regcache
);
2915 tp
= inferior_thread ();
2917 /* Fill in with reasonable starting values. */
2918 init_thread_stepping_state (tp
);
2920 gdb_assert (!thread_is_in_step_over_chain (tp
));
2922 if (addr
== (CORE_ADDR
) -1)
2925 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
2926 && execution_direction
!= EXEC_REVERSE
)
2927 /* There is a breakpoint at the address we will resume at,
2928 step one instruction before inserting breakpoints so that
2929 we do not stop right away (and report a second hit at this
2932 Note, we don't do this in reverse, because we won't
2933 actually be executing the breakpoint insn anyway.
2934 We'll be (un-)executing the previous instruction. */
2935 tp
->stepping_over_breakpoint
= 1;
2936 else if (gdbarch_single_step_through_delay_p (gdbarch
)
2937 && gdbarch_single_step_through_delay (gdbarch
,
2938 get_current_frame ()))
2939 /* We stepped onto an instruction that needs to be stepped
2940 again before re-inserting the breakpoint, do so. */
2941 tp
->stepping_over_breakpoint
= 1;
2945 regcache_write_pc (regcache
, addr
);
2948 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
2949 tp
->suspend
.stop_signal
= siggnal
;
2951 /* Record the interpreter that issued the execution command that
2952 caused this thread to resume. If the top level interpreter is
2953 MI/async, and the execution command was a CLI command
2954 (next/step/etc.), we'll want to print stop event output to the MI
2955 console channel (the stepped-to line, etc.), as if the user
2956 entered the execution command on a real GDB console. */
2957 tp
->control
.command_interp
= command_interp ();
2959 resume_ptid
= user_visible_resume_ptid (tp
->control
.stepping_command
);
2961 /* If an exception is thrown from this point on, make sure to
2962 propagate GDB's knowledge of the executing state to the
2963 frontend/user running state. */
2964 old_chain
= make_cleanup (finish_thread_state_cleanup
, &resume_ptid
);
2966 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
2967 threads (e.g., we might need to set threads stepping over
2968 breakpoints first), from the user/frontend's point of view, all
2969 threads in RESUME_PTID are now running. Unless we're calling an
2970 inferior function, as in that case we pretend the inferior
2971 doesn't run at all. */
2972 if (!tp
->control
.in_infcall
)
2973 set_running (resume_ptid
, 1);
2976 fprintf_unfiltered (gdb_stdlog
,
2977 "infrun: proceed (addr=%s, signal=%s)\n",
2978 paddress (gdbarch
, addr
),
2979 gdb_signal_to_symbol_string (siggnal
));
2981 annotate_starting ();
2983 /* Make sure that output from GDB appears before output from the
2985 gdb_flush (gdb_stdout
);
2987 /* In a multi-threaded task we may select another thread and
2988 then continue or step.
2990 But if a thread that we're resuming had stopped at a breakpoint,
2991 it will immediately cause another breakpoint stop without any
2992 execution (i.e. it will report a breakpoint hit incorrectly). So
2993 we must step over it first.
2995 Look for threads other than the current (TP) that reported a
2996 breakpoint hit and haven't been resumed yet since. */
2998 /* If scheduler locking applies, we can avoid iterating over all
3000 if (!non_stop
&& !schedlock_applies (tp
))
3002 struct thread_info
*current
= tp
;
3004 ALL_NON_EXITED_THREADS (tp
)
3006 /* Ignore the current thread here. It's handled
3011 /* Ignore threads of processes we're not resuming. */
3012 if (!ptid_match (tp
->ptid
, resume_ptid
))
3015 if (!thread_still_needs_step_over (tp
))
3018 gdb_assert (!thread_is_in_step_over_chain (tp
));
3021 fprintf_unfiltered (gdb_stdlog
,
3022 "infrun: need to step-over [%s] first\n",
3023 target_pid_to_str (tp
->ptid
));
3025 thread_step_over_chain_enqueue (tp
);
3031 /* Enqueue the current thread last, so that we move all other
3032 threads over their breakpoints first. */
3033 if (tp
->stepping_over_breakpoint
)
3034 thread_step_over_chain_enqueue (tp
);
3036 /* If the thread isn't started, we'll still need to set its prev_pc,
3037 so that switch_back_to_stepped_thread knows the thread hasn't
3038 advanced. Must do this before resuming any thread, as in
3039 all-stop/remote, once we resume we can't send any other packet
3040 until the target stops again. */
3041 tp
->prev_pc
= regcache_read_pc (regcache
);
3043 started
= start_step_over ();
3045 if (step_over_info_valid_p ())
3047 /* Either this thread started a new in-line step over, or some
3048 other thread was already doing one. In either case, don't
3049 resume anything else until the step-over is finished. */
3051 else if (started
&& !target_is_non_stop_p ())
3053 /* A new displaced stepping sequence was started. In all-stop,
3054 we can't talk to the target anymore until it next stops. */
3056 else if (!non_stop
&& target_is_non_stop_p ())
3058 /* In all-stop, but the target is always in non-stop mode.
3059 Start all other threads that are implicitly resumed too. */
3060 ALL_NON_EXITED_THREADS (tp
)
3062 /* Ignore threads of processes we're not resuming. */
3063 if (!ptid_match (tp
->ptid
, resume_ptid
))
3069 fprintf_unfiltered (gdb_stdlog
,
3070 "infrun: proceed: [%s] resumed\n",
3071 target_pid_to_str (tp
->ptid
));
3072 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
3076 if (thread_is_in_step_over_chain (tp
))
3079 fprintf_unfiltered (gdb_stdlog
,
3080 "infrun: proceed: [%s] needs step-over\n",
3081 target_pid_to_str (tp
->ptid
));
3086 fprintf_unfiltered (gdb_stdlog
,
3087 "infrun: proceed: resuming %s\n",
3088 target_pid_to_str (tp
->ptid
));
3090 reset_ecs (ecs
, tp
);
3091 switch_to_thread (tp
->ptid
);
3092 keep_going_pass_signal (ecs
);
3093 if (!ecs
->wait_some_more
)
3094 error (_("Command aborted."));
3097 else if (!tp
->resumed
&& !thread_is_in_step_over_chain (tp
))
3099 /* The thread wasn't started, and isn't queued, run it now. */
3100 reset_ecs (ecs
, tp
);
3101 switch_to_thread (tp
->ptid
);
3102 keep_going_pass_signal (ecs
);
3103 if (!ecs
->wait_some_more
)
3104 error (_("Command aborted."));
3107 discard_cleanups (old_chain
);
3109 /* Tell the event loop to wait for it to stop. If the target
3110 supports asynchronous execution, it'll do this from within
3112 if (!target_can_async_p ())
3113 mark_async_event_handler (infrun_async_inferior_event_token
);
3117 /* Start remote-debugging of a machine over a serial link. */
3120 start_remote (int from_tty
)
3122 struct inferior
*inferior
;
3124 inferior
= current_inferior ();
3125 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3127 /* Always go on waiting for the target, regardless of the mode. */
3128 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3129 indicate to wait_for_inferior that a target should timeout if
3130 nothing is returned (instead of just blocking). Because of this,
3131 targets expecting an immediate response need to, internally, set
3132 things up so that the target_wait() is forced to eventually
3134 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3135 differentiate to its caller what the state of the target is after
3136 the initial open has been performed. Here we're assuming that
3137 the target has stopped. It should be possible to eventually have
3138 target_open() return to the caller an indication that the target
3139 is currently running and GDB state should be set to the same as
3140 for an async run. */
3141 wait_for_inferior ();
3143 /* Now that the inferior has stopped, do any bookkeeping like
3144 loading shared libraries. We want to do this before normal_stop,
3145 so that the displayed frame is up to date. */
3146 post_create_inferior (¤t_target
, from_tty
);
3151 /* Initialize static vars when a new inferior begins. */
3154 init_wait_for_inferior (void)
3156 /* These are meaningless until the first time through wait_for_inferior. */
3158 breakpoint_init_inferior (inf_starting
);
3160 clear_proceed_status (0);
3162 target_last_wait_ptid
= minus_one_ptid
;
3164 previous_inferior_ptid
= inferior_ptid
;
3166 /* Discard any skipped inlined frames. */
3167 clear_inline_frame_state (minus_one_ptid
);
3172 static void handle_inferior_event (struct execution_control_state
*ecs
);
3174 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3175 struct execution_control_state
*ecs
);
3176 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3177 struct execution_control_state
*ecs
);
3178 static void handle_signal_stop (struct execution_control_state
*ecs
);
3179 static void check_exception_resume (struct execution_control_state
*,
3180 struct frame_info
*);
3182 static void end_stepping_range (struct execution_control_state
*ecs
);
3183 static void stop_waiting (struct execution_control_state
*ecs
);
3184 static void keep_going (struct execution_control_state
*ecs
);
3185 static void process_event_stop_test (struct execution_control_state
*ecs
);
3186 static int switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3188 /* Callback for iterate over threads. If the thread is stopped, but
3189 the user/frontend doesn't know about that yet, go through
3190 normal_stop, as if the thread had just stopped now. ARG points at
3191 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
3192 ptid_is_pid(PTID) is true, applies to all threads of the process
3193 pointed at by PTID. Otherwise, apply only to the thread pointed by
3197 infrun_thread_stop_requested_callback (struct thread_info
*info
, void *arg
)
3199 ptid_t ptid
= * (ptid_t
*) arg
;
3201 if ((ptid_equal (info
->ptid
, ptid
)
3202 || ptid_equal (minus_one_ptid
, ptid
)
3203 || (ptid_is_pid (ptid
)
3204 && ptid_get_pid (ptid
) == ptid_get_pid (info
->ptid
)))
3205 && is_running (info
->ptid
)
3206 && !is_executing (info
->ptid
))
3208 struct cleanup
*old_chain
;
3209 struct execution_control_state ecss
;
3210 struct execution_control_state
*ecs
= &ecss
;
3212 memset (ecs
, 0, sizeof (*ecs
));
3214 old_chain
= make_cleanup_restore_current_thread ();
3216 overlay_cache_invalid
= 1;
3217 /* Flush target cache before starting to handle each event.
3218 Target was running and cache could be stale. This is just a
3219 heuristic. Running threads may modify target memory, but we
3220 don't get any event. */
3221 target_dcache_invalidate ();
3223 /* Go through handle_inferior_event/normal_stop, so we always
3224 have consistent output as if the stop event had been
3226 ecs
->ptid
= info
->ptid
;
3227 ecs
->event_thread
= info
;
3228 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
3229 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
3231 handle_inferior_event (ecs
);
3233 if (!ecs
->wait_some_more
)
3235 /* Cancel any running execution command. */
3236 thread_cancel_execution_command (info
);
3241 do_cleanups (old_chain
);
3247 /* This function is attached as a "thread_stop_requested" observer.
3248 Cleanup local state that assumed the PTID was to be resumed, and
3249 report the stop to the frontend. */
3252 infrun_thread_stop_requested (ptid_t ptid
)
3254 struct thread_info
*tp
;
3256 /* PTID was requested to stop. Remove matching threads from the
3257 step-over queue, so we don't try to resume them
3259 ALL_NON_EXITED_THREADS (tp
)
3260 if (ptid_match (tp
->ptid
, ptid
))
3262 if (thread_is_in_step_over_chain (tp
))
3263 thread_step_over_chain_remove (tp
);
3266 iterate_over_threads (infrun_thread_stop_requested_callback
, &ptid
);
3270 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3272 if (ptid_equal (target_last_wait_ptid
, tp
->ptid
))
3273 nullify_last_target_wait_ptid ();
3276 /* Delete the step resume, single-step and longjmp/exception resume
3277 breakpoints of TP. */
3280 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3282 delete_step_resume_breakpoint (tp
);
3283 delete_exception_resume_breakpoint (tp
);
3284 delete_single_step_breakpoints (tp
);
3287 /* If the target still has execution, call FUNC for each thread that
3288 just stopped. In all-stop, that's all the non-exited threads; in
3289 non-stop, that's the current thread, only. */
3291 typedef void (*for_each_just_stopped_thread_callback_func
)
3292 (struct thread_info
*tp
);
3295 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3297 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
3300 if (target_is_non_stop_p ())
3302 /* If in non-stop mode, only the current thread stopped. */
3303 func (inferior_thread ());
3307 struct thread_info
*tp
;
3309 /* In all-stop mode, all threads have stopped. */
3310 ALL_NON_EXITED_THREADS (tp
)
3317 /* Delete the step resume and longjmp/exception resume breakpoints of
3318 the threads that just stopped. */
3321 delete_just_stopped_threads_infrun_breakpoints (void)
3323 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3326 /* Delete the single-step breakpoints of the threads that just
3330 delete_just_stopped_threads_single_step_breakpoints (void)
3332 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3335 /* A cleanup wrapper. */
3338 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg
)
3340 delete_just_stopped_threads_infrun_breakpoints ();
3346 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3347 const struct target_waitstatus
*ws
)
3349 char *status_string
= target_waitstatus_to_string (ws
);
3350 struct ui_file
*tmp_stream
= mem_fileopen ();
3353 /* The text is split over several lines because it was getting too long.
3354 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3355 output as a unit; we want only one timestamp printed if debug_timestamp
3358 fprintf_unfiltered (tmp_stream
,
3359 "infrun: target_wait (%d.%ld.%ld",
3360 ptid_get_pid (waiton_ptid
),
3361 ptid_get_lwp (waiton_ptid
),
3362 ptid_get_tid (waiton_ptid
));
3363 if (ptid_get_pid (waiton_ptid
) != -1)
3364 fprintf_unfiltered (tmp_stream
,
3365 " [%s]", target_pid_to_str (waiton_ptid
));
3366 fprintf_unfiltered (tmp_stream
, ", status) =\n");
3367 fprintf_unfiltered (tmp_stream
,
3368 "infrun: %d.%ld.%ld [%s],\n",
3369 ptid_get_pid (result_ptid
),
3370 ptid_get_lwp (result_ptid
),
3371 ptid_get_tid (result_ptid
),
3372 target_pid_to_str (result_ptid
));
3373 fprintf_unfiltered (tmp_stream
,
3377 text
= ui_file_xstrdup (tmp_stream
, NULL
);
3379 /* This uses %s in part to handle %'s in the text, but also to avoid
3380 a gcc error: the format attribute requires a string literal. */
3381 fprintf_unfiltered (gdb_stdlog
, "%s", text
);
3383 xfree (status_string
);
3385 ui_file_delete (tmp_stream
);
3388 /* Select a thread at random, out of those which are resumed and have
3391 static struct thread_info
*
3392 random_pending_event_thread (ptid_t waiton_ptid
)
3394 struct thread_info
*event_tp
;
3396 int random_selector
;
3398 /* First see how many events we have. Count only resumed threads
3399 that have an event pending. */
3400 ALL_NON_EXITED_THREADS (event_tp
)
3401 if (ptid_match (event_tp
->ptid
, waiton_ptid
)
3402 && event_tp
->resumed
3403 && event_tp
->suspend
.waitstatus_pending_p
)
3406 if (num_events
== 0)
3409 /* Now randomly pick a thread out of those that have had events. */
3410 random_selector
= (int)
3411 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
3413 if (debug_infrun
&& num_events
> 1)
3414 fprintf_unfiltered (gdb_stdlog
,
3415 "infrun: Found %d events, selecting #%d\n",
3416 num_events
, random_selector
);
3418 /* Select the Nth thread that has had an event. */
3419 ALL_NON_EXITED_THREADS (event_tp
)
3420 if (ptid_match (event_tp
->ptid
, waiton_ptid
)
3421 && event_tp
->resumed
3422 && event_tp
->suspend
.waitstatus_pending_p
)
3423 if (random_selector
-- == 0)
3429 /* Wrapper for target_wait that first checks whether threads have
3430 pending statuses to report before actually asking the target for
3434 do_target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3437 struct thread_info
*tp
;
3439 /* First check if there is a resumed thread with a wait status
3441 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
3443 tp
= random_pending_event_thread (ptid
);
3448 fprintf_unfiltered (gdb_stdlog
,
3449 "infrun: Waiting for specific thread %s.\n",
3450 target_pid_to_str (ptid
));
3452 /* We have a specific thread to check. */
3453 tp
= find_thread_ptid (ptid
);
3454 gdb_assert (tp
!= NULL
);
3455 if (!tp
->suspend
.waitstatus_pending_p
)
3460 && (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3461 || tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
3463 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
3464 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3468 pc
= regcache_read_pc (regcache
);
3470 if (pc
!= tp
->suspend
.stop_pc
)
3473 fprintf_unfiltered (gdb_stdlog
,
3474 "infrun: PC of %s changed. was=%s, now=%s\n",
3475 target_pid_to_str (tp
->ptid
),
3476 paddress (gdbarch
, tp
->prev_pc
),
3477 paddress (gdbarch
, pc
));
3480 else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
3483 fprintf_unfiltered (gdb_stdlog
,
3484 "infrun: previous breakpoint of %s, at %s gone\n",
3485 target_pid_to_str (tp
->ptid
),
3486 paddress (gdbarch
, pc
));
3494 fprintf_unfiltered (gdb_stdlog
,
3495 "infrun: pending event of %s cancelled.\n",
3496 target_pid_to_str (tp
->ptid
));
3498 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_SPURIOUS
;
3499 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3509 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
3510 fprintf_unfiltered (gdb_stdlog
,
3511 "infrun: Using pending wait status %s for %s.\n",
3513 target_pid_to_str (tp
->ptid
));
3517 /* Now that we've selected our final event LWP, un-adjust its PC
3518 if it was a software breakpoint (and the target doesn't
3519 always adjust the PC itself). */
3520 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3521 && !target_supports_stopped_by_sw_breakpoint ())
3523 struct regcache
*regcache
;
3524 struct gdbarch
*gdbarch
;
3527 regcache
= get_thread_regcache (tp
->ptid
);
3528 gdbarch
= get_regcache_arch (regcache
);
3530 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3535 pc
= regcache_read_pc (regcache
);
3536 regcache_write_pc (regcache
, pc
+ decr_pc
);
3540 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3541 *status
= tp
->suspend
.waitstatus
;
3542 tp
->suspend
.waitstatus_pending_p
= 0;
3544 /* Wake up the event loop again, until all pending events are
3546 if (target_is_async_p ())
3547 mark_async_event_handler (infrun_async_inferior_event_token
);
3551 /* But if we don't find one, we'll have to wait. */
3553 if (deprecated_target_wait_hook
)
3554 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3556 event_ptid
= target_wait (ptid
, status
, options
);
3561 /* Prepare and stabilize the inferior for detaching it. E.g.,
3562 detaching while a thread is displaced stepping is a recipe for
3563 crashing it, as nothing would readjust the PC out of the scratch
3567 prepare_for_detach (void)
3569 struct inferior
*inf
= current_inferior ();
3570 ptid_t pid_ptid
= pid_to_ptid (inf
->pid
);
3571 struct cleanup
*old_chain_1
;
3572 struct displaced_step_inferior_state
*displaced
;
3574 displaced
= get_displaced_stepping_state (inf
->pid
);
3576 /* Is any thread of this process displaced stepping? If not,
3577 there's nothing else to do. */
3578 if (displaced
== NULL
|| ptid_equal (displaced
->step_ptid
, null_ptid
))
3582 fprintf_unfiltered (gdb_stdlog
,
3583 "displaced-stepping in-process while detaching");
3585 old_chain_1
= make_cleanup_restore_integer (&inf
->detaching
);
3588 while (!ptid_equal (displaced
->step_ptid
, null_ptid
))
3590 struct cleanup
*old_chain_2
;
3591 struct execution_control_state ecss
;
3592 struct execution_control_state
*ecs
;
3595 memset (ecs
, 0, sizeof (*ecs
));
3597 overlay_cache_invalid
= 1;
3598 /* Flush target cache before starting to handle each event.
3599 Target was running and cache could be stale. This is just a
3600 heuristic. Running threads may modify target memory, but we
3601 don't get any event. */
3602 target_dcache_invalidate ();
3604 ecs
->ptid
= do_target_wait (pid_ptid
, &ecs
->ws
, 0);
3607 print_target_wait_results (pid_ptid
, ecs
->ptid
, &ecs
->ws
);
3609 /* If an error happens while handling the event, propagate GDB's
3610 knowledge of the executing state to the frontend/user running
3612 old_chain_2
= make_cleanup (finish_thread_state_cleanup
,
3615 /* Now figure out what to do with the result of the result. */
3616 handle_inferior_event (ecs
);
3618 /* No error, don't finish the state yet. */
3619 discard_cleanups (old_chain_2
);
3621 /* Breakpoints and watchpoints are not installed on the target
3622 at this point, and signals are passed directly to the
3623 inferior, so this must mean the process is gone. */
3624 if (!ecs
->wait_some_more
)
3626 discard_cleanups (old_chain_1
);
3627 error (_("Program exited while detaching"));
3631 discard_cleanups (old_chain_1
);
3634 /* Wait for control to return from inferior to debugger.
3636 If inferior gets a signal, we may decide to start it up again
3637 instead of returning. That is why there is a loop in this function.
3638 When this function actually returns it means the inferior
3639 should be left stopped and GDB should read more commands. */
3642 wait_for_inferior (void)
3644 struct cleanup
*old_cleanups
;
3645 struct cleanup
*thread_state_chain
;
3649 (gdb_stdlog
, "infrun: wait_for_inferior ()\n");
3652 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
,
3655 /* If an error happens while handling the event, propagate GDB's
3656 knowledge of the executing state to the frontend/user running
3658 thread_state_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3662 struct execution_control_state ecss
;
3663 struct execution_control_state
*ecs
= &ecss
;
3664 ptid_t waiton_ptid
= minus_one_ptid
;
3666 memset (ecs
, 0, sizeof (*ecs
));
3668 overlay_cache_invalid
= 1;
3670 /* Flush target cache before starting to handle each event.
3671 Target was running and cache could be stale. This is just a
3672 heuristic. Running threads may modify target memory, but we
3673 don't get any event. */
3674 target_dcache_invalidate ();
3676 ecs
->ptid
= do_target_wait (waiton_ptid
, &ecs
->ws
, 0);
3679 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3681 /* Now figure out what to do with the result of the result. */
3682 handle_inferior_event (ecs
);
3684 if (!ecs
->wait_some_more
)
3688 /* No error, don't finish the state yet. */
3689 discard_cleanups (thread_state_chain
);
3691 do_cleanups (old_cleanups
);
3694 /* Cleanup that reinstalls the readline callback handler, if the
3695 target is running in the background. If while handling the target
3696 event something triggered a secondary prompt, like e.g., a
3697 pagination prompt, we'll have removed the callback handler (see
3698 gdb_readline_wrapper_line). Need to do this as we go back to the
3699 event loop, ready to process further input. Note this has no
3700 effect if the handler hasn't actually been removed, because calling
3701 rl_callback_handler_install resets the line buffer, thus losing
3705 reinstall_readline_callback_handler_cleanup (void *arg
)
3707 if (!interpreter_async
)
3709 /* We're not going back to the top level event loop yet. Don't
3710 install the readline callback, as it'd prep the terminal,
3711 readline-style (raw, noecho) (e.g., --batch). We'll install
3712 it the next time the prompt is displayed, when we're ready
3717 if (async_command_editing_p
&& !sync_execution
)
3718 gdb_rl_callback_handler_reinstall ();
3721 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3722 that's just the event thread. In all-stop, that's all threads. */
3725 clean_up_just_stopped_threads_fsms (struct execution_control_state
*ecs
)
3727 struct thread_info
*thr
= ecs
->event_thread
;
3729 if (thr
!= NULL
&& thr
->thread_fsm
!= NULL
)
3730 thread_fsm_clean_up (thr
->thread_fsm
);
3734 ALL_NON_EXITED_THREADS (thr
)
3736 if (thr
->thread_fsm
== NULL
)
3738 if (thr
== ecs
->event_thread
)
3741 switch_to_thread (thr
->ptid
);
3742 thread_fsm_clean_up (thr
->thread_fsm
);
3745 if (ecs
->event_thread
!= NULL
)
3746 switch_to_thread (ecs
->event_thread
->ptid
);
3750 /* Asynchronous version of wait_for_inferior. It is called by the
3751 event loop whenever a change of state is detected on the file
3752 descriptor corresponding to the target. It can be called more than
3753 once to complete a single execution command. In such cases we need
3754 to keep the state in a global variable ECSS. If it is the last time
3755 that this function is called for a single execution command, then
3756 report to the user that the inferior has stopped, and do the
3757 necessary cleanups. */
3760 fetch_inferior_event (void *client_data
)
3762 struct execution_control_state ecss
;
3763 struct execution_control_state
*ecs
= &ecss
;
3764 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3765 struct cleanup
*ts_old_chain
;
3766 int was_sync
= sync_execution
;
3768 ptid_t waiton_ptid
= minus_one_ptid
;
3770 memset (ecs
, 0, sizeof (*ecs
));
3772 /* End up with readline processing input, if necessary. */
3773 make_cleanup (reinstall_readline_callback_handler_cleanup
, NULL
);
3775 /* We're handling a live event, so make sure we're doing live
3776 debugging. If we're looking at traceframes while the target is
3777 running, we're going to need to get back to that mode after
3778 handling the event. */
3781 make_cleanup_restore_current_traceframe ();
3782 set_current_traceframe (-1);
3786 /* In non-stop mode, the user/frontend should not notice a thread
3787 switch due to internal events. Make sure we reverse to the
3788 user selected thread and frame after handling the event and
3789 running any breakpoint commands. */
3790 make_cleanup_restore_current_thread ();
3792 overlay_cache_invalid
= 1;
3793 /* Flush target cache before starting to handle each event. Target
3794 was running and cache could be stale. This is just a heuristic.
3795 Running threads may modify target memory, but we don't get any
3797 target_dcache_invalidate ();
3799 make_cleanup_restore_integer (&execution_direction
);
3800 execution_direction
= target_execution_direction ();
3802 ecs
->ptid
= do_target_wait (waiton_ptid
, &ecs
->ws
,
3803 target_can_async_p () ? TARGET_WNOHANG
: 0);
3806 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3808 /* If an error happens while handling the event, propagate GDB's
3809 knowledge of the executing state to the frontend/user running
3811 if (!target_is_non_stop_p ())
3812 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3814 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &ecs
->ptid
);
3816 /* Get executed before make_cleanup_restore_current_thread above to apply
3817 still for the thread which has thrown the exception. */
3818 make_bpstat_clear_actions_cleanup ();
3820 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
, NULL
);
3822 /* Now figure out what to do with the result of the result. */
3823 handle_inferior_event (ecs
);
3825 if (!ecs
->wait_some_more
)
3827 struct inferior
*inf
= find_inferior_ptid (ecs
->ptid
);
3828 int should_stop
= 1;
3829 struct thread_info
*thr
= ecs
->event_thread
;
3830 int should_notify_stop
= 1;
3832 delete_just_stopped_threads_infrun_breakpoints ();
3836 struct thread_fsm
*thread_fsm
= thr
->thread_fsm
;
3838 if (thread_fsm
!= NULL
)
3839 should_stop
= thread_fsm_should_stop (thread_fsm
);
3848 clean_up_just_stopped_threads_fsms (ecs
);
3850 if (thr
!= NULL
&& thr
->thread_fsm
!= NULL
)
3853 = thread_fsm_should_notify_stop (thr
->thread_fsm
);
3856 if (should_notify_stop
)
3858 /* We may not find an inferior if this was a process exit. */
3859 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
3862 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
3868 /* No error, don't finish the thread states yet. */
3869 discard_cleanups (ts_old_chain
);
3871 /* Revert thread and frame. */
3872 do_cleanups (old_chain
);
3874 /* If the inferior was in sync execution mode, and now isn't,
3875 restore the prompt (a synchronous execution command has finished,
3876 and we're ready for input). */
3877 if (interpreter_async
&& was_sync
&& !sync_execution
)
3878 observer_notify_sync_execution_done ();
3882 && exec_done_display_p
3883 && (ptid_equal (inferior_ptid
, null_ptid
)
3884 || !is_running (inferior_ptid
)))
3885 printf_unfiltered (_("completed.\n"));
3888 /* Record the frame and location we're currently stepping through. */
3890 set_step_info (struct frame_info
*frame
, struct symtab_and_line sal
)
3892 struct thread_info
*tp
= inferior_thread ();
3894 tp
->control
.step_frame_id
= get_frame_id (frame
);
3895 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
3897 tp
->current_symtab
= sal
.symtab
;
3898 tp
->current_line
= sal
.line
;
3901 /* Clear context switchable stepping state. */
3904 init_thread_stepping_state (struct thread_info
*tss
)
3906 tss
->stepped_breakpoint
= 0;
3907 tss
->stepping_over_breakpoint
= 0;
3908 tss
->stepping_over_watchpoint
= 0;
3909 tss
->step_after_step_resume_breakpoint
= 0;
3912 /* Set the cached copy of the last ptid/waitstatus. */
3915 set_last_target_status (ptid_t ptid
, struct target_waitstatus status
)
3917 target_last_wait_ptid
= ptid
;
3918 target_last_waitstatus
= status
;
3921 /* Return the cached copy of the last pid/waitstatus returned by
3922 target_wait()/deprecated_target_wait_hook(). The data is actually
3923 cached by handle_inferior_event(), which gets called immediately
3924 after target_wait()/deprecated_target_wait_hook(). */
3927 get_last_target_status (ptid_t
*ptidp
, struct target_waitstatus
*status
)
3929 *ptidp
= target_last_wait_ptid
;
3930 *status
= target_last_waitstatus
;
3934 nullify_last_target_wait_ptid (void)
3936 target_last_wait_ptid
= minus_one_ptid
;
3939 /* Switch thread contexts. */
3942 context_switch (ptid_t ptid
)
3944 if (debug_infrun
&& !ptid_equal (ptid
, inferior_ptid
))
3946 fprintf_unfiltered (gdb_stdlog
, "infrun: Switching context from %s ",
3947 target_pid_to_str (inferior_ptid
));
3948 fprintf_unfiltered (gdb_stdlog
, "to %s\n",
3949 target_pid_to_str (ptid
));
3952 switch_to_thread (ptid
);
3955 /* If the target can't tell whether we've hit breakpoints
3956 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
3957 check whether that could have been caused by a breakpoint. If so,
3958 adjust the PC, per gdbarch_decr_pc_after_break. */
3961 adjust_pc_after_break (struct thread_info
*thread
,
3962 struct target_waitstatus
*ws
)
3964 struct regcache
*regcache
;
3965 struct gdbarch
*gdbarch
;
3966 struct address_space
*aspace
;
3967 CORE_ADDR breakpoint_pc
, decr_pc
;
3969 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
3970 we aren't, just return.
3972 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3973 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
3974 implemented by software breakpoints should be handled through the normal
3977 NOTE drow/2004-01-31: On some targets, breakpoints may generate
3978 different signals (SIGILL or SIGEMT for instance), but it is less
3979 clear where the PC is pointing afterwards. It may not match
3980 gdbarch_decr_pc_after_break. I don't know any specific target that
3981 generates these signals at breakpoints (the code has been in GDB since at
3982 least 1992) so I can not guess how to handle them here.
3984 In earlier versions of GDB, a target with
3985 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3986 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
3987 target with both of these set in GDB history, and it seems unlikely to be
3988 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
3990 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
3993 if (ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
3996 /* In reverse execution, when a breakpoint is hit, the instruction
3997 under it has already been de-executed. The reported PC always
3998 points at the breakpoint address, so adjusting it further would
3999 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4002 B1 0x08000000 : INSN1
4003 B2 0x08000001 : INSN2
4005 PC -> 0x08000003 : INSN4
4007 Say you're stopped at 0x08000003 as above. Reverse continuing
4008 from that point should hit B2 as below. Reading the PC when the
4009 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4010 been de-executed already.
4012 B1 0x08000000 : INSN1
4013 B2 PC -> 0x08000001 : INSN2
4017 We can't apply the same logic as for forward execution, because
4018 we would wrongly adjust the PC to 0x08000000, since there's a
4019 breakpoint at PC - 1. We'd then report a hit on B1, although
4020 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4022 if (execution_direction
== EXEC_REVERSE
)
4025 /* If the target can tell whether the thread hit a SW breakpoint,
4026 trust it. Targets that can tell also adjust the PC
4028 if (target_supports_stopped_by_sw_breakpoint ())
4031 /* Note that relying on whether a breakpoint is planted in memory to
4032 determine this can fail. E.g,. the breakpoint could have been
4033 removed since. Or the thread could have been told to step an
4034 instruction the size of a breakpoint instruction, and only
4035 _after_ was a breakpoint inserted at its address. */
4037 /* If this target does not decrement the PC after breakpoints, then
4038 we have nothing to do. */
4039 regcache
= get_thread_regcache (thread
->ptid
);
4040 gdbarch
= get_regcache_arch (regcache
);
4042 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
4046 aspace
= get_regcache_aspace (regcache
);
4048 /* Find the location where (if we've hit a breakpoint) the
4049 breakpoint would be. */
4050 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4052 /* If the target can't tell whether a software breakpoint triggered,
4053 fallback to figuring it out based on breakpoints we think were
4054 inserted in the target, and on whether the thread was stepped or
4057 /* Check whether there actually is a software breakpoint inserted at
4060 If in non-stop mode, a race condition is possible where we've
4061 removed a breakpoint, but stop events for that breakpoint were
4062 already queued and arrive later. To suppress those spurious
4063 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4064 and retire them after a number of stop events are reported. Note
4065 this is an heuristic and can thus get confused. The real fix is
4066 to get the "stopped by SW BP and needs adjustment" info out of
4067 the target/kernel (and thus never reach here; see above). */
4068 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4069 || (target_is_non_stop_p ()
4070 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4072 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
4074 if (record_full_is_used ())
4075 record_full_gdb_operation_disable_set ();
4077 /* When using hardware single-step, a SIGTRAP is reported for both
4078 a completed single-step and a software breakpoint. Need to
4079 differentiate between the two, as the latter needs adjusting
4080 but the former does not.
4082 The SIGTRAP can be due to a completed hardware single-step only if
4083 - we didn't insert software single-step breakpoints
4084 - this thread is currently being stepped
4086 If any of these events did not occur, we must have stopped due
4087 to hitting a software breakpoint, and have to back up to the
4090 As a special case, we could have hardware single-stepped a
4091 software breakpoint. In this case (prev_pc == breakpoint_pc),
4092 we also need to back up to the breakpoint address. */
4094 if (thread_has_single_step_breakpoints_set (thread
)
4095 || !currently_stepping (thread
)
4096 || (thread
->stepped_breakpoint
4097 && thread
->prev_pc
== breakpoint_pc
))
4098 regcache_write_pc (regcache
, breakpoint_pc
);
4100 do_cleanups (old_cleanups
);
4105 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4107 for (frame
= get_prev_frame (frame
);
4109 frame
= get_prev_frame (frame
))
4111 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4113 if (get_frame_type (frame
) != INLINE_FRAME
)
4120 /* Auxiliary function that handles syscall entry/return events.
4121 It returns 1 if the inferior should keep going (and GDB
4122 should ignore the event), or 0 if the event deserves to be
4126 handle_syscall_event (struct execution_control_state
*ecs
)
4128 struct regcache
*regcache
;
4131 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4132 context_switch (ecs
->ptid
);
4134 regcache
= get_thread_regcache (ecs
->ptid
);
4135 syscall_number
= ecs
->ws
.value
.syscall_number
;
4136 stop_pc
= regcache_read_pc (regcache
);
4138 if (catch_syscall_enabled () > 0
4139 && catching_syscall_number (syscall_number
) > 0)
4142 fprintf_unfiltered (gdb_stdlog
, "infrun: syscall number = '%d'\n",
4145 ecs
->event_thread
->control
.stop_bpstat
4146 = bpstat_stop_status (get_regcache_aspace (regcache
),
4147 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4149 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4151 /* Catchpoint hit. */
4156 /* If no catchpoint triggered for this, then keep going. */
4161 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4164 fill_in_stop_func (struct gdbarch
*gdbarch
,
4165 struct execution_control_state
*ecs
)
4167 if (!ecs
->stop_func_filled_in
)
4169 /* Don't care about return value; stop_func_start and stop_func_name
4170 will both be 0 if it doesn't work. */
4171 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
4172 &ecs
->stop_func_start
, &ecs
->stop_func_end
);
4173 ecs
->stop_func_start
4174 += gdbarch_deprecated_function_start_offset (gdbarch
);
4176 if (gdbarch_skip_entrypoint_p (gdbarch
))
4177 ecs
->stop_func_start
= gdbarch_skip_entrypoint (gdbarch
,
4178 ecs
->stop_func_start
);
4180 ecs
->stop_func_filled_in
= 1;
4185 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
4187 static enum stop_kind
4188 get_inferior_stop_soon (ptid_t ptid
)
4190 struct inferior
*inf
= find_inferior_ptid (ptid
);
4192 gdb_assert (inf
!= NULL
);
4193 return inf
->control
.stop_soon
;
4196 /* Wait for one event. Store the resulting waitstatus in WS, and
4197 return the event ptid. */
4200 wait_one (struct target_waitstatus
*ws
)
4203 ptid_t wait_ptid
= minus_one_ptid
;
4205 overlay_cache_invalid
= 1;
4207 /* Flush target cache before starting to handle each event.
4208 Target was running and cache could be stale. This is just a
4209 heuristic. Running threads may modify target memory, but we
4210 don't get any event. */
4211 target_dcache_invalidate ();
4213 if (deprecated_target_wait_hook
)
4214 event_ptid
= deprecated_target_wait_hook (wait_ptid
, ws
, 0);
4216 event_ptid
= target_wait (wait_ptid
, ws
, 0);
4219 print_target_wait_results (wait_ptid
, event_ptid
, ws
);
4224 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4225 instead of the current thread. */
4226 #define THREAD_STOPPED_BY(REASON) \
4228 thread_stopped_by_ ## REASON (ptid_t ptid) \
4230 struct cleanup *old_chain; \
4233 old_chain = save_inferior_ptid (); \
4234 inferior_ptid = ptid; \
4236 res = target_stopped_by_ ## REASON (); \
4238 do_cleanups (old_chain); \
4243 /* Generate thread_stopped_by_watchpoint. */
4244 THREAD_STOPPED_BY (watchpoint
)
4245 /* Generate thread_stopped_by_sw_breakpoint. */
4246 THREAD_STOPPED_BY (sw_breakpoint
)
4247 /* Generate thread_stopped_by_hw_breakpoint. */
4248 THREAD_STOPPED_BY (hw_breakpoint
)
4250 /* Cleanups that switches to the PTID pointed at by PTID_P. */
4253 switch_to_thread_cleanup (void *ptid_p
)
4255 ptid_t ptid
= *(ptid_t
*) ptid_p
;
4257 switch_to_thread (ptid
);
4260 /* Save the thread's event and stop reason to process it later. */
4263 save_waitstatus (struct thread_info
*tp
, struct target_waitstatus
*ws
)
4265 struct regcache
*regcache
;
4266 struct address_space
*aspace
;
4272 statstr
= target_waitstatus_to_string (ws
);
4273 fprintf_unfiltered (gdb_stdlog
,
4274 "infrun: saving status %s for %d.%ld.%ld\n",
4276 ptid_get_pid (tp
->ptid
),
4277 ptid_get_lwp (tp
->ptid
),
4278 ptid_get_tid (tp
->ptid
));
4282 /* Record for later. */
4283 tp
->suspend
.waitstatus
= *ws
;
4284 tp
->suspend
.waitstatus_pending_p
= 1;
4286 regcache
= get_thread_regcache (tp
->ptid
);
4287 aspace
= get_regcache_aspace (regcache
);
4289 if (ws
->kind
== TARGET_WAITKIND_STOPPED
4290 && ws
->value
.sig
== GDB_SIGNAL_TRAP
)
4292 CORE_ADDR pc
= regcache_read_pc (regcache
);
4294 adjust_pc_after_break (tp
, &tp
->suspend
.waitstatus
);
4296 if (thread_stopped_by_watchpoint (tp
->ptid
))
4298 tp
->suspend
.stop_reason
4299 = TARGET_STOPPED_BY_WATCHPOINT
;
4301 else if (target_supports_stopped_by_sw_breakpoint ()
4302 && thread_stopped_by_sw_breakpoint (tp
->ptid
))
4304 tp
->suspend
.stop_reason
4305 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4307 else if (target_supports_stopped_by_hw_breakpoint ()
4308 && thread_stopped_by_hw_breakpoint (tp
->ptid
))
4310 tp
->suspend
.stop_reason
4311 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4313 else if (!target_supports_stopped_by_hw_breakpoint ()
4314 && hardware_breakpoint_inserted_here_p (aspace
,
4317 tp
->suspend
.stop_reason
4318 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4320 else if (!target_supports_stopped_by_sw_breakpoint ()
4321 && software_breakpoint_inserted_here_p (aspace
,
4324 tp
->suspend
.stop_reason
4325 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4327 else if (!thread_has_single_step_breakpoints_set (tp
)
4328 && currently_stepping (tp
))
4330 tp
->suspend
.stop_reason
4331 = TARGET_STOPPED_BY_SINGLE_STEP
;
4336 /* Stop all threads. */
4339 stop_all_threads (void)
4341 /* We may need multiple passes to discover all threads. */
4345 struct cleanup
*old_chain
;
4347 gdb_assert (target_is_non_stop_p ());
4350 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads\n");
4352 entry_ptid
= inferior_ptid
;
4353 old_chain
= make_cleanup (switch_to_thread_cleanup
, &entry_ptid
);
4355 /* Request threads to stop, and then wait for the stops. Because
4356 threads we already know about can spawn more threads while we're
4357 trying to stop them, and we only learn about new threads when we
4358 update the thread list, do this in a loop, and keep iterating
4359 until two passes find no threads that need to be stopped. */
4360 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4363 fprintf_unfiltered (gdb_stdlog
,
4364 "infrun: stop_all_threads, pass=%d, "
4365 "iterations=%d\n", pass
, iterations
);
4369 struct target_waitstatus ws
;
4371 struct thread_info
*t
;
4373 update_thread_list ();
4375 /* Go through all threads looking for threads that we need
4376 to tell the target to stop. */
4377 ALL_NON_EXITED_THREADS (t
)
4381 /* If already stopping, don't request a stop again.
4382 We just haven't seen the notification yet. */
4383 if (!t
->stop_requested
)
4386 fprintf_unfiltered (gdb_stdlog
,
4387 "infrun: %s executing, "
4389 target_pid_to_str (t
->ptid
));
4390 target_stop (t
->ptid
);
4391 t
->stop_requested
= 1;
4396 fprintf_unfiltered (gdb_stdlog
,
4397 "infrun: %s executing, "
4398 "already stopping\n",
4399 target_pid_to_str (t
->ptid
));
4402 if (t
->stop_requested
)
4408 fprintf_unfiltered (gdb_stdlog
,
4409 "infrun: %s not executing\n",
4410 target_pid_to_str (t
->ptid
));
4412 /* The thread may be not executing, but still be
4413 resumed with a pending status to process. */
4421 /* If we find new threads on the second iteration, restart
4422 over. We want to see two iterations in a row with all
4427 event_ptid
= wait_one (&ws
);
4428 if (ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4430 /* All resumed threads exited. */
4432 else if (ws
.kind
== TARGET_WAITKIND_EXITED
4433 || ws
.kind
== TARGET_WAITKIND_SIGNALLED
)
4437 ptid_t ptid
= pid_to_ptid (ws
.value
.integer
);
4439 fprintf_unfiltered (gdb_stdlog
,
4440 "infrun: %s exited while "
4441 "stopping threads\n",
4442 target_pid_to_str (ptid
));
4447 t
= find_thread_ptid (event_ptid
);
4449 t
= add_thread (event_ptid
);
4451 t
->stop_requested
= 0;
4454 t
->control
.may_range_step
= 0;
4456 if (ws
.kind
== TARGET_WAITKIND_STOPPED
4457 && ws
.value
.sig
== GDB_SIGNAL_0
)
4459 /* We caught the event that we intended to catch, so
4460 there's no event pending. */
4461 t
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
4462 t
->suspend
.waitstatus_pending_p
= 0;
4464 if (displaced_step_fixup (t
->ptid
, GDB_SIGNAL_0
) < 0)
4466 /* Add it back to the step-over queue. */
4469 fprintf_unfiltered (gdb_stdlog
,
4470 "infrun: displaced-step of %s "
4471 "canceled: adding back to the "
4472 "step-over queue\n",
4473 target_pid_to_str (t
->ptid
));
4475 t
->control
.trap_expected
= 0;
4476 thread_step_over_chain_enqueue (t
);
4481 enum gdb_signal sig
;
4482 struct regcache
*regcache
;
4483 struct address_space
*aspace
;
4489 statstr
= target_waitstatus_to_string (&ws
);
4490 fprintf_unfiltered (gdb_stdlog
,
4491 "infrun: target_wait %s, saving "
4492 "status for %d.%ld.%ld\n",
4494 ptid_get_pid (t
->ptid
),
4495 ptid_get_lwp (t
->ptid
),
4496 ptid_get_tid (t
->ptid
));
4500 /* Record for later. */
4501 save_waitstatus (t
, &ws
);
4503 sig
= (ws
.kind
== TARGET_WAITKIND_STOPPED
4504 ? ws
.value
.sig
: GDB_SIGNAL_0
);
4506 if (displaced_step_fixup (t
->ptid
, sig
) < 0)
4508 /* Add it back to the step-over queue. */
4509 t
->control
.trap_expected
= 0;
4510 thread_step_over_chain_enqueue (t
);
4513 regcache
= get_thread_regcache (t
->ptid
);
4514 t
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4518 fprintf_unfiltered (gdb_stdlog
,
4519 "infrun: saved stop_pc=%s for %s "
4520 "(currently_stepping=%d)\n",
4521 paddress (target_gdbarch (),
4522 t
->suspend
.stop_pc
),
4523 target_pid_to_str (t
->ptid
),
4524 currently_stepping (t
));
4531 do_cleanups (old_chain
);
4534 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads done\n");
4537 /* Given an execution control state that has been freshly filled in by
4538 an event from the inferior, figure out what it means and take
4541 The alternatives are:
4543 1) stop_waiting and return; to really stop and return to the
4546 2) keep_going and return; to wait for the next event (set
4547 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4551 handle_inferior_event_1 (struct execution_control_state
*ecs
)
4553 enum stop_kind stop_soon
;
4555 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
4557 /* We had an event in the inferior, but we are not interested in
4558 handling it at this level. The lower layers have already
4559 done what needs to be done, if anything.
4561 One of the possible circumstances for this is when the
4562 inferior produces output for the console. The inferior has
4563 not stopped, and we are ignoring the event. Another possible
4564 circumstance is any event which the lower level knows will be
4565 reported multiple times without an intervening resume. */
4567 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_IGNORE\n");
4568 prepare_to_wait (ecs
);
4572 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
4573 && target_can_async_p () && !sync_execution
)
4575 /* There were no unwaited-for children left in the target, but,
4576 we're not synchronously waiting for events either. Just
4577 ignore. Otherwise, if we were running a synchronous
4578 execution command, we need to cancel it and give the user
4579 back the terminal. */
4581 fprintf_unfiltered (gdb_stdlog
,
4582 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
4583 prepare_to_wait (ecs
);
4587 /* Cache the last pid/waitstatus. */
4588 set_last_target_status (ecs
->ptid
, ecs
->ws
);
4590 /* Always clear state belonging to the previous time we stopped. */
4591 stop_stack_dummy
= STOP_NONE
;
4593 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4595 /* No unwaited-for children left. IOW, all resumed children
4598 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4600 stop_print_frame
= 0;
4605 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
4606 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
4608 ecs
->event_thread
= find_thread_ptid (ecs
->ptid
);
4609 /* If it's a new thread, add it to the thread database. */
4610 if (ecs
->event_thread
== NULL
)
4611 ecs
->event_thread
= add_thread (ecs
->ptid
);
4613 /* Disable range stepping. If the next step request could use a
4614 range, this will be end up re-enabled then. */
4615 ecs
->event_thread
->control
.may_range_step
= 0;
4618 /* Dependent on valid ECS->EVENT_THREAD. */
4619 adjust_pc_after_break (ecs
->event_thread
, &ecs
->ws
);
4621 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4622 reinit_frame_cache ();
4624 breakpoint_retire_moribund ();
4626 /* First, distinguish signals caused by the debugger from signals
4627 that have to do with the program's own actions. Note that
4628 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4629 on the operating system version. Here we detect when a SIGILL or
4630 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4631 something similar for SIGSEGV, since a SIGSEGV will be generated
4632 when we're trying to execute a breakpoint instruction on a
4633 non-executable stack. This happens for call dummy breakpoints
4634 for architectures like SPARC that place call dummies on the
4636 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
4637 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
4638 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
4639 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
4641 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4643 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
),
4644 regcache_read_pc (regcache
)))
4647 fprintf_unfiltered (gdb_stdlog
,
4648 "infrun: Treating signal as SIGTRAP\n");
4649 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
4653 /* Mark the non-executing threads accordingly. In all-stop, all
4654 threads of all processes are stopped when we get any event
4655 reported. In non-stop mode, only the event thread stops. */
4659 if (!target_is_non_stop_p ())
4660 mark_ptid
= minus_one_ptid
;
4661 else if (ecs
->ws
.kind
== TARGET_WAITKIND_SIGNALLED
4662 || ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4664 /* If we're handling a process exit in non-stop mode, even
4665 though threads haven't been deleted yet, one would think
4666 that there is nothing to do, as threads of the dead process
4667 will be soon deleted, and threads of any other process were
4668 left running. However, on some targets, threads survive a
4669 process exit event. E.g., for the "checkpoint" command,
4670 when the current checkpoint/fork exits, linux-fork.c
4671 automatically switches to another fork from within
4672 target_mourn_inferior, by associating the same
4673 inferior/thread to another fork. We haven't mourned yet at
4674 this point, but we must mark any threads left in the
4675 process as not-executing so that finish_thread_state marks
4676 them stopped (in the user's perspective) if/when we present
4677 the stop to the user. */
4678 mark_ptid
= pid_to_ptid (ptid_get_pid (ecs
->ptid
));
4681 mark_ptid
= ecs
->ptid
;
4683 set_executing (mark_ptid
, 0);
4685 /* Likewise the resumed flag. */
4686 set_resumed (mark_ptid
, 0);
4689 switch (ecs
->ws
.kind
)
4691 case TARGET_WAITKIND_LOADED
:
4693 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_LOADED\n");
4694 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4695 context_switch (ecs
->ptid
);
4696 /* Ignore gracefully during startup of the inferior, as it might
4697 be the shell which has just loaded some objects, otherwise
4698 add the symbols for the newly loaded objects. Also ignore at
4699 the beginning of an attach or remote session; we will query
4700 the full list of libraries once the connection is
4703 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
4704 if (stop_soon
== NO_STOP_QUIETLY
)
4706 struct regcache
*regcache
;
4708 regcache
= get_thread_regcache (ecs
->ptid
);
4710 handle_solib_event ();
4712 ecs
->event_thread
->control
.stop_bpstat
4713 = bpstat_stop_status (get_regcache_aspace (regcache
),
4714 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4716 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4718 /* A catchpoint triggered. */
4719 process_event_stop_test (ecs
);
4723 /* If requested, stop when the dynamic linker notifies
4724 gdb of events. This allows the user to get control
4725 and place breakpoints in initializer routines for
4726 dynamically loaded objects (among other things). */
4727 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4728 if (stop_on_solib_events
)
4730 /* Make sure we print "Stopped due to solib-event" in
4732 stop_print_frame
= 1;
4739 /* If we are skipping through a shell, or through shared library
4740 loading that we aren't interested in, resume the program. If
4741 we're running the program normally, also resume. */
4742 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
4744 /* Loading of shared libraries might have changed breakpoint
4745 addresses. Make sure new breakpoints are inserted. */
4746 if (stop_soon
== NO_STOP_QUIETLY
)
4747 insert_breakpoints ();
4748 resume (GDB_SIGNAL_0
);
4749 prepare_to_wait (ecs
);
4753 /* But stop if we're attaching or setting up a remote
4755 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
4756 || stop_soon
== STOP_QUIETLY_REMOTE
)
4759 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
4764 internal_error (__FILE__
, __LINE__
,
4765 _("unhandled stop_soon: %d"), (int) stop_soon
);
4767 case TARGET_WAITKIND_SPURIOUS
:
4769 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_SPURIOUS\n");
4770 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4771 context_switch (ecs
->ptid
);
4772 resume (GDB_SIGNAL_0
);
4773 prepare_to_wait (ecs
);
4776 case TARGET_WAITKIND_EXITED
:
4777 case TARGET_WAITKIND_SIGNALLED
:
4780 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4781 fprintf_unfiltered (gdb_stdlog
,
4782 "infrun: TARGET_WAITKIND_EXITED\n");
4784 fprintf_unfiltered (gdb_stdlog
,
4785 "infrun: TARGET_WAITKIND_SIGNALLED\n");
4788 inferior_ptid
= ecs
->ptid
;
4789 set_current_inferior (find_inferior_ptid (ecs
->ptid
));
4790 set_current_program_space (current_inferior ()->pspace
);
4791 handle_vfork_child_exec_or_exit (0);
4792 target_terminal_ours (); /* Must do this before mourn anyway. */
4794 /* Clearing any previous state of convenience variables. */
4795 clear_exit_convenience_vars ();
4797 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4799 /* Record the exit code in the convenience variable $_exitcode, so
4800 that the user can inspect this again later. */
4801 set_internalvar_integer (lookup_internalvar ("_exitcode"),
4802 (LONGEST
) ecs
->ws
.value
.integer
);
4804 /* Also record this in the inferior itself. */
4805 current_inferior ()->has_exit_code
= 1;
4806 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
4808 /* Support the --return-child-result option. */
4809 return_child_result_value
= ecs
->ws
.value
.integer
;
4811 observer_notify_exited (ecs
->ws
.value
.integer
);
4815 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4816 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4818 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
4820 /* Set the value of the internal variable $_exitsignal,
4821 which holds the signal uncaught by the inferior. */
4822 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
4823 gdbarch_gdb_signal_to_target (gdbarch
,
4824 ecs
->ws
.value
.sig
));
4828 /* We don't have access to the target's method used for
4829 converting between signal numbers (GDB's internal
4830 representation <-> target's representation).
4831 Therefore, we cannot do a good job at displaying this
4832 information to the user. It's better to just warn
4833 her about it (if infrun debugging is enabled), and
4836 fprintf_filtered (gdb_stdlog
, _("\
4837 Cannot fill $_exitsignal with the correct signal number.\n"));
4840 observer_notify_signal_exited (ecs
->ws
.value
.sig
);
4843 gdb_flush (gdb_stdout
);
4844 target_mourn_inferior ();
4845 stop_print_frame
= 0;
4849 /* The following are the only cases in which we keep going;
4850 the above cases end in a continue or goto. */
4851 case TARGET_WAITKIND_FORKED
:
4852 case TARGET_WAITKIND_VFORKED
:
4855 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
4856 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_FORKED\n");
4858 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_VFORKED\n");
4861 /* Check whether the inferior is displaced stepping. */
4863 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4864 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4865 struct displaced_step_inferior_state
*displaced
4866 = get_displaced_stepping_state (ptid_get_pid (ecs
->ptid
));
4868 /* If checking displaced stepping is supported, and thread
4869 ecs->ptid is displaced stepping. */
4870 if (displaced
&& ptid_equal (displaced
->step_ptid
, ecs
->ptid
))
4872 struct inferior
*parent_inf
4873 = find_inferior_ptid (ecs
->ptid
);
4874 struct regcache
*child_regcache
;
4875 CORE_ADDR parent_pc
;
4877 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
4878 indicating that the displaced stepping of syscall instruction
4879 has been done. Perform cleanup for parent process here. Note
4880 that this operation also cleans up the child process for vfork,
4881 because their pages are shared. */
4882 displaced_step_fixup (ecs
->ptid
, GDB_SIGNAL_TRAP
);
4883 /* Start a new step-over in another thread if there's one
4887 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
4889 /* Restore scratch pad for child process. */
4890 displaced_step_restore (displaced
, ecs
->ws
.value
.related_pid
);
4893 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
4894 the child's PC is also within the scratchpad. Set the child's PC
4895 to the parent's PC value, which has already been fixed up.
4896 FIXME: we use the parent's aspace here, although we're touching
4897 the child, because the child hasn't been added to the inferior
4898 list yet at this point. */
4901 = get_thread_arch_aspace_regcache (ecs
->ws
.value
.related_pid
,
4903 parent_inf
->aspace
);
4904 /* Read PC value of parent process. */
4905 parent_pc
= regcache_read_pc (regcache
);
4907 if (debug_displaced
)
4908 fprintf_unfiltered (gdb_stdlog
,
4909 "displaced: write child pc from %s to %s\n",
4911 regcache_read_pc (child_regcache
)),
4912 paddress (gdbarch
, parent_pc
));
4914 regcache_write_pc (child_regcache
, parent_pc
);
4918 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4919 context_switch (ecs
->ptid
);
4921 /* Immediately detach breakpoints from the child before there's
4922 any chance of letting the user delete breakpoints from the
4923 breakpoint lists. If we don't do this early, it's easy to
4924 leave left over traps in the child, vis: "break foo; catch
4925 fork; c; <fork>; del; c; <child calls foo>". We only follow
4926 the fork on the last `continue', and by that time the
4927 breakpoint at "foo" is long gone from the breakpoint table.
4928 If we vforked, then we don't need to unpatch here, since both
4929 parent and child are sharing the same memory pages; we'll
4930 need to unpatch at follow/detach time instead to be certain
4931 that new breakpoints added between catchpoint hit time and
4932 vfork follow are detached. */
4933 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
4935 /* This won't actually modify the breakpoint list, but will
4936 physically remove the breakpoints from the child. */
4937 detach_breakpoints (ecs
->ws
.value
.related_pid
);
4940 delete_just_stopped_threads_single_step_breakpoints ();
4942 /* In case the event is caught by a catchpoint, remember that
4943 the event is to be followed at the next resume of the thread,
4944 and not immediately. */
4945 ecs
->event_thread
->pending_follow
= ecs
->ws
;
4947 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4949 ecs
->event_thread
->control
.stop_bpstat
4950 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4951 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4953 /* If no catchpoint triggered for this, then keep going. Note
4954 that we're interested in knowing the bpstat actually causes a
4955 stop, not just if it may explain the signal. Software
4956 watchpoints, for example, always appear in the bpstat. */
4957 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4963 = (follow_fork_mode_string
== follow_fork_mode_child
);
4965 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4967 should_resume
= follow_fork ();
4970 child
= ecs
->ws
.value
.related_pid
;
4972 /* In non-stop mode, also resume the other branch. */
4973 if (!detach_fork
&& (non_stop
4974 || (sched_multi
&& target_is_non_stop_p ())))
4977 switch_to_thread (parent
);
4979 switch_to_thread (child
);
4981 ecs
->event_thread
= inferior_thread ();
4982 ecs
->ptid
= inferior_ptid
;
4987 switch_to_thread (child
);
4989 switch_to_thread (parent
);
4991 ecs
->event_thread
= inferior_thread ();
4992 ecs
->ptid
= inferior_ptid
;
5000 process_event_stop_test (ecs
);
5003 case TARGET_WAITKIND_VFORK_DONE
:
5004 /* Done with the shared memory region. Re-insert breakpoints in
5005 the parent, and keep going. */
5008 fprintf_unfiltered (gdb_stdlog
,
5009 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
5011 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5012 context_switch (ecs
->ptid
);
5014 current_inferior ()->waiting_for_vfork_done
= 0;
5015 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
5016 /* This also takes care of reinserting breakpoints in the
5017 previously locked inferior. */
5021 case TARGET_WAITKIND_EXECD
:
5023 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_EXECD\n");
5025 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5026 context_switch (ecs
->ptid
);
5028 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5030 /* Do whatever is necessary to the parent branch of the vfork. */
5031 handle_vfork_child_exec_or_exit (1);
5033 /* This causes the eventpoints and symbol table to be reset.
5034 Must do this now, before trying to determine whether to
5036 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
5038 /* In follow_exec we may have deleted the original thread and
5039 created a new one. Make sure that the event thread is the
5040 execd thread for that case (this is a nop otherwise). */
5041 ecs
->event_thread
= inferior_thread ();
5043 ecs
->event_thread
->control
.stop_bpstat
5044 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5045 stop_pc
, ecs
->ptid
, &ecs
->ws
);
5047 /* Note that this may be referenced from inside
5048 bpstat_stop_status above, through inferior_has_execd. */
5049 xfree (ecs
->ws
.value
.execd_pathname
);
5050 ecs
->ws
.value
.execd_pathname
= NULL
;
5052 /* If no catchpoint triggered for this, then keep going. */
5053 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5055 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5059 process_event_stop_test (ecs
);
5062 /* Be careful not to try to gather much state about a thread
5063 that's in a syscall. It's frequently a losing proposition. */
5064 case TARGET_WAITKIND_SYSCALL_ENTRY
:
5066 fprintf_unfiltered (gdb_stdlog
,
5067 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
5068 /* Getting the current syscall number. */
5069 if (handle_syscall_event (ecs
) == 0)
5070 process_event_stop_test (ecs
);
5073 /* Before examining the threads further, step this thread to
5074 get it entirely out of the syscall. (We get notice of the
5075 event when the thread is just on the verge of exiting a
5076 syscall. Stepping one instruction seems to get it back
5078 case TARGET_WAITKIND_SYSCALL_RETURN
:
5080 fprintf_unfiltered (gdb_stdlog
,
5081 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5082 if (handle_syscall_event (ecs
) == 0)
5083 process_event_stop_test (ecs
);
5086 case TARGET_WAITKIND_STOPPED
:
5088 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_STOPPED\n");
5089 ecs
->event_thread
->suspend
.stop_signal
= ecs
->ws
.value
.sig
;
5090 handle_signal_stop (ecs
);
5093 case TARGET_WAITKIND_NO_HISTORY
:
5095 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5096 /* Reverse execution: target ran out of history info. */
5098 delete_just_stopped_threads_single_step_breakpoints ();
5099 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5100 observer_notify_no_history ();
5106 /* A wrapper around handle_inferior_event_1, which also makes sure
5107 that all temporary struct value objects that were created during
5108 the handling of the event get deleted at the end. */
5111 handle_inferior_event (struct execution_control_state
*ecs
)
5113 struct value
*mark
= value_mark ();
5115 handle_inferior_event_1 (ecs
);
5116 /* Purge all temporary values created during the event handling,
5117 as it could be a long time before we return to the command level
5118 where such values would otherwise be purged. */
5119 value_free_to_mark (mark
);
5122 /* Restart threads back to what they were trying to do back when we
5123 paused them for an in-line step-over. The EVENT_THREAD thread is
5127 restart_threads (struct thread_info
*event_thread
)
5129 struct thread_info
*tp
;
5130 struct thread_info
*step_over
= NULL
;
5132 /* In case the instruction just stepped spawned a new thread. */
5133 update_thread_list ();
5135 ALL_NON_EXITED_THREADS (tp
)
5137 if (tp
== event_thread
)
5140 fprintf_unfiltered (gdb_stdlog
,
5141 "infrun: restart threads: "
5142 "[%s] is event thread\n",
5143 target_pid_to_str (tp
->ptid
));
5147 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5150 fprintf_unfiltered (gdb_stdlog
,
5151 "infrun: restart threads: "
5152 "[%s] not meant to be running\n",
5153 target_pid_to_str (tp
->ptid
));
5160 fprintf_unfiltered (gdb_stdlog
,
5161 "infrun: restart threads: [%s] resumed\n",
5162 target_pid_to_str (tp
->ptid
));
5163 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
5167 if (thread_is_in_step_over_chain (tp
))
5170 fprintf_unfiltered (gdb_stdlog
,
5171 "infrun: restart threads: "
5172 "[%s] needs step-over\n",
5173 target_pid_to_str (tp
->ptid
));
5174 gdb_assert (!tp
->resumed
);
5179 if (tp
->suspend
.waitstatus_pending_p
)
5182 fprintf_unfiltered (gdb_stdlog
,
5183 "infrun: restart threads: "
5184 "[%s] has pending status\n",
5185 target_pid_to_str (tp
->ptid
));
5190 /* If some thread needs to start a step-over at this point, it
5191 should still be in the step-over queue, and thus skipped
5193 if (thread_still_needs_step_over (tp
))
5195 internal_error (__FILE__
, __LINE__
,
5196 "thread [%s] needs a step-over, but not in "
5197 "step-over queue\n",
5198 target_pid_to_str (tp
->ptid
));
5201 if (currently_stepping (tp
))
5204 fprintf_unfiltered (gdb_stdlog
,
5205 "infrun: restart threads: [%s] was stepping\n",
5206 target_pid_to_str (tp
->ptid
));
5207 keep_going_stepped_thread (tp
);
5211 struct execution_control_state ecss
;
5212 struct execution_control_state
*ecs
= &ecss
;
5215 fprintf_unfiltered (gdb_stdlog
,
5216 "infrun: restart threads: [%s] continuing\n",
5217 target_pid_to_str (tp
->ptid
));
5218 reset_ecs (ecs
, tp
);
5219 switch_to_thread (tp
->ptid
);
5220 keep_going_pass_signal (ecs
);
5225 /* Callback for iterate_over_threads. Find a resumed thread that has
5226 a pending waitstatus. */
5229 resumed_thread_with_pending_status (struct thread_info
*tp
,
5233 && tp
->suspend
.waitstatus_pending_p
);
5236 /* Called when we get an event that may finish an in-line or
5237 out-of-line (displaced stepping) step-over started previously.
5238 Return true if the event is processed and we should go back to the
5239 event loop; false if the caller should continue processing the
5243 finish_step_over (struct execution_control_state
*ecs
)
5245 int had_step_over_info
;
5247 displaced_step_fixup (ecs
->ptid
,
5248 ecs
->event_thread
->suspend
.stop_signal
);
5250 had_step_over_info
= step_over_info_valid_p ();
5252 if (had_step_over_info
)
5254 /* If we're stepping over a breakpoint with all threads locked,
5255 then only the thread that was stepped should be reporting
5257 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5259 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5260 clear_step_over_info ();
5263 if (!target_is_non_stop_p ())
5266 /* Start a new step-over in another thread if there's one that
5270 /* If we were stepping over a breakpoint before, and haven't started
5271 a new in-line step-over sequence, then restart all other threads
5272 (except the event thread). We can't do this in all-stop, as then
5273 e.g., we wouldn't be able to issue any other remote packet until
5274 these other threads stop. */
5275 if (had_step_over_info
&& !step_over_info_valid_p ())
5277 struct thread_info
*pending
;
5279 /* If we only have threads with pending statuses, the restart
5280 below won't restart any thread and so nothing re-inserts the
5281 breakpoint we just stepped over. But we need it inserted
5282 when we later process the pending events, otherwise if
5283 another thread has a pending event for this breakpoint too,
5284 we'd discard its event (because the breakpoint that
5285 originally caused the event was no longer inserted). */
5286 context_switch (ecs
->ptid
);
5287 insert_breakpoints ();
5289 restart_threads (ecs
->event_thread
);
5291 /* If we have events pending, go through handle_inferior_event
5292 again, picking up a pending event at random. This avoids
5293 thread starvation. */
5295 /* But not if we just stepped over a watchpoint in order to let
5296 the instruction execute so we can evaluate its expression.
5297 The set of watchpoints that triggered is recorded in the
5298 breakpoint objects themselves (see bp->watchpoint_triggered).
5299 If we processed another event first, that other event could
5300 clobber this info. */
5301 if (ecs
->event_thread
->stepping_over_watchpoint
)
5304 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5306 if (pending
!= NULL
)
5308 struct thread_info
*tp
= ecs
->event_thread
;
5309 struct regcache
*regcache
;
5313 fprintf_unfiltered (gdb_stdlog
,
5314 "infrun: found resumed threads with "
5315 "pending events, saving status\n");
5318 gdb_assert (pending
!= tp
);
5320 /* Record the event thread's event for later. */
5321 save_waitstatus (tp
, &ecs
->ws
);
5322 /* This was cleared early, by handle_inferior_event. Set it
5323 so this pending event is considered by
5327 gdb_assert (!tp
->executing
);
5329 regcache
= get_thread_regcache (tp
->ptid
);
5330 tp
->suspend
.stop_pc
= regcache_read_pc (regcache
);
5334 fprintf_unfiltered (gdb_stdlog
,
5335 "infrun: saved stop_pc=%s for %s "
5336 "(currently_stepping=%d)\n",
5337 paddress (target_gdbarch (),
5338 tp
->suspend
.stop_pc
),
5339 target_pid_to_str (tp
->ptid
),
5340 currently_stepping (tp
));
5343 /* This in-line step-over finished; clear this so we won't
5344 start a new one. This is what handle_signal_stop would
5345 do, if we returned false. */
5346 tp
->stepping_over_breakpoint
= 0;
5348 /* Wake up the event loop again. */
5349 mark_async_event_handler (infrun_async_inferior_event_token
);
5351 prepare_to_wait (ecs
);
5359 /* Come here when the program has stopped with a signal. */
5362 handle_signal_stop (struct execution_control_state
*ecs
)
5364 struct frame_info
*frame
;
5365 struct gdbarch
*gdbarch
;
5366 int stopped_by_watchpoint
;
5367 enum stop_kind stop_soon
;
5370 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5372 /* Do we need to clean up the state of a thread that has
5373 completed a displaced single-step? (Doing so usually affects
5374 the PC, so do it here, before we set stop_pc.) */
5375 if (finish_step_over (ecs
))
5378 /* If we either finished a single-step or hit a breakpoint, but
5379 the user wanted this thread to be stopped, pretend we got a
5380 SIG0 (generic unsignaled stop). */
5381 if (ecs
->event_thread
->stop_requested
5382 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5383 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5385 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5389 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
5390 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5391 struct cleanup
*old_chain
= save_inferior_ptid ();
5393 inferior_ptid
= ecs
->ptid
;
5395 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_pc = %s\n",
5396 paddress (gdbarch
, stop_pc
));
5397 if (target_stopped_by_watchpoint ())
5401 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped by watchpoint\n");
5403 if (target_stopped_data_address (¤t_target
, &addr
))
5404 fprintf_unfiltered (gdb_stdlog
,
5405 "infrun: stopped data address = %s\n",
5406 paddress (gdbarch
, addr
));
5408 fprintf_unfiltered (gdb_stdlog
,
5409 "infrun: (no data address available)\n");
5412 do_cleanups (old_chain
);
5415 /* This is originated from start_remote(), start_inferior() and
5416 shared libraries hook functions. */
5417 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
5418 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5420 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5421 context_switch (ecs
->ptid
);
5423 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
5424 stop_print_frame
= 1;
5429 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5432 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5433 context_switch (ecs
->ptid
);
5435 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped\n");
5436 stop_print_frame
= 0;
5441 /* This originates from attach_command(). We need to overwrite
5442 the stop_signal here, because some kernels don't ignore a
5443 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5444 See more comments in inferior.h. On the other hand, if we
5445 get a non-SIGSTOP, report it to the user - assume the backend
5446 will handle the SIGSTOP if it should show up later.
5448 Also consider that the attach is complete when we see a
5449 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5450 target extended-remote report it instead of a SIGSTOP
5451 (e.g. gdbserver). We already rely on SIGTRAP being our
5452 signal, so this is no exception.
5454 Also consider that the attach is complete when we see a
5455 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5456 the target to stop all threads of the inferior, in case the
5457 low level attach operation doesn't stop them implicitly. If
5458 they weren't stopped implicitly, then the stub will report a
5459 GDB_SIGNAL_0, meaning: stopped for no particular reason
5460 other than GDB's request. */
5461 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5462 && (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_STOP
5463 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5464 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_0
))
5466 stop_print_frame
= 1;
5468 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5472 /* See if something interesting happened to the non-current thread. If
5473 so, then switch to that thread. */
5474 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5477 fprintf_unfiltered (gdb_stdlog
, "infrun: context switch\n");
5479 context_switch (ecs
->ptid
);
5481 if (deprecated_context_hook
)
5482 deprecated_context_hook (pid_to_thread_id (ecs
->ptid
));
5485 /* At this point, get hold of the now-current thread's frame. */
5486 frame
= get_current_frame ();
5487 gdbarch
= get_frame_arch (frame
);
5489 /* Pull the single step breakpoints out of the target. */
5490 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5492 struct regcache
*regcache
;
5493 struct address_space
*aspace
;
5496 regcache
= get_thread_regcache (ecs
->ptid
);
5497 aspace
= get_regcache_aspace (regcache
);
5498 pc
= regcache_read_pc (regcache
);
5500 /* However, before doing so, if this single-step breakpoint was
5501 actually for another thread, set this thread up for moving
5503 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
5506 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
5510 fprintf_unfiltered (gdb_stdlog
,
5511 "infrun: [%s] hit another thread's "
5512 "single-step breakpoint\n",
5513 target_pid_to_str (ecs
->ptid
));
5515 ecs
->hit_singlestep_breakpoint
= 1;
5522 fprintf_unfiltered (gdb_stdlog
,
5523 "infrun: [%s] hit its "
5524 "single-step breakpoint\n",
5525 target_pid_to_str (ecs
->ptid
));
5529 delete_just_stopped_threads_single_step_breakpoints ();
5531 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5532 && ecs
->event_thread
->control
.trap_expected
5533 && ecs
->event_thread
->stepping_over_watchpoint
)
5534 stopped_by_watchpoint
= 0;
5536 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
5538 /* If necessary, step over this watchpoint. We'll be back to display
5540 if (stopped_by_watchpoint
5541 && (target_have_steppable_watchpoint
5542 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
5544 /* At this point, we are stopped at an instruction which has
5545 attempted to write to a piece of memory under control of
5546 a watchpoint. The instruction hasn't actually executed
5547 yet. If we were to evaluate the watchpoint expression
5548 now, we would get the old value, and therefore no change
5549 would seem to have occurred.
5551 In order to make watchpoints work `right', we really need
5552 to complete the memory write, and then evaluate the
5553 watchpoint expression. We do this by single-stepping the
5556 It may not be necessary to disable the watchpoint to step over
5557 it. For example, the PA can (with some kernel cooperation)
5558 single step over a watchpoint without disabling the watchpoint.
5560 It is far more common to need to disable a watchpoint to step
5561 the inferior over it. If we have non-steppable watchpoints,
5562 we must disable the current watchpoint; it's simplest to
5563 disable all watchpoints.
5565 Any breakpoint at PC must also be stepped over -- if there's
5566 one, it will have already triggered before the watchpoint
5567 triggered, and we either already reported it to the user, or
5568 it didn't cause a stop and we called keep_going. In either
5569 case, if there was a breakpoint at PC, we must be trying to
5571 ecs
->event_thread
->stepping_over_watchpoint
= 1;
5576 ecs
->event_thread
->stepping_over_breakpoint
= 0;
5577 ecs
->event_thread
->stepping_over_watchpoint
= 0;
5578 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
5579 ecs
->event_thread
->control
.stop_step
= 0;
5580 stop_print_frame
= 1;
5581 stopped_by_random_signal
= 0;
5583 /* Hide inlined functions starting here, unless we just performed stepi or
5584 nexti. After stepi and nexti, always show the innermost frame (not any
5585 inline function call sites). */
5586 if (ecs
->event_thread
->control
.step_range_end
!= 1)
5588 struct address_space
*aspace
=
5589 get_regcache_aspace (get_thread_regcache (ecs
->ptid
));
5591 /* skip_inline_frames is expensive, so we avoid it if we can
5592 determine that the address is one where functions cannot have
5593 been inlined. This improves performance with inferiors that
5594 load a lot of shared libraries, because the solib event
5595 breakpoint is defined as the address of a function (i.e. not
5596 inline). Note that we have to check the previous PC as well
5597 as the current one to catch cases when we have just
5598 single-stepped off a breakpoint prior to reinstating it.
5599 Note that we're assuming that the code we single-step to is
5600 not inline, but that's not definitive: there's nothing
5601 preventing the event breakpoint function from containing
5602 inlined code, and the single-step ending up there. If the
5603 user had set a breakpoint on that inlined code, the missing
5604 skip_inline_frames call would break things. Fortunately
5605 that's an extremely unlikely scenario. */
5606 if (!pc_at_non_inline_function (aspace
, stop_pc
, &ecs
->ws
)
5607 && !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5608 && ecs
->event_thread
->control
.trap_expected
5609 && pc_at_non_inline_function (aspace
,
5610 ecs
->event_thread
->prev_pc
,
5613 skip_inline_frames (ecs
->ptid
);
5615 /* Re-fetch current thread's frame in case that invalidated
5617 frame
= get_current_frame ();
5618 gdbarch
= get_frame_arch (frame
);
5622 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5623 && ecs
->event_thread
->control
.trap_expected
5624 && gdbarch_single_step_through_delay_p (gdbarch
)
5625 && currently_stepping (ecs
->event_thread
))
5627 /* We're trying to step off a breakpoint. Turns out that we're
5628 also on an instruction that needs to be stepped multiple
5629 times before it's been fully executing. E.g., architectures
5630 with a delay slot. It needs to be stepped twice, once for
5631 the instruction and once for the delay slot. */
5632 int step_through_delay
5633 = gdbarch_single_step_through_delay (gdbarch
, frame
);
5635 if (debug_infrun
&& step_through_delay
)
5636 fprintf_unfiltered (gdb_stdlog
, "infrun: step through delay\n");
5637 if (ecs
->event_thread
->control
.step_range_end
== 0
5638 && step_through_delay
)
5640 /* The user issued a continue when stopped at a breakpoint.
5641 Set up for another trap and get out of here. */
5642 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5646 else if (step_through_delay
)
5648 /* The user issued a step when stopped at a breakpoint.
5649 Maybe we should stop, maybe we should not - the delay
5650 slot *might* correspond to a line of source. In any
5651 case, don't decide that here, just set
5652 ecs->stepping_over_breakpoint, making sure we
5653 single-step again before breakpoints are re-inserted. */
5654 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5658 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5659 handles this event. */
5660 ecs
->event_thread
->control
.stop_bpstat
5661 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5662 stop_pc
, ecs
->ptid
, &ecs
->ws
);
5664 /* Following in case break condition called a
5666 stop_print_frame
= 1;
5668 /* This is where we handle "moribund" watchpoints. Unlike
5669 software breakpoints traps, hardware watchpoint traps are
5670 always distinguishable from random traps. If no high-level
5671 watchpoint is associated with the reported stop data address
5672 anymore, then the bpstat does not explain the signal ---
5673 simply make sure to ignore it if `stopped_by_watchpoint' is
5677 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5678 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
5680 && stopped_by_watchpoint
)
5681 fprintf_unfiltered (gdb_stdlog
,
5682 "infrun: no user watchpoint explains "
5683 "watchpoint SIGTRAP, ignoring\n");
5685 /* NOTE: cagney/2003-03-29: These checks for a random signal
5686 at one stage in the past included checks for an inferior
5687 function call's call dummy's return breakpoint. The original
5688 comment, that went with the test, read:
5690 ``End of a stack dummy. Some systems (e.g. Sony news) give
5691 another signal besides SIGTRAP, so check here as well as
5694 If someone ever tries to get call dummys on a
5695 non-executable stack to work (where the target would stop
5696 with something like a SIGSEGV), then those tests might need
5697 to be re-instated. Given, however, that the tests were only
5698 enabled when momentary breakpoints were not being used, I
5699 suspect that it won't be the case.
5701 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5702 be necessary for call dummies on a non-executable stack on
5705 /* See if the breakpoints module can explain the signal. */
5707 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
5708 ecs
->event_thread
->suspend
.stop_signal
);
5710 /* Maybe this was a trap for a software breakpoint that has since
5712 if (random_signal
&& target_stopped_by_sw_breakpoint ())
5714 if (program_breakpoint_here_p (gdbarch
, stop_pc
))
5716 struct regcache
*regcache
;
5719 /* Re-adjust PC to what the program would see if GDB was not
5721 regcache
= get_thread_regcache (ecs
->event_thread
->ptid
);
5722 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
5725 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
5727 if (record_full_is_used ())
5728 record_full_gdb_operation_disable_set ();
5730 regcache_write_pc (regcache
, stop_pc
+ decr_pc
);
5732 do_cleanups (old_cleanups
);
5737 /* A delayed software breakpoint event. Ignore the trap. */
5739 fprintf_unfiltered (gdb_stdlog
,
5740 "infrun: delayed software breakpoint "
5741 "trap, ignoring\n");
5746 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
5747 has since been removed. */
5748 if (random_signal
&& target_stopped_by_hw_breakpoint ())
5750 /* A delayed hardware breakpoint event. Ignore the trap. */
5752 fprintf_unfiltered (gdb_stdlog
,
5753 "infrun: delayed hardware breakpoint/watchpoint "
5754 "trap, ignoring\n");
5758 /* If not, perhaps stepping/nexting can. */
5760 random_signal
= !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5761 && currently_stepping (ecs
->event_thread
));
5763 /* Perhaps the thread hit a single-step breakpoint of _another_
5764 thread. Single-step breakpoints are transparent to the
5765 breakpoints module. */
5767 random_signal
= !ecs
->hit_singlestep_breakpoint
;
5769 /* No? Perhaps we got a moribund watchpoint. */
5771 random_signal
= !stopped_by_watchpoint
;
5773 /* For the program's own signals, act according to
5774 the signal handling tables. */
5778 /* Signal not for debugging purposes. */
5779 struct inferior
*inf
= find_inferior_ptid (ecs
->ptid
);
5780 enum gdb_signal stop_signal
= ecs
->event_thread
->suspend
.stop_signal
;
5783 fprintf_unfiltered (gdb_stdlog
, "infrun: random signal (%s)\n",
5784 gdb_signal_to_symbol_string (stop_signal
));
5786 stopped_by_random_signal
= 1;
5788 /* Always stop on signals if we're either just gaining control
5789 of the program, or the user explicitly requested this thread
5790 to remain stopped. */
5791 if (stop_soon
!= NO_STOP_QUIETLY
5792 || ecs
->event_thread
->stop_requested
5794 && signal_stop_state (ecs
->event_thread
->suspend
.stop_signal
)))
5800 /* Notify observers the signal has "handle print" set. Note we
5801 returned early above if stopping; normal_stop handles the
5802 printing in that case. */
5803 if (signal_print
[ecs
->event_thread
->suspend
.stop_signal
])
5805 /* The signal table tells us to print about this signal. */
5806 target_terminal_ours_for_output ();
5807 observer_notify_signal_received (ecs
->event_thread
->suspend
.stop_signal
);
5808 target_terminal_inferior ();
5811 /* Clear the signal if it should not be passed. */
5812 if (signal_program
[ecs
->event_thread
->suspend
.stop_signal
] == 0)
5813 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5815 if (ecs
->event_thread
->prev_pc
== stop_pc
5816 && ecs
->event_thread
->control
.trap_expected
5817 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
5821 /* We were just starting a new sequence, attempting to
5822 single-step off of a breakpoint and expecting a SIGTRAP.
5823 Instead this signal arrives. This signal will take us out
5824 of the stepping range so GDB needs to remember to, when
5825 the signal handler returns, resume stepping off that
5827 /* To simplify things, "continue" is forced to use the same
5828 code paths as single-step - set a breakpoint at the
5829 signal return address and then, once hit, step off that
5832 fprintf_unfiltered (gdb_stdlog
,
5833 "infrun: signal arrived while stepping over "
5836 was_in_line
= step_over_info_valid_p ();
5837 clear_step_over_info ();
5838 insert_hp_step_resume_breakpoint_at_frame (frame
);
5839 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
5840 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5841 ecs
->event_thread
->control
.trap_expected
= 0;
5843 if (target_is_non_stop_p ())
5845 /* Either "set non-stop" is "on", or the target is
5846 always in non-stop mode. In this case, we have a bit
5847 more work to do. Resume the current thread, and if
5848 we had paused all threads, restart them while the
5849 signal handler runs. */
5854 restart_threads (ecs
->event_thread
);
5856 else if (debug_infrun
)
5858 fprintf_unfiltered (gdb_stdlog
,
5859 "infrun: no need to restart threads\n");
5864 /* If we were nexting/stepping some other thread, switch to
5865 it, so that we don't continue it, losing control. */
5866 if (!switch_back_to_stepped_thread (ecs
))
5871 if (ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
5872 && (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
5873 || ecs
->event_thread
->control
.step_range_end
== 1)
5874 && frame_id_eq (get_stack_frame_id (frame
),
5875 ecs
->event_thread
->control
.step_stack_frame_id
)
5876 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
5878 /* The inferior is about to take a signal that will take it
5879 out of the single step range. Set a breakpoint at the
5880 current PC (which is presumably where the signal handler
5881 will eventually return) and then allow the inferior to
5884 Note that this is only needed for a signal delivered
5885 while in the single-step range. Nested signals aren't a
5886 problem as they eventually all return. */
5888 fprintf_unfiltered (gdb_stdlog
,
5889 "infrun: signal may take us out of "
5890 "single-step range\n");
5892 clear_step_over_info ();
5893 insert_hp_step_resume_breakpoint_at_frame (frame
);
5894 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
5895 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5896 ecs
->event_thread
->control
.trap_expected
= 0;
5901 /* Note: step_resume_breakpoint may be non-NULL. This occures
5902 when either there's a nested signal, or when there's a
5903 pending signal enabled just as the signal handler returns
5904 (leaving the inferior at the step-resume-breakpoint without
5905 actually executing it). Either way continue until the
5906 breakpoint is really hit. */
5908 if (!switch_back_to_stepped_thread (ecs
))
5911 fprintf_unfiltered (gdb_stdlog
,
5912 "infrun: random signal, keep going\n");
5919 process_event_stop_test (ecs
);
5922 /* Come here when we've got some debug event / signal we can explain
5923 (IOW, not a random signal), and test whether it should cause a
5924 stop, or whether we should resume the inferior (transparently).
5925 E.g., could be a breakpoint whose condition evaluates false; we
5926 could be still stepping within the line; etc. */
5929 process_event_stop_test (struct execution_control_state
*ecs
)
5931 struct symtab_and_line stop_pc_sal
;
5932 struct frame_info
*frame
;
5933 struct gdbarch
*gdbarch
;
5934 CORE_ADDR jmp_buf_pc
;
5935 struct bpstat_what what
;
5937 /* Handle cases caused by hitting a breakpoint. */
5939 frame
= get_current_frame ();
5940 gdbarch
= get_frame_arch (frame
);
5942 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
5944 if (what
.call_dummy
)
5946 stop_stack_dummy
= what
.call_dummy
;
5949 /* A few breakpoint types have callbacks associated (e.g.,
5950 bp_jit_event). Run them now. */
5951 bpstat_run_callbacks (ecs
->event_thread
->control
.stop_bpstat
);
5953 /* If we hit an internal event that triggers symbol changes, the
5954 current frame will be invalidated within bpstat_what (e.g., if we
5955 hit an internal solib event). Re-fetch it. */
5956 frame
= get_current_frame ();
5957 gdbarch
= get_frame_arch (frame
);
5959 switch (what
.main_action
)
5961 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
5962 /* If we hit the breakpoint at longjmp while stepping, we
5963 install a momentary breakpoint at the target of the
5967 fprintf_unfiltered (gdb_stdlog
,
5968 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
5970 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5972 if (what
.is_longjmp
)
5974 struct value
*arg_value
;
5976 /* If we set the longjmp breakpoint via a SystemTap probe,
5977 then use it to extract the arguments. The destination PC
5978 is the third argument to the probe. */
5979 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
5982 jmp_buf_pc
= value_as_address (arg_value
);
5983 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
5985 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
5986 || !gdbarch_get_longjmp_target (gdbarch
,
5987 frame
, &jmp_buf_pc
))
5990 fprintf_unfiltered (gdb_stdlog
,
5991 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
5992 "(!gdbarch_get_longjmp_target)\n");
5997 /* Insert a breakpoint at resume address. */
5998 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
6001 check_exception_resume (ecs
, frame
);
6005 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
6007 struct frame_info
*init_frame
;
6009 /* There are several cases to consider.
6011 1. The initiating frame no longer exists. In this case we
6012 must stop, because the exception or longjmp has gone too
6015 2. The initiating frame exists, and is the same as the
6016 current frame. We stop, because the exception or longjmp
6019 3. The initiating frame exists and is different from the
6020 current frame. This means the exception or longjmp has
6021 been caught beneath the initiating frame, so keep going.
6023 4. longjmp breakpoint has been placed just to protect
6024 against stale dummy frames and user is not interested in
6025 stopping around longjmps. */
6028 fprintf_unfiltered (gdb_stdlog
,
6029 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
6031 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
6033 delete_exception_resume_breakpoint (ecs
->event_thread
);
6035 if (what
.is_longjmp
)
6037 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
6039 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
6047 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
6051 struct frame_id current_id
6052 = get_frame_id (get_current_frame ());
6053 if (frame_id_eq (current_id
,
6054 ecs
->event_thread
->initiating_frame
))
6056 /* Case 2. Fall through. */
6066 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6068 delete_step_resume_breakpoint (ecs
->event_thread
);
6070 end_stepping_range (ecs
);
6074 case BPSTAT_WHAT_SINGLE
:
6076 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_SINGLE\n");
6077 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6078 /* Still need to check other stuff, at least the case where we
6079 are stepping and step out of the right range. */
6082 case BPSTAT_WHAT_STEP_RESUME
:
6084 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6086 delete_step_resume_breakpoint (ecs
->event_thread
);
6087 if (ecs
->event_thread
->control
.proceed_to_finish
6088 && execution_direction
== EXEC_REVERSE
)
6090 struct thread_info
*tp
= ecs
->event_thread
;
6092 /* We are finishing a function in reverse, and just hit the
6093 step-resume breakpoint at the start address of the
6094 function, and we're almost there -- just need to back up
6095 by one more single-step, which should take us back to the
6097 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6101 fill_in_stop_func (gdbarch
, ecs
);
6102 if (stop_pc
== ecs
->stop_func_start
6103 && execution_direction
== EXEC_REVERSE
)
6105 /* We are stepping over a function call in reverse, and just
6106 hit the step-resume breakpoint at the start address of
6107 the function. Go back to single-stepping, which should
6108 take us back to the function call. */
6109 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6115 case BPSTAT_WHAT_STOP_NOISY
:
6117 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6118 stop_print_frame
= 1;
6120 /* Assume the thread stopped for a breapoint. We'll still check
6121 whether a/the breakpoint is there when the thread is next
6123 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6128 case BPSTAT_WHAT_STOP_SILENT
:
6130 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6131 stop_print_frame
= 0;
6133 /* Assume the thread stopped for a breapoint. We'll still check
6134 whether a/the breakpoint is there when the thread is next
6136 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6140 case BPSTAT_WHAT_HP_STEP_RESUME
:
6142 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6144 delete_step_resume_breakpoint (ecs
->event_thread
);
6145 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6147 /* Back when the step-resume breakpoint was inserted, we
6148 were trying to single-step off a breakpoint. Go back to
6150 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6151 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6157 case BPSTAT_WHAT_KEEP_CHECKING
:
6161 /* If we stepped a permanent breakpoint and we had a high priority
6162 step-resume breakpoint for the address we stepped, but we didn't
6163 hit it, then we must have stepped into the signal handler. The
6164 step-resume was only necessary to catch the case of _not_
6165 stepping into the handler, so delete it, and fall through to
6166 checking whether the step finished. */
6167 if (ecs
->event_thread
->stepped_breakpoint
)
6169 struct breakpoint
*sr_bp
6170 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6173 && sr_bp
->loc
->permanent
6174 && sr_bp
->type
== bp_hp_step_resume
6175 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6178 fprintf_unfiltered (gdb_stdlog
,
6179 "infrun: stepped permanent breakpoint, stopped in "
6181 delete_step_resume_breakpoint (ecs
->event_thread
);
6182 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6186 /* We come here if we hit a breakpoint but should not stop for it.
6187 Possibly we also were stepping and should stop for that. So fall
6188 through and test for stepping. But, if not stepping, do not
6191 /* In all-stop mode, if we're currently stepping but have stopped in
6192 some other thread, we need to switch back to the stepped thread. */
6193 if (switch_back_to_stepped_thread (ecs
))
6196 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6199 fprintf_unfiltered (gdb_stdlog
,
6200 "infrun: step-resume breakpoint is inserted\n");
6202 /* Having a step-resume breakpoint overrides anything
6203 else having to do with stepping commands until
6204 that breakpoint is reached. */
6209 if (ecs
->event_thread
->control
.step_range_end
== 0)
6212 fprintf_unfiltered (gdb_stdlog
, "infrun: no stepping, continue\n");
6213 /* Likewise if we aren't even stepping. */
6218 /* Re-fetch current thread's frame in case the code above caused
6219 the frame cache to be re-initialized, making our FRAME variable
6220 a dangling pointer. */
6221 frame
= get_current_frame ();
6222 gdbarch
= get_frame_arch (frame
);
6223 fill_in_stop_func (gdbarch
, ecs
);
6225 /* If stepping through a line, keep going if still within it.
6227 Note that step_range_end is the address of the first instruction
6228 beyond the step range, and NOT the address of the last instruction
6231 Note also that during reverse execution, we may be stepping
6232 through a function epilogue and therefore must detect when
6233 the current-frame changes in the middle of a line. */
6235 if (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
6236 && (execution_direction
!= EXEC_REVERSE
6237 || frame_id_eq (get_frame_id (frame
),
6238 ecs
->event_thread
->control
.step_frame_id
)))
6242 (gdb_stdlog
, "infrun: stepping inside range [%s-%s]\n",
6243 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6244 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6246 /* Tentatively re-enable range stepping; `resume' disables it if
6247 necessary (e.g., if we're stepping over a breakpoint or we
6248 have software watchpoints). */
6249 ecs
->event_thread
->control
.may_range_step
= 1;
6251 /* When stepping backward, stop at beginning of line range
6252 (unless it's the function entry point, in which case
6253 keep going back to the call point). */
6254 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6255 && stop_pc
!= ecs
->stop_func_start
6256 && execution_direction
== EXEC_REVERSE
)
6257 end_stepping_range (ecs
);
6264 /* We stepped out of the stepping range. */
6266 /* If we are stepping at the source level and entered the runtime
6267 loader dynamic symbol resolution code...
6269 EXEC_FORWARD: we keep on single stepping until we exit the run
6270 time loader code and reach the callee's address.
6272 EXEC_REVERSE: we've already executed the callee (backward), and
6273 the runtime loader code is handled just like any other
6274 undebuggable function call. Now we need only keep stepping
6275 backward through the trampoline code, and that's handled further
6276 down, so there is nothing for us to do here. */
6278 if (execution_direction
!= EXEC_REVERSE
6279 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6280 && in_solib_dynsym_resolve_code (stop_pc
))
6282 CORE_ADDR pc_after_resolver
=
6283 gdbarch_skip_solib_resolver (gdbarch
, stop_pc
);
6286 fprintf_unfiltered (gdb_stdlog
,
6287 "infrun: stepped into dynsym resolve code\n");
6289 if (pc_after_resolver
)
6291 /* Set up a step-resume breakpoint at the address
6292 indicated by SKIP_SOLIB_RESOLVER. */
6293 struct symtab_and_line sr_sal
;
6296 sr_sal
.pc
= pc_after_resolver
;
6297 sr_sal
.pspace
= get_frame_program_space (frame
);
6299 insert_step_resume_breakpoint_at_sal (gdbarch
,
6300 sr_sal
, null_frame_id
);
6307 if (ecs
->event_thread
->control
.step_range_end
!= 1
6308 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6309 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6310 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6313 fprintf_unfiltered (gdb_stdlog
,
6314 "infrun: stepped into signal trampoline\n");
6315 /* The inferior, while doing a "step" or "next", has ended up in
6316 a signal trampoline (either by a signal being delivered or by
6317 the signal handler returning). Just single-step until the
6318 inferior leaves the trampoline (either by calling the handler
6324 /* If we're in the return path from a shared library trampoline,
6325 we want to proceed through the trampoline when stepping. */
6326 /* macro/2012-04-25: This needs to come before the subroutine
6327 call check below as on some targets return trampolines look
6328 like subroutine calls (MIPS16 return thunks). */
6329 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6330 stop_pc
, ecs
->stop_func_name
)
6331 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6333 /* Determine where this trampoline returns. */
6334 CORE_ADDR real_stop_pc
;
6336 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6339 fprintf_unfiltered (gdb_stdlog
,
6340 "infrun: stepped into solib return tramp\n");
6342 /* Only proceed through if we know where it's going. */
6345 /* And put the step-breakpoint there and go until there. */
6346 struct symtab_and_line sr_sal
;
6348 init_sal (&sr_sal
); /* initialize to zeroes */
6349 sr_sal
.pc
= real_stop_pc
;
6350 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6351 sr_sal
.pspace
= get_frame_program_space (frame
);
6353 /* Do not specify what the fp should be when we stop since
6354 on some machines the prologue is where the new fp value
6356 insert_step_resume_breakpoint_at_sal (gdbarch
,
6357 sr_sal
, null_frame_id
);
6359 /* Restart without fiddling with the step ranges or
6366 /* Check for subroutine calls. The check for the current frame
6367 equalling the step ID is not necessary - the check of the
6368 previous frame's ID is sufficient - but it is a common case and
6369 cheaper than checking the previous frame's ID.
6371 NOTE: frame_id_eq will never report two invalid frame IDs as
6372 being equal, so to get into this block, both the current and
6373 previous frame must have valid frame IDs. */
6374 /* The outer_frame_id check is a heuristic to detect stepping
6375 through startup code. If we step over an instruction which
6376 sets the stack pointer from an invalid value to a valid value,
6377 we may detect that as a subroutine call from the mythical
6378 "outermost" function. This could be fixed by marking
6379 outermost frames as !stack_p,code_p,special_p. Then the
6380 initial outermost frame, before sp was valid, would
6381 have code_addr == &_start. See the comment in frame_id_eq
6383 if (!frame_id_eq (get_stack_frame_id (frame
),
6384 ecs
->event_thread
->control
.step_stack_frame_id
)
6385 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6386 ecs
->event_thread
->control
.step_stack_frame_id
)
6387 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6389 || (ecs
->event_thread
->control
.step_start_function
6390 != find_pc_function (stop_pc
)))))
6392 CORE_ADDR real_stop_pc
;
6395 fprintf_unfiltered (gdb_stdlog
, "infrun: stepped into subroutine\n");
6397 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6399 /* I presume that step_over_calls is only 0 when we're
6400 supposed to be stepping at the assembly language level
6401 ("stepi"). Just stop. */
6402 /* And this works the same backward as frontward. MVS */
6403 end_stepping_range (ecs
);
6407 /* Reverse stepping through solib trampolines. */
6409 if (execution_direction
== EXEC_REVERSE
6410 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6411 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6412 || (ecs
->stop_func_start
== 0
6413 && in_solib_dynsym_resolve_code (stop_pc
))))
6415 /* Any solib trampoline code can be handled in reverse
6416 by simply continuing to single-step. We have already
6417 executed the solib function (backwards), and a few
6418 steps will take us back through the trampoline to the
6424 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6426 /* We're doing a "next".
6428 Normal (forward) execution: set a breakpoint at the
6429 callee's return address (the address at which the caller
6432 Reverse (backward) execution. set the step-resume
6433 breakpoint at the start of the function that we just
6434 stepped into (backwards), and continue to there. When we
6435 get there, we'll need to single-step back to the caller. */
6437 if (execution_direction
== EXEC_REVERSE
)
6439 /* If we're already at the start of the function, we've either
6440 just stepped backward into a single instruction function,
6441 or stepped back out of a signal handler to the first instruction
6442 of the function. Just keep going, which will single-step back
6444 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6446 struct symtab_and_line sr_sal
;
6448 /* Normal function call return (static or dynamic). */
6450 sr_sal
.pc
= ecs
->stop_func_start
;
6451 sr_sal
.pspace
= get_frame_program_space (frame
);
6452 insert_step_resume_breakpoint_at_sal (gdbarch
,
6453 sr_sal
, null_frame_id
);
6457 insert_step_resume_breakpoint_at_caller (frame
);
6463 /* If we are in a function call trampoline (a stub between the
6464 calling routine and the real function), locate the real
6465 function. That's what tells us (a) whether we want to step
6466 into it at all, and (b) what prologue we want to run to the
6467 end of, if we do step into it. */
6468 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6469 if (real_stop_pc
== 0)
6470 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6471 if (real_stop_pc
!= 0)
6472 ecs
->stop_func_start
= real_stop_pc
;
6474 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6476 struct symtab_and_line sr_sal
;
6479 sr_sal
.pc
= ecs
->stop_func_start
;
6480 sr_sal
.pspace
= get_frame_program_space (frame
);
6482 insert_step_resume_breakpoint_at_sal (gdbarch
,
6483 sr_sal
, null_frame_id
);
6488 /* If we have line number information for the function we are
6489 thinking of stepping into and the function isn't on the skip
6492 If there are several symtabs at that PC (e.g. with include
6493 files), just want to know whether *any* of them have line
6494 numbers. find_pc_line handles this. */
6496 struct symtab_and_line tmp_sal
;
6498 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6499 if (tmp_sal
.line
!= 0
6500 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6503 if (execution_direction
== EXEC_REVERSE
)
6504 handle_step_into_function_backward (gdbarch
, ecs
);
6506 handle_step_into_function (gdbarch
, ecs
);
6511 /* If we have no line number and the step-stop-if-no-debug is
6512 set, we stop the step so that the user has a chance to switch
6513 in assembly mode. */
6514 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6515 && step_stop_if_no_debug
)
6517 end_stepping_range (ecs
);
6521 if (execution_direction
== EXEC_REVERSE
)
6523 /* If we're already at the start of the function, we've either just
6524 stepped backward into a single instruction function without line
6525 number info, or stepped back out of a signal handler to the first
6526 instruction of the function without line number info. Just keep
6527 going, which will single-step back to the caller. */
6528 if (ecs
->stop_func_start
!= stop_pc
)
6530 /* Set a breakpoint at callee's start address.
6531 From there we can step once and be back in the caller. */
6532 struct symtab_and_line sr_sal
;
6535 sr_sal
.pc
= ecs
->stop_func_start
;
6536 sr_sal
.pspace
= get_frame_program_space (frame
);
6537 insert_step_resume_breakpoint_at_sal (gdbarch
,
6538 sr_sal
, null_frame_id
);
6542 /* Set a breakpoint at callee's return address (the address
6543 at which the caller will resume). */
6544 insert_step_resume_breakpoint_at_caller (frame
);
6550 /* Reverse stepping through solib trampolines. */
6552 if (execution_direction
== EXEC_REVERSE
6553 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6555 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6556 || (ecs
->stop_func_start
== 0
6557 && in_solib_dynsym_resolve_code (stop_pc
)))
6559 /* Any solib trampoline code can be handled in reverse
6560 by simply continuing to single-step. We have already
6561 executed the solib function (backwards), and a few
6562 steps will take us back through the trampoline to the
6567 else if (in_solib_dynsym_resolve_code (stop_pc
))
6569 /* Stepped backward into the solib dynsym resolver.
6570 Set a breakpoint at its start and continue, then
6571 one more step will take us out. */
6572 struct symtab_and_line sr_sal
;
6575 sr_sal
.pc
= ecs
->stop_func_start
;
6576 sr_sal
.pspace
= get_frame_program_space (frame
);
6577 insert_step_resume_breakpoint_at_sal (gdbarch
,
6578 sr_sal
, null_frame_id
);
6584 stop_pc_sal
= find_pc_line (stop_pc
, 0);
6586 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6587 the trampoline processing logic, however, there are some trampolines
6588 that have no names, so we should do trampoline handling first. */
6589 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6590 && ecs
->stop_func_name
== NULL
6591 && stop_pc_sal
.line
== 0)
6594 fprintf_unfiltered (gdb_stdlog
,
6595 "infrun: stepped into undebuggable function\n");
6597 /* The inferior just stepped into, or returned to, an
6598 undebuggable function (where there is no debugging information
6599 and no line number corresponding to the address where the
6600 inferior stopped). Since we want to skip this kind of code,
6601 we keep going until the inferior returns from this
6602 function - unless the user has asked us not to (via
6603 set step-mode) or we no longer know how to get back
6604 to the call site. */
6605 if (step_stop_if_no_debug
6606 || !frame_id_p (frame_unwind_caller_id (frame
)))
6608 /* If we have no line number and the step-stop-if-no-debug
6609 is set, we stop the step so that the user has a chance to
6610 switch in assembly mode. */
6611 end_stepping_range (ecs
);
6616 /* Set a breakpoint at callee's return address (the address
6617 at which the caller will resume). */
6618 insert_step_resume_breakpoint_at_caller (frame
);
6624 if (ecs
->event_thread
->control
.step_range_end
== 1)
6626 /* It is stepi or nexti. We always want to stop stepping after
6629 fprintf_unfiltered (gdb_stdlog
, "infrun: stepi/nexti\n");
6630 end_stepping_range (ecs
);
6634 if (stop_pc_sal
.line
== 0)
6636 /* We have no line number information. That means to stop
6637 stepping (does this always happen right after one instruction,
6638 when we do "s" in a function with no line numbers,
6639 or can this happen as a result of a return or longjmp?). */
6641 fprintf_unfiltered (gdb_stdlog
, "infrun: no line number info\n");
6642 end_stepping_range (ecs
);
6646 /* Look for "calls" to inlined functions, part one. If the inline
6647 frame machinery detected some skipped call sites, we have entered
6648 a new inline function. */
6650 if (frame_id_eq (get_frame_id (get_current_frame ()),
6651 ecs
->event_thread
->control
.step_frame_id
)
6652 && inline_skipped_frames (ecs
->ptid
))
6654 struct symtab_and_line call_sal
;
6657 fprintf_unfiltered (gdb_stdlog
,
6658 "infrun: stepped into inlined function\n");
6660 find_frame_sal (get_current_frame (), &call_sal
);
6662 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
6664 /* For "step", we're going to stop. But if the call site
6665 for this inlined function is on the same source line as
6666 we were previously stepping, go down into the function
6667 first. Otherwise stop at the call site. */
6669 if (call_sal
.line
== ecs
->event_thread
->current_line
6670 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
6671 step_into_inline_frame (ecs
->ptid
);
6673 end_stepping_range (ecs
);
6678 /* For "next", we should stop at the call site if it is on a
6679 different source line. Otherwise continue through the
6680 inlined function. */
6681 if (call_sal
.line
== ecs
->event_thread
->current_line
6682 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
6685 end_stepping_range (ecs
);
6690 /* Look for "calls" to inlined functions, part two. If we are still
6691 in the same real function we were stepping through, but we have
6692 to go further up to find the exact frame ID, we are stepping
6693 through a more inlined call beyond its call site. */
6695 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6696 && !frame_id_eq (get_frame_id (get_current_frame ()),
6697 ecs
->event_thread
->control
.step_frame_id
)
6698 && stepped_in_from (get_current_frame (),
6699 ecs
->event_thread
->control
.step_frame_id
))
6702 fprintf_unfiltered (gdb_stdlog
,
6703 "infrun: stepping through inlined function\n");
6705 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6708 end_stepping_range (ecs
);
6712 if ((stop_pc
== stop_pc_sal
.pc
)
6713 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
6714 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
6716 /* We are at the start of a different line. So stop. Note that
6717 we don't stop if we step into the middle of a different line.
6718 That is said to make things like for (;;) statements work
6721 fprintf_unfiltered (gdb_stdlog
,
6722 "infrun: stepped to a different line\n");
6723 end_stepping_range (ecs
);
6727 /* We aren't done stepping.
6729 Optimize by setting the stepping range to the line.
6730 (We might not be in the original line, but if we entered a
6731 new line in mid-statement, we continue stepping. This makes
6732 things like for(;;) statements work better.) */
6734 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
6735 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
6736 ecs
->event_thread
->control
.may_range_step
= 1;
6737 set_step_info (frame
, stop_pc_sal
);
6740 fprintf_unfiltered (gdb_stdlog
, "infrun: keep going\n");
6744 /* In all-stop mode, if we're currently stepping but have stopped in
6745 some other thread, we may need to switch back to the stepped
6746 thread. Returns true we set the inferior running, false if we left
6747 it stopped (and the event needs further processing). */
6750 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
6752 if (!target_is_non_stop_p ())
6754 struct thread_info
*tp
;
6755 struct thread_info
*stepping_thread
;
6757 /* If any thread is blocked on some internal breakpoint, and we
6758 simply need to step over that breakpoint to get it going
6759 again, do that first. */
6761 /* However, if we see an event for the stepping thread, then we
6762 know all other threads have been moved past their breakpoints
6763 already. Let the caller check whether the step is finished,
6764 etc., before deciding to move it past a breakpoint. */
6765 if (ecs
->event_thread
->control
.step_range_end
!= 0)
6768 /* Check if the current thread is blocked on an incomplete
6769 step-over, interrupted by a random signal. */
6770 if (ecs
->event_thread
->control
.trap_expected
6771 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
6775 fprintf_unfiltered (gdb_stdlog
,
6776 "infrun: need to finish step-over of [%s]\n",
6777 target_pid_to_str (ecs
->event_thread
->ptid
));
6783 /* Check if the current thread is blocked by a single-step
6784 breakpoint of another thread. */
6785 if (ecs
->hit_singlestep_breakpoint
)
6789 fprintf_unfiltered (gdb_stdlog
,
6790 "infrun: need to step [%s] over single-step "
6792 target_pid_to_str (ecs
->ptid
));
6798 /* If this thread needs yet another step-over (e.g., stepping
6799 through a delay slot), do it first before moving on to
6801 if (thread_still_needs_step_over (ecs
->event_thread
))
6805 fprintf_unfiltered (gdb_stdlog
,
6806 "infrun: thread [%s] still needs step-over\n",
6807 target_pid_to_str (ecs
->event_thread
->ptid
));
6813 /* If scheduler locking applies even if not stepping, there's no
6814 need to walk over threads. Above we've checked whether the
6815 current thread is stepping. If some other thread not the
6816 event thread is stepping, then it must be that scheduler
6817 locking is not in effect. */
6818 if (schedlock_applies (ecs
->event_thread
))
6821 /* Otherwise, we no longer expect a trap in the current thread.
6822 Clear the trap_expected flag before switching back -- this is
6823 what keep_going does as well, if we call it. */
6824 ecs
->event_thread
->control
.trap_expected
= 0;
6826 /* Likewise, clear the signal if it should not be passed. */
6827 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
6828 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6830 /* Do all pending step-overs before actually proceeding with
6832 if (start_step_over ())
6834 prepare_to_wait (ecs
);
6838 /* Look for the stepping/nexting thread. */
6839 stepping_thread
= NULL
;
6841 ALL_NON_EXITED_THREADS (tp
)
6843 /* Ignore threads of processes the caller is not
6846 && ptid_get_pid (tp
->ptid
) != ptid_get_pid (ecs
->ptid
))
6849 /* When stepping over a breakpoint, we lock all threads
6850 except the one that needs to move past the breakpoint.
6851 If a non-event thread has this set, the "incomplete
6852 step-over" check above should have caught it earlier. */
6853 if (tp
->control
.trap_expected
)
6855 internal_error (__FILE__
, __LINE__
,
6856 "[%s] has inconsistent state: "
6857 "trap_expected=%d\n",
6858 target_pid_to_str (tp
->ptid
),
6859 tp
->control
.trap_expected
);
6862 /* Did we find the stepping thread? */
6863 if (tp
->control
.step_range_end
)
6865 /* Yep. There should only one though. */
6866 gdb_assert (stepping_thread
== NULL
);
6868 /* The event thread is handled at the top, before we
6870 gdb_assert (tp
!= ecs
->event_thread
);
6872 /* If some thread other than the event thread is
6873 stepping, then scheduler locking can't be in effect,
6874 otherwise we wouldn't have resumed the current event
6875 thread in the first place. */
6876 gdb_assert (!schedlock_applies (tp
));
6878 stepping_thread
= tp
;
6882 if (stepping_thread
!= NULL
)
6885 fprintf_unfiltered (gdb_stdlog
,
6886 "infrun: switching back to stepped thread\n");
6888 if (keep_going_stepped_thread (stepping_thread
))
6890 prepare_to_wait (ecs
);
6899 /* Set a previously stepped thread back to stepping. Returns true on
6900 success, false if the resume is not possible (e.g., the thread
6904 keep_going_stepped_thread (struct thread_info
*tp
)
6906 struct frame_info
*frame
;
6907 struct gdbarch
*gdbarch
;
6908 struct execution_control_state ecss
;
6909 struct execution_control_state
*ecs
= &ecss
;
6911 /* If the stepping thread exited, then don't try to switch back and
6912 resume it, which could fail in several different ways depending
6913 on the target. Instead, just keep going.
6915 We can find a stepping dead thread in the thread list in two
6918 - The target supports thread exit events, and when the target
6919 tries to delete the thread from the thread list, inferior_ptid
6920 pointed at the exiting thread. In such case, calling
6921 delete_thread does not really remove the thread from the list;
6922 instead, the thread is left listed, with 'exited' state.
6924 - The target's debug interface does not support thread exit
6925 events, and so we have no idea whatsoever if the previously
6926 stepping thread is still alive. For that reason, we need to
6927 synchronously query the target now. */
6929 if (is_exited (tp
->ptid
)
6930 || !target_thread_alive (tp
->ptid
))
6933 fprintf_unfiltered (gdb_stdlog
,
6934 "infrun: not resuming previously "
6935 "stepped thread, it has vanished\n");
6937 delete_thread (tp
->ptid
);
6942 fprintf_unfiltered (gdb_stdlog
,
6943 "infrun: resuming previously stepped thread\n");
6945 reset_ecs (ecs
, tp
);
6946 switch_to_thread (tp
->ptid
);
6948 stop_pc
= regcache_read_pc (get_thread_regcache (tp
->ptid
));
6949 frame
= get_current_frame ();
6950 gdbarch
= get_frame_arch (frame
);
6952 /* If the PC of the thread we were trying to single-step has
6953 changed, then that thread has trapped or been signaled, but the
6954 event has not been reported to GDB yet. Re-poll the target
6955 looking for this particular thread's event (i.e. temporarily
6956 enable schedlock) by:
6958 - setting a break at the current PC
6959 - resuming that particular thread, only (by setting trap
6962 This prevents us continuously moving the single-step breakpoint
6963 forward, one instruction at a time, overstepping. */
6965 if (stop_pc
!= tp
->prev_pc
)
6970 fprintf_unfiltered (gdb_stdlog
,
6971 "infrun: expected thread advanced also (%s -> %s)\n",
6972 paddress (target_gdbarch (), tp
->prev_pc
),
6973 paddress (target_gdbarch (), stop_pc
));
6975 /* Clear the info of the previous step-over, as it's no longer
6976 valid (if the thread was trying to step over a breakpoint, it
6977 has already succeeded). It's what keep_going would do too,
6978 if we called it. Do this before trying to insert the sss
6979 breakpoint, otherwise if we were previously trying to step
6980 over this exact address in another thread, the breakpoint is
6982 clear_step_over_info ();
6983 tp
->control
.trap_expected
= 0;
6985 insert_single_step_breakpoint (get_frame_arch (frame
),
6986 get_frame_address_space (frame
),
6990 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
6991 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
6996 fprintf_unfiltered (gdb_stdlog
,
6997 "infrun: expected thread still hasn't advanced\n");
6999 keep_going_pass_signal (ecs
);
7004 /* Is thread TP in the middle of (software or hardware)
7005 single-stepping? (Note the result of this function must never be
7006 passed directly as target_resume's STEP parameter.) */
7009 currently_stepping (struct thread_info
*tp
)
7011 return ((tp
->control
.step_range_end
7012 && tp
->control
.step_resume_breakpoint
== NULL
)
7013 || tp
->control
.trap_expected
7014 || tp
->stepped_breakpoint
7015 || bpstat_should_step ());
7018 /* Inferior has stepped into a subroutine call with source code that
7019 we should not step over. Do step to the first line of code in
7023 handle_step_into_function (struct gdbarch
*gdbarch
,
7024 struct execution_control_state
*ecs
)
7026 struct compunit_symtab
*cust
;
7027 struct symtab_and_line stop_func_sal
, sr_sal
;
7029 fill_in_stop_func (gdbarch
, ecs
);
7031 cust
= find_pc_compunit_symtab (stop_pc
);
7032 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7033 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
7034 ecs
->stop_func_start
);
7036 stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
7037 /* Use the step_resume_break to step until the end of the prologue,
7038 even if that involves jumps (as it seems to on the vax under
7040 /* If the prologue ends in the middle of a source line, continue to
7041 the end of that source line (if it is still within the function).
7042 Otherwise, just go to end of prologue. */
7043 if (stop_func_sal
.end
7044 && stop_func_sal
.pc
!= ecs
->stop_func_start
7045 && stop_func_sal
.end
< ecs
->stop_func_end
)
7046 ecs
->stop_func_start
= stop_func_sal
.end
;
7048 /* Architectures which require breakpoint adjustment might not be able
7049 to place a breakpoint at the computed address. If so, the test
7050 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7051 ecs->stop_func_start to an address at which a breakpoint may be
7052 legitimately placed.
7054 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7055 made, GDB will enter an infinite loop when stepping through
7056 optimized code consisting of VLIW instructions which contain
7057 subinstructions corresponding to different source lines. On
7058 FR-V, it's not permitted to place a breakpoint on any but the
7059 first subinstruction of a VLIW instruction. When a breakpoint is
7060 set, GDB will adjust the breakpoint address to the beginning of
7061 the VLIW instruction. Thus, we need to make the corresponding
7062 adjustment here when computing the stop address. */
7064 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7066 ecs
->stop_func_start
7067 = gdbarch_adjust_breakpoint_address (gdbarch
,
7068 ecs
->stop_func_start
);
7071 if (ecs
->stop_func_start
== stop_pc
)
7073 /* We are already there: stop now. */
7074 end_stepping_range (ecs
);
7079 /* Put the step-breakpoint there and go until there. */
7080 init_sal (&sr_sal
); /* initialize to zeroes */
7081 sr_sal
.pc
= ecs
->stop_func_start
;
7082 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7083 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7085 /* Do not specify what the fp should be when we stop since on
7086 some machines the prologue is where the new fp value is
7088 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7090 /* And make sure stepping stops right away then. */
7091 ecs
->event_thread
->control
.step_range_end
7092 = ecs
->event_thread
->control
.step_range_start
;
7097 /* Inferior has stepped backward into a subroutine call with source
7098 code that we should not step over. Do step to the beginning of the
7099 last line of code in it. */
7102 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7103 struct execution_control_state
*ecs
)
7105 struct compunit_symtab
*cust
;
7106 struct symtab_and_line stop_func_sal
;
7108 fill_in_stop_func (gdbarch
, ecs
);
7110 cust
= find_pc_compunit_symtab (stop_pc
);
7111 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7112 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
7113 ecs
->stop_func_start
);
7115 stop_func_sal
= find_pc_line (stop_pc
, 0);
7117 /* OK, we're just going to keep stepping here. */
7118 if (stop_func_sal
.pc
== stop_pc
)
7120 /* We're there already. Just stop stepping now. */
7121 end_stepping_range (ecs
);
7125 /* Else just reset the step range and keep going.
7126 No step-resume breakpoint, they don't work for
7127 epilogues, which can have multiple entry paths. */
7128 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7129 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7135 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7136 This is used to both functions and to skip over code. */
7139 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7140 struct symtab_and_line sr_sal
,
7141 struct frame_id sr_id
,
7142 enum bptype sr_type
)
7144 /* There should never be more than one step-resume or longjmp-resume
7145 breakpoint per thread, so we should never be setting a new
7146 step_resume_breakpoint when one is already active. */
7147 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7148 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7151 fprintf_unfiltered (gdb_stdlog
,
7152 "infrun: inserting step-resume breakpoint at %s\n",
7153 paddress (gdbarch
, sr_sal
.pc
));
7155 inferior_thread ()->control
.step_resume_breakpoint
7156 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
);
7160 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7161 struct symtab_and_line sr_sal
,
7162 struct frame_id sr_id
)
7164 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7169 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7170 This is used to skip a potential signal handler.
7172 This is called with the interrupted function's frame. The signal
7173 handler, when it returns, will resume the interrupted function at
7177 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7179 struct symtab_and_line sr_sal
;
7180 struct gdbarch
*gdbarch
;
7182 gdb_assert (return_frame
!= NULL
);
7183 init_sal (&sr_sal
); /* initialize to zeros */
7185 gdbarch
= get_frame_arch (return_frame
);
7186 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7187 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7188 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7190 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7191 get_stack_frame_id (return_frame
),
7195 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7196 is used to skip a function after stepping into it (for "next" or if
7197 the called function has no debugging information).
7199 The current function has almost always been reached by single
7200 stepping a call or return instruction. NEXT_FRAME belongs to the
7201 current function, and the breakpoint will be set at the caller's
7204 This is a separate function rather than reusing
7205 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7206 get_prev_frame, which may stop prematurely (see the implementation
7207 of frame_unwind_caller_id for an example). */
7210 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7212 struct symtab_and_line sr_sal
;
7213 struct gdbarch
*gdbarch
;
7215 /* We shouldn't have gotten here if we don't know where the call site
7217 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7219 init_sal (&sr_sal
); /* initialize to zeros */
7221 gdbarch
= frame_unwind_caller_arch (next_frame
);
7222 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7223 frame_unwind_caller_pc (next_frame
));
7224 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7225 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7227 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7228 frame_unwind_caller_id (next_frame
));
7231 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7232 new breakpoint at the target of a jmp_buf. The handling of
7233 longjmp-resume uses the same mechanisms used for handling
7234 "step-resume" breakpoints. */
7237 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7239 /* There should never be more than one longjmp-resume breakpoint per
7240 thread, so we should never be setting a new
7241 longjmp_resume_breakpoint when one is already active. */
7242 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7245 fprintf_unfiltered (gdb_stdlog
,
7246 "infrun: inserting longjmp-resume breakpoint at %s\n",
7247 paddress (gdbarch
, pc
));
7249 inferior_thread ()->control
.exception_resume_breakpoint
=
7250 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
);
7253 /* Insert an exception resume breakpoint. TP is the thread throwing
7254 the exception. The block B is the block of the unwinder debug hook
7255 function. FRAME is the frame corresponding to the call to this
7256 function. SYM is the symbol of the function argument holding the
7257 target PC of the exception. */
7260 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7261 const struct block
*b
,
7262 struct frame_info
*frame
,
7267 struct block_symbol vsym
;
7268 struct value
*value
;
7270 struct breakpoint
*bp
;
7272 vsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
), b
, VAR_DOMAIN
, NULL
);
7273 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
7274 /* If the value was optimized out, revert to the old behavior. */
7275 if (! value_optimized_out (value
))
7277 handler
= value_as_address (value
);
7280 fprintf_unfiltered (gdb_stdlog
,
7281 "infrun: exception resume at %lx\n",
7282 (unsigned long) handler
);
7284 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7285 handler
, bp_exception_resume
);
7287 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7290 bp
->thread
= tp
->num
;
7291 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7294 CATCH (e
, RETURN_MASK_ERROR
)
7296 /* We want to ignore errors here. */
7301 /* A helper for check_exception_resume that sets an
7302 exception-breakpoint based on a SystemTap probe. */
7305 insert_exception_resume_from_probe (struct thread_info
*tp
,
7306 const struct bound_probe
*probe
,
7307 struct frame_info
*frame
)
7309 struct value
*arg_value
;
7311 struct breakpoint
*bp
;
7313 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7317 handler
= value_as_address (arg_value
);
7320 fprintf_unfiltered (gdb_stdlog
,
7321 "infrun: exception resume at %s\n",
7322 paddress (get_objfile_arch (probe
->objfile
),
7325 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7326 handler
, bp_exception_resume
);
7327 bp
->thread
= tp
->num
;
7328 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7331 /* This is called when an exception has been intercepted. Check to
7332 see whether the exception's destination is of interest, and if so,
7333 set an exception resume breakpoint there. */
7336 check_exception_resume (struct execution_control_state
*ecs
,
7337 struct frame_info
*frame
)
7339 struct bound_probe probe
;
7340 struct symbol
*func
;
7342 /* First see if this exception unwinding breakpoint was set via a
7343 SystemTap probe point. If so, the probe has two arguments: the
7344 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7345 set a breakpoint there. */
7346 probe
= find_probe_by_pc (get_frame_pc (frame
));
7349 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7353 func
= get_frame_function (frame
);
7359 const struct block
*b
;
7360 struct block_iterator iter
;
7364 /* The exception breakpoint is a thread-specific breakpoint on
7365 the unwinder's debug hook, declared as:
7367 void _Unwind_DebugHook (void *cfa, void *handler);
7369 The CFA argument indicates the frame to which control is
7370 about to be transferred. HANDLER is the destination PC.
7372 We ignore the CFA and set a temporary breakpoint at HANDLER.
7373 This is not extremely efficient but it avoids issues in gdb
7374 with computing the DWARF CFA, and it also works even in weird
7375 cases such as throwing an exception from inside a signal
7378 b
= SYMBOL_BLOCK_VALUE (func
);
7379 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7381 if (!SYMBOL_IS_ARGUMENT (sym
))
7388 insert_exception_resume_breakpoint (ecs
->event_thread
,
7394 CATCH (e
, RETURN_MASK_ERROR
)
7401 stop_waiting (struct execution_control_state
*ecs
)
7404 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_waiting\n");
7406 clear_step_over_info ();
7408 /* Let callers know we don't want to wait for the inferior anymore. */
7409 ecs
->wait_some_more
= 0;
7411 /* If all-stop, but the target is always in non-stop mode, stop all
7412 threads now that we're presenting the stop to the user. */
7413 if (!non_stop
&& target_is_non_stop_p ())
7414 stop_all_threads ();
7417 /* Like keep_going, but passes the signal to the inferior, even if the
7418 signal is set to nopass. */
7421 keep_going_pass_signal (struct execution_control_state
*ecs
)
7423 /* Make sure normal_stop is called if we get a QUIT handled before
7425 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
7427 gdb_assert (ptid_equal (ecs
->event_thread
->ptid
, inferior_ptid
));
7428 gdb_assert (!ecs
->event_thread
->resumed
);
7430 /* Save the pc before execution, to compare with pc after stop. */
7431 ecs
->event_thread
->prev_pc
7432 = regcache_read_pc (get_thread_regcache (ecs
->ptid
));
7434 if (ecs
->event_thread
->control
.trap_expected
)
7436 struct thread_info
*tp
= ecs
->event_thread
;
7439 fprintf_unfiltered (gdb_stdlog
,
7440 "infrun: %s has trap_expected set, "
7441 "resuming to collect trap\n",
7442 target_pid_to_str (tp
->ptid
));
7444 /* We haven't yet gotten our trap, and either: intercepted a
7445 non-signal event (e.g., a fork); or took a signal which we
7446 are supposed to pass through to the inferior. Simply
7448 discard_cleanups (old_cleanups
);
7449 resume (ecs
->event_thread
->suspend
.stop_signal
);
7451 else if (step_over_info_valid_p ())
7453 /* Another thread is stepping over a breakpoint in-line. If
7454 this thread needs a step-over too, queue the request. In
7455 either case, this resume must be deferred for later. */
7456 struct thread_info
*tp
= ecs
->event_thread
;
7458 if (ecs
->hit_singlestep_breakpoint
7459 || thread_still_needs_step_over (tp
))
7462 fprintf_unfiltered (gdb_stdlog
,
7463 "infrun: step-over already in progress: "
7464 "step-over for %s deferred\n",
7465 target_pid_to_str (tp
->ptid
));
7466 thread_step_over_chain_enqueue (tp
);
7471 fprintf_unfiltered (gdb_stdlog
,
7472 "infrun: step-over in progress: "
7473 "resume of %s deferred\n",
7474 target_pid_to_str (tp
->ptid
));
7477 discard_cleanups (old_cleanups
);
7481 struct regcache
*regcache
= get_current_regcache ();
7484 enum step_over_what step_what
;
7486 /* Either the trap was not expected, but we are continuing
7487 anyway (if we got a signal, the user asked it be passed to
7490 We got our expected trap, but decided we should resume from
7493 We're going to run this baby now!
7495 Note that insert_breakpoints won't try to re-insert
7496 already inserted breakpoints. Therefore, we don't
7497 care if breakpoints were already inserted, or not. */
7499 /* If we need to step over a breakpoint, and we're not using
7500 displaced stepping to do so, insert all breakpoints
7501 (watchpoints, etc.) but the one we're stepping over, step one
7502 instruction, and then re-insert the breakpoint when that step
7505 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
7507 remove_bp
= (ecs
->hit_singlestep_breakpoint
7508 || (step_what
& STEP_OVER_BREAKPOINT
));
7509 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
7511 /* We can't use displaced stepping if we need to step past a
7512 watchpoint. The instruction copied to the scratch pad would
7513 still trigger the watchpoint. */
7515 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
7517 set_step_over_info (get_regcache_aspace (regcache
),
7518 regcache_read_pc (regcache
), remove_wps
);
7520 else if (remove_wps
)
7521 set_step_over_info (NULL
, 0, remove_wps
);
7523 /* If we now need to do an in-line step-over, we need to stop
7524 all other threads. Note this must be done before
7525 insert_breakpoints below, because that removes the breakpoint
7526 we're about to step over, otherwise other threads could miss
7528 if (step_over_info_valid_p () && target_is_non_stop_p ())
7529 stop_all_threads ();
7531 /* Stop stepping if inserting breakpoints fails. */
7534 insert_breakpoints ();
7536 CATCH (e
, RETURN_MASK_ERROR
)
7538 exception_print (gdb_stderr
, e
);
7540 discard_cleanups (old_cleanups
);
7545 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
7547 discard_cleanups (old_cleanups
);
7548 resume (ecs
->event_thread
->suspend
.stop_signal
);
7551 prepare_to_wait (ecs
);
7554 /* Called when we should continue running the inferior, because the
7555 current event doesn't cause a user visible stop. This does the
7556 resuming part; waiting for the next event is done elsewhere. */
7559 keep_going (struct execution_control_state
*ecs
)
7561 if (ecs
->event_thread
->control
.trap_expected
7562 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
7563 ecs
->event_thread
->control
.trap_expected
= 0;
7565 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7566 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7567 keep_going_pass_signal (ecs
);
7570 /* This function normally comes after a resume, before
7571 handle_inferior_event exits. It takes care of any last bits of
7572 housekeeping, and sets the all-important wait_some_more flag. */
7575 prepare_to_wait (struct execution_control_state
*ecs
)
7578 fprintf_unfiltered (gdb_stdlog
, "infrun: prepare_to_wait\n");
7580 ecs
->wait_some_more
= 1;
7582 if (!target_is_async_p ())
7583 mark_infrun_async_event_handler ();
7586 /* We are done with the step range of a step/next/si/ni command.
7587 Called once for each n of a "step n" operation. */
7590 end_stepping_range (struct execution_control_state
*ecs
)
7592 ecs
->event_thread
->control
.stop_step
= 1;
7596 /* Several print_*_reason functions to print why the inferior has stopped.
7597 We always print something when the inferior exits, or receives a signal.
7598 The rest of the cases are dealt with later on in normal_stop and
7599 print_it_typical. Ideally there should be a call to one of these
7600 print_*_reason functions functions from handle_inferior_event each time
7601 stop_waiting is called.
7603 Note that we don't call these directly, instead we delegate that to
7604 the interpreters, through observers. Interpreters then call these
7605 with whatever uiout is right. */
7608 print_end_stepping_range_reason (struct ui_out
*uiout
)
7610 /* For CLI-like interpreters, print nothing. */
7612 if (ui_out_is_mi_like_p (uiout
))
7614 ui_out_field_string (uiout
, "reason",
7615 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
7620 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7622 annotate_signalled ();
7623 if (ui_out_is_mi_like_p (uiout
))
7625 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
7626 ui_out_text (uiout
, "\nProgram terminated with signal ");
7627 annotate_signal_name ();
7628 ui_out_field_string (uiout
, "signal-name",
7629 gdb_signal_to_name (siggnal
));
7630 annotate_signal_name_end ();
7631 ui_out_text (uiout
, ", ");
7632 annotate_signal_string ();
7633 ui_out_field_string (uiout
, "signal-meaning",
7634 gdb_signal_to_string (siggnal
));
7635 annotate_signal_string_end ();
7636 ui_out_text (uiout
, ".\n");
7637 ui_out_text (uiout
, "The program no longer exists.\n");
7641 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
7643 struct inferior
*inf
= current_inferior ();
7644 const char *pidstr
= target_pid_to_str (pid_to_ptid (inf
->pid
));
7646 annotate_exited (exitstatus
);
7649 if (ui_out_is_mi_like_p (uiout
))
7650 ui_out_field_string (uiout
, "reason",
7651 async_reason_lookup (EXEC_ASYNC_EXITED
));
7652 ui_out_text (uiout
, "[Inferior ");
7653 ui_out_text (uiout
, plongest (inf
->num
));
7654 ui_out_text (uiout
, " (");
7655 ui_out_text (uiout
, pidstr
);
7656 ui_out_text (uiout
, ") exited with code ");
7657 ui_out_field_fmt (uiout
, "exit-code", "0%o", (unsigned int) exitstatus
);
7658 ui_out_text (uiout
, "]\n");
7662 if (ui_out_is_mi_like_p (uiout
))
7664 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
7665 ui_out_text (uiout
, "[Inferior ");
7666 ui_out_text (uiout
, plongest (inf
->num
));
7667 ui_out_text (uiout
, " (");
7668 ui_out_text (uiout
, pidstr
);
7669 ui_out_text (uiout
, ") exited normally]\n");
7674 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7678 if (siggnal
== GDB_SIGNAL_0
&& !ui_out_is_mi_like_p (uiout
))
7680 struct thread_info
*t
= inferior_thread ();
7682 ui_out_text (uiout
, "\n[");
7683 ui_out_field_string (uiout
, "thread-name",
7684 target_pid_to_str (t
->ptid
));
7685 ui_out_field_fmt (uiout
, "thread-id", "] #%d", t
->num
);
7686 ui_out_text (uiout
, " stopped");
7690 ui_out_text (uiout
, "\nProgram received signal ");
7691 annotate_signal_name ();
7692 if (ui_out_is_mi_like_p (uiout
))
7694 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
7695 ui_out_field_string (uiout
, "signal-name",
7696 gdb_signal_to_name (siggnal
));
7697 annotate_signal_name_end ();
7698 ui_out_text (uiout
, ", ");
7699 annotate_signal_string ();
7700 ui_out_field_string (uiout
, "signal-meaning",
7701 gdb_signal_to_string (siggnal
));
7702 annotate_signal_string_end ();
7704 ui_out_text (uiout
, ".\n");
7708 print_no_history_reason (struct ui_out
*uiout
)
7710 ui_out_text (uiout
, "\nNo more reverse-execution history.\n");
7713 /* Print current location without a level number, if we have changed
7714 functions or hit a breakpoint. Print source line if we have one.
7715 bpstat_print contains the logic deciding in detail what to print,
7716 based on the event(s) that just occurred. */
7719 print_stop_location (struct target_waitstatus
*ws
)
7722 enum print_what source_flag
;
7723 int do_frame_printing
= 1;
7724 struct thread_info
*tp
= inferior_thread ();
7726 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
7730 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
7731 should) carry around the function and does (or should) use
7732 that when doing a frame comparison. */
7733 if (tp
->control
.stop_step
7734 && frame_id_eq (tp
->control
.step_frame_id
,
7735 get_frame_id (get_current_frame ()))
7736 && tp
->control
.step_start_function
== find_pc_function (stop_pc
))
7738 /* Finished step, just print source line. */
7739 source_flag
= SRC_LINE
;
7743 /* Print location and source line. */
7744 source_flag
= SRC_AND_LOC
;
7747 case PRINT_SRC_AND_LOC
:
7748 /* Print location and source line. */
7749 source_flag
= SRC_AND_LOC
;
7751 case PRINT_SRC_ONLY
:
7752 source_flag
= SRC_LINE
;
7755 /* Something bogus. */
7756 source_flag
= SRC_LINE
;
7757 do_frame_printing
= 0;
7760 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
7763 /* The behavior of this routine with respect to the source
7765 SRC_LINE: Print only source line
7766 LOCATION: Print only location
7767 SRC_AND_LOC: Print location and source line. */
7768 if (do_frame_printing
)
7769 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
7772 /* Cleanup that restores a previous current uiout. */
7775 restore_current_uiout_cleanup (void *arg
)
7777 struct ui_out
*saved_uiout
= arg
;
7779 current_uiout
= saved_uiout
;
7785 print_stop_event (struct ui_out
*uiout
)
7787 struct cleanup
*old_chain
;
7788 struct target_waitstatus last
;
7790 struct thread_info
*tp
;
7792 get_last_target_status (&last_ptid
, &last
);
7794 old_chain
= make_cleanup (restore_current_uiout_cleanup
, current_uiout
);
7795 current_uiout
= uiout
;
7797 print_stop_location (&last
);
7799 /* Display the auto-display expressions. */
7802 do_cleanups (old_chain
);
7804 tp
= inferior_thread ();
7805 if (tp
->thread_fsm
!= NULL
7806 && thread_fsm_finished_p (tp
->thread_fsm
))
7808 struct return_value_info
*rv
;
7810 rv
= thread_fsm_return_value (tp
->thread_fsm
);
7812 print_return_value (uiout
, rv
);
7819 maybe_remove_breakpoints (void)
7821 if (!breakpoints_should_be_inserted_now () && target_has_execution
)
7823 if (remove_breakpoints ())
7825 target_terminal_ours_for_output ();
7826 printf_filtered (_("Cannot remove breakpoints because "
7827 "program is no longer writable.\nFurther "
7828 "execution is probably impossible.\n"));
7833 /* Here to return control to GDB when the inferior stops for real.
7834 Print appropriate messages, remove breakpoints, give terminal our modes.
7836 STOP_PRINT_FRAME nonzero means print the executing frame
7837 (pc, function, args, file, line number and line text).
7838 BREAKPOINTS_FAILED nonzero means stop was due to error
7839 attempting to insert breakpoints. */
7844 struct target_waitstatus last
;
7846 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
7849 get_last_target_status (&last_ptid
, &last
);
7851 /* If an exception is thrown from this point on, make sure to
7852 propagate GDB's knowledge of the executing state to the
7853 frontend/user running state. A QUIT is an easy exception to see
7854 here, so do this before any filtered output. */
7856 make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
7857 else if (last
.kind
== TARGET_WAITKIND_SIGNALLED
7858 || last
.kind
== TARGET_WAITKIND_EXITED
)
7860 /* On some targets, we may still have live threads in the
7861 inferior when we get a process exit event. E.g., for
7862 "checkpoint", when the current checkpoint/fork exits,
7863 linux-fork.c automatically switches to another fork from
7864 within target_mourn_inferior. */
7865 if (!ptid_equal (inferior_ptid
, null_ptid
))
7867 pid_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
7868 make_cleanup (finish_thread_state_cleanup
, &pid_ptid
);
7871 else if (last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
7872 make_cleanup (finish_thread_state_cleanup
, &inferior_ptid
);
7874 /* As we're presenting a stop, and potentially removing breakpoints,
7875 update the thread list so we can tell whether there are threads
7876 running on the target. With target remote, for example, we can
7877 only learn about new threads when we explicitly update the thread
7878 list. Do this before notifying the interpreters about signal
7879 stops, end of stepping ranges, etc., so that the "new thread"
7880 output is emitted before e.g., "Program received signal FOO",
7881 instead of after. */
7882 update_thread_list ();
7884 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
7885 observer_notify_signal_received (inferior_thread ()->suspend
.stop_signal
);
7887 /* As with the notification of thread events, we want to delay
7888 notifying the user that we've switched thread context until
7889 the inferior actually stops.
7891 There's no point in saying anything if the inferior has exited.
7892 Note that SIGNALLED here means "exited with a signal", not
7893 "received a signal".
7895 Also skip saying anything in non-stop mode. In that mode, as we
7896 don't want GDB to switch threads behind the user's back, to avoid
7897 races where the user is typing a command to apply to thread x,
7898 but GDB switches to thread y before the user finishes entering
7899 the command, fetch_inferior_event installs a cleanup to restore
7900 the current thread back to the thread the user had selected right
7901 after this event is handled, so we're not really switching, only
7902 informing of a stop. */
7904 && !ptid_equal (previous_inferior_ptid
, inferior_ptid
)
7905 && target_has_execution
7906 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
7907 && last
.kind
!= TARGET_WAITKIND_EXITED
7908 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
7910 target_terminal_ours_for_output ();
7911 printf_filtered (_("[Switching to %s]\n"),
7912 target_pid_to_str (inferior_ptid
));
7913 annotate_thread_changed ();
7914 previous_inferior_ptid
= inferior_ptid
;
7917 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
7919 gdb_assert (sync_execution
|| !target_can_async_p ());
7921 target_terminal_ours_for_output ();
7922 printf_filtered (_("No unwaited-for children left.\n"));
7925 /* Note: this depends on the update_thread_list call above. */
7926 maybe_remove_breakpoints ();
7928 /* If an auto-display called a function and that got a signal,
7929 delete that auto-display to avoid an infinite recursion. */
7931 if (stopped_by_random_signal
)
7932 disable_current_display ();
7934 target_terminal_ours ();
7935 async_enable_stdin ();
7937 /* Let the user/frontend see the threads as stopped. */
7938 do_cleanups (old_chain
);
7940 /* Select innermost stack frame - i.e., current frame is frame 0,
7941 and current location is based on that. Handle the case where the
7942 dummy call is returning after being stopped. E.g. the dummy call
7943 previously hit a breakpoint. (If the dummy call returns
7944 normally, we won't reach here.) Do this before the stop hook is
7945 run, so that it doesn't get to see the temporary dummy frame,
7946 which is not where we'll present the stop. */
7947 if (has_stack_frames ())
7949 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
7951 /* Pop the empty frame that contains the stack dummy. This
7952 also restores inferior state prior to the call (struct
7953 infcall_suspend_state). */
7954 struct frame_info
*frame
= get_current_frame ();
7956 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
7958 /* frame_pop calls reinit_frame_cache as the last thing it
7959 does which means there's now no selected frame. */
7962 select_frame (get_current_frame ());
7964 /* Set the current source location. */
7965 set_current_sal_from_frame (get_current_frame ());
7968 /* Look up the hook_stop and run it (CLI internally handles problem
7969 of stop_command's pre-hook not existing). */
7971 catch_errors (hook_stop_stub
, stop_command
,
7972 "Error while running hook_stop:\n", RETURN_MASK_ALL
);
7974 /* Notify observers about the stop. This is where the interpreters
7975 print the stop event. */
7976 if (!ptid_equal (inferior_ptid
, null_ptid
))
7977 observer_notify_normal_stop (inferior_thread ()->control
.stop_bpstat
,
7980 observer_notify_normal_stop (NULL
, stop_print_frame
);
7982 annotate_stopped ();
7984 if (target_has_execution
)
7986 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
7987 && last
.kind
!= TARGET_WAITKIND_EXITED
)
7988 /* Delete the breakpoint we stopped at, if it wants to be deleted.
7989 Delete any breakpoint that is to be deleted at the next stop. */
7990 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
7993 /* Try to get rid of automatically added inferiors that are no
7994 longer needed. Keeping those around slows down things linearly.
7995 Note that this never removes the current inferior. */
8000 hook_stop_stub (void *cmd
)
8002 execute_cmd_pre_hook ((struct cmd_list_element
*) cmd
);
8007 signal_stop_state (int signo
)
8009 return signal_stop
[signo
];
8013 signal_print_state (int signo
)
8015 return signal_print
[signo
];
8019 signal_pass_state (int signo
)
8021 return signal_program
[signo
];
8025 signal_cache_update (int signo
)
8029 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
8030 signal_cache_update (signo
);
8035 signal_pass
[signo
] = (signal_stop
[signo
] == 0
8036 && signal_print
[signo
] == 0
8037 && signal_program
[signo
] == 1
8038 && signal_catch
[signo
] == 0);
8042 signal_stop_update (int signo
, int state
)
8044 int ret
= signal_stop
[signo
];
8046 signal_stop
[signo
] = state
;
8047 signal_cache_update (signo
);
8052 signal_print_update (int signo
, int state
)
8054 int ret
= signal_print
[signo
];
8056 signal_print
[signo
] = state
;
8057 signal_cache_update (signo
);
8062 signal_pass_update (int signo
, int state
)
8064 int ret
= signal_program
[signo
];
8066 signal_program
[signo
] = state
;
8067 signal_cache_update (signo
);
8071 /* Update the global 'signal_catch' from INFO and notify the
8075 signal_catch_update (const unsigned int *info
)
8079 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8080 signal_catch
[i
] = info
[i
] > 0;
8081 signal_cache_update (-1);
8082 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
8086 sig_print_header (void)
8088 printf_filtered (_("Signal Stop\tPrint\tPass "
8089 "to program\tDescription\n"));
8093 sig_print_info (enum gdb_signal oursig
)
8095 const char *name
= gdb_signal_to_name (oursig
);
8096 int name_padding
= 13 - strlen (name
);
8098 if (name_padding
<= 0)
8101 printf_filtered ("%s", name
);
8102 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8103 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8104 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8105 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8106 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8109 /* Specify how various signals in the inferior should be handled. */
8112 handle_command (char *args
, int from_tty
)
8115 int digits
, wordlen
;
8116 int sigfirst
, signum
, siglast
;
8117 enum gdb_signal oursig
;
8120 unsigned char *sigs
;
8121 struct cleanup
*old_chain
;
8125 error_no_arg (_("signal to handle"));
8128 /* Allocate and zero an array of flags for which signals to handle. */
8130 nsigs
= (int) GDB_SIGNAL_LAST
;
8131 sigs
= (unsigned char *) alloca (nsigs
);
8132 memset (sigs
, 0, nsigs
);
8134 /* Break the command line up into args. */
8136 argv
= gdb_buildargv (args
);
8137 old_chain
= make_cleanup_freeargv (argv
);
8139 /* Walk through the args, looking for signal oursigs, signal names, and
8140 actions. Signal numbers and signal names may be interspersed with
8141 actions, with the actions being performed for all signals cumulatively
8142 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8144 while (*argv
!= NULL
)
8146 wordlen
= strlen (*argv
);
8147 for (digits
= 0; isdigit ((*argv
)[digits
]); digits
++)
8151 sigfirst
= siglast
= -1;
8153 if (wordlen
>= 1 && !strncmp (*argv
, "all", wordlen
))
8155 /* Apply action to all signals except those used by the
8156 debugger. Silently skip those. */
8159 siglast
= nsigs
- 1;
8161 else if (wordlen
>= 1 && !strncmp (*argv
, "stop", wordlen
))
8163 SET_SIGS (nsigs
, sigs
, signal_stop
);
8164 SET_SIGS (nsigs
, sigs
, signal_print
);
8166 else if (wordlen
>= 1 && !strncmp (*argv
, "ignore", wordlen
))
8168 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8170 else if (wordlen
>= 2 && !strncmp (*argv
, "print", wordlen
))
8172 SET_SIGS (nsigs
, sigs
, signal_print
);
8174 else if (wordlen
>= 2 && !strncmp (*argv
, "pass", wordlen
))
8176 SET_SIGS (nsigs
, sigs
, signal_program
);
8178 else if (wordlen
>= 3 && !strncmp (*argv
, "nostop", wordlen
))
8180 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8182 else if (wordlen
>= 3 && !strncmp (*argv
, "noignore", wordlen
))
8184 SET_SIGS (nsigs
, sigs
, signal_program
);
8186 else if (wordlen
>= 4 && !strncmp (*argv
, "noprint", wordlen
))
8188 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8189 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8191 else if (wordlen
>= 4 && !strncmp (*argv
, "nopass", wordlen
))
8193 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8195 else if (digits
> 0)
8197 /* It is numeric. The numeric signal refers to our own
8198 internal signal numbering from target.h, not to host/target
8199 signal number. This is a feature; users really should be
8200 using symbolic names anyway, and the common ones like
8201 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8203 sigfirst
= siglast
= (int)
8204 gdb_signal_from_command (atoi (*argv
));
8205 if ((*argv
)[digits
] == '-')
8208 gdb_signal_from_command (atoi ((*argv
) + digits
+ 1));
8210 if (sigfirst
> siglast
)
8212 /* Bet he didn't figure we'd think of this case... */
8220 oursig
= gdb_signal_from_name (*argv
);
8221 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8223 sigfirst
= siglast
= (int) oursig
;
8227 /* Not a number and not a recognized flag word => complain. */
8228 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv
);
8232 /* If any signal numbers or symbol names were found, set flags for
8233 which signals to apply actions to. */
8235 for (signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8237 switch ((enum gdb_signal
) signum
)
8239 case GDB_SIGNAL_TRAP
:
8240 case GDB_SIGNAL_INT
:
8241 if (!allsigs
&& !sigs
[signum
])
8243 if (query (_("%s is used by the debugger.\n\
8244 Are you sure you want to change it? "),
8245 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8251 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8252 gdb_flush (gdb_stdout
);
8257 case GDB_SIGNAL_DEFAULT
:
8258 case GDB_SIGNAL_UNKNOWN
:
8259 /* Make sure that "all" doesn't print these. */
8270 for (signum
= 0; signum
< nsigs
; signum
++)
8273 signal_cache_update (-1);
8274 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
8275 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
8279 /* Show the results. */
8280 sig_print_header ();
8281 for (; signum
< nsigs
; signum
++)
8283 sig_print_info ((enum gdb_signal
) signum
);
8289 do_cleanups (old_chain
);
8292 /* Complete the "handle" command. */
8294 static VEC (char_ptr
) *
8295 handle_completer (struct cmd_list_element
*ignore
,
8296 const char *text
, const char *word
)
8298 VEC (char_ptr
) *vec_signals
, *vec_keywords
, *return_val
;
8299 static const char * const keywords
[] =
8313 vec_signals
= signal_completer (ignore
, text
, word
);
8314 vec_keywords
= complete_on_enum (keywords
, word
, word
);
8316 return_val
= VEC_merge (char_ptr
, vec_signals
, vec_keywords
);
8317 VEC_free (char_ptr
, vec_signals
);
8318 VEC_free (char_ptr
, vec_keywords
);
8323 gdb_signal_from_command (int num
)
8325 if (num
>= 1 && num
<= 15)
8326 return (enum gdb_signal
) num
;
8327 error (_("Only signals 1-15 are valid as numeric signals.\n\
8328 Use \"info signals\" for a list of symbolic signals."));
8331 /* Print current contents of the tables set by the handle command.
8332 It is possible we should just be printing signals actually used
8333 by the current target (but for things to work right when switching
8334 targets, all signals should be in the signal tables). */
8337 signals_info (char *signum_exp
, int from_tty
)
8339 enum gdb_signal oursig
;
8341 sig_print_header ();
8345 /* First see if this is a symbol name. */
8346 oursig
= gdb_signal_from_name (signum_exp
);
8347 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8349 /* No, try numeric. */
8351 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8353 sig_print_info (oursig
);
8357 printf_filtered ("\n");
8358 /* These ugly casts brought to you by the native VAX compiler. */
8359 for (oursig
= GDB_SIGNAL_FIRST
;
8360 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8361 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8365 if (oursig
!= GDB_SIGNAL_UNKNOWN
8366 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8367 sig_print_info (oursig
);
8370 printf_filtered (_("\nUse the \"handle\" command "
8371 "to change these tables.\n"));
8374 /* Check if it makes sense to read $_siginfo from the current thread
8375 at this point. If not, throw an error. */
8378 validate_siginfo_access (void)
8380 /* No current inferior, no siginfo. */
8381 if (ptid_equal (inferior_ptid
, null_ptid
))
8382 error (_("No thread selected."));
8384 /* Don't try to read from a dead thread. */
8385 if (is_exited (inferior_ptid
))
8386 error (_("The current thread has terminated"));
8388 /* ... or from a spinning thread. */
8389 if (is_running (inferior_ptid
))
8390 error (_("Selected thread is running."));
8393 /* The $_siginfo convenience variable is a bit special. We don't know
8394 for sure the type of the value until we actually have a chance to
8395 fetch the data. The type can change depending on gdbarch, so it is
8396 also dependent on which thread you have selected.
8398 1. making $_siginfo be an internalvar that creates a new value on
8401 2. making the value of $_siginfo be an lval_computed value. */
8403 /* This function implements the lval_computed support for reading a
8407 siginfo_value_read (struct value
*v
)
8409 LONGEST transferred
;
8411 validate_siginfo_access ();
8414 target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
,
8416 value_contents_all_raw (v
),
8418 TYPE_LENGTH (value_type (v
)));
8420 if (transferred
!= TYPE_LENGTH (value_type (v
)))
8421 error (_("Unable to read siginfo"));
8424 /* This function implements the lval_computed support for writing a
8428 siginfo_value_write (struct value
*v
, struct value
*fromval
)
8430 LONGEST transferred
;
8432 validate_siginfo_access ();
8434 transferred
= target_write (¤t_target
,
8435 TARGET_OBJECT_SIGNAL_INFO
,
8437 value_contents_all_raw (fromval
),
8439 TYPE_LENGTH (value_type (fromval
)));
8441 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
8442 error (_("Unable to write siginfo"));
8445 static const struct lval_funcs siginfo_value_funcs
=
8451 /* Return a new value with the correct type for the siginfo object of
8452 the current thread using architecture GDBARCH. Return a void value
8453 if there's no object available. */
8455 static struct value
*
8456 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
8459 if (target_has_stack
8460 && !ptid_equal (inferior_ptid
, null_ptid
)
8461 && gdbarch_get_siginfo_type_p (gdbarch
))
8463 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8465 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
8468 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
8472 /* infcall_suspend_state contains state about the program itself like its
8473 registers and any signal it received when it last stopped.
8474 This state must be restored regardless of how the inferior function call
8475 ends (either successfully, or after it hits a breakpoint or signal)
8476 if the program is to properly continue where it left off. */
8478 struct infcall_suspend_state
8480 struct thread_suspend_state thread_suspend
;
8484 struct regcache
*registers
;
8486 /* Format of SIGINFO_DATA or NULL if it is not present. */
8487 struct gdbarch
*siginfo_gdbarch
;
8489 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8490 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8491 content would be invalid. */
8492 gdb_byte
*siginfo_data
;
8495 struct infcall_suspend_state
*
8496 save_infcall_suspend_state (void)
8498 struct infcall_suspend_state
*inf_state
;
8499 struct thread_info
*tp
= inferior_thread ();
8500 struct regcache
*regcache
= get_current_regcache ();
8501 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
8502 gdb_byte
*siginfo_data
= NULL
;
8504 if (gdbarch_get_siginfo_type_p (gdbarch
))
8506 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8507 size_t len
= TYPE_LENGTH (type
);
8508 struct cleanup
*back_to
;
8510 siginfo_data
= xmalloc (len
);
8511 back_to
= make_cleanup (xfree
, siginfo_data
);
8513 if (target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8514 siginfo_data
, 0, len
) == len
)
8515 discard_cleanups (back_to
);
8518 /* Errors ignored. */
8519 do_cleanups (back_to
);
8520 siginfo_data
= NULL
;
8524 inf_state
= XCNEW (struct infcall_suspend_state
);
8528 inf_state
->siginfo_gdbarch
= gdbarch
;
8529 inf_state
->siginfo_data
= siginfo_data
;
8532 inf_state
->thread_suspend
= tp
->suspend
;
8534 /* run_inferior_call will not use the signal due to its `proceed' call with
8535 GDB_SIGNAL_0 anyway. */
8536 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
8538 inf_state
->stop_pc
= stop_pc
;
8540 inf_state
->registers
= regcache_dup (regcache
);
8545 /* Restore inferior session state to INF_STATE. */
8548 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8550 struct thread_info
*tp
= inferior_thread ();
8551 struct regcache
*regcache
= get_current_regcache ();
8552 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
8554 tp
->suspend
= inf_state
->thread_suspend
;
8556 stop_pc
= inf_state
->stop_pc
;
8558 if (inf_state
->siginfo_gdbarch
== gdbarch
)
8560 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8562 /* Errors ignored. */
8563 target_write (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8564 inf_state
->siginfo_data
, 0, TYPE_LENGTH (type
));
8567 /* The inferior can be gone if the user types "print exit(0)"
8568 (and perhaps other times). */
8569 if (target_has_execution
)
8570 /* NB: The register write goes through to the target. */
8571 regcache_cpy (regcache
, inf_state
->registers
);
8573 discard_infcall_suspend_state (inf_state
);
8577 do_restore_infcall_suspend_state_cleanup (void *state
)
8579 restore_infcall_suspend_state (state
);
8583 make_cleanup_restore_infcall_suspend_state
8584 (struct infcall_suspend_state
*inf_state
)
8586 return make_cleanup (do_restore_infcall_suspend_state_cleanup
, inf_state
);
8590 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8592 regcache_xfree (inf_state
->registers
);
8593 xfree (inf_state
->siginfo_data
);
8598 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
8600 return inf_state
->registers
;
8603 /* infcall_control_state contains state regarding gdb's control of the
8604 inferior itself like stepping control. It also contains session state like
8605 the user's currently selected frame. */
8607 struct infcall_control_state
8609 struct thread_control_state thread_control
;
8610 struct inferior_control_state inferior_control
;
8613 enum stop_stack_kind stop_stack_dummy
;
8614 int stopped_by_random_signal
;
8615 int stop_after_trap
;
8617 /* ID if the selected frame when the inferior function call was made. */
8618 struct frame_id selected_frame_id
;
8621 /* Save all of the information associated with the inferior<==>gdb
8624 struct infcall_control_state
*
8625 save_infcall_control_state (void)
8627 struct infcall_control_state
*inf_status
=
8628 XNEW (struct infcall_control_state
);
8629 struct thread_info
*tp
= inferior_thread ();
8630 struct inferior
*inf
= current_inferior ();
8632 inf_status
->thread_control
= tp
->control
;
8633 inf_status
->inferior_control
= inf
->control
;
8635 tp
->control
.step_resume_breakpoint
= NULL
;
8636 tp
->control
.exception_resume_breakpoint
= NULL
;
8638 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8639 chain. If caller's caller is walking the chain, they'll be happier if we
8640 hand them back the original chain when restore_infcall_control_state is
8642 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
8645 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
8646 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
8647 inf_status
->stop_after_trap
= stop_after_trap
;
8649 inf_status
->selected_frame_id
= get_frame_id (get_selected_frame (NULL
));
8655 restore_selected_frame (void *args
)
8657 struct frame_id
*fid
= (struct frame_id
*) args
;
8658 struct frame_info
*frame
;
8660 frame
= frame_find_by_id (*fid
);
8662 /* If inf_status->selected_frame_id is NULL, there was no previously
8666 warning (_("Unable to restore previously selected frame."));
8670 select_frame (frame
);
8675 /* Restore inferior session state to INF_STATUS. */
8678 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
8680 struct thread_info
*tp
= inferior_thread ();
8681 struct inferior
*inf
= current_inferior ();
8683 if (tp
->control
.step_resume_breakpoint
)
8684 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
8686 if (tp
->control
.exception_resume_breakpoint
)
8687 tp
->control
.exception_resume_breakpoint
->disposition
8688 = disp_del_at_next_stop
;
8690 /* Handle the bpstat_copy of the chain. */
8691 bpstat_clear (&tp
->control
.stop_bpstat
);
8693 tp
->control
= inf_status
->thread_control
;
8694 inf
->control
= inf_status
->inferior_control
;
8697 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
8698 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
8699 stop_after_trap
= inf_status
->stop_after_trap
;
8701 if (target_has_stack
)
8703 /* The point of catch_errors is that if the stack is clobbered,
8704 walking the stack might encounter a garbage pointer and
8705 error() trying to dereference it. */
8707 (restore_selected_frame
, &inf_status
->selected_frame_id
,
8708 "Unable to restore previously selected frame:\n",
8709 RETURN_MASK_ERROR
) == 0)
8710 /* Error in restoring the selected frame. Select the innermost
8712 select_frame (get_current_frame ());
8719 do_restore_infcall_control_state_cleanup (void *sts
)
8721 restore_infcall_control_state (sts
);
8725 make_cleanup_restore_infcall_control_state
8726 (struct infcall_control_state
*inf_status
)
8728 return make_cleanup (do_restore_infcall_control_state_cleanup
, inf_status
);
8732 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
8734 if (inf_status
->thread_control
.step_resume_breakpoint
)
8735 inf_status
->thread_control
.step_resume_breakpoint
->disposition
8736 = disp_del_at_next_stop
;
8738 if (inf_status
->thread_control
.exception_resume_breakpoint
)
8739 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
8740 = disp_del_at_next_stop
;
8742 /* See save_infcall_control_state for info on stop_bpstat. */
8743 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
8748 /* restore_inferior_ptid() will be used by the cleanup machinery
8749 to restore the inferior_ptid value saved in a call to
8750 save_inferior_ptid(). */
8753 restore_inferior_ptid (void *arg
)
8755 ptid_t
*saved_ptid_ptr
= arg
;
8757 inferior_ptid
= *saved_ptid_ptr
;
8761 /* Save the value of inferior_ptid so that it may be restored by a
8762 later call to do_cleanups(). Returns the struct cleanup pointer
8763 needed for later doing the cleanup. */
8766 save_inferior_ptid (void)
8768 ptid_t
*saved_ptid_ptr
= XNEW (ptid_t
);
8770 *saved_ptid_ptr
= inferior_ptid
;
8771 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
8777 clear_exit_convenience_vars (void)
8779 clear_internalvar (lookup_internalvar ("_exitsignal"));
8780 clear_internalvar (lookup_internalvar ("_exitcode"));
8784 /* User interface for reverse debugging:
8785 Set exec-direction / show exec-direction commands
8786 (returns error unless target implements to_set_exec_direction method). */
8788 int execution_direction
= EXEC_FORWARD
;
8789 static const char exec_forward
[] = "forward";
8790 static const char exec_reverse
[] = "reverse";
8791 static const char *exec_direction
= exec_forward
;
8792 static const char *const exec_direction_names
[] = {
8799 set_exec_direction_func (char *args
, int from_tty
,
8800 struct cmd_list_element
*cmd
)
8802 if (target_can_execute_reverse
)
8804 if (!strcmp (exec_direction
, exec_forward
))
8805 execution_direction
= EXEC_FORWARD
;
8806 else if (!strcmp (exec_direction
, exec_reverse
))
8807 execution_direction
= EXEC_REVERSE
;
8811 exec_direction
= exec_forward
;
8812 error (_("Target does not support this operation."));
8817 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
8818 struct cmd_list_element
*cmd
, const char *value
)
8820 switch (execution_direction
) {
8822 fprintf_filtered (out
, _("Forward.\n"));
8825 fprintf_filtered (out
, _("Reverse.\n"));
8828 internal_error (__FILE__
, __LINE__
,
8829 _("bogus execution_direction value: %d"),
8830 (int) execution_direction
);
8835 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
8836 struct cmd_list_element
*c
, const char *value
)
8838 fprintf_filtered (file
, _("Resuming the execution of threads "
8839 "of all processes is %s.\n"), value
);
8842 /* Implementation of `siginfo' variable. */
8844 static const struct internalvar_funcs siginfo_funcs
=
8851 /* Callback for infrun's target events source. This is marked when a
8852 thread has a pending status to process. */
8855 infrun_async_inferior_event_handler (gdb_client_data data
)
8857 inferior_event_handler (INF_REG_EVENT
, NULL
);
8861 _initialize_infrun (void)
8865 struct cmd_list_element
*c
;
8867 /* Register extra event sources in the event loop. */
8868 infrun_async_inferior_event_token
8869 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
);
8871 add_info ("signals", signals_info
, _("\
8872 What debugger does when program gets various signals.\n\
8873 Specify a signal as argument to print info on that signal only."));
8874 add_info_alias ("handle", "signals", 0);
8876 c
= add_com ("handle", class_run
, handle_command
, _("\
8877 Specify how to handle signals.\n\
8878 Usage: handle SIGNAL [ACTIONS]\n\
8879 Args are signals and actions to apply to those signals.\n\
8880 If no actions are specified, the current settings for the specified signals\n\
8881 will be displayed instead.\n\
8883 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
8884 from 1-15 are allowed for compatibility with old versions of GDB.\n\
8885 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
8886 The special arg \"all\" is recognized to mean all signals except those\n\
8887 used by the debugger, typically SIGTRAP and SIGINT.\n\
8889 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
8890 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
8891 Stop means reenter debugger if this signal happens (implies print).\n\
8892 Print means print a message if this signal happens.\n\
8893 Pass means let program see this signal; otherwise program doesn't know.\n\
8894 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
8895 Pass and Stop may be combined.\n\
8897 Multiple signals may be specified. Signal numbers and signal names\n\
8898 may be interspersed with actions, with the actions being performed for\n\
8899 all signals cumulatively specified."));
8900 set_cmd_completer (c
, handle_completer
);
8903 stop_command
= add_cmd ("stop", class_obscure
,
8904 not_just_help_class_command
, _("\
8905 There is no `stop' command, but you can set a hook on `stop'.\n\
8906 This allows you to set a list of commands to be run each time execution\n\
8907 of the program stops."), &cmdlist
);
8909 add_setshow_zuinteger_cmd ("infrun", class_maintenance
, &debug_infrun
, _("\
8910 Set inferior debugging."), _("\
8911 Show inferior debugging."), _("\
8912 When non-zero, inferior specific debugging is enabled."),
8915 &setdebuglist
, &showdebuglist
);
8917 add_setshow_boolean_cmd ("displaced", class_maintenance
,
8918 &debug_displaced
, _("\
8919 Set displaced stepping debugging."), _("\
8920 Show displaced stepping debugging."), _("\
8921 When non-zero, displaced stepping specific debugging is enabled."),
8923 show_debug_displaced
,
8924 &setdebuglist
, &showdebuglist
);
8926 add_setshow_boolean_cmd ("non-stop", no_class
,
8928 Set whether gdb controls the inferior in non-stop mode."), _("\
8929 Show whether gdb controls the inferior in non-stop mode."), _("\
8930 When debugging a multi-threaded program and this setting is\n\
8931 off (the default, also called all-stop mode), when one thread stops\n\
8932 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
8933 all other threads in the program while you interact with the thread of\n\
8934 interest. When you continue or step a thread, you can allow the other\n\
8935 threads to run, or have them remain stopped, but while you inspect any\n\
8936 thread's state, all threads stop.\n\
8938 In non-stop mode, when one thread stops, other threads can continue\n\
8939 to run freely. You'll be able to step each thread independently,\n\
8940 leave it stopped or free to run as needed."),
8946 numsigs
= (int) GDB_SIGNAL_LAST
;
8947 signal_stop
= XNEWVEC (unsigned char, numsigs
);
8948 signal_print
= XNEWVEC (unsigned char, numsigs
);
8949 signal_program
= XNEWVEC (unsigned char, numsigs
);
8950 signal_catch
= XNEWVEC (unsigned char, numsigs
);
8951 signal_pass
= XNEWVEC (unsigned char, numsigs
);
8952 for (i
= 0; i
< numsigs
; i
++)
8955 signal_print
[i
] = 1;
8956 signal_program
[i
] = 1;
8957 signal_catch
[i
] = 0;
8960 /* Signals caused by debugger's own actions should not be given to
8961 the program afterwards.
8963 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
8964 explicitly specifies that it should be delivered to the target
8965 program. Typically, that would occur when a user is debugging a
8966 target monitor on a simulator: the target monitor sets a
8967 breakpoint; the simulator encounters this breakpoint and halts
8968 the simulation handing control to GDB; GDB, noting that the stop
8969 address doesn't map to any known breakpoint, returns control back
8970 to the simulator; the simulator then delivers the hardware
8971 equivalent of a GDB_SIGNAL_TRAP to the program being
8973 signal_program
[GDB_SIGNAL_TRAP
] = 0;
8974 signal_program
[GDB_SIGNAL_INT
] = 0;
8976 /* Signals that are not errors should not normally enter the debugger. */
8977 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
8978 signal_print
[GDB_SIGNAL_ALRM
] = 0;
8979 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
8980 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
8981 signal_stop
[GDB_SIGNAL_PROF
] = 0;
8982 signal_print
[GDB_SIGNAL_PROF
] = 0;
8983 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
8984 signal_print
[GDB_SIGNAL_CHLD
] = 0;
8985 signal_stop
[GDB_SIGNAL_IO
] = 0;
8986 signal_print
[GDB_SIGNAL_IO
] = 0;
8987 signal_stop
[GDB_SIGNAL_POLL
] = 0;
8988 signal_print
[GDB_SIGNAL_POLL
] = 0;
8989 signal_stop
[GDB_SIGNAL_URG
] = 0;
8990 signal_print
[GDB_SIGNAL_URG
] = 0;
8991 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
8992 signal_print
[GDB_SIGNAL_WINCH
] = 0;
8993 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
8994 signal_print
[GDB_SIGNAL_PRIO
] = 0;
8996 /* These signals are used internally by user-level thread
8997 implementations. (See signal(5) on Solaris.) Like the above
8998 signals, a healthy program receives and handles them as part of
8999 its normal operation. */
9000 signal_stop
[GDB_SIGNAL_LWP
] = 0;
9001 signal_print
[GDB_SIGNAL_LWP
] = 0;
9002 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
9003 signal_print
[GDB_SIGNAL_WAITING
] = 0;
9004 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
9005 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
9007 /* Update cached state. */
9008 signal_cache_update (-1);
9010 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
9011 &stop_on_solib_events
, _("\
9012 Set stopping for shared library events."), _("\
9013 Show stopping for shared library events."), _("\
9014 If nonzero, gdb will give control to the user when the dynamic linker\n\
9015 notifies gdb of shared library events. The most common event of interest\n\
9016 to the user would be loading/unloading of a new library."),
9017 set_stop_on_solib_events
,
9018 show_stop_on_solib_events
,
9019 &setlist
, &showlist
);
9021 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
9022 follow_fork_mode_kind_names
,
9023 &follow_fork_mode_string
, _("\
9024 Set debugger response to a program call of fork or vfork."), _("\
9025 Show debugger response to a program call of fork or vfork."), _("\
9026 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9027 parent - the original process is debugged after a fork\n\
9028 child - the new process is debugged after a fork\n\
9029 The unfollowed process will continue to run.\n\
9030 By default, the debugger will follow the parent process."),
9032 show_follow_fork_mode_string
,
9033 &setlist
, &showlist
);
9035 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
9036 follow_exec_mode_names
,
9037 &follow_exec_mode_string
, _("\
9038 Set debugger response to a program call of exec."), _("\
9039 Show debugger response to a program call of exec."), _("\
9040 An exec call replaces the program image of a process.\n\
9042 follow-exec-mode can be:\n\
9044 new - the debugger creates a new inferior and rebinds the process\n\
9045 to this new inferior. The program the process was running before\n\
9046 the exec call can be restarted afterwards by restarting the original\n\
9049 same - the debugger keeps the process bound to the same inferior.\n\
9050 The new executable image replaces the previous executable loaded in\n\
9051 the inferior. Restarting the inferior after the exec call restarts\n\
9052 the executable the process was running after the exec call.\n\
9054 By default, the debugger will use the same inferior."),
9056 show_follow_exec_mode_string
,
9057 &setlist
, &showlist
);
9059 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9060 scheduler_enums
, &scheduler_mode
, _("\
9061 Set mode for locking scheduler during execution."), _("\
9062 Show mode for locking scheduler during execution."), _("\
9063 off == no locking (threads may preempt at any time)\n\
9064 on == full locking (no thread except the current thread may run)\n\
9065 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9066 In this mode, other threads may run during other commands."),
9067 set_schedlock_func
, /* traps on target vector */
9068 show_scheduler_mode
,
9069 &setlist
, &showlist
);
9071 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9072 Set mode for resuming threads of all processes."), _("\
9073 Show mode for resuming threads of all processes."), _("\
9074 When on, execution commands (such as 'continue' or 'next') resume all\n\
9075 threads of all processes. When off (which is the default), execution\n\
9076 commands only resume the threads of the current process. The set of\n\
9077 threads that are resumed is further refined by the scheduler-locking\n\
9078 mode (see help set scheduler-locking)."),
9080 show_schedule_multiple
,
9081 &setlist
, &showlist
);
9083 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9084 Set mode of the step operation."), _("\
9085 Show mode of the step operation."), _("\
9086 When set, doing a step over a function without debug line information\n\
9087 will stop at the first instruction of that function. Otherwise, the\n\
9088 function is skipped and the step command stops at a different source line."),
9090 show_step_stop_if_no_debug
,
9091 &setlist
, &showlist
);
9093 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9094 &can_use_displaced_stepping
, _("\
9095 Set debugger's willingness to use displaced stepping."), _("\
9096 Show debugger's willingness to use displaced stepping."), _("\
9097 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9098 supported by the target architecture. If off, gdb will not use displaced\n\
9099 stepping to step over breakpoints, even if such is supported by the target\n\
9100 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9101 if the target architecture supports it and non-stop mode is active, but will not\n\
9102 use it in all-stop mode (see help set non-stop)."),
9104 show_can_use_displaced_stepping
,
9105 &setlist
, &showlist
);
9107 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9108 &exec_direction
, _("Set direction of execution.\n\
9109 Options are 'forward' or 'reverse'."),
9110 _("Show direction of execution (forward/reverse)."),
9111 _("Tells gdb whether to execute forward or backward."),
9112 set_exec_direction_func
, show_exec_direction_func
,
9113 &setlist
, &showlist
);
9115 /* Set/show detach-on-fork: user-settable mode. */
9117 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9118 Set whether gdb will detach the child of a fork."), _("\
9119 Show whether gdb will detach the child of a fork."), _("\
9120 Tells gdb whether to detach the child of a fork."),
9121 NULL
, NULL
, &setlist
, &showlist
);
9123 /* Set/show disable address space randomization mode. */
9125 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9126 &disable_randomization
, _("\
9127 Set disabling of debuggee's virtual address space randomization."), _("\
9128 Show disabling of debuggee's virtual address space randomization."), _("\
9129 When this mode is on (which is the default), randomization of the virtual\n\
9130 address space is disabled. Standalone programs run with the randomization\n\
9131 enabled by default on some platforms."),
9132 &set_disable_randomization
,
9133 &show_disable_randomization
,
9134 &setlist
, &showlist
);
9136 /* ptid initializations */
9137 inferior_ptid
= null_ptid
;
9138 target_last_wait_ptid
= minus_one_ptid
;
9140 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed
);
9141 observer_attach_thread_stop_requested (infrun_thread_stop_requested
);
9142 observer_attach_thread_exit (infrun_thread_thread_exit
);
9143 observer_attach_inferior_exit (infrun_inferior_exit
);
9145 /* Explicitly create without lookup, since that tries to create a
9146 value with a void typed value, and when we get here, gdbarch
9147 isn't initialized yet. At this point, we're quite sure there
9148 isn't another convenience variable of the same name. */
9149 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9151 add_setshow_boolean_cmd ("observer", no_class
,
9152 &observer_mode_1
, _("\
9153 Set whether gdb controls the inferior in observer mode."), _("\
9154 Show whether gdb controls the inferior in observer mode."), _("\
9155 In observer mode, GDB can get data from the inferior, but not\n\
9156 affect its execution. Registers and memory may not be changed,\n\
9157 breakpoints may not be set, and the program cannot be interrupted\n\