1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2014 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 /* Prototypes for local functions */
66 static void signals_info (char *, int);
68 static void handle_command (char *, int);
70 static void sig_print_info (enum gdb_signal
);
72 static void sig_print_header (void);
74 static void resume_cleanups (void *);
76 static int hook_stop_stub (void *);
78 static int restore_selected_frame (void *);
80 static int follow_fork (void);
82 static int follow_fork_inferior (int follow_child
, int detach_fork
);
84 static void follow_inferior_reset_breakpoints (void);
86 static void set_schedlock_func (char *args
, int from_tty
,
87 struct cmd_list_element
*c
);
89 static int currently_stepping (struct thread_info
*tp
);
91 static void xdb_handle_command (char *args
, int from_tty
);
93 void _initialize_infrun (void);
95 void nullify_last_target_wait_ptid (void);
97 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
99 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
101 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
103 /* When set, stop the 'step' command if we enter a function which has
104 no line number information. The normal behavior is that we step
105 over such function. */
106 int step_stop_if_no_debug
= 0;
108 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
109 struct cmd_list_element
*c
, const char *value
)
111 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
114 /* In asynchronous mode, but simulating synchronous execution. */
116 int sync_execution
= 0;
118 /* proceed and normal_stop use this to notify the user when the
119 inferior stopped in a different thread than it had been running
122 static ptid_t previous_inferior_ptid
;
124 /* If set (default for legacy reasons), when following a fork, GDB
125 will detach from one of the fork branches, child or parent.
126 Exactly which branch is detached depends on 'set follow-fork-mode'
129 static int detach_fork
= 1;
131 int debug_displaced
= 0;
133 show_debug_displaced (struct ui_file
*file
, int from_tty
,
134 struct cmd_list_element
*c
, const char *value
)
136 fprintf_filtered (file
, _("Displace stepping debugging is %s.\n"), value
);
139 unsigned int debug_infrun
= 0;
141 show_debug_infrun (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
, const char *value
)
144 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
148 /* Support for disabling address space randomization. */
150 int disable_randomization
= 1;
153 show_disable_randomization (struct ui_file
*file
, int from_tty
,
154 struct cmd_list_element
*c
, const char *value
)
156 if (target_supports_disable_randomization ())
157 fprintf_filtered (file
,
158 _("Disabling randomization of debuggee's "
159 "virtual address space is %s.\n"),
162 fputs_filtered (_("Disabling randomization of debuggee's "
163 "virtual address space is unsupported on\n"
164 "this platform.\n"), file
);
168 set_disable_randomization (char *args
, int from_tty
,
169 struct cmd_list_element
*c
)
171 if (!target_supports_disable_randomization ())
172 error (_("Disabling randomization of debuggee's "
173 "virtual address space is unsupported on\n"
177 /* User interface for non-stop mode. */
180 static int non_stop_1
= 0;
183 set_non_stop (char *args
, int from_tty
,
184 struct cmd_list_element
*c
)
186 if (target_has_execution
)
188 non_stop_1
= non_stop
;
189 error (_("Cannot change this setting while the inferior is running."));
192 non_stop
= non_stop_1
;
196 show_non_stop (struct ui_file
*file
, int from_tty
,
197 struct cmd_list_element
*c
, const char *value
)
199 fprintf_filtered (file
,
200 _("Controlling the inferior in non-stop mode is %s.\n"),
204 /* "Observer mode" is somewhat like a more extreme version of
205 non-stop, in which all GDB operations that might affect the
206 target's execution have been disabled. */
208 int observer_mode
= 0;
209 static int observer_mode_1
= 0;
212 set_observer_mode (char *args
, int from_tty
,
213 struct cmd_list_element
*c
)
215 if (target_has_execution
)
217 observer_mode_1
= observer_mode
;
218 error (_("Cannot change this setting while the inferior is running."));
221 observer_mode
= observer_mode_1
;
223 may_write_registers
= !observer_mode
;
224 may_write_memory
= !observer_mode
;
225 may_insert_breakpoints
= !observer_mode
;
226 may_insert_tracepoints
= !observer_mode
;
227 /* We can insert fast tracepoints in or out of observer mode,
228 but enable them if we're going into this mode. */
230 may_insert_fast_tracepoints
= 1;
231 may_stop
= !observer_mode
;
232 update_target_permissions ();
234 /* Going *into* observer mode we must force non-stop, then
235 going out we leave it that way. */
238 pagination_enabled
= 0;
239 non_stop
= non_stop_1
= 1;
243 printf_filtered (_("Observer mode is now %s.\n"),
244 (observer_mode
? "on" : "off"));
248 show_observer_mode (struct ui_file
*file
, int from_tty
,
249 struct cmd_list_element
*c
, const char *value
)
251 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
254 /* This updates the value of observer mode based on changes in
255 permissions. Note that we are deliberately ignoring the values of
256 may-write-registers and may-write-memory, since the user may have
257 reason to enable these during a session, for instance to turn on a
258 debugging-related global. */
261 update_observer_mode (void)
265 newval
= (!may_insert_breakpoints
266 && !may_insert_tracepoints
267 && may_insert_fast_tracepoints
271 /* Let the user know if things change. */
272 if (newval
!= observer_mode
)
273 printf_filtered (_("Observer mode is now %s.\n"),
274 (newval
? "on" : "off"));
276 observer_mode
= observer_mode_1
= newval
;
279 /* Tables of how to react to signals; the user sets them. */
281 static unsigned char *signal_stop
;
282 static unsigned char *signal_print
;
283 static unsigned char *signal_program
;
285 /* Table of signals that are registered with "catch signal". A
286 non-zero entry indicates that the signal is caught by some "catch
287 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
289 static unsigned char *signal_catch
;
291 /* Table of signals that the target may silently handle.
292 This is automatically determined from the flags above,
293 and simply cached here. */
294 static unsigned char *signal_pass
;
296 #define SET_SIGS(nsigs,sigs,flags) \
298 int signum = (nsigs); \
299 while (signum-- > 0) \
300 if ((sigs)[signum]) \
301 (flags)[signum] = 1; \
304 #define UNSET_SIGS(nsigs,sigs,flags) \
306 int signum = (nsigs); \
307 while (signum-- > 0) \
308 if ((sigs)[signum]) \
309 (flags)[signum] = 0; \
312 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
313 this function is to avoid exporting `signal_program'. */
316 update_signals_program_target (void)
318 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
321 /* Value to pass to target_resume() to cause all threads to resume. */
323 #define RESUME_ALL minus_one_ptid
325 /* Command list pointer for the "stop" placeholder. */
327 static struct cmd_list_element
*stop_command
;
329 /* Function inferior was in as of last step command. */
331 static struct symbol
*step_start_function
;
333 /* Nonzero if we want to give control to the user when we're notified
334 of shared library events by the dynamic linker. */
335 int stop_on_solib_events
;
337 /* Enable or disable optional shared library event breakpoints
338 as appropriate when the above flag is changed. */
341 set_stop_on_solib_events (char *args
, int from_tty
, struct cmd_list_element
*c
)
343 update_solib_breakpoints ();
347 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
348 struct cmd_list_element
*c
, const char *value
)
350 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
354 /* Nonzero means expecting a trace trap
355 and should stop the inferior and return silently when it happens. */
359 /* Save register contents here when executing a "finish" command or are
360 about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set.
361 Thus this contains the return value from the called function (assuming
362 values are returned in a register). */
364 struct regcache
*stop_registers
;
366 /* Nonzero after stop if current stack frame should be printed. */
368 static int stop_print_frame
;
370 /* This is a cached copy of the pid/waitstatus of the last event
371 returned by target_wait()/deprecated_target_wait_hook(). This
372 information is returned by get_last_target_status(). */
373 static ptid_t target_last_wait_ptid
;
374 static struct target_waitstatus target_last_waitstatus
;
376 static void context_switch (ptid_t ptid
);
378 void init_thread_stepping_state (struct thread_info
*tss
);
380 static const char follow_fork_mode_child
[] = "child";
381 static const char follow_fork_mode_parent
[] = "parent";
383 static const char *const follow_fork_mode_kind_names
[] = {
384 follow_fork_mode_child
,
385 follow_fork_mode_parent
,
389 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
391 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
392 struct cmd_list_element
*c
, const char *value
)
394 fprintf_filtered (file
,
395 _("Debugger response to a program "
396 "call of fork or vfork is \"%s\".\n"),
401 /* Handle changes to the inferior list based on the type of fork,
402 which process is being followed, and whether the other process
403 should be detached. On entry inferior_ptid must be the ptid of
404 the fork parent. At return inferior_ptid is the ptid of the
405 followed inferior. */
408 follow_fork_inferior (int follow_child
, int detach_fork
)
411 int parent_pid
, child_pid
;
413 has_vforked
= (inferior_thread ()->pending_follow
.kind
414 == TARGET_WAITKIND_VFORKED
);
415 parent_pid
= ptid_get_lwp (inferior_ptid
);
417 parent_pid
= ptid_get_pid (inferior_ptid
);
419 = ptid_get_pid (inferior_thread ()->pending_follow
.value
.related_pid
);
422 && !non_stop
/* Non-stop always resumes both branches. */
423 && (!target_is_async_p () || sync_execution
)
424 && !(follow_child
|| detach_fork
|| sched_multi
))
426 /* The parent stays blocked inside the vfork syscall until the
427 child execs or exits. If we don't let the child run, then
428 the parent stays blocked. If we're telling the parent to run
429 in the foreground, the user will not be able to ctrl-c to get
430 back the terminal, effectively hanging the debug session. */
431 fprintf_filtered (gdb_stderr
, _("\
432 Can not resume the parent process over vfork in the foreground while\n\
433 holding the child stopped. Try \"set detach-on-fork\" or \
434 \"set schedule-multiple\".\n"));
435 /* FIXME output string > 80 columns. */
441 /* Detach new forked process? */
444 struct cleanup
*old_chain
;
446 /* Before detaching from the child, remove all breakpoints
447 from it. If we forked, then this has already been taken
448 care of by infrun.c. If we vforked however, any
449 breakpoint inserted in the parent is visible in the
450 child, even those added while stopped in a vfork
451 catchpoint. This will remove the breakpoints from the
452 parent also, but they'll be reinserted below. */
455 /* Keep breakpoints list in sync. */
456 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
459 if (info_verbose
|| debug_infrun
)
461 target_terminal_ours ();
462 fprintf_filtered (gdb_stdlog
,
463 "Detaching after fork from "
464 "child process %d.\n",
470 struct inferior
*parent_inf
, *child_inf
;
471 struct cleanup
*old_chain
;
473 /* Add process to GDB's tables. */
474 child_inf
= add_inferior (child_pid
);
476 parent_inf
= current_inferior ();
477 child_inf
->attach_flag
= parent_inf
->attach_flag
;
478 copy_terminal_info (child_inf
, parent_inf
);
479 child_inf
->gdbarch
= parent_inf
->gdbarch
;
480 copy_inferior_target_desc_info (child_inf
, parent_inf
);
482 old_chain
= save_inferior_ptid ();
483 save_current_program_space ();
485 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
486 add_thread (inferior_ptid
);
487 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
489 /* If this is a vfork child, then the address-space is
490 shared with the parent. */
493 child_inf
->pspace
= parent_inf
->pspace
;
494 child_inf
->aspace
= parent_inf
->aspace
;
496 /* The parent will be frozen until the child is done
497 with the shared region. Keep track of the
499 child_inf
->vfork_parent
= parent_inf
;
500 child_inf
->pending_detach
= 0;
501 parent_inf
->vfork_child
= child_inf
;
502 parent_inf
->pending_detach
= 0;
506 child_inf
->aspace
= new_address_space ();
507 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
508 child_inf
->removable
= 1;
509 set_current_program_space (child_inf
->pspace
);
510 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
512 /* Let the shared library layer (e.g., solib-svr4) learn
513 about this new process, relocate the cloned exec, pull
514 in shared libraries, and install the solib event
515 breakpoint. If a "cloned-VM" event was propagated
516 better throughout the core, this wouldn't be
518 solib_create_inferior_hook (0);
521 do_cleanups (old_chain
);
526 struct inferior
*parent_inf
;
528 parent_inf
= current_inferior ();
530 /* If we detached from the child, then we have to be careful
531 to not insert breakpoints in the parent until the child
532 is done with the shared memory region. However, if we're
533 staying attached to the child, then we can and should
534 insert breakpoints, so that we can debug it. A
535 subsequent child exec or exit is enough to know when does
536 the child stops using the parent's address space. */
537 parent_inf
->waiting_for_vfork_done
= detach_fork
;
538 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
543 /* Follow the child. */
544 struct inferior
*parent_inf
, *child_inf
;
545 struct program_space
*parent_pspace
;
547 if (info_verbose
|| debug_infrun
)
549 target_terminal_ours ();
551 fprintf_filtered (gdb_stdlog
,
552 _("Attaching after process %d "
553 "vfork to child process %d.\n"),
554 parent_pid
, child_pid
);
556 fprintf_filtered (gdb_stdlog
,
557 _("Attaching after process %d "
558 "fork to child process %d.\n"),
559 parent_pid
, child_pid
);
562 /* Add the new inferior first, so that the target_detach below
563 doesn't unpush the target. */
565 child_inf
= add_inferior (child_pid
);
567 parent_inf
= current_inferior ();
568 child_inf
->attach_flag
= parent_inf
->attach_flag
;
569 copy_terminal_info (child_inf
, parent_inf
);
570 child_inf
->gdbarch
= parent_inf
->gdbarch
;
571 copy_inferior_target_desc_info (child_inf
, parent_inf
);
573 parent_pspace
= parent_inf
->pspace
;
575 /* If we're vforking, we want to hold on to the parent until the
576 child exits or execs. At child exec or exit time we can
577 remove the old breakpoints from the parent and detach or
578 resume debugging it. Otherwise, detach the parent now; we'll
579 want to reuse it's program/address spaces, but we can't set
580 them to the child before removing breakpoints from the
581 parent, otherwise, the breakpoints module could decide to
582 remove breakpoints from the wrong process (since they'd be
583 assigned to the same address space). */
587 gdb_assert (child_inf
->vfork_parent
== NULL
);
588 gdb_assert (parent_inf
->vfork_child
== NULL
);
589 child_inf
->vfork_parent
= parent_inf
;
590 child_inf
->pending_detach
= 0;
591 parent_inf
->vfork_child
= child_inf
;
592 parent_inf
->pending_detach
= detach_fork
;
593 parent_inf
->waiting_for_vfork_done
= 0;
595 else if (detach_fork
)
596 target_detach (NULL
, 0);
598 /* Note that the detach above makes PARENT_INF dangling. */
600 /* Add the child thread to the appropriate lists, and switch to
601 this new thread, before cloning the program space, and
602 informing the solib layer about this new process. */
604 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
605 add_thread (inferior_ptid
);
607 /* If this is a vfork child, then the address-space is shared
608 with the parent. If we detached from the parent, then we can
609 reuse the parent's program/address spaces. */
610 if (has_vforked
|| detach_fork
)
612 child_inf
->pspace
= parent_pspace
;
613 child_inf
->aspace
= child_inf
->pspace
->aspace
;
617 child_inf
->aspace
= new_address_space ();
618 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
619 child_inf
->removable
= 1;
620 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
621 set_current_program_space (child_inf
->pspace
);
622 clone_program_space (child_inf
->pspace
, parent_pspace
);
624 /* Let the shared library layer (e.g., solib-svr4) learn
625 about this new process, relocate the cloned exec, pull in
626 shared libraries, and install the solib event breakpoint.
627 If a "cloned-VM" event was propagated better throughout
628 the core, this wouldn't be required. */
629 solib_create_inferior_hook (0);
633 return target_follow_fork (follow_child
, detach_fork
);
636 /* Tell the target to follow the fork we're stopped at. Returns true
637 if the inferior should be resumed; false, if the target for some
638 reason decided it's best not to resume. */
643 int follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
644 int should_resume
= 1;
645 struct thread_info
*tp
;
647 /* Copy user stepping state to the new inferior thread. FIXME: the
648 followed fork child thread should have a copy of most of the
649 parent thread structure's run control related fields, not just these.
650 Initialized to avoid "may be used uninitialized" warnings from gcc. */
651 struct breakpoint
*step_resume_breakpoint
= NULL
;
652 struct breakpoint
*exception_resume_breakpoint
= NULL
;
653 CORE_ADDR step_range_start
= 0;
654 CORE_ADDR step_range_end
= 0;
655 struct frame_id step_frame_id
= { 0 };
656 struct interp
*command_interp
= NULL
;
661 struct target_waitstatus wait_status
;
663 /* Get the last target status returned by target_wait(). */
664 get_last_target_status (&wait_ptid
, &wait_status
);
666 /* If not stopped at a fork event, then there's nothing else to
668 if (wait_status
.kind
!= TARGET_WAITKIND_FORKED
669 && wait_status
.kind
!= TARGET_WAITKIND_VFORKED
)
672 /* Check if we switched over from WAIT_PTID, since the event was
674 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
675 && !ptid_equal (inferior_ptid
, wait_ptid
))
677 /* We did. Switch back to WAIT_PTID thread, to tell the
678 target to follow it (in either direction). We'll
679 afterwards refuse to resume, and inform the user what
681 switch_to_thread (wait_ptid
);
686 tp
= inferior_thread ();
688 /* If there were any forks/vforks that were caught and are now to be
689 followed, then do so now. */
690 switch (tp
->pending_follow
.kind
)
692 case TARGET_WAITKIND_FORKED
:
693 case TARGET_WAITKIND_VFORKED
:
695 ptid_t parent
, child
;
697 /* If the user did a next/step, etc, over a fork call,
698 preserve the stepping state in the fork child. */
699 if (follow_child
&& should_resume
)
701 step_resume_breakpoint
= clone_momentary_breakpoint
702 (tp
->control
.step_resume_breakpoint
);
703 step_range_start
= tp
->control
.step_range_start
;
704 step_range_end
= tp
->control
.step_range_end
;
705 step_frame_id
= tp
->control
.step_frame_id
;
706 exception_resume_breakpoint
707 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
708 command_interp
= tp
->control
.command_interp
;
710 /* For now, delete the parent's sr breakpoint, otherwise,
711 parent/child sr breakpoints are considered duplicates,
712 and the child version will not be installed. Remove
713 this when the breakpoints module becomes aware of
714 inferiors and address spaces. */
715 delete_step_resume_breakpoint (tp
);
716 tp
->control
.step_range_start
= 0;
717 tp
->control
.step_range_end
= 0;
718 tp
->control
.step_frame_id
= null_frame_id
;
719 delete_exception_resume_breakpoint (tp
);
720 tp
->control
.command_interp
= NULL
;
723 parent
= inferior_ptid
;
724 child
= tp
->pending_follow
.value
.related_pid
;
726 /* Set up inferior(s) as specified by the caller, and tell the
727 target to do whatever is necessary to follow either parent
729 if (follow_fork_inferior (follow_child
, detach_fork
))
731 /* Target refused to follow, or there's some other reason
732 we shouldn't resume. */
737 /* This pending follow fork event is now handled, one way
738 or another. The previous selected thread may be gone
739 from the lists by now, but if it is still around, need
740 to clear the pending follow request. */
741 tp
= find_thread_ptid (parent
);
743 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
745 /* This makes sure we don't try to apply the "Switched
746 over from WAIT_PID" logic above. */
747 nullify_last_target_wait_ptid ();
749 /* If we followed the child, switch to it... */
752 switch_to_thread (child
);
754 /* ... and preserve the stepping state, in case the
755 user was stepping over the fork call. */
758 tp
= inferior_thread ();
759 tp
->control
.step_resume_breakpoint
760 = step_resume_breakpoint
;
761 tp
->control
.step_range_start
= step_range_start
;
762 tp
->control
.step_range_end
= step_range_end
;
763 tp
->control
.step_frame_id
= step_frame_id
;
764 tp
->control
.exception_resume_breakpoint
765 = exception_resume_breakpoint
;
766 tp
->control
.command_interp
= command_interp
;
770 /* If we get here, it was because we're trying to
771 resume from a fork catchpoint, but, the user
772 has switched threads away from the thread that
773 forked. In that case, the resume command
774 issued is most likely not applicable to the
775 child, so just warn, and refuse to resume. */
776 warning (_("Not resuming: switched threads "
777 "before following fork child.\n"));
780 /* Reset breakpoints in the child as appropriate. */
781 follow_inferior_reset_breakpoints ();
784 switch_to_thread (parent
);
788 case TARGET_WAITKIND_SPURIOUS
:
789 /* Nothing to follow. */
792 internal_error (__FILE__
, __LINE__
,
793 "Unexpected pending_follow.kind %d\n",
794 tp
->pending_follow
.kind
);
798 return should_resume
;
802 follow_inferior_reset_breakpoints (void)
804 struct thread_info
*tp
= inferior_thread ();
806 /* Was there a step_resume breakpoint? (There was if the user
807 did a "next" at the fork() call.) If so, explicitly reset its
808 thread number. Cloned step_resume breakpoints are disabled on
809 creation, so enable it here now that it is associated with the
812 step_resumes are a form of bp that are made to be per-thread.
813 Since we created the step_resume bp when the parent process
814 was being debugged, and now are switching to the child process,
815 from the breakpoint package's viewpoint, that's a switch of
816 "threads". We must update the bp's notion of which thread
817 it is for, or it'll be ignored when it triggers. */
819 if (tp
->control
.step_resume_breakpoint
)
821 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
822 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
825 /* Treat exception_resume breakpoints like step_resume breakpoints. */
826 if (tp
->control
.exception_resume_breakpoint
)
828 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
829 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
832 /* Reinsert all breakpoints in the child. The user may have set
833 breakpoints after catching the fork, in which case those
834 were never set in the child, but only in the parent. This makes
835 sure the inserted breakpoints match the breakpoint list. */
837 breakpoint_re_set ();
838 insert_breakpoints ();
841 /* The child has exited or execed: resume threads of the parent the
842 user wanted to be executing. */
845 proceed_after_vfork_done (struct thread_info
*thread
,
848 int pid
= * (int *) arg
;
850 if (ptid_get_pid (thread
->ptid
) == pid
851 && is_running (thread
->ptid
)
852 && !is_executing (thread
->ptid
)
853 && !thread
->stop_requested
854 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
857 fprintf_unfiltered (gdb_stdlog
,
858 "infrun: resuming vfork parent thread %s\n",
859 target_pid_to_str (thread
->ptid
));
861 switch_to_thread (thread
->ptid
);
862 clear_proceed_status (0);
863 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
869 /* Called whenever we notice an exec or exit event, to handle
870 detaching or resuming a vfork parent. */
873 handle_vfork_child_exec_or_exit (int exec
)
875 struct inferior
*inf
= current_inferior ();
877 if (inf
->vfork_parent
)
879 int resume_parent
= -1;
881 /* This exec or exit marks the end of the shared memory region
882 between the parent and the child. If the user wanted to
883 detach from the parent, now is the time. */
885 if (inf
->vfork_parent
->pending_detach
)
887 struct thread_info
*tp
;
888 struct cleanup
*old_chain
;
889 struct program_space
*pspace
;
890 struct address_space
*aspace
;
892 /* follow-fork child, detach-on-fork on. */
894 inf
->vfork_parent
->pending_detach
= 0;
898 /* If we're handling a child exit, then inferior_ptid
899 points at the inferior's pid, not to a thread. */
900 old_chain
= save_inferior_ptid ();
901 save_current_program_space ();
902 save_current_inferior ();
905 old_chain
= save_current_space_and_thread ();
907 /* We're letting loose of the parent. */
908 tp
= any_live_thread_of_process (inf
->vfork_parent
->pid
);
909 switch_to_thread (tp
->ptid
);
911 /* We're about to detach from the parent, which implicitly
912 removes breakpoints from its address space. There's a
913 catch here: we want to reuse the spaces for the child,
914 but, parent/child are still sharing the pspace at this
915 point, although the exec in reality makes the kernel give
916 the child a fresh set of new pages. The problem here is
917 that the breakpoints module being unaware of this, would
918 likely chose the child process to write to the parent
919 address space. Swapping the child temporarily away from
920 the spaces has the desired effect. Yes, this is "sort
923 pspace
= inf
->pspace
;
924 aspace
= inf
->aspace
;
928 if (debug_infrun
|| info_verbose
)
930 target_terminal_ours ();
933 fprintf_filtered (gdb_stdlog
,
934 "Detaching vfork parent process "
935 "%d after child exec.\n",
936 inf
->vfork_parent
->pid
);
938 fprintf_filtered (gdb_stdlog
,
939 "Detaching vfork parent process "
940 "%d after child exit.\n",
941 inf
->vfork_parent
->pid
);
944 target_detach (NULL
, 0);
947 inf
->pspace
= pspace
;
948 inf
->aspace
= aspace
;
950 do_cleanups (old_chain
);
954 /* We're staying attached to the parent, so, really give the
955 child a new address space. */
956 inf
->pspace
= add_program_space (maybe_new_address_space ());
957 inf
->aspace
= inf
->pspace
->aspace
;
959 set_current_program_space (inf
->pspace
);
961 resume_parent
= inf
->vfork_parent
->pid
;
963 /* Break the bonds. */
964 inf
->vfork_parent
->vfork_child
= NULL
;
968 struct cleanup
*old_chain
;
969 struct program_space
*pspace
;
971 /* If this is a vfork child exiting, then the pspace and
972 aspaces were shared with the parent. Since we're
973 reporting the process exit, we'll be mourning all that is
974 found in the address space, and switching to null_ptid,
975 preparing to start a new inferior. But, since we don't
976 want to clobber the parent's address/program spaces, we
977 go ahead and create a new one for this exiting
980 /* Switch to null_ptid, so that clone_program_space doesn't want
981 to read the selected frame of a dead process. */
982 old_chain
= save_inferior_ptid ();
983 inferior_ptid
= null_ptid
;
985 /* This inferior is dead, so avoid giving the breakpoints
986 module the option to write through to it (cloning a
987 program space resets breakpoints). */
990 pspace
= add_program_space (maybe_new_address_space ());
991 set_current_program_space (pspace
);
993 inf
->symfile_flags
= SYMFILE_NO_READ
;
994 clone_program_space (pspace
, inf
->vfork_parent
->pspace
);
995 inf
->pspace
= pspace
;
996 inf
->aspace
= pspace
->aspace
;
998 /* Put back inferior_ptid. We'll continue mourning this
1000 do_cleanups (old_chain
);
1002 resume_parent
= inf
->vfork_parent
->pid
;
1003 /* Break the bonds. */
1004 inf
->vfork_parent
->vfork_child
= NULL
;
1007 inf
->vfork_parent
= NULL
;
1009 gdb_assert (current_program_space
== inf
->pspace
);
1011 if (non_stop
&& resume_parent
!= -1)
1013 /* If the user wanted the parent to be running, let it go
1015 struct cleanup
*old_chain
= make_cleanup_restore_current_thread ();
1018 fprintf_unfiltered (gdb_stdlog
,
1019 "infrun: resuming vfork parent process %d\n",
1022 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1024 do_cleanups (old_chain
);
1029 /* Enum strings for "set|show follow-exec-mode". */
1031 static const char follow_exec_mode_new
[] = "new";
1032 static const char follow_exec_mode_same
[] = "same";
1033 static const char *const follow_exec_mode_names
[] =
1035 follow_exec_mode_new
,
1036 follow_exec_mode_same
,
1040 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1042 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1043 struct cmd_list_element
*c
, const char *value
)
1045 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1048 /* EXECD_PATHNAME is assumed to be non-NULL. */
1051 follow_exec (ptid_t pid
, char *execd_pathname
)
1053 struct thread_info
*th
= inferior_thread ();
1054 struct inferior
*inf
= current_inferior ();
1056 /* This is an exec event that we actually wish to pay attention to.
1057 Refresh our symbol table to the newly exec'd program, remove any
1058 momentary bp's, etc.
1060 If there are breakpoints, they aren't really inserted now,
1061 since the exec() transformed our inferior into a fresh set
1064 We want to preserve symbolic breakpoints on the list, since
1065 we have hopes that they can be reset after the new a.out's
1066 symbol table is read.
1068 However, any "raw" breakpoints must be removed from the list
1069 (e.g., the solib bp's), since their address is probably invalid
1072 And, we DON'T want to call delete_breakpoints() here, since
1073 that may write the bp's "shadow contents" (the instruction
1074 value that was overwritten witha TRAP instruction). Since
1075 we now have a new a.out, those shadow contents aren't valid. */
1077 mark_breakpoints_out ();
1079 update_breakpoints_after_exec ();
1081 /* If there was one, it's gone now. We cannot truly step-to-next
1082 statement through an exec(). */
1083 th
->control
.step_resume_breakpoint
= NULL
;
1084 th
->control
.exception_resume_breakpoint
= NULL
;
1085 th
->control
.single_step_breakpoints
= NULL
;
1086 th
->control
.step_range_start
= 0;
1087 th
->control
.step_range_end
= 0;
1089 /* The target reports the exec event to the main thread, even if
1090 some other thread does the exec, and even if the main thread was
1091 already stopped --- if debugging in non-stop mode, it's possible
1092 the user had the main thread held stopped in the previous image
1093 --- release it now. This is the same behavior as step-over-exec
1094 with scheduler-locking on in all-stop mode. */
1095 th
->stop_requested
= 0;
1097 /* What is this a.out's name? */
1098 printf_unfiltered (_("%s is executing new program: %s\n"),
1099 target_pid_to_str (inferior_ptid
),
1102 /* We've followed the inferior through an exec. Therefore, the
1103 inferior has essentially been killed & reborn. */
1105 gdb_flush (gdb_stdout
);
1107 breakpoint_init_inferior (inf_execd
);
1109 if (gdb_sysroot
&& *gdb_sysroot
)
1111 char *name
= alloca (strlen (gdb_sysroot
)
1112 + strlen (execd_pathname
)
1115 strcpy (name
, gdb_sysroot
);
1116 strcat (name
, execd_pathname
);
1117 execd_pathname
= name
;
1120 /* Reset the shared library package. This ensures that we get a
1121 shlib event when the child reaches "_start", at which point the
1122 dld will have had a chance to initialize the child. */
1123 /* Also, loading a symbol file below may trigger symbol lookups, and
1124 we don't want those to be satisfied by the libraries of the
1125 previous incarnation of this process. */
1126 no_shared_libraries (NULL
, 0);
1128 if (follow_exec_mode_string
== follow_exec_mode_new
)
1130 struct program_space
*pspace
;
1132 /* The user wants to keep the old inferior and program spaces
1133 around. Create a new fresh one, and switch to it. */
1135 inf
= add_inferior (current_inferior ()->pid
);
1136 pspace
= add_program_space (maybe_new_address_space ());
1137 inf
->pspace
= pspace
;
1138 inf
->aspace
= pspace
->aspace
;
1140 exit_inferior_num_silent (current_inferior ()->num
);
1142 set_current_inferior (inf
);
1143 set_current_program_space (pspace
);
1147 /* The old description may no longer be fit for the new image.
1148 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1149 old description; we'll read a new one below. No need to do
1150 this on "follow-exec-mode new", as the old inferior stays
1151 around (its description is later cleared/refetched on
1153 target_clear_description ();
1156 gdb_assert (current_program_space
== inf
->pspace
);
1158 /* That a.out is now the one to use. */
1159 exec_file_attach (execd_pathname
, 0);
1161 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1162 (Position Independent Executable) main symbol file will get applied by
1163 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1164 the breakpoints with the zero displacement. */
1166 symbol_file_add (execd_pathname
,
1168 | SYMFILE_MAINLINE
| SYMFILE_DEFER_BP_RESET
),
1171 if ((inf
->symfile_flags
& SYMFILE_NO_READ
) == 0)
1172 set_initial_language ();
1174 /* If the target can specify a description, read it. Must do this
1175 after flipping to the new executable (because the target supplied
1176 description must be compatible with the executable's
1177 architecture, and the old executable may e.g., be 32-bit, while
1178 the new one 64-bit), and before anything involving memory or
1180 target_find_description ();
1182 solib_create_inferior_hook (0);
1184 jit_inferior_created_hook ();
1186 breakpoint_re_set ();
1188 /* Reinsert all breakpoints. (Those which were symbolic have
1189 been reset to the proper address in the new a.out, thanks
1190 to symbol_file_command...). */
1191 insert_breakpoints ();
1193 /* The next resume of this inferior should bring it to the shlib
1194 startup breakpoints. (If the user had also set bp's on
1195 "main" from the old (parent) process, then they'll auto-
1196 matically get reset there in the new process.). */
1199 /* Info about an instruction that is being stepped over. */
1201 struct step_over_info
1203 /* If we're stepping past a breakpoint, this is the address space
1204 and address of the instruction the breakpoint is set at. We'll
1205 skip inserting all breakpoints here. Valid iff ASPACE is
1207 struct address_space
*aspace
;
1210 /* The instruction being stepped over triggers a nonsteppable
1211 watchpoint. If true, we'll skip inserting watchpoints. */
1212 int nonsteppable_watchpoint_p
;
1215 /* The step-over info of the location that is being stepped over.
1217 Note that with async/breakpoint always-inserted mode, a user might
1218 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1219 being stepped over. As setting a new breakpoint inserts all
1220 breakpoints, we need to make sure the breakpoint being stepped over
1221 isn't inserted then. We do that by only clearing the step-over
1222 info when the step-over is actually finished (or aborted).
1224 Presently GDB can only step over one breakpoint at any given time.
1225 Given threads that can't run code in the same address space as the
1226 breakpoint's can't really miss the breakpoint, GDB could be taught
1227 to step-over at most one breakpoint per address space (so this info
1228 could move to the address space object if/when GDB is extended).
1229 The set of breakpoints being stepped over will normally be much
1230 smaller than the set of all breakpoints, so a flag in the
1231 breakpoint location structure would be wasteful. A separate list
1232 also saves complexity and run-time, as otherwise we'd have to go
1233 through all breakpoint locations clearing their flag whenever we
1234 start a new sequence. Similar considerations weigh against storing
1235 this info in the thread object. Plus, not all step overs actually
1236 have breakpoint locations -- e.g., stepping past a single-step
1237 breakpoint, or stepping to complete a non-continuable
1239 static struct step_over_info step_over_info
;
1241 /* Record the address of the breakpoint/instruction we're currently
1245 set_step_over_info (struct address_space
*aspace
, CORE_ADDR address
,
1246 int nonsteppable_watchpoint_p
)
1248 step_over_info
.aspace
= aspace
;
1249 step_over_info
.address
= address
;
1250 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1253 /* Called when we're not longer stepping over a breakpoint / an
1254 instruction, so all breakpoints are free to be (re)inserted. */
1257 clear_step_over_info (void)
1259 step_over_info
.aspace
= NULL
;
1260 step_over_info
.address
= 0;
1261 step_over_info
.nonsteppable_watchpoint_p
= 0;
1267 stepping_past_instruction_at (struct address_space
*aspace
,
1270 return (step_over_info
.aspace
!= NULL
1271 && breakpoint_address_match (aspace
, address
,
1272 step_over_info
.aspace
,
1273 step_over_info
.address
));
1279 stepping_past_nonsteppable_watchpoint (void)
1281 return step_over_info
.nonsteppable_watchpoint_p
;
1284 /* Returns true if step-over info is valid. */
1287 step_over_info_valid_p (void)
1289 return (step_over_info
.aspace
!= NULL
1290 || stepping_past_nonsteppable_watchpoint ());
1294 /* Displaced stepping. */
1296 /* In non-stop debugging mode, we must take special care to manage
1297 breakpoints properly; in particular, the traditional strategy for
1298 stepping a thread past a breakpoint it has hit is unsuitable.
1299 'Displaced stepping' is a tactic for stepping one thread past a
1300 breakpoint it has hit while ensuring that other threads running
1301 concurrently will hit the breakpoint as they should.
1303 The traditional way to step a thread T off a breakpoint in a
1304 multi-threaded program in all-stop mode is as follows:
1306 a0) Initially, all threads are stopped, and breakpoints are not
1308 a1) We single-step T, leaving breakpoints uninserted.
1309 a2) We insert breakpoints, and resume all threads.
1311 In non-stop debugging, however, this strategy is unsuitable: we
1312 don't want to have to stop all threads in the system in order to
1313 continue or step T past a breakpoint. Instead, we use displaced
1316 n0) Initially, T is stopped, other threads are running, and
1317 breakpoints are inserted.
1318 n1) We copy the instruction "under" the breakpoint to a separate
1319 location, outside the main code stream, making any adjustments
1320 to the instruction, register, and memory state as directed by
1322 n2) We single-step T over the instruction at its new location.
1323 n3) We adjust the resulting register and memory state as directed
1324 by T's architecture. This includes resetting T's PC to point
1325 back into the main instruction stream.
1328 This approach depends on the following gdbarch methods:
1330 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1331 indicate where to copy the instruction, and how much space must
1332 be reserved there. We use these in step n1.
1334 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1335 address, and makes any necessary adjustments to the instruction,
1336 register contents, and memory. We use this in step n1.
1338 - gdbarch_displaced_step_fixup adjusts registers and memory after
1339 we have successfuly single-stepped the instruction, to yield the
1340 same effect the instruction would have had if we had executed it
1341 at its original address. We use this in step n3.
1343 - gdbarch_displaced_step_free_closure provides cleanup.
1345 The gdbarch_displaced_step_copy_insn and
1346 gdbarch_displaced_step_fixup functions must be written so that
1347 copying an instruction with gdbarch_displaced_step_copy_insn,
1348 single-stepping across the copied instruction, and then applying
1349 gdbarch_displaced_insn_fixup should have the same effects on the
1350 thread's memory and registers as stepping the instruction in place
1351 would have. Exactly which responsibilities fall to the copy and
1352 which fall to the fixup is up to the author of those functions.
1354 See the comments in gdbarch.sh for details.
1356 Note that displaced stepping and software single-step cannot
1357 currently be used in combination, although with some care I think
1358 they could be made to. Software single-step works by placing
1359 breakpoints on all possible subsequent instructions; if the
1360 displaced instruction is a PC-relative jump, those breakpoints
1361 could fall in very strange places --- on pages that aren't
1362 executable, or at addresses that are not proper instruction
1363 boundaries. (We do generally let other threads run while we wait
1364 to hit the software single-step breakpoint, and they might
1365 encounter such a corrupted instruction.) One way to work around
1366 this would be to have gdbarch_displaced_step_copy_insn fully
1367 simulate the effect of PC-relative instructions (and return NULL)
1368 on architectures that use software single-stepping.
1370 In non-stop mode, we can have independent and simultaneous step
1371 requests, so more than one thread may need to simultaneously step
1372 over a breakpoint. The current implementation assumes there is
1373 only one scratch space per process. In this case, we have to
1374 serialize access to the scratch space. If thread A wants to step
1375 over a breakpoint, but we are currently waiting for some other
1376 thread to complete a displaced step, we leave thread A stopped and
1377 place it in the displaced_step_request_queue. Whenever a displaced
1378 step finishes, we pick the next thread in the queue and start a new
1379 displaced step operation on it. See displaced_step_prepare and
1380 displaced_step_fixup for details. */
1382 struct displaced_step_request
1385 struct displaced_step_request
*next
;
1388 /* Per-inferior displaced stepping state. */
1389 struct displaced_step_inferior_state
1391 /* Pointer to next in linked list. */
1392 struct displaced_step_inferior_state
*next
;
1394 /* The process this displaced step state refers to. */
1397 /* A queue of pending displaced stepping requests. One entry per
1398 thread that needs to do a displaced step. */
1399 struct displaced_step_request
*step_request_queue
;
1401 /* If this is not null_ptid, this is the thread carrying out a
1402 displaced single-step in process PID. This thread's state will
1403 require fixing up once it has completed its step. */
1406 /* The architecture the thread had when we stepped it. */
1407 struct gdbarch
*step_gdbarch
;
1409 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1410 for post-step cleanup. */
1411 struct displaced_step_closure
*step_closure
;
1413 /* The address of the original instruction, and the copy we
1415 CORE_ADDR step_original
, step_copy
;
1417 /* Saved contents of copy area. */
1418 gdb_byte
*step_saved_copy
;
1421 /* The list of states of processes involved in displaced stepping
1423 static struct displaced_step_inferior_state
*displaced_step_inferior_states
;
1425 /* Get the displaced stepping state of process PID. */
1427 static struct displaced_step_inferior_state
*
1428 get_displaced_stepping_state (int pid
)
1430 struct displaced_step_inferior_state
*state
;
1432 for (state
= displaced_step_inferior_states
;
1434 state
= state
->next
)
1435 if (state
->pid
== pid
)
1441 /* Add a new displaced stepping state for process PID to the displaced
1442 stepping state list, or return a pointer to an already existing
1443 entry, if it already exists. Never returns NULL. */
1445 static struct displaced_step_inferior_state
*
1446 add_displaced_stepping_state (int pid
)
1448 struct displaced_step_inferior_state
*state
;
1450 for (state
= displaced_step_inferior_states
;
1452 state
= state
->next
)
1453 if (state
->pid
== pid
)
1456 state
= xcalloc (1, sizeof (*state
));
1458 state
->next
= displaced_step_inferior_states
;
1459 displaced_step_inferior_states
= state
;
1464 /* If inferior is in displaced stepping, and ADDR equals to starting address
1465 of copy area, return corresponding displaced_step_closure. Otherwise,
1468 struct displaced_step_closure
*
1469 get_displaced_step_closure_by_addr (CORE_ADDR addr
)
1471 struct displaced_step_inferior_state
*displaced
1472 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
1474 /* If checking the mode of displaced instruction in copy area. */
1475 if (displaced
&& !ptid_equal (displaced
->step_ptid
, null_ptid
)
1476 && (displaced
->step_copy
== addr
))
1477 return displaced
->step_closure
;
1482 /* Remove the displaced stepping state of process PID. */
1485 remove_displaced_stepping_state (int pid
)
1487 struct displaced_step_inferior_state
*it
, **prev_next_p
;
1489 gdb_assert (pid
!= 0);
1491 it
= displaced_step_inferior_states
;
1492 prev_next_p
= &displaced_step_inferior_states
;
1497 *prev_next_p
= it
->next
;
1502 prev_next_p
= &it
->next
;
1508 infrun_inferior_exit (struct inferior
*inf
)
1510 remove_displaced_stepping_state (inf
->pid
);
1513 /* If ON, and the architecture supports it, GDB will use displaced
1514 stepping to step over breakpoints. If OFF, or if the architecture
1515 doesn't support it, GDB will instead use the traditional
1516 hold-and-step approach. If AUTO (which is the default), GDB will
1517 decide which technique to use to step over breakpoints depending on
1518 which of all-stop or non-stop mode is active --- displaced stepping
1519 in non-stop mode; hold-and-step in all-stop mode. */
1521 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1524 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1525 struct cmd_list_element
*c
,
1528 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1529 fprintf_filtered (file
,
1530 _("Debugger's willingness to use displaced stepping "
1531 "to step over breakpoints is %s (currently %s).\n"),
1532 value
, non_stop
? "on" : "off");
1534 fprintf_filtered (file
,
1535 _("Debugger's willingness to use displaced stepping "
1536 "to step over breakpoints is %s.\n"), value
);
1539 /* Return non-zero if displaced stepping can/should be used to step
1540 over breakpoints. */
1543 use_displaced_stepping (struct gdbarch
*gdbarch
)
1545 return (((can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
&& non_stop
)
1546 || can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1547 && gdbarch_displaced_step_copy_insn_p (gdbarch
)
1548 && find_record_target () == NULL
);
1551 /* Clean out any stray displaced stepping state. */
1553 displaced_step_clear (struct displaced_step_inferior_state
*displaced
)
1555 /* Indicate that there is no cleanup pending. */
1556 displaced
->step_ptid
= null_ptid
;
1558 if (displaced
->step_closure
)
1560 gdbarch_displaced_step_free_closure (displaced
->step_gdbarch
,
1561 displaced
->step_closure
);
1562 displaced
->step_closure
= NULL
;
1567 displaced_step_clear_cleanup (void *arg
)
1569 struct displaced_step_inferior_state
*state
= arg
;
1571 displaced_step_clear (state
);
1574 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1576 displaced_step_dump_bytes (struct ui_file
*file
,
1577 const gdb_byte
*buf
,
1582 for (i
= 0; i
< len
; i
++)
1583 fprintf_unfiltered (file
, "%02x ", buf
[i
]);
1584 fputs_unfiltered ("\n", file
);
1587 /* Prepare to single-step, using displaced stepping.
1589 Note that we cannot use displaced stepping when we have a signal to
1590 deliver. If we have a signal to deliver and an instruction to step
1591 over, then after the step, there will be no indication from the
1592 target whether the thread entered a signal handler or ignored the
1593 signal and stepped over the instruction successfully --- both cases
1594 result in a simple SIGTRAP. In the first case we mustn't do a
1595 fixup, and in the second case we must --- but we can't tell which.
1596 Comments in the code for 'random signals' in handle_inferior_event
1597 explain how we handle this case instead.
1599 Returns 1 if preparing was successful -- this thread is going to be
1600 stepped now; or 0 if displaced stepping this thread got queued. */
1602 displaced_step_prepare (ptid_t ptid
)
1604 struct cleanup
*old_cleanups
, *ignore_cleanups
;
1605 struct thread_info
*tp
= find_thread_ptid (ptid
);
1606 struct regcache
*regcache
= get_thread_regcache (ptid
);
1607 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1608 CORE_ADDR original
, copy
;
1610 struct displaced_step_closure
*closure
;
1611 struct displaced_step_inferior_state
*displaced
;
1614 /* We should never reach this function if the architecture does not
1615 support displaced stepping. */
1616 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch
));
1618 /* Disable range stepping while executing in the scratch pad. We
1619 want a single-step even if executing the displaced instruction in
1620 the scratch buffer lands within the stepping range (e.g., a
1622 tp
->control
.may_range_step
= 0;
1624 /* We have to displaced step one thread at a time, as we only have
1625 access to a single scratch space per inferior. */
1627 displaced
= add_displaced_stepping_state (ptid_get_pid (ptid
));
1629 if (!ptid_equal (displaced
->step_ptid
, null_ptid
))
1631 /* Already waiting for a displaced step to finish. Defer this
1632 request and place in queue. */
1633 struct displaced_step_request
*req
, *new_req
;
1635 if (debug_displaced
)
1636 fprintf_unfiltered (gdb_stdlog
,
1637 "displaced: defering step of %s\n",
1638 target_pid_to_str (ptid
));
1640 new_req
= xmalloc (sizeof (*new_req
));
1641 new_req
->ptid
= ptid
;
1642 new_req
->next
= NULL
;
1644 if (displaced
->step_request_queue
)
1646 for (req
= displaced
->step_request_queue
;
1650 req
->next
= new_req
;
1653 displaced
->step_request_queue
= new_req
;
1659 if (debug_displaced
)
1660 fprintf_unfiltered (gdb_stdlog
,
1661 "displaced: stepping %s now\n",
1662 target_pid_to_str (ptid
));
1665 displaced_step_clear (displaced
);
1667 old_cleanups
= save_inferior_ptid ();
1668 inferior_ptid
= ptid
;
1670 original
= regcache_read_pc (regcache
);
1672 copy
= gdbarch_displaced_step_location (gdbarch
);
1673 len
= gdbarch_max_insn_length (gdbarch
);
1675 /* Save the original contents of the copy area. */
1676 displaced
->step_saved_copy
= xmalloc (len
);
1677 ignore_cleanups
= make_cleanup (free_current_contents
,
1678 &displaced
->step_saved_copy
);
1679 status
= target_read_memory (copy
, displaced
->step_saved_copy
, len
);
1681 throw_error (MEMORY_ERROR
,
1682 _("Error accessing memory address %s (%s) for "
1683 "displaced-stepping scratch space."),
1684 paddress (gdbarch
, copy
), safe_strerror (status
));
1685 if (debug_displaced
)
1687 fprintf_unfiltered (gdb_stdlog
, "displaced: saved %s: ",
1688 paddress (gdbarch
, copy
));
1689 displaced_step_dump_bytes (gdb_stdlog
,
1690 displaced
->step_saved_copy
,
1694 closure
= gdbarch_displaced_step_copy_insn (gdbarch
,
1695 original
, copy
, regcache
);
1697 /* We don't support the fully-simulated case at present. */
1698 gdb_assert (closure
);
1700 /* Save the information we need to fix things up if the step
1702 displaced
->step_ptid
= ptid
;
1703 displaced
->step_gdbarch
= gdbarch
;
1704 displaced
->step_closure
= closure
;
1705 displaced
->step_original
= original
;
1706 displaced
->step_copy
= copy
;
1708 make_cleanup (displaced_step_clear_cleanup
, displaced
);
1710 /* Resume execution at the copy. */
1711 regcache_write_pc (regcache
, copy
);
1713 discard_cleanups (ignore_cleanups
);
1715 do_cleanups (old_cleanups
);
1717 if (debug_displaced
)
1718 fprintf_unfiltered (gdb_stdlog
, "displaced: displaced pc to %s\n",
1719 paddress (gdbarch
, copy
));
1725 write_memory_ptid (ptid_t ptid
, CORE_ADDR memaddr
,
1726 const gdb_byte
*myaddr
, int len
)
1728 struct cleanup
*ptid_cleanup
= save_inferior_ptid ();
1730 inferior_ptid
= ptid
;
1731 write_memory (memaddr
, myaddr
, len
);
1732 do_cleanups (ptid_cleanup
);
1735 /* Restore the contents of the copy area for thread PTID. */
1738 displaced_step_restore (struct displaced_step_inferior_state
*displaced
,
1741 ULONGEST len
= gdbarch_max_insn_length (displaced
->step_gdbarch
);
1743 write_memory_ptid (ptid
, displaced
->step_copy
,
1744 displaced
->step_saved_copy
, len
);
1745 if (debug_displaced
)
1746 fprintf_unfiltered (gdb_stdlog
, "displaced: restored %s %s\n",
1747 target_pid_to_str (ptid
),
1748 paddress (displaced
->step_gdbarch
,
1749 displaced
->step_copy
));
1753 displaced_step_fixup (ptid_t event_ptid
, enum gdb_signal signal
)
1755 struct cleanup
*old_cleanups
;
1756 struct displaced_step_inferior_state
*displaced
1757 = get_displaced_stepping_state (ptid_get_pid (event_ptid
));
1759 /* Was any thread of this process doing a displaced step? */
1760 if (displaced
== NULL
)
1763 /* Was this event for the pid we displaced? */
1764 if (ptid_equal (displaced
->step_ptid
, null_ptid
)
1765 || ! ptid_equal (displaced
->step_ptid
, event_ptid
))
1768 old_cleanups
= make_cleanup (displaced_step_clear_cleanup
, displaced
);
1770 displaced_step_restore (displaced
, displaced
->step_ptid
);
1772 /* Did the instruction complete successfully? */
1773 if (signal
== GDB_SIGNAL_TRAP
)
1775 /* Fix up the resulting state. */
1776 gdbarch_displaced_step_fixup (displaced
->step_gdbarch
,
1777 displaced
->step_closure
,
1778 displaced
->step_original
,
1779 displaced
->step_copy
,
1780 get_thread_regcache (displaced
->step_ptid
));
1784 /* Since the instruction didn't complete, all we can do is
1786 struct regcache
*regcache
= get_thread_regcache (event_ptid
);
1787 CORE_ADDR pc
= regcache_read_pc (regcache
);
1789 pc
= displaced
->step_original
+ (pc
- displaced
->step_copy
);
1790 regcache_write_pc (regcache
, pc
);
1793 do_cleanups (old_cleanups
);
1795 displaced
->step_ptid
= null_ptid
;
1797 /* Are there any pending displaced stepping requests? If so, run
1798 one now. Leave the state object around, since we're likely to
1799 need it again soon. */
1800 while (displaced
->step_request_queue
)
1802 struct displaced_step_request
*head
;
1804 struct regcache
*regcache
;
1805 struct gdbarch
*gdbarch
;
1806 CORE_ADDR actual_pc
;
1807 struct address_space
*aspace
;
1809 head
= displaced
->step_request_queue
;
1811 displaced
->step_request_queue
= head
->next
;
1814 context_switch (ptid
);
1816 regcache
= get_thread_regcache (ptid
);
1817 actual_pc
= regcache_read_pc (regcache
);
1818 aspace
= get_regcache_aspace (regcache
);
1820 if (breakpoint_here_p (aspace
, actual_pc
))
1822 if (debug_displaced
)
1823 fprintf_unfiltered (gdb_stdlog
,
1824 "displaced: stepping queued %s now\n",
1825 target_pid_to_str (ptid
));
1827 displaced_step_prepare (ptid
);
1829 gdbarch
= get_regcache_arch (regcache
);
1831 if (debug_displaced
)
1833 CORE_ADDR actual_pc
= regcache_read_pc (regcache
);
1836 fprintf_unfiltered (gdb_stdlog
, "displaced: run %s: ",
1837 paddress (gdbarch
, actual_pc
));
1838 read_memory (actual_pc
, buf
, sizeof (buf
));
1839 displaced_step_dump_bytes (gdb_stdlog
, buf
, sizeof (buf
));
1842 if (gdbarch_displaced_step_hw_singlestep (gdbarch
,
1843 displaced
->step_closure
))
1844 target_resume (ptid
, 1, GDB_SIGNAL_0
);
1846 target_resume (ptid
, 0, GDB_SIGNAL_0
);
1848 /* Done, we're stepping a thread. */
1854 struct thread_info
*tp
= inferior_thread ();
1856 /* The breakpoint we were sitting under has since been
1858 tp
->control
.trap_expected
= 0;
1860 /* Go back to what we were trying to do. */
1861 step
= currently_stepping (tp
);
1863 if (debug_displaced
)
1864 fprintf_unfiltered (gdb_stdlog
,
1865 "displaced: breakpoint is gone: %s, step(%d)\n",
1866 target_pid_to_str (tp
->ptid
), step
);
1868 target_resume (ptid
, step
, GDB_SIGNAL_0
);
1869 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
1871 /* This request was discarded. See if there's any other
1872 thread waiting for its turn. */
1877 /* Update global variables holding ptids to hold NEW_PTID if they were
1878 holding OLD_PTID. */
1880 infrun_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
1882 struct displaced_step_request
*it
;
1883 struct displaced_step_inferior_state
*displaced
;
1885 if (ptid_equal (inferior_ptid
, old_ptid
))
1886 inferior_ptid
= new_ptid
;
1888 for (displaced
= displaced_step_inferior_states
;
1890 displaced
= displaced
->next
)
1892 if (ptid_equal (displaced
->step_ptid
, old_ptid
))
1893 displaced
->step_ptid
= new_ptid
;
1895 for (it
= displaced
->step_request_queue
; it
; it
= it
->next
)
1896 if (ptid_equal (it
->ptid
, old_ptid
))
1897 it
->ptid
= new_ptid
;
1904 /* Things to clean up if we QUIT out of resume (). */
1906 resume_cleanups (void *ignore
)
1908 if (!ptid_equal (inferior_ptid
, null_ptid
))
1909 delete_single_step_breakpoints (inferior_thread ());
1914 static const char schedlock_off
[] = "off";
1915 static const char schedlock_on
[] = "on";
1916 static const char schedlock_step
[] = "step";
1917 static const char *const scheduler_enums
[] = {
1923 static const char *scheduler_mode
= schedlock_off
;
1925 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
1926 struct cmd_list_element
*c
, const char *value
)
1928 fprintf_filtered (file
,
1929 _("Mode for locking scheduler "
1930 "during execution is \"%s\".\n"),
1935 set_schedlock_func (char *args
, int from_tty
, struct cmd_list_element
*c
)
1937 if (!target_can_lock_scheduler
)
1939 scheduler_mode
= schedlock_off
;
1940 error (_("Target '%s' cannot support this command."), target_shortname
);
1944 /* True if execution commands resume all threads of all processes by
1945 default; otherwise, resume only threads of the current inferior
1947 int sched_multi
= 0;
1949 /* Try to setup for software single stepping over the specified location.
1950 Return 1 if target_resume() should use hardware single step.
1952 GDBARCH the current gdbarch.
1953 PC the location to step over. */
1956 maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1960 if (execution_direction
== EXEC_FORWARD
1961 && gdbarch_software_single_step_p (gdbarch
)
1962 && gdbarch_software_single_step (gdbarch
, get_current_frame ()))
1970 user_visible_resume_ptid (int step
)
1972 /* By default, resume all threads of all processes. */
1973 ptid_t resume_ptid
= RESUME_ALL
;
1975 /* Maybe resume only all threads of the current process. */
1976 if (!sched_multi
&& target_supports_multi_process ())
1978 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
1981 /* Maybe resume a single thread after all. */
1984 /* With non-stop mode on, threads are always handled
1986 resume_ptid
= inferior_ptid
;
1988 else if ((scheduler_mode
== schedlock_on
)
1989 || (scheduler_mode
== schedlock_step
&& step
))
1991 /* User-settable 'scheduler' mode requires solo thread resume. */
1992 resume_ptid
= inferior_ptid
;
1995 /* We may actually resume fewer threads at first, e.g., if a thread
1996 is stopped at a breakpoint that needs stepping-off, but that
1997 should not be visible to the user/frontend, and neither should
1998 the frontend/user be allowed to proceed any of the threads that
1999 happen to be stopped for internal run control handling, if a
2000 previous command wanted them resumed. */
2004 /* Resume the inferior, but allow a QUIT. This is useful if the user
2005 wants to interrupt some lengthy single-stepping operation
2006 (for child processes, the SIGINT goes to the inferior, and so
2007 we get a SIGINT random_signal, but for remote debugging and perhaps
2008 other targets, that's not true).
2010 STEP nonzero if we should step (zero to continue instead).
2011 SIG is the signal to give the inferior (zero for none). */
2013 resume (int step
, enum gdb_signal sig
)
2015 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
2016 struct regcache
*regcache
= get_current_regcache ();
2017 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2018 struct thread_info
*tp
= inferior_thread ();
2019 CORE_ADDR pc
= regcache_read_pc (regcache
);
2020 struct address_space
*aspace
= get_regcache_aspace (regcache
);
2022 /* From here on, this represents the caller's step vs continue
2023 request, while STEP represents what we'll actually request the
2024 target to do. STEP can decay from a step to a continue, if e.g.,
2025 we need to implement single-stepping with breakpoints (software
2026 single-step). When deciding whether "set scheduler-locking step"
2027 applies, it's the callers intention that counts. */
2028 const int entry_step
= step
;
2032 if (current_inferior ()->waiting_for_vfork_done
)
2034 /* Don't try to single-step a vfork parent that is waiting for
2035 the child to get out of the shared memory region (by exec'ing
2036 or exiting). This is particularly important on software
2037 single-step archs, as the child process would trip on the
2038 software single step breakpoint inserted for the parent
2039 process. Since the parent will not actually execute any
2040 instruction until the child is out of the shared region (such
2041 are vfork's semantics), it is safe to simply continue it.
2042 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2043 the parent, and tell it to `keep_going', which automatically
2044 re-sets it stepping. */
2046 fprintf_unfiltered (gdb_stdlog
,
2047 "infrun: resume : clear step\n");
2052 fprintf_unfiltered (gdb_stdlog
,
2053 "infrun: resume (step=%d, signal=%s), "
2054 "trap_expected=%d, current thread [%s] at %s\n",
2055 step
, gdb_signal_to_symbol_string (sig
),
2056 tp
->control
.trap_expected
,
2057 target_pid_to_str (inferior_ptid
),
2058 paddress (gdbarch
, pc
));
2060 /* Normally, by the time we reach `resume', the breakpoints are either
2061 removed or inserted, as appropriate. The exception is if we're sitting
2062 at a permanent breakpoint; we need to step over it, but permanent
2063 breakpoints can't be removed. So we have to test for it here. */
2064 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2066 if (gdbarch_skip_permanent_breakpoint_p (gdbarch
))
2067 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2070 The program is stopped at a permanent breakpoint, but GDB does not know\n\
2071 how to step past a permanent breakpoint on this architecture. Try using\n\
2072 a command like `return' or `jump' to continue execution."));
2075 /* If we have a breakpoint to step over, make sure to do a single
2076 step only. Same if we have software watchpoints. */
2077 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2078 tp
->control
.may_range_step
= 0;
2080 /* If enabled, step over breakpoints by executing a copy of the
2081 instruction at a different address.
2083 We can't use displaced stepping when we have a signal to deliver;
2084 the comments for displaced_step_prepare explain why. The
2085 comments in the handle_inferior event for dealing with 'random
2086 signals' explain what we do instead.
2088 We can't use displaced stepping when we are waiting for vfork_done
2089 event, displaced stepping breaks the vfork child similarly as single
2090 step software breakpoint. */
2091 if (use_displaced_stepping (gdbarch
)
2092 && (tp
->control
.trap_expected
2093 || (step
&& gdbarch_software_single_step_p (gdbarch
)))
2094 && sig
== GDB_SIGNAL_0
2095 && !current_inferior ()->waiting_for_vfork_done
)
2097 struct displaced_step_inferior_state
*displaced
;
2099 if (!displaced_step_prepare (inferior_ptid
))
2101 /* Got placed in displaced stepping queue. Will be resumed
2102 later when all the currently queued displaced stepping
2103 requests finish. The thread is not executing at this
2104 point, and the call to set_executing will be made later.
2105 But we need to call set_running here, since from the
2106 user/frontend's point of view, threads were set running.
2107 Unless we're calling an inferior function, as in that
2108 case we pretend the inferior doesn't run at all. */
2109 if (!tp
->control
.in_infcall
)
2110 set_running (user_visible_resume_ptid (entry_step
), 1);
2111 discard_cleanups (old_cleanups
);
2115 /* Update pc to reflect the new address from which we will execute
2116 instructions due to displaced stepping. */
2117 pc
= regcache_read_pc (get_thread_regcache (inferior_ptid
));
2119 displaced
= get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
2120 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
,
2121 displaced
->step_closure
);
2124 /* Do we need to do it the hard way, w/temp breakpoints? */
2126 step
= maybe_software_singlestep (gdbarch
, pc
);
2128 /* Currently, our software single-step implementation leads to different
2129 results than hardware single-stepping in one situation: when stepping
2130 into delivering a signal which has an associated signal handler,
2131 hardware single-step will stop at the first instruction of the handler,
2132 while software single-step will simply skip execution of the handler.
2134 For now, this difference in behavior is accepted since there is no
2135 easy way to actually implement single-stepping into a signal handler
2136 without kernel support.
2138 However, there is one scenario where this difference leads to follow-on
2139 problems: if we're stepping off a breakpoint by removing all breakpoints
2140 and then single-stepping. In this case, the software single-step
2141 behavior means that even if there is a *breakpoint* in the signal
2142 handler, GDB still would not stop.
2144 Fortunately, we can at least fix this particular issue. We detect
2145 here the case where we are about to deliver a signal while software
2146 single-stepping with breakpoints removed. In this situation, we
2147 revert the decisions to remove all breakpoints and insert single-
2148 step breakpoints, and instead we install a step-resume breakpoint
2149 at the current address, deliver the signal without stepping, and
2150 once we arrive back at the step-resume breakpoint, actually step
2151 over the breakpoint we originally wanted to step over. */
2152 if (thread_has_single_step_breakpoints_set (tp
)
2153 && sig
!= GDB_SIGNAL_0
2154 && step_over_info_valid_p ())
2156 /* If we have nested signals or a pending signal is delivered
2157 immediately after a handler returns, might might already have
2158 a step-resume breakpoint set on the earlier handler. We cannot
2159 set another step-resume breakpoint; just continue on until the
2160 original breakpoint is hit. */
2161 if (tp
->control
.step_resume_breakpoint
== NULL
)
2163 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2164 tp
->step_after_step_resume_breakpoint
= 1;
2167 delete_single_step_breakpoints (tp
);
2169 clear_step_over_info ();
2170 tp
->control
.trap_expected
= 0;
2172 insert_breakpoints ();
2175 /* If STEP is set, it's a request to use hardware stepping
2176 facilities. But in that case, we should never
2177 use singlestep breakpoint. */
2178 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2180 /* Decide the set of threads to ask the target to resume. Start
2181 by assuming everything will be resumed, than narrow the set
2182 by applying increasingly restricting conditions. */
2183 resume_ptid
= user_visible_resume_ptid (entry_step
);
2185 /* Even if RESUME_PTID is a wildcard, and we end up resuming less
2186 (e.g., we might need to step over a breakpoint), from the
2187 user/frontend's point of view, all threads in RESUME_PTID are now
2188 running. Unless we're calling an inferior function, as in that
2189 case pretend we inferior doesn't run at all. */
2190 if (!tp
->control
.in_infcall
)
2191 set_running (resume_ptid
, 1);
2193 /* Maybe resume a single thread after all. */
2194 if ((step
|| thread_has_single_step_breakpoints_set (tp
))
2195 && tp
->control
.trap_expected
)
2197 /* We're allowing a thread to run past a breakpoint it has
2198 hit, by single-stepping the thread with the breakpoint
2199 removed. In which case, we need to single-step only this
2200 thread, and keep others stopped, as they can miss this
2201 breakpoint if allowed to run. */
2202 resume_ptid
= inferior_ptid
;
2205 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2207 /* Most targets can step a breakpoint instruction, thus
2208 executing it normally. But if this one cannot, just
2209 continue and we will hit it anyway. */
2210 if (step
&& breakpoint_inserted_here_p (aspace
, pc
))
2215 && use_displaced_stepping (gdbarch
)
2216 && tp
->control
.trap_expected
)
2218 struct regcache
*resume_regcache
= get_thread_regcache (resume_ptid
);
2219 struct gdbarch
*resume_gdbarch
= get_regcache_arch (resume_regcache
);
2220 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2223 fprintf_unfiltered (gdb_stdlog
, "displaced: run %s: ",
2224 paddress (resume_gdbarch
, actual_pc
));
2225 read_memory (actual_pc
, buf
, sizeof (buf
));
2226 displaced_step_dump_bytes (gdb_stdlog
, buf
, sizeof (buf
));
2229 if (tp
->control
.may_range_step
)
2231 /* If we're resuming a thread with the PC out of the step
2232 range, then we're doing some nested/finer run control
2233 operation, like stepping the thread out of the dynamic
2234 linker or the displaced stepping scratch pad. We
2235 shouldn't have allowed a range step then. */
2236 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2239 /* Install inferior's terminal modes. */
2240 target_terminal_inferior ();
2242 /* Avoid confusing the next resume, if the next stop/resume
2243 happens to apply to another thread. */
2244 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2246 /* Advise target which signals may be handled silently. If we have
2247 removed breakpoints because we are stepping over one (in any
2248 thread), we need to receive all signals to avoid accidentally
2249 skipping a breakpoint during execution of a signal handler. */
2250 if (step_over_info_valid_p ())
2251 target_pass_signals (0, NULL
);
2253 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
2255 target_resume (resume_ptid
, step
, sig
);
2257 discard_cleanups (old_cleanups
);
2262 /* Clear out all variables saying what to do when inferior is continued.
2263 First do this, then set the ones you want, then call `proceed'. */
2266 clear_proceed_status_thread (struct thread_info
*tp
)
2269 fprintf_unfiltered (gdb_stdlog
,
2270 "infrun: clear_proceed_status_thread (%s)\n",
2271 target_pid_to_str (tp
->ptid
));
2273 /* If this signal should not be seen by program, give it zero.
2274 Used for debugging signals. */
2275 if (!signal_pass_state (tp
->suspend
.stop_signal
))
2276 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2278 tp
->control
.trap_expected
= 0;
2279 tp
->control
.step_range_start
= 0;
2280 tp
->control
.step_range_end
= 0;
2281 tp
->control
.may_range_step
= 0;
2282 tp
->control
.step_frame_id
= null_frame_id
;
2283 tp
->control
.step_stack_frame_id
= null_frame_id
;
2284 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2285 tp
->stop_requested
= 0;
2287 tp
->control
.stop_step
= 0;
2289 tp
->control
.proceed_to_finish
= 0;
2291 tp
->control
.command_interp
= NULL
;
2293 /* Discard any remaining commands or status from previous stop. */
2294 bpstat_clear (&tp
->control
.stop_bpstat
);
2298 clear_proceed_status (int step
)
2302 struct thread_info
*tp
;
2305 resume_ptid
= user_visible_resume_ptid (step
);
2307 /* In all-stop mode, delete the per-thread status of all threads
2308 we're about to resume, implicitly and explicitly. */
2309 ALL_NON_EXITED_THREADS (tp
)
2311 if (!ptid_match (tp
->ptid
, resume_ptid
))
2313 clear_proceed_status_thread (tp
);
2317 if (!ptid_equal (inferior_ptid
, null_ptid
))
2319 struct inferior
*inferior
;
2323 /* If in non-stop mode, only delete the per-thread status of
2324 the current thread. */
2325 clear_proceed_status_thread (inferior_thread ());
2328 inferior
= current_inferior ();
2329 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2332 stop_after_trap
= 0;
2334 clear_step_over_info ();
2336 observer_notify_about_to_proceed ();
2340 regcache_xfree (stop_registers
);
2341 stop_registers
= NULL
;
2345 /* Returns true if TP is still stopped at a breakpoint that needs
2346 stepping-over in order to make progress. If the breakpoint is gone
2347 meanwhile, we can skip the whole step-over dance. */
2350 thread_still_needs_step_over (struct thread_info
*tp
)
2352 if (tp
->stepping_over_breakpoint
)
2354 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
2356 if (breakpoint_here_p (get_regcache_aspace (regcache
),
2357 regcache_read_pc (regcache
)))
2360 tp
->stepping_over_breakpoint
= 0;
2366 /* Returns true if scheduler locking applies. STEP indicates whether
2367 we're about to do a step/next-like command to a thread. */
2370 schedlock_applies (int step
)
2372 return (scheduler_mode
== schedlock_on
2373 || (scheduler_mode
== schedlock_step
2377 /* Look a thread other than EXCEPT that has previously reported a
2378 breakpoint event, and thus needs a step-over in order to make
2379 progress. Returns NULL is none is found. STEP indicates whether
2380 we're about to step the current thread, in order to decide whether
2381 "set scheduler-locking step" applies. */
2383 static struct thread_info
*
2384 find_thread_needs_step_over (int step
, struct thread_info
*except
)
2386 struct thread_info
*tp
, *current
;
2388 /* With non-stop mode on, threads are always handled individually. */
2389 gdb_assert (! non_stop
);
2391 current
= inferior_thread ();
2393 /* If scheduler locking applies, we can avoid iterating over all
2395 if (schedlock_applies (step
))
2397 if (except
!= current
2398 && thread_still_needs_step_over (current
))
2404 ALL_NON_EXITED_THREADS (tp
)
2406 /* Ignore the EXCEPT thread. */
2409 /* Ignore threads of processes we're not resuming. */
2411 && ptid_get_pid (tp
->ptid
) != ptid_get_pid (inferior_ptid
))
2414 if (thread_still_needs_step_over (tp
))
2421 /* Basic routine for continuing the program in various fashions.
2423 ADDR is the address to resume at, or -1 for resume where stopped.
2424 SIGGNAL is the signal to give it, or 0 for none,
2425 or -1 for act according to how it stopped.
2426 STEP is nonzero if should trap after one instruction.
2427 -1 means return after that and print nothing.
2428 You should probably set various step_... variables
2429 before calling here, if you are stepping.
2431 You should call clear_proceed_status before calling proceed. */
2434 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
, int step
)
2436 struct regcache
*regcache
;
2437 struct gdbarch
*gdbarch
;
2438 struct thread_info
*tp
;
2440 struct address_space
*aspace
;
2442 /* If we're stopped at a fork/vfork, follow the branch set by the
2443 "set follow-fork-mode" command; otherwise, we'll just proceed
2444 resuming the current thread. */
2445 if (!follow_fork ())
2447 /* The target for some reason decided not to resume. */
2449 if (target_can_async_p ())
2450 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
2454 /* We'll update this if & when we switch to a new thread. */
2455 previous_inferior_ptid
= inferior_ptid
;
2457 regcache
= get_current_regcache ();
2458 gdbarch
= get_regcache_arch (regcache
);
2459 aspace
= get_regcache_aspace (regcache
);
2460 pc
= regcache_read_pc (regcache
);
2461 tp
= inferior_thread ();
2464 step_start_function
= find_pc_function (pc
);
2466 stop_after_trap
= 1;
2468 /* Fill in with reasonable starting values. */
2469 init_thread_stepping_state (tp
);
2471 if (addr
== (CORE_ADDR
) -1)
2473 if (pc
== stop_pc
&& breakpoint_here_p (aspace
, pc
)
2474 && execution_direction
!= EXEC_REVERSE
)
2475 /* There is a breakpoint at the address we will resume at,
2476 step one instruction before inserting breakpoints so that
2477 we do not stop right away (and report a second hit at this
2480 Note, we don't do this in reverse, because we won't
2481 actually be executing the breakpoint insn anyway.
2482 We'll be (un-)executing the previous instruction. */
2483 tp
->stepping_over_breakpoint
= 1;
2484 else if (gdbarch_single_step_through_delay_p (gdbarch
)
2485 && gdbarch_single_step_through_delay (gdbarch
,
2486 get_current_frame ()))
2487 /* We stepped onto an instruction that needs to be stepped
2488 again before re-inserting the breakpoint, do so. */
2489 tp
->stepping_over_breakpoint
= 1;
2493 regcache_write_pc (regcache
, addr
);
2496 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
2497 tp
->suspend
.stop_signal
= siggnal
;
2499 /* Record the interpreter that issued the execution command that
2500 caused this thread to resume. If the top level interpreter is
2501 MI/async, and the execution command was a CLI command
2502 (next/step/etc.), we'll want to print stop event output to the MI
2503 console channel (the stepped-to line, etc.), as if the user
2504 entered the execution command on a real GDB console. */
2505 inferior_thread ()->control
.command_interp
= command_interp ();
2508 fprintf_unfiltered (gdb_stdlog
,
2509 "infrun: proceed (addr=%s, signal=%s, step=%d)\n",
2510 paddress (gdbarch
, addr
),
2511 gdb_signal_to_symbol_string (siggnal
), step
);
2514 /* In non-stop, each thread is handled individually. The context
2515 must already be set to the right thread here. */
2519 struct thread_info
*step_over
;
2521 /* In a multi-threaded task we may select another thread and
2522 then continue or step.
2524 But if the old thread was stopped at a breakpoint, it will
2525 immediately cause another breakpoint stop without any
2526 execution (i.e. it will report a breakpoint hit incorrectly).
2527 So we must step over it first.
2529 Look for a thread other than the current (TP) that reported a
2530 breakpoint hit and hasn't been resumed yet since. */
2531 step_over
= find_thread_needs_step_over (step
, tp
);
2532 if (step_over
!= NULL
)
2535 fprintf_unfiltered (gdb_stdlog
,
2536 "infrun: need to step-over [%s] first\n",
2537 target_pid_to_str (step_over
->ptid
));
2539 /* Store the prev_pc for the stepping thread too, needed by
2540 switch_back_to_stepping thread. */
2541 tp
->prev_pc
= regcache_read_pc (get_current_regcache ());
2542 switch_to_thread (step_over
->ptid
);
2547 /* If we need to step over a breakpoint, and we're not using
2548 displaced stepping to do so, insert all breakpoints (watchpoints,
2549 etc.) but the one we're stepping over, step one instruction, and
2550 then re-insert the breakpoint when that step is finished. */
2551 if (tp
->stepping_over_breakpoint
&& !use_displaced_stepping (gdbarch
))
2553 struct regcache
*regcache
= get_current_regcache ();
2555 set_step_over_info (get_regcache_aspace (regcache
),
2556 regcache_read_pc (regcache
), 0);
2559 clear_step_over_info ();
2561 insert_breakpoints ();
2563 tp
->control
.trap_expected
= tp
->stepping_over_breakpoint
;
2565 annotate_starting ();
2567 /* Make sure that output from GDB appears before output from the
2569 gdb_flush (gdb_stdout
);
2571 /* Refresh prev_pc value just prior to resuming. This used to be
2572 done in stop_waiting, however, setting prev_pc there did not handle
2573 scenarios such as inferior function calls or returning from
2574 a function via the return command. In those cases, the prev_pc
2575 value was not set properly for subsequent commands. The prev_pc value
2576 is used to initialize the starting line number in the ecs. With an
2577 invalid value, the gdb next command ends up stopping at the position
2578 represented by the next line table entry past our start position.
2579 On platforms that generate one line table entry per line, this
2580 is not a problem. However, on the ia64, the compiler generates
2581 extraneous line table entries that do not increase the line number.
2582 When we issue the gdb next command on the ia64 after an inferior call
2583 or a return command, we often end up a few instructions forward, still
2584 within the original line we started.
2586 An attempt was made to refresh the prev_pc at the same time the
2587 execution_control_state is initialized (for instance, just before
2588 waiting for an inferior event). But this approach did not work
2589 because of platforms that use ptrace, where the pc register cannot
2590 be read unless the inferior is stopped. At that point, we are not
2591 guaranteed the inferior is stopped and so the regcache_read_pc() call
2592 can fail. Setting the prev_pc value here ensures the value is updated
2593 correctly when the inferior is stopped. */
2594 tp
->prev_pc
= regcache_read_pc (get_current_regcache ());
2596 /* Resume inferior. */
2597 resume (tp
->control
.trap_expected
|| step
|| bpstat_should_step (),
2598 tp
->suspend
.stop_signal
);
2600 /* Wait for it to stop (if not standalone)
2601 and in any case decode why it stopped, and act accordingly. */
2602 /* Do this only if we are not using the event loop, or if the target
2603 does not support asynchronous execution. */
2604 if (!target_can_async_p ())
2606 wait_for_inferior ();
2612 /* Start remote-debugging of a machine over a serial link. */
2615 start_remote (int from_tty
)
2617 struct inferior
*inferior
;
2619 inferior
= current_inferior ();
2620 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2622 /* Always go on waiting for the target, regardless of the mode. */
2623 /* FIXME: cagney/1999-09-23: At present it isn't possible to
2624 indicate to wait_for_inferior that a target should timeout if
2625 nothing is returned (instead of just blocking). Because of this,
2626 targets expecting an immediate response need to, internally, set
2627 things up so that the target_wait() is forced to eventually
2629 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
2630 differentiate to its caller what the state of the target is after
2631 the initial open has been performed. Here we're assuming that
2632 the target has stopped. It should be possible to eventually have
2633 target_open() return to the caller an indication that the target
2634 is currently running and GDB state should be set to the same as
2635 for an async run. */
2636 wait_for_inferior ();
2638 /* Now that the inferior has stopped, do any bookkeeping like
2639 loading shared libraries. We want to do this before normal_stop,
2640 so that the displayed frame is up to date. */
2641 post_create_inferior (¤t_target
, from_tty
);
2646 /* Initialize static vars when a new inferior begins. */
2649 init_wait_for_inferior (void)
2651 /* These are meaningless until the first time through wait_for_inferior. */
2653 breakpoint_init_inferior (inf_starting
);
2655 clear_proceed_status (0);
2657 target_last_wait_ptid
= minus_one_ptid
;
2659 previous_inferior_ptid
= inferior_ptid
;
2661 /* Discard any skipped inlined frames. */
2662 clear_inline_frame_state (minus_one_ptid
);
2666 /* This enum encodes possible reasons for doing a target_wait, so that
2667 wfi can call target_wait in one place. (Ultimately the call will be
2668 moved out of the infinite loop entirely.) */
2672 infwait_normal_state
,
2673 infwait_step_watch_state
,
2674 infwait_nonstep_watch_state
2677 /* Current inferior wait state. */
2678 static enum infwait_states infwait_state
;
2680 /* Data to be passed around while handling an event. This data is
2681 discarded between events. */
2682 struct execution_control_state
2685 /* The thread that got the event, if this was a thread event; NULL
2687 struct thread_info
*event_thread
;
2689 struct target_waitstatus ws
;
2690 int stop_func_filled_in
;
2691 CORE_ADDR stop_func_start
;
2692 CORE_ADDR stop_func_end
;
2693 const char *stop_func_name
;
2696 /* True if the event thread hit the single-step breakpoint of
2697 another thread. Thus the event doesn't cause a stop, the thread
2698 needs to be single-stepped past the single-step breakpoint before
2699 we can switch back to the original stepping thread. */
2700 int hit_singlestep_breakpoint
;
2703 static void handle_inferior_event (struct execution_control_state
*ecs
);
2705 static void handle_step_into_function (struct gdbarch
*gdbarch
,
2706 struct execution_control_state
*ecs
);
2707 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
2708 struct execution_control_state
*ecs
);
2709 static void handle_signal_stop (struct execution_control_state
*ecs
);
2710 static void check_exception_resume (struct execution_control_state
*,
2711 struct frame_info
*);
2713 static void end_stepping_range (struct execution_control_state
*ecs
);
2714 static void stop_waiting (struct execution_control_state
*ecs
);
2715 static void prepare_to_wait (struct execution_control_state
*ecs
);
2716 static void keep_going (struct execution_control_state
*ecs
);
2717 static void process_event_stop_test (struct execution_control_state
*ecs
);
2718 static int switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
2720 /* Callback for iterate over threads. If the thread is stopped, but
2721 the user/frontend doesn't know about that yet, go through
2722 normal_stop, as if the thread had just stopped now. ARG points at
2723 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
2724 ptid_is_pid(PTID) is true, applies to all threads of the process
2725 pointed at by PTID. Otherwise, apply only to the thread pointed by
2729 infrun_thread_stop_requested_callback (struct thread_info
*info
, void *arg
)
2731 ptid_t ptid
= * (ptid_t
*) arg
;
2733 if ((ptid_equal (info
->ptid
, ptid
)
2734 || ptid_equal (minus_one_ptid
, ptid
)
2735 || (ptid_is_pid (ptid
)
2736 && ptid_get_pid (ptid
) == ptid_get_pid (info
->ptid
)))
2737 && is_running (info
->ptid
)
2738 && !is_executing (info
->ptid
))
2740 struct cleanup
*old_chain
;
2741 struct execution_control_state ecss
;
2742 struct execution_control_state
*ecs
= &ecss
;
2744 memset (ecs
, 0, sizeof (*ecs
));
2746 old_chain
= make_cleanup_restore_current_thread ();
2748 overlay_cache_invalid
= 1;
2749 /* Flush target cache before starting to handle each event.
2750 Target was running and cache could be stale. This is just a
2751 heuristic. Running threads may modify target memory, but we
2752 don't get any event. */
2753 target_dcache_invalidate ();
2755 /* Go through handle_inferior_event/normal_stop, so we always
2756 have consistent output as if the stop event had been
2758 ecs
->ptid
= info
->ptid
;
2759 ecs
->event_thread
= find_thread_ptid (info
->ptid
);
2760 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
2761 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
2763 handle_inferior_event (ecs
);
2765 if (!ecs
->wait_some_more
)
2767 struct thread_info
*tp
;
2771 /* Finish off the continuations. */
2772 tp
= inferior_thread ();
2773 do_all_intermediate_continuations_thread (tp
, 1);
2774 do_all_continuations_thread (tp
, 1);
2777 do_cleanups (old_chain
);
2783 /* This function is attached as a "thread_stop_requested" observer.
2784 Cleanup local state that assumed the PTID was to be resumed, and
2785 report the stop to the frontend. */
2788 infrun_thread_stop_requested (ptid_t ptid
)
2790 struct displaced_step_inferior_state
*displaced
;
2792 /* PTID was requested to stop. Remove it from the displaced
2793 stepping queue, so we don't try to resume it automatically. */
2795 for (displaced
= displaced_step_inferior_states
;
2797 displaced
= displaced
->next
)
2799 struct displaced_step_request
*it
, **prev_next_p
;
2801 it
= displaced
->step_request_queue
;
2802 prev_next_p
= &displaced
->step_request_queue
;
2805 if (ptid_match (it
->ptid
, ptid
))
2807 *prev_next_p
= it
->next
;
2813 prev_next_p
= &it
->next
;
2820 iterate_over_threads (infrun_thread_stop_requested_callback
, &ptid
);
2824 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
2826 if (ptid_equal (target_last_wait_ptid
, tp
->ptid
))
2827 nullify_last_target_wait_ptid ();
2830 /* Delete the step resume, single-step and longjmp/exception resume
2831 breakpoints of TP. */
2834 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
2836 delete_step_resume_breakpoint (tp
);
2837 delete_exception_resume_breakpoint (tp
);
2838 delete_single_step_breakpoints (tp
);
2841 /* If the target still has execution, call FUNC for each thread that
2842 just stopped. In all-stop, that's all the non-exited threads; in
2843 non-stop, that's the current thread, only. */
2845 typedef void (*for_each_just_stopped_thread_callback_func
)
2846 (struct thread_info
*tp
);
2849 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
2851 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
2856 /* If in non-stop mode, only the current thread stopped. */
2857 func (inferior_thread ());
2861 struct thread_info
*tp
;
2863 /* In all-stop mode, all threads have stopped. */
2864 ALL_NON_EXITED_THREADS (tp
)
2871 /* Delete the step resume and longjmp/exception resume breakpoints of
2872 the threads that just stopped. */
2875 delete_just_stopped_threads_infrun_breakpoints (void)
2877 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
2880 /* Delete the single-step breakpoints of the threads that just
2884 delete_just_stopped_threads_single_step_breakpoints (void)
2886 for_each_just_stopped_thread (delete_single_step_breakpoints
);
2889 /* A cleanup wrapper. */
2892 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg
)
2894 delete_just_stopped_threads_infrun_breakpoints ();
2897 /* Pretty print the results of target_wait, for debugging purposes. */
2900 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
2901 const struct target_waitstatus
*ws
)
2903 char *status_string
= target_waitstatus_to_string (ws
);
2904 struct ui_file
*tmp_stream
= mem_fileopen ();
2907 /* The text is split over several lines because it was getting too long.
2908 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
2909 output as a unit; we want only one timestamp printed if debug_timestamp
2912 fprintf_unfiltered (tmp_stream
,
2913 "infrun: target_wait (%d", ptid_get_pid (waiton_ptid
));
2914 if (ptid_get_pid (waiton_ptid
) != -1)
2915 fprintf_unfiltered (tmp_stream
,
2916 " [%s]", target_pid_to_str (waiton_ptid
));
2917 fprintf_unfiltered (tmp_stream
, ", status) =\n");
2918 fprintf_unfiltered (tmp_stream
,
2919 "infrun: %d [%s],\n",
2920 ptid_get_pid (result_ptid
),
2921 target_pid_to_str (result_ptid
));
2922 fprintf_unfiltered (tmp_stream
,
2926 text
= ui_file_xstrdup (tmp_stream
, NULL
);
2928 /* This uses %s in part to handle %'s in the text, but also to avoid
2929 a gcc error: the format attribute requires a string literal. */
2930 fprintf_unfiltered (gdb_stdlog
, "%s", text
);
2932 xfree (status_string
);
2934 ui_file_delete (tmp_stream
);
2937 /* Prepare and stabilize the inferior for detaching it. E.g.,
2938 detaching while a thread is displaced stepping is a recipe for
2939 crashing it, as nothing would readjust the PC out of the scratch
2943 prepare_for_detach (void)
2945 struct inferior
*inf
= current_inferior ();
2946 ptid_t pid_ptid
= pid_to_ptid (inf
->pid
);
2947 struct cleanup
*old_chain_1
;
2948 struct displaced_step_inferior_state
*displaced
;
2950 displaced
= get_displaced_stepping_state (inf
->pid
);
2952 /* Is any thread of this process displaced stepping? If not,
2953 there's nothing else to do. */
2954 if (displaced
== NULL
|| ptid_equal (displaced
->step_ptid
, null_ptid
))
2958 fprintf_unfiltered (gdb_stdlog
,
2959 "displaced-stepping in-process while detaching");
2961 old_chain_1
= make_cleanup_restore_integer (&inf
->detaching
);
2964 while (!ptid_equal (displaced
->step_ptid
, null_ptid
))
2966 struct cleanup
*old_chain_2
;
2967 struct execution_control_state ecss
;
2968 struct execution_control_state
*ecs
;
2971 memset (ecs
, 0, sizeof (*ecs
));
2973 overlay_cache_invalid
= 1;
2974 /* Flush target cache before starting to handle each event.
2975 Target was running and cache could be stale. This is just a
2976 heuristic. Running threads may modify target memory, but we
2977 don't get any event. */
2978 target_dcache_invalidate ();
2980 if (deprecated_target_wait_hook
)
2981 ecs
->ptid
= deprecated_target_wait_hook (pid_ptid
, &ecs
->ws
, 0);
2983 ecs
->ptid
= target_wait (pid_ptid
, &ecs
->ws
, 0);
2986 print_target_wait_results (pid_ptid
, ecs
->ptid
, &ecs
->ws
);
2988 /* If an error happens while handling the event, propagate GDB's
2989 knowledge of the executing state to the frontend/user running
2991 old_chain_2
= make_cleanup (finish_thread_state_cleanup
,
2994 /* Now figure out what to do with the result of the result. */
2995 handle_inferior_event (ecs
);
2997 /* No error, don't finish the state yet. */
2998 discard_cleanups (old_chain_2
);
3000 /* Breakpoints and watchpoints are not installed on the target
3001 at this point, and signals are passed directly to the
3002 inferior, so this must mean the process is gone. */
3003 if (!ecs
->wait_some_more
)
3005 discard_cleanups (old_chain_1
);
3006 error (_("Program exited while detaching"));
3010 discard_cleanups (old_chain_1
);
3013 /* Wait for control to return from inferior to debugger.
3015 If inferior gets a signal, we may decide to start it up again
3016 instead of returning. That is why there is a loop in this function.
3017 When this function actually returns it means the inferior
3018 should be left stopped and GDB should read more commands. */
3021 wait_for_inferior (void)
3023 struct cleanup
*old_cleanups
;
3027 (gdb_stdlog
, "infrun: wait_for_inferior ()\n");
3030 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
,
3035 struct execution_control_state ecss
;
3036 struct execution_control_state
*ecs
= &ecss
;
3037 struct cleanup
*old_chain
;
3038 ptid_t waiton_ptid
= minus_one_ptid
;
3040 memset (ecs
, 0, sizeof (*ecs
));
3042 overlay_cache_invalid
= 1;
3044 /* Flush target cache before starting to handle each event.
3045 Target was running and cache could be stale. This is just a
3046 heuristic. Running threads may modify target memory, but we
3047 don't get any event. */
3048 target_dcache_invalidate ();
3050 if (deprecated_target_wait_hook
)
3051 ecs
->ptid
= deprecated_target_wait_hook (waiton_ptid
, &ecs
->ws
, 0);
3053 ecs
->ptid
= target_wait (waiton_ptid
, &ecs
->ws
, 0);
3056 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3058 /* If an error happens while handling the event, propagate GDB's
3059 knowledge of the executing state to the frontend/user running
3061 old_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3063 /* Now figure out what to do with the result of the result. */
3064 handle_inferior_event (ecs
);
3066 /* No error, don't finish the state yet. */
3067 discard_cleanups (old_chain
);
3069 if (!ecs
->wait_some_more
)
3073 do_cleanups (old_cleanups
);
3076 /* Asynchronous version of wait_for_inferior. It is called by the
3077 event loop whenever a change of state is detected on the file
3078 descriptor corresponding to the target. It can be called more than
3079 once to complete a single execution command. In such cases we need
3080 to keep the state in a global variable ECSS. If it is the last time
3081 that this function is called for a single execution command, then
3082 report to the user that the inferior has stopped, and do the
3083 necessary cleanups. */
3086 fetch_inferior_event (void *client_data
)
3088 struct execution_control_state ecss
;
3089 struct execution_control_state
*ecs
= &ecss
;
3090 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3091 struct cleanup
*ts_old_chain
;
3092 int was_sync
= sync_execution
;
3094 ptid_t waiton_ptid
= minus_one_ptid
;
3096 memset (ecs
, 0, sizeof (*ecs
));
3098 /* We're handling a live event, so make sure we're doing live
3099 debugging. If we're looking at traceframes while the target is
3100 running, we're going to need to get back to that mode after
3101 handling the event. */
3104 make_cleanup_restore_current_traceframe ();
3105 set_current_traceframe (-1);
3109 /* In non-stop mode, the user/frontend should not notice a thread
3110 switch due to internal events. Make sure we reverse to the
3111 user selected thread and frame after handling the event and
3112 running any breakpoint commands. */
3113 make_cleanup_restore_current_thread ();
3115 overlay_cache_invalid
= 1;
3116 /* Flush target cache before starting to handle each event. Target
3117 was running and cache could be stale. This is just a heuristic.
3118 Running threads may modify target memory, but we don't get any
3120 target_dcache_invalidate ();
3122 make_cleanup_restore_integer (&execution_direction
);
3123 execution_direction
= target_execution_direction ();
3125 if (deprecated_target_wait_hook
)
3127 deprecated_target_wait_hook (waiton_ptid
, &ecs
->ws
, TARGET_WNOHANG
);
3129 ecs
->ptid
= target_wait (waiton_ptid
, &ecs
->ws
, TARGET_WNOHANG
);
3132 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3134 /* If an error happens while handling the event, propagate GDB's
3135 knowledge of the executing state to the frontend/user running
3138 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3140 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &ecs
->ptid
);
3142 /* Get executed before make_cleanup_restore_current_thread above to apply
3143 still for the thread which has thrown the exception. */
3144 make_bpstat_clear_actions_cleanup ();
3146 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
, NULL
);
3148 /* Now figure out what to do with the result of the result. */
3149 handle_inferior_event (ecs
);
3151 if (!ecs
->wait_some_more
)
3153 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (ecs
->ptid
));
3155 delete_just_stopped_threads_infrun_breakpoints ();
3157 /* We may not find an inferior if this was a process exit. */
3158 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
3161 if (target_has_execution
3162 && ecs
->ws
.kind
!= TARGET_WAITKIND_NO_RESUMED
3163 && ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
3164 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
3165 && ecs
->event_thread
->step_multi
3166 && ecs
->event_thread
->control
.stop_step
)
3167 inferior_event_handler (INF_EXEC_CONTINUE
, NULL
);
3170 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
3175 /* No error, don't finish the thread states yet. */
3176 discard_cleanups (ts_old_chain
);
3178 /* Revert thread and frame. */
3179 do_cleanups (old_chain
);
3181 /* If the inferior was in sync execution mode, and now isn't,
3182 restore the prompt (a synchronous execution command has finished,
3183 and we're ready for input). */
3184 if (interpreter_async
&& was_sync
&& !sync_execution
)
3185 observer_notify_sync_execution_done ();
3189 && exec_done_display_p
3190 && (ptid_equal (inferior_ptid
, null_ptid
)
3191 || !is_running (inferior_ptid
)))
3192 printf_unfiltered (_("completed.\n"));
3195 /* Record the frame and location we're currently stepping through. */
3197 set_step_info (struct frame_info
*frame
, struct symtab_and_line sal
)
3199 struct thread_info
*tp
= inferior_thread ();
3201 tp
->control
.step_frame_id
= get_frame_id (frame
);
3202 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
3204 tp
->current_symtab
= sal
.symtab
;
3205 tp
->current_line
= sal
.line
;
3208 /* Clear context switchable stepping state. */
3211 init_thread_stepping_state (struct thread_info
*tss
)
3213 tss
->stepping_over_breakpoint
= 0;
3214 tss
->stepping_over_watchpoint
= 0;
3215 tss
->step_after_step_resume_breakpoint
= 0;
3218 /* Set the cached copy of the last ptid/waitstatus. */
3221 set_last_target_status (ptid_t ptid
, struct target_waitstatus status
)
3223 target_last_wait_ptid
= ptid
;
3224 target_last_waitstatus
= status
;
3227 /* Return the cached copy of the last pid/waitstatus returned by
3228 target_wait()/deprecated_target_wait_hook(). The data is actually
3229 cached by handle_inferior_event(), which gets called immediately
3230 after target_wait()/deprecated_target_wait_hook(). */
3233 get_last_target_status (ptid_t
*ptidp
, struct target_waitstatus
*status
)
3235 *ptidp
= target_last_wait_ptid
;
3236 *status
= target_last_waitstatus
;
3240 nullify_last_target_wait_ptid (void)
3242 target_last_wait_ptid
= minus_one_ptid
;
3245 /* Switch thread contexts. */
3248 context_switch (ptid_t ptid
)
3250 if (debug_infrun
&& !ptid_equal (ptid
, inferior_ptid
))
3252 fprintf_unfiltered (gdb_stdlog
, "infrun: Switching context from %s ",
3253 target_pid_to_str (inferior_ptid
));
3254 fprintf_unfiltered (gdb_stdlog
, "to %s\n",
3255 target_pid_to_str (ptid
));
3258 switch_to_thread (ptid
);
3262 adjust_pc_after_break (struct execution_control_state
*ecs
)
3264 struct regcache
*regcache
;
3265 struct gdbarch
*gdbarch
;
3266 struct address_space
*aspace
;
3267 CORE_ADDR breakpoint_pc
, decr_pc
;
3269 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
3270 we aren't, just return.
3272 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3273 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
3274 implemented by software breakpoints should be handled through the normal
3277 NOTE drow/2004-01-31: On some targets, breakpoints may generate
3278 different signals (SIGILL or SIGEMT for instance), but it is less
3279 clear where the PC is pointing afterwards. It may not match
3280 gdbarch_decr_pc_after_break. I don't know any specific target that
3281 generates these signals at breakpoints (the code has been in GDB since at
3282 least 1992) so I can not guess how to handle them here.
3284 In earlier versions of GDB, a target with
3285 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3286 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
3287 target with both of these set in GDB history, and it seems unlikely to be
3288 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
3290 if (ecs
->ws
.kind
!= TARGET_WAITKIND_STOPPED
)
3293 if (ecs
->ws
.value
.sig
!= GDB_SIGNAL_TRAP
)
3296 /* In reverse execution, when a breakpoint is hit, the instruction
3297 under it has already been de-executed. The reported PC always
3298 points at the breakpoint address, so adjusting it further would
3299 be wrong. E.g., consider this case on a decr_pc_after_break == 1
3302 B1 0x08000000 : INSN1
3303 B2 0x08000001 : INSN2
3305 PC -> 0x08000003 : INSN4
3307 Say you're stopped at 0x08000003 as above. Reverse continuing
3308 from that point should hit B2 as below. Reading the PC when the
3309 SIGTRAP is reported should read 0x08000001 and INSN2 should have
3310 been de-executed already.
3312 B1 0x08000000 : INSN1
3313 B2 PC -> 0x08000001 : INSN2
3317 We can't apply the same logic as for forward execution, because
3318 we would wrongly adjust the PC to 0x08000000, since there's a
3319 breakpoint at PC - 1. We'd then report a hit on B1, although
3320 INSN1 hadn't been de-executed yet. Doing nothing is the correct
3322 if (execution_direction
== EXEC_REVERSE
)
3325 /* If this target does not decrement the PC after breakpoints, then
3326 we have nothing to do. */
3327 regcache
= get_thread_regcache (ecs
->ptid
);
3328 gdbarch
= get_regcache_arch (regcache
);
3330 decr_pc
= target_decr_pc_after_break (gdbarch
);
3334 aspace
= get_regcache_aspace (regcache
);
3336 /* Find the location where (if we've hit a breakpoint) the
3337 breakpoint would be. */
3338 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
3340 /* Check whether there actually is a software breakpoint inserted at
3343 If in non-stop mode, a race condition is possible where we've
3344 removed a breakpoint, but stop events for that breakpoint were
3345 already queued and arrive later. To suppress those spurious
3346 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
3347 and retire them after a number of stop events are reported. */
3348 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
3349 || (non_stop
&& moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
3351 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
3353 if (record_full_is_used ())
3354 record_full_gdb_operation_disable_set ();
3356 /* When using hardware single-step, a SIGTRAP is reported for both
3357 a completed single-step and a software breakpoint. Need to
3358 differentiate between the two, as the latter needs adjusting
3359 but the former does not.
3361 The SIGTRAP can be due to a completed hardware single-step only if
3362 - we didn't insert software single-step breakpoints
3363 - the thread to be examined is still the current thread
3364 - this thread is currently being stepped
3366 If any of these events did not occur, we must have stopped due
3367 to hitting a software breakpoint, and have to back up to the
3370 As a special case, we could have hardware single-stepped a
3371 software breakpoint. In this case (prev_pc == breakpoint_pc),
3372 we also need to back up to the breakpoint address. */
3374 if (thread_has_single_step_breakpoints_set (ecs
->event_thread
)
3375 || !ptid_equal (ecs
->ptid
, inferior_ptid
)
3376 || !currently_stepping (ecs
->event_thread
)
3377 || ecs
->event_thread
->prev_pc
== breakpoint_pc
)
3378 regcache_write_pc (regcache
, breakpoint_pc
);
3380 do_cleanups (old_cleanups
);
3385 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
3387 for (frame
= get_prev_frame (frame
);
3389 frame
= get_prev_frame (frame
))
3391 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
3393 if (get_frame_type (frame
) != INLINE_FRAME
)
3400 /* Auxiliary function that handles syscall entry/return events.
3401 It returns 1 if the inferior should keep going (and GDB
3402 should ignore the event), or 0 if the event deserves to be
3406 handle_syscall_event (struct execution_control_state
*ecs
)
3408 struct regcache
*regcache
;
3411 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
3412 context_switch (ecs
->ptid
);
3414 regcache
= get_thread_regcache (ecs
->ptid
);
3415 syscall_number
= ecs
->ws
.value
.syscall_number
;
3416 stop_pc
= regcache_read_pc (regcache
);
3418 if (catch_syscall_enabled () > 0
3419 && catching_syscall_number (syscall_number
) > 0)
3422 fprintf_unfiltered (gdb_stdlog
, "infrun: syscall number = '%d'\n",
3425 ecs
->event_thread
->control
.stop_bpstat
3426 = bpstat_stop_status (get_regcache_aspace (regcache
),
3427 stop_pc
, ecs
->ptid
, &ecs
->ws
);
3429 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
3431 /* Catchpoint hit. */
3436 /* If no catchpoint triggered for this, then keep going. */
3441 /* Lazily fill in the execution_control_state's stop_func_* fields. */
3444 fill_in_stop_func (struct gdbarch
*gdbarch
,
3445 struct execution_control_state
*ecs
)
3447 if (!ecs
->stop_func_filled_in
)
3449 /* Don't care about return value; stop_func_start and stop_func_name
3450 will both be 0 if it doesn't work. */
3451 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
3452 &ecs
->stop_func_start
, &ecs
->stop_func_end
);
3453 ecs
->stop_func_start
3454 += gdbarch_deprecated_function_start_offset (gdbarch
);
3456 if (gdbarch_skip_entrypoint_p (gdbarch
))
3457 ecs
->stop_func_start
= gdbarch_skip_entrypoint (gdbarch
,
3458 ecs
->stop_func_start
);
3460 ecs
->stop_func_filled_in
= 1;
3465 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
3467 static enum stop_kind
3468 get_inferior_stop_soon (ptid_t ptid
)
3470 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (ptid
));
3472 gdb_assert (inf
!= NULL
);
3473 return inf
->control
.stop_soon
;
3476 /* Given an execution control state that has been freshly filled in by
3477 an event from the inferior, figure out what it means and take
3480 The alternatives are:
3482 1) stop_waiting and return; to really stop and return to the
3485 2) keep_going and return; to wait for the next event (set
3486 ecs->event_thread->stepping_over_breakpoint to 1 to single step
3490 handle_inferior_event (struct execution_control_state
*ecs
)
3492 enum stop_kind stop_soon
;
3494 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
3496 /* We had an event in the inferior, but we are not interested in
3497 handling it at this level. The lower layers have already
3498 done what needs to be done, if anything.
3500 One of the possible circumstances for this is when the
3501 inferior produces output for the console. The inferior has
3502 not stopped, and we are ignoring the event. Another possible
3503 circumstance is any event which the lower level knows will be
3504 reported multiple times without an intervening resume. */
3506 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_IGNORE\n");
3507 prepare_to_wait (ecs
);
3511 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
3512 && target_can_async_p () && !sync_execution
)
3514 /* There were no unwaited-for children left in the target, but,
3515 we're not synchronously waiting for events either. Just
3516 ignore. Otherwise, if we were running a synchronous
3517 execution command, we need to cancel it and give the user
3518 back the terminal. */
3520 fprintf_unfiltered (gdb_stdlog
,
3521 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
3522 prepare_to_wait (ecs
);
3526 /* Cache the last pid/waitstatus. */
3527 set_last_target_status (ecs
->ptid
, ecs
->ws
);
3529 /* Always clear state belonging to the previous time we stopped. */
3530 stop_stack_dummy
= STOP_NONE
;
3532 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
3534 /* No unwaited-for children left. IOW, all resumed children
3537 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
3539 stop_print_frame
= 0;
3544 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
3545 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
3547 ecs
->event_thread
= find_thread_ptid (ecs
->ptid
);
3548 /* If it's a new thread, add it to the thread database. */
3549 if (ecs
->event_thread
== NULL
)
3550 ecs
->event_thread
= add_thread (ecs
->ptid
);
3552 /* Disable range stepping. If the next step request could use a
3553 range, this will be end up re-enabled then. */
3554 ecs
->event_thread
->control
.may_range_step
= 0;
3557 /* Dependent on valid ECS->EVENT_THREAD. */
3558 adjust_pc_after_break (ecs
);
3560 /* Dependent on the current PC value modified by adjust_pc_after_break. */
3561 reinit_frame_cache ();
3563 breakpoint_retire_moribund ();
3565 /* First, distinguish signals caused by the debugger from signals
3566 that have to do with the program's own actions. Note that
3567 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
3568 on the operating system version. Here we detect when a SIGILL or
3569 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
3570 something similar for SIGSEGV, since a SIGSEGV will be generated
3571 when we're trying to execute a breakpoint instruction on a
3572 non-executable stack. This happens for call dummy breakpoints
3573 for architectures like SPARC that place call dummies on the
3575 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
3576 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
3577 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
3578 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
3580 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
3582 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
),
3583 regcache_read_pc (regcache
)))
3586 fprintf_unfiltered (gdb_stdlog
,
3587 "infrun: Treating signal as SIGTRAP\n");
3588 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
3592 /* Mark the non-executing threads accordingly. In all-stop, all
3593 threads of all processes are stopped when we get any event
3594 reported. In non-stop mode, only the event thread stops. If
3595 we're handling a process exit in non-stop mode, there's nothing
3596 to do, as threads of the dead process are gone, and threads of
3597 any other process were left running. */
3599 set_executing (minus_one_ptid
, 0);
3600 else if (ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
3601 && ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
)
3602 set_executing (ecs
->ptid
, 0);
3604 switch (ecs
->ws
.kind
)
3606 case TARGET_WAITKIND_LOADED
:
3608 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_LOADED\n");
3609 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
3610 context_switch (ecs
->ptid
);
3611 /* Ignore gracefully during startup of the inferior, as it might
3612 be the shell which has just loaded some objects, otherwise
3613 add the symbols for the newly loaded objects. Also ignore at
3614 the beginning of an attach or remote session; we will query
3615 the full list of libraries once the connection is
3618 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
3619 if (stop_soon
== NO_STOP_QUIETLY
)
3621 struct regcache
*regcache
;
3623 regcache
= get_thread_regcache (ecs
->ptid
);
3625 handle_solib_event ();
3627 ecs
->event_thread
->control
.stop_bpstat
3628 = bpstat_stop_status (get_regcache_aspace (regcache
),
3629 stop_pc
, ecs
->ptid
, &ecs
->ws
);
3631 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
3633 /* A catchpoint triggered. */
3634 process_event_stop_test (ecs
);
3638 /* If requested, stop when the dynamic linker notifies
3639 gdb of events. This allows the user to get control
3640 and place breakpoints in initializer routines for
3641 dynamically loaded objects (among other things). */
3642 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
3643 if (stop_on_solib_events
)
3645 /* Make sure we print "Stopped due to solib-event" in
3647 stop_print_frame
= 1;
3654 /* If we are skipping through a shell, or through shared library
3655 loading that we aren't interested in, resume the program. If
3656 we're running the program normally, also resume. */
3657 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
3659 /* Loading of shared libraries might have changed breakpoint
3660 addresses. Make sure new breakpoints are inserted. */
3661 if (stop_soon
== NO_STOP_QUIETLY
)
3662 insert_breakpoints ();
3663 resume (0, GDB_SIGNAL_0
);
3664 prepare_to_wait (ecs
);
3668 /* But stop if we're attaching or setting up a remote
3670 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
3671 || stop_soon
== STOP_QUIETLY_REMOTE
)
3674 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
3679 internal_error (__FILE__
, __LINE__
,
3680 _("unhandled stop_soon: %d"), (int) stop_soon
);
3682 case TARGET_WAITKIND_SPURIOUS
:
3684 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_SPURIOUS\n");
3685 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
3686 context_switch (ecs
->ptid
);
3687 resume (0, GDB_SIGNAL_0
);
3688 prepare_to_wait (ecs
);
3691 case TARGET_WAITKIND_EXITED
:
3692 case TARGET_WAITKIND_SIGNALLED
:
3695 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
3696 fprintf_unfiltered (gdb_stdlog
,
3697 "infrun: TARGET_WAITKIND_EXITED\n");
3699 fprintf_unfiltered (gdb_stdlog
,
3700 "infrun: TARGET_WAITKIND_SIGNALLED\n");
3703 inferior_ptid
= ecs
->ptid
;
3704 set_current_inferior (find_inferior_pid (ptid_get_pid (ecs
->ptid
)));
3705 set_current_program_space (current_inferior ()->pspace
);
3706 handle_vfork_child_exec_or_exit (0);
3707 target_terminal_ours (); /* Must do this before mourn anyway. */
3709 /* Clearing any previous state of convenience variables. */
3710 clear_exit_convenience_vars ();
3712 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
3714 /* Record the exit code in the convenience variable $_exitcode, so
3715 that the user can inspect this again later. */
3716 set_internalvar_integer (lookup_internalvar ("_exitcode"),
3717 (LONGEST
) ecs
->ws
.value
.integer
);
3719 /* Also record this in the inferior itself. */
3720 current_inferior ()->has_exit_code
= 1;
3721 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
3723 /* Support the --return-child-result option. */
3724 return_child_result_value
= ecs
->ws
.value
.integer
;
3726 observer_notify_exited (ecs
->ws
.value
.integer
);
3730 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
3731 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3733 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
3735 /* Set the value of the internal variable $_exitsignal,
3736 which holds the signal uncaught by the inferior. */
3737 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
3738 gdbarch_gdb_signal_to_target (gdbarch
,
3739 ecs
->ws
.value
.sig
));
3743 /* We don't have access to the target's method used for
3744 converting between signal numbers (GDB's internal
3745 representation <-> target's representation).
3746 Therefore, we cannot do a good job at displaying this
3747 information to the user. It's better to just warn
3748 her about it (if infrun debugging is enabled), and
3751 fprintf_filtered (gdb_stdlog
, _("\
3752 Cannot fill $_exitsignal with the correct signal number.\n"));
3755 observer_notify_signal_exited (ecs
->ws
.value
.sig
);
3758 gdb_flush (gdb_stdout
);
3759 target_mourn_inferior ();
3760 stop_print_frame
= 0;
3764 /* The following are the only cases in which we keep going;
3765 the above cases end in a continue or goto. */
3766 case TARGET_WAITKIND_FORKED
:
3767 case TARGET_WAITKIND_VFORKED
:
3770 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
3771 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_FORKED\n");
3773 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_VFORKED\n");
3776 /* Check whether the inferior is displaced stepping. */
3778 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
3779 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3780 struct displaced_step_inferior_state
*displaced
3781 = get_displaced_stepping_state (ptid_get_pid (ecs
->ptid
));
3783 /* If checking displaced stepping is supported, and thread
3784 ecs->ptid is displaced stepping. */
3785 if (displaced
&& ptid_equal (displaced
->step_ptid
, ecs
->ptid
))
3787 struct inferior
*parent_inf
3788 = find_inferior_pid (ptid_get_pid (ecs
->ptid
));
3789 struct regcache
*child_regcache
;
3790 CORE_ADDR parent_pc
;
3792 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
3793 indicating that the displaced stepping of syscall instruction
3794 has been done. Perform cleanup for parent process here. Note
3795 that this operation also cleans up the child process for vfork,
3796 because their pages are shared. */
3797 displaced_step_fixup (ecs
->ptid
, GDB_SIGNAL_TRAP
);
3799 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
3801 /* Restore scratch pad for child process. */
3802 displaced_step_restore (displaced
, ecs
->ws
.value
.related_pid
);
3805 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
3806 the child's PC is also within the scratchpad. Set the child's PC
3807 to the parent's PC value, which has already been fixed up.
3808 FIXME: we use the parent's aspace here, although we're touching
3809 the child, because the child hasn't been added to the inferior
3810 list yet at this point. */
3813 = get_thread_arch_aspace_regcache (ecs
->ws
.value
.related_pid
,
3815 parent_inf
->aspace
);
3816 /* Read PC value of parent process. */
3817 parent_pc
= regcache_read_pc (regcache
);
3819 if (debug_displaced
)
3820 fprintf_unfiltered (gdb_stdlog
,
3821 "displaced: write child pc from %s to %s\n",
3823 regcache_read_pc (child_regcache
)),
3824 paddress (gdbarch
, parent_pc
));
3826 regcache_write_pc (child_regcache
, parent_pc
);
3830 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
3831 context_switch (ecs
->ptid
);
3833 /* Immediately detach breakpoints from the child before there's
3834 any chance of letting the user delete breakpoints from the
3835 breakpoint lists. If we don't do this early, it's easy to
3836 leave left over traps in the child, vis: "break foo; catch
3837 fork; c; <fork>; del; c; <child calls foo>". We only follow
3838 the fork on the last `continue', and by that time the
3839 breakpoint at "foo" is long gone from the breakpoint table.
3840 If we vforked, then we don't need to unpatch here, since both
3841 parent and child are sharing the same memory pages; we'll
3842 need to unpatch at follow/detach time instead to be certain
3843 that new breakpoints added between catchpoint hit time and
3844 vfork follow are detached. */
3845 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
3847 /* This won't actually modify the breakpoint list, but will
3848 physically remove the breakpoints from the child. */
3849 detach_breakpoints (ecs
->ws
.value
.related_pid
);
3852 delete_just_stopped_threads_single_step_breakpoints ();
3854 /* In case the event is caught by a catchpoint, remember that
3855 the event is to be followed at the next resume of the thread,
3856 and not immediately. */
3857 ecs
->event_thread
->pending_follow
= ecs
->ws
;
3859 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
3861 ecs
->event_thread
->control
.stop_bpstat
3862 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3863 stop_pc
, ecs
->ptid
, &ecs
->ws
);
3865 /* If no catchpoint triggered for this, then keep going. Note
3866 that we're interested in knowing the bpstat actually causes a
3867 stop, not just if it may explain the signal. Software
3868 watchpoints, for example, always appear in the bpstat. */
3869 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
3875 = (follow_fork_mode_string
== follow_fork_mode_child
);
3877 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
3879 should_resume
= follow_fork ();
3882 child
= ecs
->ws
.value
.related_pid
;
3884 /* In non-stop mode, also resume the other branch. */
3885 if (non_stop
&& !detach_fork
)
3888 switch_to_thread (parent
);
3890 switch_to_thread (child
);
3892 ecs
->event_thread
= inferior_thread ();
3893 ecs
->ptid
= inferior_ptid
;
3898 switch_to_thread (child
);
3900 switch_to_thread (parent
);
3902 ecs
->event_thread
= inferior_thread ();
3903 ecs
->ptid
= inferior_ptid
;
3911 process_event_stop_test (ecs
);
3914 case TARGET_WAITKIND_VFORK_DONE
:
3915 /* Done with the shared memory region. Re-insert breakpoints in
3916 the parent, and keep going. */
3919 fprintf_unfiltered (gdb_stdlog
,
3920 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
3922 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
3923 context_switch (ecs
->ptid
);
3925 current_inferior ()->waiting_for_vfork_done
= 0;
3926 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
3927 /* This also takes care of reinserting breakpoints in the
3928 previously locked inferior. */
3932 case TARGET_WAITKIND_EXECD
:
3934 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_EXECD\n");
3936 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
3937 context_switch (ecs
->ptid
);
3939 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
3941 /* Do whatever is necessary to the parent branch of the vfork. */
3942 handle_vfork_child_exec_or_exit (1);
3944 /* This causes the eventpoints and symbol table to be reset.
3945 Must do this now, before trying to determine whether to
3947 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
3949 ecs
->event_thread
->control
.stop_bpstat
3950 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3951 stop_pc
, ecs
->ptid
, &ecs
->ws
);
3953 /* Note that this may be referenced from inside
3954 bpstat_stop_status above, through inferior_has_execd. */
3955 xfree (ecs
->ws
.value
.execd_pathname
);
3956 ecs
->ws
.value
.execd_pathname
= NULL
;
3958 /* If no catchpoint triggered for this, then keep going. */
3959 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
3961 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
3965 process_event_stop_test (ecs
);
3968 /* Be careful not to try to gather much state about a thread
3969 that's in a syscall. It's frequently a losing proposition. */
3970 case TARGET_WAITKIND_SYSCALL_ENTRY
:
3972 fprintf_unfiltered (gdb_stdlog
,
3973 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
3974 /* Getting the current syscall number. */
3975 if (handle_syscall_event (ecs
) == 0)
3976 process_event_stop_test (ecs
);
3979 /* Before examining the threads further, step this thread to
3980 get it entirely out of the syscall. (We get notice of the
3981 event when the thread is just on the verge of exiting a
3982 syscall. Stepping one instruction seems to get it back
3984 case TARGET_WAITKIND_SYSCALL_RETURN
:
3986 fprintf_unfiltered (gdb_stdlog
,
3987 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
3988 if (handle_syscall_event (ecs
) == 0)
3989 process_event_stop_test (ecs
);
3992 case TARGET_WAITKIND_STOPPED
:
3994 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_STOPPED\n");
3995 ecs
->event_thread
->suspend
.stop_signal
= ecs
->ws
.value
.sig
;
3996 handle_signal_stop (ecs
);
3999 case TARGET_WAITKIND_NO_HISTORY
:
4001 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
4002 /* Reverse execution: target ran out of history info. */
4004 delete_just_stopped_threads_single_step_breakpoints ();
4005 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4006 observer_notify_no_history ();
4012 /* Come here when the program has stopped with a signal. */
4015 handle_signal_stop (struct execution_control_state
*ecs
)
4017 struct frame_info
*frame
;
4018 struct gdbarch
*gdbarch
;
4019 int stopped_by_watchpoint
;
4020 enum stop_kind stop_soon
;
4023 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
4025 /* Do we need to clean up the state of a thread that has
4026 completed a displaced single-step? (Doing so usually affects
4027 the PC, so do it here, before we set stop_pc.) */
4028 displaced_step_fixup (ecs
->ptid
,
4029 ecs
->event_thread
->suspend
.stop_signal
);
4031 /* If we either finished a single-step or hit a breakpoint, but
4032 the user wanted this thread to be stopped, pretend we got a
4033 SIG0 (generic unsignaled stop). */
4034 if (ecs
->event_thread
->stop_requested
4035 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
4036 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4038 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4042 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4043 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4044 struct cleanup
*old_chain
= save_inferior_ptid ();
4046 inferior_ptid
= ecs
->ptid
;
4048 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_pc = %s\n",
4049 paddress (gdbarch
, stop_pc
));
4050 if (target_stopped_by_watchpoint ())
4054 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped by watchpoint\n");
4056 if (target_stopped_data_address (¤t_target
, &addr
))
4057 fprintf_unfiltered (gdb_stdlog
,
4058 "infrun: stopped data address = %s\n",
4059 paddress (gdbarch
, addr
));
4061 fprintf_unfiltered (gdb_stdlog
,
4062 "infrun: (no data address available)\n");
4065 do_cleanups (old_chain
);
4068 /* This is originated from start_remote(), start_inferior() and
4069 shared libraries hook functions. */
4070 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
4071 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
4073 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4074 context_switch (ecs
->ptid
);
4076 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
4077 stop_print_frame
= 1;
4082 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4085 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4086 context_switch (ecs
->ptid
);
4088 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped\n");
4089 stop_print_frame
= 0;
4094 /* This originates from attach_command(). We need to overwrite
4095 the stop_signal here, because some kernels don't ignore a
4096 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
4097 See more comments in inferior.h. On the other hand, if we
4098 get a non-SIGSTOP, report it to the user - assume the backend
4099 will handle the SIGSTOP if it should show up later.
4101 Also consider that the attach is complete when we see a
4102 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
4103 target extended-remote report it instead of a SIGSTOP
4104 (e.g. gdbserver). We already rely on SIGTRAP being our
4105 signal, so this is no exception.
4107 Also consider that the attach is complete when we see a
4108 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
4109 the target to stop all threads of the inferior, in case the
4110 low level attach operation doesn't stop them implicitly. If
4111 they weren't stopped implicitly, then the stub will report a
4112 GDB_SIGNAL_0, meaning: stopped for no particular reason
4113 other than GDB's request. */
4114 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
4115 && (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_STOP
4116 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4117 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_0
))
4119 stop_print_frame
= 1;
4121 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4125 /* See if something interesting happened to the non-current thread. If
4126 so, then switch to that thread. */
4127 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4130 fprintf_unfiltered (gdb_stdlog
, "infrun: context switch\n");
4132 context_switch (ecs
->ptid
);
4134 if (deprecated_context_hook
)
4135 deprecated_context_hook (pid_to_thread_id (ecs
->ptid
));
4138 /* At this point, get hold of the now-current thread's frame. */
4139 frame
= get_current_frame ();
4140 gdbarch
= get_frame_arch (frame
);
4142 /* Pull the single step breakpoints out of the target. */
4143 if (gdbarch_software_single_step_p (gdbarch
))
4145 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
4147 struct regcache
*regcache
;
4148 struct address_space
*aspace
;
4151 regcache
= get_thread_regcache (ecs
->ptid
);
4152 aspace
= get_regcache_aspace (regcache
);
4153 pc
= regcache_read_pc (regcache
);
4155 /* However, before doing so, if this single-step breakpoint was
4156 actually for another thread, set this thread up for moving
4158 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
4161 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
4165 fprintf_unfiltered (gdb_stdlog
,
4166 "infrun: [%s] hit another thread's "
4167 "single-step breakpoint\n",
4168 target_pid_to_str (ecs
->ptid
));
4170 ecs
->hit_singlestep_breakpoint
= 1;
4177 fprintf_unfiltered (gdb_stdlog
,
4178 "infrun: [%s] hit its "
4179 "single-step breakpoint\n",
4180 target_pid_to_str (ecs
->ptid
));
4185 delete_just_stopped_threads_single_step_breakpoints ();
4188 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4189 && ecs
->event_thread
->control
.trap_expected
4190 && ecs
->event_thread
->stepping_over_watchpoint
)
4191 stopped_by_watchpoint
= 0;
4193 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
4195 /* If necessary, step over this watchpoint. We'll be back to display
4197 if (stopped_by_watchpoint
4198 && (target_have_steppable_watchpoint
4199 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
4201 /* At this point, we are stopped at an instruction which has
4202 attempted to write to a piece of memory under control of
4203 a watchpoint. The instruction hasn't actually executed
4204 yet. If we were to evaluate the watchpoint expression
4205 now, we would get the old value, and therefore no change
4206 would seem to have occurred.
4208 In order to make watchpoints work `right', we really need
4209 to complete the memory write, and then evaluate the
4210 watchpoint expression. We do this by single-stepping the
4213 It may not be necessary to disable the watchpoint to step over
4214 it. For example, the PA can (with some kernel cooperation)
4215 single step over a watchpoint without disabling the watchpoint.
4217 It is far more common to need to disable a watchpoint to step
4218 the inferior over it. If we have non-steppable watchpoints,
4219 we must disable the current watchpoint; it's simplest to
4220 disable all watchpoints.
4222 Any breakpoint at PC must also be stepped over -- if there's
4223 one, it will have already triggered before the watchpoint
4224 triggered, and we either already reported it to the user, or
4225 it didn't cause a stop and we called keep_going. In either
4226 case, if there was a breakpoint at PC, we must be trying to
4228 ecs
->event_thread
->stepping_over_watchpoint
= 1;
4233 ecs
->event_thread
->stepping_over_breakpoint
= 0;
4234 ecs
->event_thread
->stepping_over_watchpoint
= 0;
4235 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
4236 ecs
->event_thread
->control
.stop_step
= 0;
4237 stop_print_frame
= 1;
4238 stopped_by_random_signal
= 0;
4240 /* Hide inlined functions starting here, unless we just performed stepi or
4241 nexti. After stepi and nexti, always show the innermost frame (not any
4242 inline function call sites). */
4243 if (ecs
->event_thread
->control
.step_range_end
!= 1)
4245 struct address_space
*aspace
=
4246 get_regcache_aspace (get_thread_regcache (ecs
->ptid
));
4248 /* skip_inline_frames is expensive, so we avoid it if we can
4249 determine that the address is one where functions cannot have
4250 been inlined. This improves performance with inferiors that
4251 load a lot of shared libraries, because the solib event
4252 breakpoint is defined as the address of a function (i.e. not
4253 inline). Note that we have to check the previous PC as well
4254 as the current one to catch cases when we have just
4255 single-stepped off a breakpoint prior to reinstating it.
4256 Note that we're assuming that the code we single-step to is
4257 not inline, but that's not definitive: there's nothing
4258 preventing the event breakpoint function from containing
4259 inlined code, and the single-step ending up there. If the
4260 user had set a breakpoint on that inlined code, the missing
4261 skip_inline_frames call would break things. Fortunately
4262 that's an extremely unlikely scenario. */
4263 if (!pc_at_non_inline_function (aspace
, stop_pc
, &ecs
->ws
)
4264 && !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4265 && ecs
->event_thread
->control
.trap_expected
4266 && pc_at_non_inline_function (aspace
,
4267 ecs
->event_thread
->prev_pc
,
4270 skip_inline_frames (ecs
->ptid
);
4272 /* Re-fetch current thread's frame in case that invalidated
4274 frame
= get_current_frame ();
4275 gdbarch
= get_frame_arch (frame
);
4279 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4280 && ecs
->event_thread
->control
.trap_expected
4281 && gdbarch_single_step_through_delay_p (gdbarch
)
4282 && currently_stepping (ecs
->event_thread
))
4284 /* We're trying to step off a breakpoint. Turns out that we're
4285 also on an instruction that needs to be stepped multiple
4286 times before it's been fully executing. E.g., architectures
4287 with a delay slot. It needs to be stepped twice, once for
4288 the instruction and once for the delay slot. */
4289 int step_through_delay
4290 = gdbarch_single_step_through_delay (gdbarch
, frame
);
4292 if (debug_infrun
&& step_through_delay
)
4293 fprintf_unfiltered (gdb_stdlog
, "infrun: step through delay\n");
4294 if (ecs
->event_thread
->control
.step_range_end
== 0
4295 && step_through_delay
)
4297 /* The user issued a continue when stopped at a breakpoint.
4298 Set up for another trap and get out of here. */
4299 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4303 else if (step_through_delay
)
4305 /* The user issued a step when stopped at a breakpoint.
4306 Maybe we should stop, maybe we should not - the delay
4307 slot *might* correspond to a line of source. In any
4308 case, don't decide that here, just set
4309 ecs->stepping_over_breakpoint, making sure we
4310 single-step again before breakpoints are re-inserted. */
4311 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4315 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
4316 handles this event. */
4317 ecs
->event_thread
->control
.stop_bpstat
4318 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4319 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4321 /* Following in case break condition called a
4323 stop_print_frame
= 1;
4325 /* This is where we handle "moribund" watchpoints. Unlike
4326 software breakpoints traps, hardware watchpoint traps are
4327 always distinguishable from random traps. If no high-level
4328 watchpoint is associated with the reported stop data address
4329 anymore, then the bpstat does not explain the signal ---
4330 simply make sure to ignore it if `stopped_by_watchpoint' is
4334 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4335 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
4337 && stopped_by_watchpoint
)
4338 fprintf_unfiltered (gdb_stdlog
,
4339 "infrun: no user watchpoint explains "
4340 "watchpoint SIGTRAP, ignoring\n");
4342 /* NOTE: cagney/2003-03-29: These checks for a random signal
4343 at one stage in the past included checks for an inferior
4344 function call's call dummy's return breakpoint. The original
4345 comment, that went with the test, read:
4347 ``End of a stack dummy. Some systems (e.g. Sony news) give
4348 another signal besides SIGTRAP, so check here as well as
4351 If someone ever tries to get call dummys on a
4352 non-executable stack to work (where the target would stop
4353 with something like a SIGSEGV), then those tests might need
4354 to be re-instated. Given, however, that the tests were only
4355 enabled when momentary breakpoints were not being used, I
4356 suspect that it won't be the case.
4358 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
4359 be necessary for call dummies on a non-executable stack on
4362 /* See if the breakpoints module can explain the signal. */
4364 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
4365 ecs
->event_thread
->suspend
.stop_signal
);
4367 /* If not, perhaps stepping/nexting can. */
4369 random_signal
= !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
4370 && currently_stepping (ecs
->event_thread
));
4372 /* Perhaps the thread hit a single-step breakpoint of _another_
4373 thread. Single-step breakpoints are transparent to the
4374 breakpoints module. */
4376 random_signal
= !ecs
->hit_singlestep_breakpoint
;
4378 /* No? Perhaps we got a moribund watchpoint. */
4380 random_signal
= !stopped_by_watchpoint
;
4382 /* For the program's own signals, act according to
4383 the signal handling tables. */
4387 /* Signal not for debugging purposes. */
4388 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (ecs
->ptid
));
4389 enum gdb_signal stop_signal
= ecs
->event_thread
->suspend
.stop_signal
;
4392 fprintf_unfiltered (gdb_stdlog
, "infrun: random signal (%s)\n",
4393 gdb_signal_to_symbol_string (stop_signal
));
4395 stopped_by_random_signal
= 1;
4397 /* Always stop on signals if we're either just gaining control
4398 of the program, or the user explicitly requested this thread
4399 to remain stopped. */
4400 if (stop_soon
!= NO_STOP_QUIETLY
4401 || ecs
->event_thread
->stop_requested
4403 && signal_stop_state (ecs
->event_thread
->suspend
.stop_signal
)))
4409 /* Notify observers the signal has "handle print" set. Note we
4410 returned early above if stopping; normal_stop handles the
4411 printing in that case. */
4412 if (signal_print
[ecs
->event_thread
->suspend
.stop_signal
])
4414 /* The signal table tells us to print about this signal. */
4415 target_terminal_ours_for_output ();
4416 observer_notify_signal_received (ecs
->event_thread
->suspend
.stop_signal
);
4417 target_terminal_inferior ();
4420 /* Clear the signal if it should not be passed. */
4421 if (signal_program
[ecs
->event_thread
->suspend
.stop_signal
] == 0)
4422 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4424 if (ecs
->event_thread
->prev_pc
== stop_pc
4425 && ecs
->event_thread
->control
.trap_expected
4426 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
4428 /* We were just starting a new sequence, attempting to
4429 single-step off of a breakpoint and expecting a SIGTRAP.
4430 Instead this signal arrives. This signal will take us out
4431 of the stepping range so GDB needs to remember to, when
4432 the signal handler returns, resume stepping off that
4434 /* To simplify things, "continue" is forced to use the same
4435 code paths as single-step - set a breakpoint at the
4436 signal return address and then, once hit, step off that
4439 fprintf_unfiltered (gdb_stdlog
,
4440 "infrun: signal arrived while stepping over "
4443 insert_hp_step_resume_breakpoint_at_frame (frame
);
4444 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
4445 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4446 ecs
->event_thread
->control
.trap_expected
= 0;
4448 /* If we were nexting/stepping some other thread, switch to
4449 it, so that we don't continue it, losing control. */
4450 if (!switch_back_to_stepped_thread (ecs
))
4455 if (ecs
->event_thread
->control
.step_range_end
!= 0
4456 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
4457 && pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
4458 && frame_id_eq (get_stack_frame_id (frame
),
4459 ecs
->event_thread
->control
.step_stack_frame_id
)
4460 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
4462 /* The inferior is about to take a signal that will take it
4463 out of the single step range. Set a breakpoint at the
4464 current PC (which is presumably where the signal handler
4465 will eventually return) and then allow the inferior to
4468 Note that this is only needed for a signal delivered
4469 while in the single-step range. Nested signals aren't a
4470 problem as they eventually all return. */
4472 fprintf_unfiltered (gdb_stdlog
,
4473 "infrun: signal may take us out of "
4474 "single-step range\n");
4476 insert_hp_step_resume_breakpoint_at_frame (frame
);
4477 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4478 ecs
->event_thread
->control
.trap_expected
= 0;
4483 /* Note: step_resume_breakpoint may be non-NULL. This occures
4484 when either there's a nested signal, or when there's a
4485 pending signal enabled just as the signal handler returns
4486 (leaving the inferior at the step-resume-breakpoint without
4487 actually executing it). Either way continue until the
4488 breakpoint is really hit. */
4490 if (!switch_back_to_stepped_thread (ecs
))
4493 fprintf_unfiltered (gdb_stdlog
,
4494 "infrun: random signal, keep going\n");
4501 process_event_stop_test (ecs
);
4504 /* Come here when we've got some debug event / signal we can explain
4505 (IOW, not a random signal), and test whether it should cause a
4506 stop, or whether we should resume the inferior (transparently).
4507 E.g., could be a breakpoint whose condition evaluates false; we
4508 could be still stepping within the line; etc. */
4511 process_event_stop_test (struct execution_control_state
*ecs
)
4513 struct symtab_and_line stop_pc_sal
;
4514 struct frame_info
*frame
;
4515 struct gdbarch
*gdbarch
;
4516 CORE_ADDR jmp_buf_pc
;
4517 struct bpstat_what what
;
4519 /* Handle cases caused by hitting a breakpoint. */
4521 frame
= get_current_frame ();
4522 gdbarch
= get_frame_arch (frame
);
4524 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
4526 if (what
.call_dummy
)
4528 stop_stack_dummy
= what
.call_dummy
;
4531 /* If we hit an internal event that triggers symbol changes, the
4532 current frame will be invalidated within bpstat_what (e.g., if we
4533 hit an internal solib event). Re-fetch it. */
4534 frame
= get_current_frame ();
4535 gdbarch
= get_frame_arch (frame
);
4537 switch (what
.main_action
)
4539 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
4540 /* If we hit the breakpoint at longjmp while stepping, we
4541 install a momentary breakpoint at the target of the
4545 fprintf_unfiltered (gdb_stdlog
,
4546 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4548 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4550 if (what
.is_longjmp
)
4552 struct value
*arg_value
;
4554 /* If we set the longjmp breakpoint via a SystemTap probe,
4555 then use it to extract the arguments. The destination PC
4556 is the third argument to the probe. */
4557 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
4560 jmp_buf_pc
= value_as_address (arg_value
);
4561 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
4563 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
4564 || !gdbarch_get_longjmp_target (gdbarch
,
4565 frame
, &jmp_buf_pc
))
4568 fprintf_unfiltered (gdb_stdlog
,
4569 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4570 "(!gdbarch_get_longjmp_target)\n");
4575 /* Insert a breakpoint at resume address. */
4576 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
4579 check_exception_resume (ecs
, frame
);
4583 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
4585 struct frame_info
*init_frame
;
4587 /* There are several cases to consider.
4589 1. The initiating frame no longer exists. In this case we
4590 must stop, because the exception or longjmp has gone too
4593 2. The initiating frame exists, and is the same as the
4594 current frame. We stop, because the exception or longjmp
4597 3. The initiating frame exists and is different from the
4598 current frame. This means the exception or longjmp has
4599 been caught beneath the initiating frame, so keep going.
4601 4. longjmp breakpoint has been placed just to protect
4602 against stale dummy frames and user is not interested in
4603 stopping around longjmps. */
4606 fprintf_unfiltered (gdb_stdlog
,
4607 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4609 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
4611 delete_exception_resume_breakpoint (ecs
->event_thread
);
4613 if (what
.is_longjmp
)
4615 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
4617 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
4625 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
4629 struct frame_id current_id
4630 = get_frame_id (get_current_frame ());
4631 if (frame_id_eq (current_id
,
4632 ecs
->event_thread
->initiating_frame
))
4634 /* Case 2. Fall through. */
4644 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
4646 delete_step_resume_breakpoint (ecs
->event_thread
);
4648 end_stepping_range (ecs
);
4652 case BPSTAT_WHAT_SINGLE
:
4654 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_SINGLE\n");
4655 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4656 /* Still need to check other stuff, at least the case where we
4657 are stepping and step out of the right range. */
4660 case BPSTAT_WHAT_STEP_RESUME
:
4662 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
4664 delete_step_resume_breakpoint (ecs
->event_thread
);
4665 if (ecs
->event_thread
->control
.proceed_to_finish
4666 && execution_direction
== EXEC_REVERSE
)
4668 struct thread_info
*tp
= ecs
->event_thread
;
4670 /* We are finishing a function in reverse, and just hit the
4671 step-resume breakpoint at the start address of the
4672 function, and we're almost there -- just need to back up
4673 by one more single-step, which should take us back to the
4675 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
4679 fill_in_stop_func (gdbarch
, ecs
);
4680 if (stop_pc
== ecs
->stop_func_start
4681 && execution_direction
== EXEC_REVERSE
)
4683 /* We are stepping over a function call in reverse, and just
4684 hit the step-resume breakpoint at the start address of
4685 the function. Go back to single-stepping, which should
4686 take us back to the function call. */
4687 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4693 case BPSTAT_WHAT_STOP_NOISY
:
4695 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
4696 stop_print_frame
= 1;
4698 /* Assume the thread stopped for a breapoint. We'll still check
4699 whether a/the breakpoint is there when the thread is next
4701 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4706 case BPSTAT_WHAT_STOP_SILENT
:
4708 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
4709 stop_print_frame
= 0;
4711 /* Assume the thread stopped for a breapoint. We'll still check
4712 whether a/the breakpoint is there when the thread is next
4714 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4718 case BPSTAT_WHAT_HP_STEP_RESUME
:
4720 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
4722 delete_step_resume_breakpoint (ecs
->event_thread
);
4723 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
4725 /* Back when the step-resume breakpoint was inserted, we
4726 were trying to single-step off a breakpoint. Go back to
4728 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
4729 ecs
->event_thread
->stepping_over_breakpoint
= 1;
4735 case BPSTAT_WHAT_KEEP_CHECKING
:
4739 /* We come here if we hit a breakpoint but should not stop for it.
4740 Possibly we also were stepping and should stop for that. So fall
4741 through and test for stepping. But, if not stepping, do not
4744 /* In all-stop mode, if we're currently stepping but have stopped in
4745 some other thread, we need to switch back to the stepped thread. */
4746 if (switch_back_to_stepped_thread (ecs
))
4749 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
4752 fprintf_unfiltered (gdb_stdlog
,
4753 "infrun: step-resume breakpoint is inserted\n");
4755 /* Having a step-resume breakpoint overrides anything
4756 else having to do with stepping commands until
4757 that breakpoint is reached. */
4762 if (ecs
->event_thread
->control
.step_range_end
== 0)
4765 fprintf_unfiltered (gdb_stdlog
, "infrun: no stepping, continue\n");
4766 /* Likewise if we aren't even stepping. */
4771 /* Re-fetch current thread's frame in case the code above caused
4772 the frame cache to be re-initialized, making our FRAME variable
4773 a dangling pointer. */
4774 frame
= get_current_frame ();
4775 gdbarch
= get_frame_arch (frame
);
4776 fill_in_stop_func (gdbarch
, ecs
);
4778 /* If stepping through a line, keep going if still within it.
4780 Note that step_range_end is the address of the first instruction
4781 beyond the step range, and NOT the address of the last instruction
4784 Note also that during reverse execution, we may be stepping
4785 through a function epilogue and therefore must detect when
4786 the current-frame changes in the middle of a line. */
4788 if (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
4789 && (execution_direction
!= EXEC_REVERSE
4790 || frame_id_eq (get_frame_id (frame
),
4791 ecs
->event_thread
->control
.step_frame_id
)))
4795 (gdb_stdlog
, "infrun: stepping inside range [%s-%s]\n",
4796 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
4797 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
4799 /* Tentatively re-enable range stepping; `resume' disables it if
4800 necessary (e.g., if we're stepping over a breakpoint or we
4801 have software watchpoints). */
4802 ecs
->event_thread
->control
.may_range_step
= 1;
4804 /* When stepping backward, stop at beginning of line range
4805 (unless it's the function entry point, in which case
4806 keep going back to the call point). */
4807 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
4808 && stop_pc
!= ecs
->stop_func_start
4809 && execution_direction
== EXEC_REVERSE
)
4810 end_stepping_range (ecs
);
4817 /* We stepped out of the stepping range. */
4819 /* If we are stepping at the source level and entered the runtime
4820 loader dynamic symbol resolution code...
4822 EXEC_FORWARD: we keep on single stepping until we exit the run
4823 time loader code and reach the callee's address.
4825 EXEC_REVERSE: we've already executed the callee (backward), and
4826 the runtime loader code is handled just like any other
4827 undebuggable function call. Now we need only keep stepping
4828 backward through the trampoline code, and that's handled further
4829 down, so there is nothing for us to do here. */
4831 if (execution_direction
!= EXEC_REVERSE
4832 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
4833 && in_solib_dynsym_resolve_code (stop_pc
))
4835 CORE_ADDR pc_after_resolver
=
4836 gdbarch_skip_solib_resolver (gdbarch
, stop_pc
);
4839 fprintf_unfiltered (gdb_stdlog
,
4840 "infrun: stepped into dynsym resolve code\n");
4842 if (pc_after_resolver
)
4844 /* Set up a step-resume breakpoint at the address
4845 indicated by SKIP_SOLIB_RESOLVER. */
4846 struct symtab_and_line sr_sal
;
4849 sr_sal
.pc
= pc_after_resolver
;
4850 sr_sal
.pspace
= get_frame_program_space (frame
);
4852 insert_step_resume_breakpoint_at_sal (gdbarch
,
4853 sr_sal
, null_frame_id
);
4860 if (ecs
->event_thread
->control
.step_range_end
!= 1
4861 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
4862 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
4863 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
4866 fprintf_unfiltered (gdb_stdlog
,
4867 "infrun: stepped into signal trampoline\n");
4868 /* The inferior, while doing a "step" or "next", has ended up in
4869 a signal trampoline (either by a signal being delivered or by
4870 the signal handler returning). Just single-step until the
4871 inferior leaves the trampoline (either by calling the handler
4877 /* If we're in the return path from a shared library trampoline,
4878 we want to proceed through the trampoline when stepping. */
4879 /* macro/2012-04-25: This needs to come before the subroutine
4880 call check below as on some targets return trampolines look
4881 like subroutine calls (MIPS16 return thunks). */
4882 if (gdbarch_in_solib_return_trampoline (gdbarch
,
4883 stop_pc
, ecs
->stop_func_name
)
4884 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
4886 /* Determine where this trampoline returns. */
4887 CORE_ADDR real_stop_pc
;
4889 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
4892 fprintf_unfiltered (gdb_stdlog
,
4893 "infrun: stepped into solib return tramp\n");
4895 /* Only proceed through if we know where it's going. */
4898 /* And put the step-breakpoint there and go until there. */
4899 struct symtab_and_line sr_sal
;
4901 init_sal (&sr_sal
); /* initialize to zeroes */
4902 sr_sal
.pc
= real_stop_pc
;
4903 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
4904 sr_sal
.pspace
= get_frame_program_space (frame
);
4906 /* Do not specify what the fp should be when we stop since
4907 on some machines the prologue is where the new fp value
4909 insert_step_resume_breakpoint_at_sal (gdbarch
,
4910 sr_sal
, null_frame_id
);
4912 /* Restart without fiddling with the step ranges or
4919 /* Check for subroutine calls. The check for the current frame
4920 equalling the step ID is not necessary - the check of the
4921 previous frame's ID is sufficient - but it is a common case and
4922 cheaper than checking the previous frame's ID.
4924 NOTE: frame_id_eq will never report two invalid frame IDs as
4925 being equal, so to get into this block, both the current and
4926 previous frame must have valid frame IDs. */
4927 /* The outer_frame_id check is a heuristic to detect stepping
4928 through startup code. If we step over an instruction which
4929 sets the stack pointer from an invalid value to a valid value,
4930 we may detect that as a subroutine call from the mythical
4931 "outermost" function. This could be fixed by marking
4932 outermost frames as !stack_p,code_p,special_p. Then the
4933 initial outermost frame, before sp was valid, would
4934 have code_addr == &_start. See the comment in frame_id_eq
4936 if (!frame_id_eq (get_stack_frame_id (frame
),
4937 ecs
->event_thread
->control
.step_stack_frame_id
)
4938 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
4939 ecs
->event_thread
->control
.step_stack_frame_id
)
4940 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
4942 || step_start_function
!= find_pc_function (stop_pc
))))
4944 CORE_ADDR real_stop_pc
;
4947 fprintf_unfiltered (gdb_stdlog
, "infrun: stepped into subroutine\n");
4949 if ((ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
4950 || ((ecs
->event_thread
->control
.step_range_end
== 1)
4951 && in_prologue (gdbarch
, ecs
->event_thread
->prev_pc
,
4952 ecs
->stop_func_start
)))
4954 /* I presume that step_over_calls is only 0 when we're
4955 supposed to be stepping at the assembly language level
4956 ("stepi"). Just stop. */
4957 /* Also, maybe we just did a "nexti" inside a prolog, so we
4958 thought it was a subroutine call but it was not. Stop as
4960 /* And this works the same backward as frontward. MVS */
4961 end_stepping_range (ecs
);
4965 /* Reverse stepping through solib trampolines. */
4967 if (execution_direction
== EXEC_REVERSE
4968 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
4969 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
4970 || (ecs
->stop_func_start
== 0
4971 && in_solib_dynsym_resolve_code (stop_pc
))))
4973 /* Any solib trampoline code can be handled in reverse
4974 by simply continuing to single-step. We have already
4975 executed the solib function (backwards), and a few
4976 steps will take us back through the trampoline to the
4982 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
4984 /* We're doing a "next".
4986 Normal (forward) execution: set a breakpoint at the
4987 callee's return address (the address at which the caller
4990 Reverse (backward) execution. set the step-resume
4991 breakpoint at the start of the function that we just
4992 stepped into (backwards), and continue to there. When we
4993 get there, we'll need to single-step back to the caller. */
4995 if (execution_direction
== EXEC_REVERSE
)
4997 /* If we're already at the start of the function, we've either
4998 just stepped backward into a single instruction function,
4999 or stepped back out of a signal handler to the first instruction
5000 of the function. Just keep going, which will single-step back
5002 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
5004 struct symtab_and_line sr_sal
;
5006 /* Normal function call return (static or dynamic). */
5008 sr_sal
.pc
= ecs
->stop_func_start
;
5009 sr_sal
.pspace
= get_frame_program_space (frame
);
5010 insert_step_resume_breakpoint_at_sal (gdbarch
,
5011 sr_sal
, null_frame_id
);
5015 insert_step_resume_breakpoint_at_caller (frame
);
5021 /* If we are in a function call trampoline (a stub between the
5022 calling routine and the real function), locate the real
5023 function. That's what tells us (a) whether we want to step
5024 into it at all, and (b) what prologue we want to run to the
5025 end of, if we do step into it. */
5026 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
5027 if (real_stop_pc
== 0)
5028 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
5029 if (real_stop_pc
!= 0)
5030 ecs
->stop_func_start
= real_stop_pc
;
5032 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
5034 struct symtab_and_line sr_sal
;
5037 sr_sal
.pc
= ecs
->stop_func_start
;
5038 sr_sal
.pspace
= get_frame_program_space (frame
);
5040 insert_step_resume_breakpoint_at_sal (gdbarch
,
5041 sr_sal
, null_frame_id
);
5046 /* If we have line number information for the function we are
5047 thinking of stepping into and the function isn't on the skip
5050 If there are several symtabs at that PC (e.g. with include
5051 files), just want to know whether *any* of them have line
5052 numbers. find_pc_line handles this. */
5054 struct symtab_and_line tmp_sal
;
5056 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
5057 if (tmp_sal
.line
!= 0
5058 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
5061 if (execution_direction
== EXEC_REVERSE
)
5062 handle_step_into_function_backward (gdbarch
, ecs
);
5064 handle_step_into_function (gdbarch
, ecs
);
5069 /* If we have no line number and the step-stop-if-no-debug is
5070 set, we stop the step so that the user has a chance to switch
5071 in assembly mode. */
5072 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
5073 && step_stop_if_no_debug
)
5075 end_stepping_range (ecs
);
5079 if (execution_direction
== EXEC_REVERSE
)
5081 /* If we're already at the start of the function, we've either just
5082 stepped backward into a single instruction function without line
5083 number info, or stepped back out of a signal handler to the first
5084 instruction of the function without line number info. Just keep
5085 going, which will single-step back to the caller. */
5086 if (ecs
->stop_func_start
!= stop_pc
)
5088 /* Set a breakpoint at callee's start address.
5089 From there we can step once and be back in the caller. */
5090 struct symtab_and_line sr_sal
;
5093 sr_sal
.pc
= ecs
->stop_func_start
;
5094 sr_sal
.pspace
= get_frame_program_space (frame
);
5095 insert_step_resume_breakpoint_at_sal (gdbarch
,
5096 sr_sal
, null_frame_id
);
5100 /* Set a breakpoint at callee's return address (the address
5101 at which the caller will resume). */
5102 insert_step_resume_breakpoint_at_caller (frame
);
5108 /* Reverse stepping through solib trampolines. */
5110 if (execution_direction
== EXEC_REVERSE
5111 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
5113 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
5114 || (ecs
->stop_func_start
== 0
5115 && in_solib_dynsym_resolve_code (stop_pc
)))
5117 /* Any solib trampoline code can be handled in reverse
5118 by simply continuing to single-step. We have already
5119 executed the solib function (backwards), and a few
5120 steps will take us back through the trampoline to the
5125 else if (in_solib_dynsym_resolve_code (stop_pc
))
5127 /* Stepped backward into the solib dynsym resolver.
5128 Set a breakpoint at its start and continue, then
5129 one more step will take us out. */
5130 struct symtab_and_line sr_sal
;
5133 sr_sal
.pc
= ecs
->stop_func_start
;
5134 sr_sal
.pspace
= get_frame_program_space (frame
);
5135 insert_step_resume_breakpoint_at_sal (gdbarch
,
5136 sr_sal
, null_frame_id
);
5142 stop_pc_sal
= find_pc_line (stop_pc
, 0);
5144 /* NOTE: tausq/2004-05-24: This if block used to be done before all
5145 the trampoline processing logic, however, there are some trampolines
5146 that have no names, so we should do trampoline handling first. */
5147 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
5148 && ecs
->stop_func_name
== NULL
5149 && stop_pc_sal
.line
== 0)
5152 fprintf_unfiltered (gdb_stdlog
,
5153 "infrun: stepped into undebuggable function\n");
5155 /* The inferior just stepped into, or returned to, an
5156 undebuggable function (where there is no debugging information
5157 and no line number corresponding to the address where the
5158 inferior stopped). Since we want to skip this kind of code,
5159 we keep going until the inferior returns from this
5160 function - unless the user has asked us not to (via
5161 set step-mode) or we no longer know how to get back
5162 to the call site. */
5163 if (step_stop_if_no_debug
5164 || !frame_id_p (frame_unwind_caller_id (frame
)))
5166 /* If we have no line number and the step-stop-if-no-debug
5167 is set, we stop the step so that the user has a chance to
5168 switch in assembly mode. */
5169 end_stepping_range (ecs
);
5174 /* Set a breakpoint at callee's return address (the address
5175 at which the caller will resume). */
5176 insert_step_resume_breakpoint_at_caller (frame
);
5182 if (ecs
->event_thread
->control
.step_range_end
== 1)
5184 /* It is stepi or nexti. We always want to stop stepping after
5187 fprintf_unfiltered (gdb_stdlog
, "infrun: stepi/nexti\n");
5188 end_stepping_range (ecs
);
5192 if (stop_pc_sal
.line
== 0)
5194 /* We have no line number information. That means to stop
5195 stepping (does this always happen right after one instruction,
5196 when we do "s" in a function with no line numbers,
5197 or can this happen as a result of a return or longjmp?). */
5199 fprintf_unfiltered (gdb_stdlog
, "infrun: no line number info\n");
5200 end_stepping_range (ecs
);
5204 /* Look for "calls" to inlined functions, part one. If the inline
5205 frame machinery detected some skipped call sites, we have entered
5206 a new inline function. */
5208 if (frame_id_eq (get_frame_id (get_current_frame ()),
5209 ecs
->event_thread
->control
.step_frame_id
)
5210 && inline_skipped_frames (ecs
->ptid
))
5212 struct symtab_and_line call_sal
;
5215 fprintf_unfiltered (gdb_stdlog
,
5216 "infrun: stepped into inlined function\n");
5218 find_frame_sal (get_current_frame (), &call_sal
);
5220 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
5222 /* For "step", we're going to stop. But if the call site
5223 for this inlined function is on the same source line as
5224 we were previously stepping, go down into the function
5225 first. Otherwise stop at the call site. */
5227 if (call_sal
.line
== ecs
->event_thread
->current_line
5228 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
5229 step_into_inline_frame (ecs
->ptid
);
5231 end_stepping_range (ecs
);
5236 /* For "next", we should stop at the call site if it is on a
5237 different source line. Otherwise continue through the
5238 inlined function. */
5239 if (call_sal
.line
== ecs
->event_thread
->current_line
5240 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
5243 end_stepping_range (ecs
);
5248 /* Look for "calls" to inlined functions, part two. If we are still
5249 in the same real function we were stepping through, but we have
5250 to go further up to find the exact frame ID, we are stepping
5251 through a more inlined call beyond its call site. */
5253 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
5254 && !frame_id_eq (get_frame_id (get_current_frame ()),
5255 ecs
->event_thread
->control
.step_frame_id
)
5256 && stepped_in_from (get_current_frame (),
5257 ecs
->event_thread
->control
.step_frame_id
))
5260 fprintf_unfiltered (gdb_stdlog
,
5261 "infrun: stepping through inlined function\n");
5263 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
5266 end_stepping_range (ecs
);
5270 if ((stop_pc
== stop_pc_sal
.pc
)
5271 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
5272 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
5274 /* We are at the start of a different line. So stop. Note that
5275 we don't stop if we step into the middle of a different line.
5276 That is said to make things like for (;;) statements work
5279 fprintf_unfiltered (gdb_stdlog
,
5280 "infrun: stepped to a different line\n");
5281 end_stepping_range (ecs
);
5285 /* We aren't done stepping.
5287 Optimize by setting the stepping range to the line.
5288 (We might not be in the original line, but if we entered a
5289 new line in mid-statement, we continue stepping. This makes
5290 things like for(;;) statements work better.) */
5292 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
5293 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
5294 ecs
->event_thread
->control
.may_range_step
= 1;
5295 set_step_info (frame
, stop_pc_sal
);
5298 fprintf_unfiltered (gdb_stdlog
, "infrun: keep going\n");
5302 /* In all-stop mode, if we're currently stepping but have stopped in
5303 some other thread, we may need to switch back to the stepped
5304 thread. Returns true we set the inferior running, false if we left
5305 it stopped (and the event needs further processing). */
5308 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
5312 struct thread_info
*tp
;
5313 struct thread_info
*stepping_thread
;
5314 struct thread_info
*step_over
;
5316 /* If any thread is blocked on some internal breakpoint, and we
5317 simply need to step over that breakpoint to get it going
5318 again, do that first. */
5320 /* However, if we see an event for the stepping thread, then we
5321 know all other threads have been moved past their breakpoints
5322 already. Let the caller check whether the step is finished,
5323 etc., before deciding to move it past a breakpoint. */
5324 if (ecs
->event_thread
->control
.step_range_end
!= 0)
5327 /* Check if the current thread is blocked on an incomplete
5328 step-over, interrupted by a random signal. */
5329 if (ecs
->event_thread
->control
.trap_expected
5330 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
5334 fprintf_unfiltered (gdb_stdlog
,
5335 "infrun: need to finish step-over of [%s]\n",
5336 target_pid_to_str (ecs
->event_thread
->ptid
));
5342 /* Check if the current thread is blocked by a single-step
5343 breakpoint of another thread. */
5344 if (ecs
->hit_singlestep_breakpoint
)
5348 fprintf_unfiltered (gdb_stdlog
,
5349 "infrun: need to step [%s] over single-step "
5351 target_pid_to_str (ecs
->ptid
));
5357 /* Otherwise, we no longer expect a trap in the current thread.
5358 Clear the trap_expected flag before switching back -- this is
5359 what keep_going does as well, if we call it. */
5360 ecs
->event_thread
->control
.trap_expected
= 0;
5362 /* Likewise, clear the signal if it should not be passed. */
5363 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
5364 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5366 /* If scheduler locking applies even if not stepping, there's no
5367 need to walk over threads. Above we've checked whether the
5368 current thread is stepping. If some other thread not the
5369 event thread is stepping, then it must be that scheduler
5370 locking is not in effect. */
5371 if (schedlock_applies (0))
5374 /* Look for the stepping/nexting thread, and check if any other
5375 thread other than the stepping thread needs to start a
5376 step-over. Do all step-overs before actually proceeding with
5378 stepping_thread
= NULL
;
5380 ALL_NON_EXITED_THREADS (tp
)
5382 /* Ignore threads of processes we're not resuming. */
5384 && ptid_get_pid (tp
->ptid
) != ptid_get_pid (inferior_ptid
))
5387 /* When stepping over a breakpoint, we lock all threads
5388 except the one that needs to move past the breakpoint.
5389 If a non-event thread has this set, the "incomplete
5390 step-over" check above should have caught it earlier. */
5391 gdb_assert (!tp
->control
.trap_expected
);
5393 /* Did we find the stepping thread? */
5394 if (tp
->control
.step_range_end
)
5396 /* Yep. There should only one though. */
5397 gdb_assert (stepping_thread
== NULL
);
5399 /* The event thread is handled at the top, before we
5401 gdb_assert (tp
!= ecs
->event_thread
);
5403 /* If some thread other than the event thread is
5404 stepping, then scheduler locking can't be in effect,
5405 otherwise we wouldn't have resumed the current event
5406 thread in the first place. */
5407 gdb_assert (!schedlock_applies (1));
5409 stepping_thread
= tp
;
5411 else if (thread_still_needs_step_over (tp
))
5415 /* At the top we've returned early if the event thread
5416 is stepping. If some other thread not the event
5417 thread is stepping, then scheduler locking can't be
5418 in effect, and we can resume this thread. No need to
5419 keep looking for the stepping thread then. */
5424 if (step_over
!= NULL
)
5429 fprintf_unfiltered (gdb_stdlog
,
5430 "infrun: need to step-over [%s]\n",
5431 target_pid_to_str (tp
->ptid
));
5434 /* Only the stepping thread should have this set. */
5435 gdb_assert (tp
->control
.step_range_end
== 0);
5437 ecs
->ptid
= tp
->ptid
;
5438 ecs
->event_thread
= tp
;
5439 switch_to_thread (ecs
->ptid
);
5444 if (stepping_thread
!= NULL
)
5446 struct frame_info
*frame
;
5447 struct gdbarch
*gdbarch
;
5449 tp
= stepping_thread
;
5451 /* If the stepping thread exited, then don't try to switch
5452 back and resume it, which could fail in several different
5453 ways depending on the target. Instead, just keep going.
5455 We can find a stepping dead thread in the thread list in
5458 - The target supports thread exit events, and when the
5459 target tries to delete the thread from the thread list,
5460 inferior_ptid pointed at the exiting thread. In such
5461 case, calling delete_thread does not really remove the
5462 thread from the list; instead, the thread is left listed,
5463 with 'exited' state.
5465 - The target's debug interface does not support thread
5466 exit events, and so we have no idea whatsoever if the
5467 previously stepping thread is still alive. For that
5468 reason, we need to synchronously query the target
5470 if (is_exited (tp
->ptid
)
5471 || !target_thread_alive (tp
->ptid
))
5474 fprintf_unfiltered (gdb_stdlog
,
5475 "infrun: not switching back to "
5476 "stepped thread, it has vanished\n");
5478 delete_thread (tp
->ptid
);
5484 fprintf_unfiltered (gdb_stdlog
,
5485 "infrun: switching back to stepped thread\n");
5487 ecs
->event_thread
= tp
;
5488 ecs
->ptid
= tp
->ptid
;
5489 context_switch (ecs
->ptid
);
5491 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5492 frame
= get_current_frame ();
5493 gdbarch
= get_frame_arch (frame
);
5495 /* If the PC of the thread we were trying to single-step has
5496 changed, then that thread has trapped or been signaled,
5497 but the event has not been reported to GDB yet. Re-poll
5498 the target looking for this particular thread's event
5499 (i.e. temporarily enable schedlock) by:
5501 - setting a break at the current PC
5502 - resuming that particular thread, only (by setting
5505 This prevents us continuously moving the single-step
5506 breakpoint forward, one instruction at a time,
5509 if (gdbarch_software_single_step_p (gdbarch
)
5510 && stop_pc
!= tp
->prev_pc
)
5513 fprintf_unfiltered (gdb_stdlog
,
5514 "infrun: expected thread advanced also\n");
5516 /* Clear the info of the previous step-over, as it's no
5517 longer valid. It's what keep_going would do too, if
5518 we called it. Must do this before trying to insert
5519 the sss breakpoint, otherwise if we were previously
5520 trying to step over this exact address in another
5521 thread, the breakpoint ends up not installed. */
5522 clear_step_over_info ();
5524 insert_single_step_breakpoint (get_frame_arch (frame
),
5525 get_frame_address_space (frame
),
5527 ecs
->event_thread
->control
.trap_expected
= 1;
5529 resume (0, GDB_SIGNAL_0
);
5530 prepare_to_wait (ecs
);
5535 fprintf_unfiltered (gdb_stdlog
,
5536 "infrun: expected thread still "
5537 "hasn't advanced\n");
5547 /* Is thread TP in the middle of single-stepping? */
5550 currently_stepping (struct thread_info
*tp
)
5552 return ((tp
->control
.step_range_end
5553 && tp
->control
.step_resume_breakpoint
== NULL
)
5554 || tp
->control
.trap_expected
5555 || bpstat_should_step ());
5558 /* Inferior has stepped into a subroutine call with source code that
5559 we should not step over. Do step to the first line of code in
5563 handle_step_into_function (struct gdbarch
*gdbarch
,
5564 struct execution_control_state
*ecs
)
5567 struct symtab_and_line stop_func_sal
, sr_sal
;
5569 fill_in_stop_func (gdbarch
, ecs
);
5571 s
= find_pc_symtab (stop_pc
);
5572 if (s
&& s
->language
!= language_asm
)
5573 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
5574 ecs
->stop_func_start
);
5576 stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
5577 /* Use the step_resume_break to step until the end of the prologue,
5578 even if that involves jumps (as it seems to on the vax under
5580 /* If the prologue ends in the middle of a source line, continue to
5581 the end of that source line (if it is still within the function).
5582 Otherwise, just go to end of prologue. */
5583 if (stop_func_sal
.end
5584 && stop_func_sal
.pc
!= ecs
->stop_func_start
5585 && stop_func_sal
.end
< ecs
->stop_func_end
)
5586 ecs
->stop_func_start
= stop_func_sal
.end
;
5588 /* Architectures which require breakpoint adjustment might not be able
5589 to place a breakpoint at the computed address. If so, the test
5590 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
5591 ecs->stop_func_start to an address at which a breakpoint may be
5592 legitimately placed.
5594 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
5595 made, GDB will enter an infinite loop when stepping through
5596 optimized code consisting of VLIW instructions which contain
5597 subinstructions corresponding to different source lines. On
5598 FR-V, it's not permitted to place a breakpoint on any but the
5599 first subinstruction of a VLIW instruction. When a breakpoint is
5600 set, GDB will adjust the breakpoint address to the beginning of
5601 the VLIW instruction. Thus, we need to make the corresponding
5602 adjustment here when computing the stop address. */
5604 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
5606 ecs
->stop_func_start
5607 = gdbarch_adjust_breakpoint_address (gdbarch
,
5608 ecs
->stop_func_start
);
5611 if (ecs
->stop_func_start
== stop_pc
)
5613 /* We are already there: stop now. */
5614 end_stepping_range (ecs
);
5619 /* Put the step-breakpoint there and go until there. */
5620 init_sal (&sr_sal
); /* initialize to zeroes */
5621 sr_sal
.pc
= ecs
->stop_func_start
;
5622 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
5623 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
5625 /* Do not specify what the fp should be when we stop since on
5626 some machines the prologue is where the new fp value is
5628 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
5630 /* And make sure stepping stops right away then. */
5631 ecs
->event_thread
->control
.step_range_end
5632 = ecs
->event_thread
->control
.step_range_start
;
5637 /* Inferior has stepped backward into a subroutine call with source
5638 code that we should not step over. Do step to the beginning of the
5639 last line of code in it. */
5642 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
5643 struct execution_control_state
*ecs
)
5646 struct symtab_and_line stop_func_sal
;
5648 fill_in_stop_func (gdbarch
, ecs
);
5650 s
= find_pc_symtab (stop_pc
);
5651 if (s
&& s
->language
!= language_asm
)
5652 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
5653 ecs
->stop_func_start
);
5655 stop_func_sal
= find_pc_line (stop_pc
, 0);
5657 /* OK, we're just going to keep stepping here. */
5658 if (stop_func_sal
.pc
== stop_pc
)
5660 /* We're there already. Just stop stepping now. */
5661 end_stepping_range (ecs
);
5665 /* Else just reset the step range and keep going.
5666 No step-resume breakpoint, they don't work for
5667 epilogues, which can have multiple entry paths. */
5668 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
5669 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
5675 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
5676 This is used to both functions and to skip over code. */
5679 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
5680 struct symtab_and_line sr_sal
,
5681 struct frame_id sr_id
,
5682 enum bptype sr_type
)
5684 /* There should never be more than one step-resume or longjmp-resume
5685 breakpoint per thread, so we should never be setting a new
5686 step_resume_breakpoint when one is already active. */
5687 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
5688 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
5691 fprintf_unfiltered (gdb_stdlog
,
5692 "infrun: inserting step-resume breakpoint at %s\n",
5693 paddress (gdbarch
, sr_sal
.pc
));
5695 inferior_thread ()->control
.step_resume_breakpoint
5696 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
);
5700 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
5701 struct symtab_and_line sr_sal
,
5702 struct frame_id sr_id
)
5704 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
5709 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
5710 This is used to skip a potential signal handler.
5712 This is called with the interrupted function's frame. The signal
5713 handler, when it returns, will resume the interrupted function at
5717 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
5719 struct symtab_and_line sr_sal
;
5720 struct gdbarch
*gdbarch
;
5722 gdb_assert (return_frame
!= NULL
);
5723 init_sal (&sr_sal
); /* initialize to zeros */
5725 gdbarch
= get_frame_arch (return_frame
);
5726 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
5727 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
5728 sr_sal
.pspace
= get_frame_program_space (return_frame
);
5730 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
5731 get_stack_frame_id (return_frame
),
5735 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
5736 is used to skip a function after stepping into it (for "next" or if
5737 the called function has no debugging information).
5739 The current function has almost always been reached by single
5740 stepping a call or return instruction. NEXT_FRAME belongs to the
5741 current function, and the breakpoint will be set at the caller's
5744 This is a separate function rather than reusing
5745 insert_hp_step_resume_breakpoint_at_frame in order to avoid
5746 get_prev_frame, which may stop prematurely (see the implementation
5747 of frame_unwind_caller_id for an example). */
5750 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
5752 struct symtab_and_line sr_sal
;
5753 struct gdbarch
*gdbarch
;
5755 /* We shouldn't have gotten here if we don't know where the call site
5757 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
5759 init_sal (&sr_sal
); /* initialize to zeros */
5761 gdbarch
= frame_unwind_caller_arch (next_frame
);
5762 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
5763 frame_unwind_caller_pc (next_frame
));
5764 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
5765 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
5767 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
5768 frame_unwind_caller_id (next_frame
));
5771 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
5772 new breakpoint at the target of a jmp_buf. The handling of
5773 longjmp-resume uses the same mechanisms used for handling
5774 "step-resume" breakpoints. */
5777 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5779 /* There should never be more than one longjmp-resume breakpoint per
5780 thread, so we should never be setting a new
5781 longjmp_resume_breakpoint when one is already active. */
5782 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
5785 fprintf_unfiltered (gdb_stdlog
,
5786 "infrun: inserting longjmp-resume breakpoint at %s\n",
5787 paddress (gdbarch
, pc
));
5789 inferior_thread ()->control
.exception_resume_breakpoint
=
5790 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
);
5793 /* Insert an exception resume breakpoint. TP is the thread throwing
5794 the exception. The block B is the block of the unwinder debug hook
5795 function. FRAME is the frame corresponding to the call to this
5796 function. SYM is the symbol of the function argument holding the
5797 target PC of the exception. */
5800 insert_exception_resume_breakpoint (struct thread_info
*tp
,
5801 const struct block
*b
,
5802 struct frame_info
*frame
,
5805 volatile struct gdb_exception e
;
5807 /* We want to ignore errors here. */
5808 TRY_CATCH (e
, RETURN_MASK_ERROR
)
5810 struct symbol
*vsym
;
5811 struct value
*value
;
5813 struct breakpoint
*bp
;
5815 vsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
), b
, VAR_DOMAIN
, NULL
);
5816 value
= read_var_value (vsym
, frame
);
5817 /* If the value was optimized out, revert to the old behavior. */
5818 if (! value_optimized_out (value
))
5820 handler
= value_as_address (value
);
5823 fprintf_unfiltered (gdb_stdlog
,
5824 "infrun: exception resume at %lx\n",
5825 (unsigned long) handler
);
5827 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
5828 handler
, bp_exception_resume
);
5830 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
5833 bp
->thread
= tp
->num
;
5834 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
5839 /* A helper for check_exception_resume that sets an
5840 exception-breakpoint based on a SystemTap probe. */
5843 insert_exception_resume_from_probe (struct thread_info
*tp
,
5844 const struct bound_probe
*probe
,
5845 struct frame_info
*frame
)
5847 struct value
*arg_value
;
5849 struct breakpoint
*bp
;
5851 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
5855 handler
= value_as_address (arg_value
);
5858 fprintf_unfiltered (gdb_stdlog
,
5859 "infrun: exception resume at %s\n",
5860 paddress (get_objfile_arch (probe
->objfile
),
5863 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
5864 handler
, bp_exception_resume
);
5865 bp
->thread
= tp
->num
;
5866 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
5869 /* This is called when an exception has been intercepted. Check to
5870 see whether the exception's destination is of interest, and if so,
5871 set an exception resume breakpoint there. */
5874 check_exception_resume (struct execution_control_state
*ecs
,
5875 struct frame_info
*frame
)
5877 volatile struct gdb_exception e
;
5878 struct bound_probe probe
;
5879 struct symbol
*func
;
5881 /* First see if this exception unwinding breakpoint was set via a
5882 SystemTap probe point. If so, the probe has two arguments: the
5883 CFA and the HANDLER. We ignore the CFA, extract the handler, and
5884 set a breakpoint there. */
5885 probe
= find_probe_by_pc (get_frame_pc (frame
));
5888 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
5892 func
= get_frame_function (frame
);
5896 TRY_CATCH (e
, RETURN_MASK_ERROR
)
5898 const struct block
*b
;
5899 struct block_iterator iter
;
5903 /* The exception breakpoint is a thread-specific breakpoint on
5904 the unwinder's debug hook, declared as:
5906 void _Unwind_DebugHook (void *cfa, void *handler);
5908 The CFA argument indicates the frame to which control is
5909 about to be transferred. HANDLER is the destination PC.
5911 We ignore the CFA and set a temporary breakpoint at HANDLER.
5912 This is not extremely efficient but it avoids issues in gdb
5913 with computing the DWARF CFA, and it also works even in weird
5914 cases such as throwing an exception from inside a signal
5917 b
= SYMBOL_BLOCK_VALUE (func
);
5918 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5920 if (!SYMBOL_IS_ARGUMENT (sym
))
5927 insert_exception_resume_breakpoint (ecs
->event_thread
,
5936 stop_waiting (struct execution_control_state
*ecs
)
5939 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_waiting\n");
5941 clear_step_over_info ();
5943 /* Let callers know we don't want to wait for the inferior anymore. */
5944 ecs
->wait_some_more
= 0;
5947 /* Called when we should continue running the inferior, because the
5948 current event doesn't cause a user visible stop. This does the
5949 resuming part; waiting for the next event is done elsewhere. */
5952 keep_going (struct execution_control_state
*ecs
)
5954 /* Make sure normal_stop is called if we get a QUIT handled before
5956 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
5958 /* Save the pc before execution, to compare with pc after stop. */
5959 ecs
->event_thread
->prev_pc
5960 = regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5962 if (ecs
->event_thread
->control
.trap_expected
5963 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
5965 /* We haven't yet gotten our trap, and either: intercepted a
5966 non-signal event (e.g., a fork); or took a signal which we
5967 are supposed to pass through to the inferior. Simply
5969 discard_cleanups (old_cleanups
);
5970 resume (currently_stepping (ecs
->event_thread
),
5971 ecs
->event_thread
->suspend
.stop_signal
);
5975 volatile struct gdb_exception e
;
5976 struct regcache
*regcache
= get_current_regcache ();
5980 /* Either the trap was not expected, but we are continuing
5981 anyway (if we got a signal, the user asked it be passed to
5984 We got our expected trap, but decided we should resume from
5987 We're going to run this baby now!
5989 Note that insert_breakpoints won't try to re-insert
5990 already inserted breakpoints. Therefore, we don't
5991 care if breakpoints were already inserted, or not. */
5993 /* If we need to step over a breakpoint, and we're not using
5994 displaced stepping to do so, insert all breakpoints
5995 (watchpoints, etc.) but the one we're stepping over, step one
5996 instruction, and then re-insert the breakpoint when that step
5999 remove_bp
= (ecs
->hit_singlestep_breakpoint
6000 || thread_still_needs_step_over (ecs
->event_thread
));
6001 remove_wps
= (ecs
->event_thread
->stepping_over_watchpoint
6002 && !target_have_steppable_watchpoint
);
6004 if (remove_bp
&& !use_displaced_stepping (get_regcache_arch (regcache
)))
6006 set_step_over_info (get_regcache_aspace (regcache
),
6007 regcache_read_pc (regcache
), remove_wps
);
6009 else if (remove_wps
)
6010 set_step_over_info (NULL
, 0, remove_wps
);
6012 clear_step_over_info ();
6014 /* Stop stepping if inserting breakpoints fails. */
6015 TRY_CATCH (e
, RETURN_MASK_ERROR
)
6017 insert_breakpoints ();
6021 exception_print (gdb_stderr
, e
);
6026 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
6028 /* Do not deliver GDB_SIGNAL_TRAP (except when the user
6029 explicitly specifies that such a signal should be delivered
6030 to the target program). Typically, that would occur when a
6031 user is debugging a target monitor on a simulator: the target
6032 monitor sets a breakpoint; the simulator encounters this
6033 breakpoint and halts the simulation handing control to GDB;
6034 GDB, noting that the stop address doesn't map to any known
6035 breakpoint, returns control back to the simulator; the
6036 simulator then delivers the hardware equivalent of a
6037 GDB_SIGNAL_TRAP to the program being debugged. */
6038 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
6039 && !signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
6040 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6042 discard_cleanups (old_cleanups
);
6043 resume (currently_stepping (ecs
->event_thread
),
6044 ecs
->event_thread
->suspend
.stop_signal
);
6047 prepare_to_wait (ecs
);
6050 /* This function normally comes after a resume, before
6051 handle_inferior_event exits. It takes care of any last bits of
6052 housekeeping, and sets the all-important wait_some_more flag. */
6055 prepare_to_wait (struct execution_control_state
*ecs
)
6058 fprintf_unfiltered (gdb_stdlog
, "infrun: prepare_to_wait\n");
6060 /* This is the old end of the while loop. Let everybody know we
6061 want to wait for the inferior some more and get called again
6063 ecs
->wait_some_more
= 1;
6066 /* We are done with the step range of a step/next/si/ni command.
6067 Called once for each n of a "step n" operation. */
6070 end_stepping_range (struct execution_control_state
*ecs
)
6072 ecs
->event_thread
->control
.stop_step
= 1;
6076 /* Several print_*_reason functions to print why the inferior has stopped.
6077 We always print something when the inferior exits, or receives a signal.
6078 The rest of the cases are dealt with later on in normal_stop and
6079 print_it_typical. Ideally there should be a call to one of these
6080 print_*_reason functions functions from handle_inferior_event each time
6081 stop_waiting is called.
6083 Note that we don't call these directly, instead we delegate that to
6084 the interpreters, through observers. Interpreters then call these
6085 with whatever uiout is right. */
6088 print_end_stepping_range_reason (struct ui_out
*uiout
)
6090 /* For CLI-like interpreters, print nothing. */
6092 if (ui_out_is_mi_like_p (uiout
))
6094 ui_out_field_string (uiout
, "reason",
6095 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
6100 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
6102 annotate_signalled ();
6103 if (ui_out_is_mi_like_p (uiout
))
6105 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
6106 ui_out_text (uiout
, "\nProgram terminated with signal ");
6107 annotate_signal_name ();
6108 ui_out_field_string (uiout
, "signal-name",
6109 gdb_signal_to_name (siggnal
));
6110 annotate_signal_name_end ();
6111 ui_out_text (uiout
, ", ");
6112 annotate_signal_string ();
6113 ui_out_field_string (uiout
, "signal-meaning",
6114 gdb_signal_to_string (siggnal
));
6115 annotate_signal_string_end ();
6116 ui_out_text (uiout
, ".\n");
6117 ui_out_text (uiout
, "The program no longer exists.\n");
6121 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
6123 struct inferior
*inf
= current_inferior ();
6124 const char *pidstr
= target_pid_to_str (pid_to_ptid (inf
->pid
));
6126 annotate_exited (exitstatus
);
6129 if (ui_out_is_mi_like_p (uiout
))
6130 ui_out_field_string (uiout
, "reason",
6131 async_reason_lookup (EXEC_ASYNC_EXITED
));
6132 ui_out_text (uiout
, "[Inferior ");
6133 ui_out_text (uiout
, plongest (inf
->num
));
6134 ui_out_text (uiout
, " (");
6135 ui_out_text (uiout
, pidstr
);
6136 ui_out_text (uiout
, ") exited with code ");
6137 ui_out_field_fmt (uiout
, "exit-code", "0%o", (unsigned int) exitstatus
);
6138 ui_out_text (uiout
, "]\n");
6142 if (ui_out_is_mi_like_p (uiout
))
6144 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
6145 ui_out_text (uiout
, "[Inferior ");
6146 ui_out_text (uiout
, plongest (inf
->num
));
6147 ui_out_text (uiout
, " (");
6148 ui_out_text (uiout
, pidstr
);
6149 ui_out_text (uiout
, ") exited normally]\n");
6154 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
6158 if (siggnal
== GDB_SIGNAL_0
&& !ui_out_is_mi_like_p (uiout
))
6160 struct thread_info
*t
= inferior_thread ();
6162 ui_out_text (uiout
, "\n[");
6163 ui_out_field_string (uiout
, "thread-name",
6164 target_pid_to_str (t
->ptid
));
6165 ui_out_field_fmt (uiout
, "thread-id", "] #%d", t
->num
);
6166 ui_out_text (uiout
, " stopped");
6170 ui_out_text (uiout
, "\nProgram received signal ");
6171 annotate_signal_name ();
6172 if (ui_out_is_mi_like_p (uiout
))
6174 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
6175 ui_out_field_string (uiout
, "signal-name",
6176 gdb_signal_to_name (siggnal
));
6177 annotate_signal_name_end ();
6178 ui_out_text (uiout
, ", ");
6179 annotate_signal_string ();
6180 ui_out_field_string (uiout
, "signal-meaning",
6181 gdb_signal_to_string (siggnal
));
6182 annotate_signal_string_end ();
6184 ui_out_text (uiout
, ".\n");
6188 print_no_history_reason (struct ui_out
*uiout
)
6190 ui_out_text (uiout
, "\nNo more reverse-execution history.\n");
6193 /* Print current location without a level number, if we have changed
6194 functions or hit a breakpoint. Print source line if we have one.
6195 bpstat_print contains the logic deciding in detail what to print,
6196 based on the event(s) that just occurred. */
6199 print_stop_event (struct target_waitstatus
*ws
)
6203 int do_frame_printing
= 1;
6204 struct thread_info
*tp
= inferior_thread ();
6206 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
6210 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
6211 should) carry around the function and does (or should) use
6212 that when doing a frame comparison. */
6213 if (tp
->control
.stop_step
6214 && frame_id_eq (tp
->control
.step_frame_id
,
6215 get_frame_id (get_current_frame ()))
6216 && step_start_function
== find_pc_function (stop_pc
))
6218 /* Finished step, just print source line. */
6219 source_flag
= SRC_LINE
;
6223 /* Print location and source line. */
6224 source_flag
= SRC_AND_LOC
;
6227 case PRINT_SRC_AND_LOC
:
6228 /* Print location and source line. */
6229 source_flag
= SRC_AND_LOC
;
6231 case PRINT_SRC_ONLY
:
6232 source_flag
= SRC_LINE
;
6235 /* Something bogus. */
6236 source_flag
= SRC_LINE
;
6237 do_frame_printing
= 0;
6240 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
6243 /* The behavior of this routine with respect to the source
6245 SRC_LINE: Print only source line
6246 LOCATION: Print only location
6247 SRC_AND_LOC: Print location and source line. */
6248 if (do_frame_printing
)
6249 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
6251 /* Display the auto-display expressions. */
6255 /* Here to return control to GDB when the inferior stops for real.
6256 Print appropriate messages, remove breakpoints, give terminal our modes.
6258 STOP_PRINT_FRAME nonzero means print the executing frame
6259 (pc, function, args, file, line number and line text).
6260 BREAKPOINTS_FAILED nonzero means stop was due to error
6261 attempting to insert breakpoints. */
6266 struct target_waitstatus last
;
6268 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
6270 get_last_target_status (&last_ptid
, &last
);
6272 /* If an exception is thrown from this point on, make sure to
6273 propagate GDB's knowledge of the executing state to the
6274 frontend/user running state. A QUIT is an easy exception to see
6275 here, so do this before any filtered output. */
6277 make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
6278 else if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
6279 && last
.kind
!= TARGET_WAITKIND_EXITED
6280 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
6281 make_cleanup (finish_thread_state_cleanup
, &inferior_ptid
);
6283 /* As we're presenting a stop, and potentially removing breakpoints,
6284 update the thread list so we can tell whether there are threads
6285 running on the target. With target remote, for example, we can
6286 only learn about new threads when we explicitly update the thread
6287 list. Do this before notifying the interpreters about signal
6288 stops, end of stepping ranges, etc., so that the "new thread"
6289 output is emitted before e.g., "Program received signal FOO",
6290 instead of after. */
6291 update_thread_list ();
6293 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
6294 observer_notify_signal_received (inferior_thread ()->suspend
.stop_signal
);
6296 /* As with the notification of thread events, we want to delay
6297 notifying the user that we've switched thread context until
6298 the inferior actually stops.
6300 There's no point in saying anything if the inferior has exited.
6301 Note that SIGNALLED here means "exited with a signal", not
6302 "received a signal".
6304 Also skip saying anything in non-stop mode. In that mode, as we
6305 don't want GDB to switch threads behind the user's back, to avoid
6306 races where the user is typing a command to apply to thread x,
6307 but GDB switches to thread y before the user finishes entering
6308 the command, fetch_inferior_event installs a cleanup to restore
6309 the current thread back to the thread the user had selected right
6310 after this event is handled, so we're not really switching, only
6311 informing of a stop. */
6313 && !ptid_equal (previous_inferior_ptid
, inferior_ptid
)
6314 && target_has_execution
6315 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
6316 && last
.kind
!= TARGET_WAITKIND_EXITED
6317 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
6319 target_terminal_ours_for_output ();
6320 printf_filtered (_("[Switching to %s]\n"),
6321 target_pid_to_str (inferior_ptid
));
6322 annotate_thread_changed ();
6323 previous_inferior_ptid
= inferior_ptid
;
6326 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
6328 gdb_assert (sync_execution
|| !target_can_async_p ());
6330 target_terminal_ours_for_output ();
6331 printf_filtered (_("No unwaited-for children left.\n"));
6334 /* Note: this depends on the update_thread_list call above. */
6335 if (!breakpoints_should_be_inserted_now () && target_has_execution
)
6337 if (remove_breakpoints ())
6339 target_terminal_ours_for_output ();
6340 printf_filtered (_("Cannot remove breakpoints because "
6341 "program is no longer writable.\nFurther "
6342 "execution is probably impossible.\n"));
6346 /* If an auto-display called a function and that got a signal,
6347 delete that auto-display to avoid an infinite recursion. */
6349 if (stopped_by_random_signal
)
6350 disable_current_display ();
6352 /* Notify observers if we finished a "step"-like command, etc. */
6353 if (target_has_execution
6354 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
6355 && last
.kind
!= TARGET_WAITKIND_EXITED
6356 && inferior_thread ()->control
.stop_step
)
6358 /* But not if in the middle of doing a "step n" operation for
6360 if (inferior_thread ()->step_multi
)
6363 observer_notify_end_stepping_range ();
6366 target_terminal_ours ();
6367 async_enable_stdin ();
6369 /* Set the current source location. This will also happen if we
6370 display the frame below, but the current SAL will be incorrect
6371 during a user hook-stop function. */
6372 if (has_stack_frames () && !stop_stack_dummy
)
6373 set_current_sal_from_frame (get_current_frame ());
6375 /* Let the user/frontend see the threads as stopped, but do nothing
6376 if the thread was running an infcall. We may be e.g., evaluating
6377 a breakpoint condition. In that case, the thread had state
6378 THREAD_RUNNING before the infcall, and shall remain set to
6379 running, all without informing the user/frontend about state
6380 transition changes. If this is actually a call command, then the
6381 thread was originally already stopped, so there's no state to
6383 if (target_has_execution
&& inferior_thread ()->control
.in_infcall
)
6384 discard_cleanups (old_chain
);
6386 do_cleanups (old_chain
);
6388 /* Look up the hook_stop and run it (CLI internally handles problem
6389 of stop_command's pre-hook not existing). */
6391 catch_errors (hook_stop_stub
, stop_command
,
6392 "Error while running hook_stop:\n", RETURN_MASK_ALL
);
6394 if (!has_stack_frames ())
6397 if (last
.kind
== TARGET_WAITKIND_SIGNALLED
6398 || last
.kind
== TARGET_WAITKIND_EXITED
)
6401 /* Select innermost stack frame - i.e., current frame is frame 0,
6402 and current location is based on that.
6403 Don't do this on return from a stack dummy routine,
6404 or if the program has exited. */
6406 if (!stop_stack_dummy
)
6408 select_frame (get_current_frame ());
6410 /* If --batch-silent is enabled then there's no need to print the current
6411 source location, and to try risks causing an error message about
6412 missing source files. */
6413 if (stop_print_frame
&& !batch_silent
)
6414 print_stop_event (&last
);
6417 /* Save the function value return registers, if we care.
6418 We might be about to restore their previous contents. */
6419 if (inferior_thread ()->control
.proceed_to_finish
6420 && execution_direction
!= EXEC_REVERSE
)
6422 /* This should not be necessary. */
6424 regcache_xfree (stop_registers
);
6426 /* NB: The copy goes through to the target picking up the value of
6427 all the registers. */
6428 stop_registers
= regcache_dup (get_current_regcache ());
6431 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
6433 /* Pop the empty frame that contains the stack dummy.
6434 This also restores inferior state prior to the call
6435 (struct infcall_suspend_state). */
6436 struct frame_info
*frame
= get_current_frame ();
6438 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
6440 /* frame_pop() calls reinit_frame_cache as the last thing it
6441 does which means there's currently no selected frame. We
6442 don't need to re-establish a selected frame if the dummy call
6443 returns normally, that will be done by
6444 restore_infcall_control_state. However, we do have to handle
6445 the case where the dummy call is returning after being
6446 stopped (e.g. the dummy call previously hit a breakpoint).
6447 We can't know which case we have so just always re-establish
6448 a selected frame here. */
6449 select_frame (get_current_frame ());
6453 annotate_stopped ();
6455 /* Suppress the stop observer if we're in the middle of:
6457 - a step n (n > 1), as there still more steps to be done.
6459 - a "finish" command, as the observer will be called in
6460 finish_command_continuation, so it can include the inferior
6461 function's return value.
6463 - calling an inferior function, as we pretend we inferior didn't
6464 run at all. The return value of the call is handled by the
6465 expression evaluator, through call_function_by_hand. */
6467 if (!target_has_execution
6468 || last
.kind
== TARGET_WAITKIND_SIGNALLED
6469 || last
.kind
== TARGET_WAITKIND_EXITED
6470 || last
.kind
== TARGET_WAITKIND_NO_RESUMED
6471 || (!(inferior_thread ()->step_multi
6472 && inferior_thread ()->control
.stop_step
)
6473 && !(inferior_thread ()->control
.stop_bpstat
6474 && inferior_thread ()->control
.proceed_to_finish
)
6475 && !inferior_thread ()->control
.in_infcall
))
6477 if (!ptid_equal (inferior_ptid
, null_ptid
))
6478 observer_notify_normal_stop (inferior_thread ()->control
.stop_bpstat
,
6481 observer_notify_normal_stop (NULL
, stop_print_frame
);
6484 if (target_has_execution
)
6486 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
6487 && last
.kind
!= TARGET_WAITKIND_EXITED
)
6488 /* Delete the breakpoint we stopped at, if it wants to be deleted.
6489 Delete any breakpoint that is to be deleted at the next stop. */
6490 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
6493 /* Try to get rid of automatically added inferiors that are no
6494 longer needed. Keeping those around slows down things linearly.
6495 Note that this never removes the current inferior. */
6500 hook_stop_stub (void *cmd
)
6502 execute_cmd_pre_hook ((struct cmd_list_element
*) cmd
);
6507 signal_stop_state (int signo
)
6509 return signal_stop
[signo
];
6513 signal_print_state (int signo
)
6515 return signal_print
[signo
];
6519 signal_pass_state (int signo
)
6521 return signal_program
[signo
];
6525 signal_cache_update (int signo
)
6529 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
6530 signal_cache_update (signo
);
6535 signal_pass
[signo
] = (signal_stop
[signo
] == 0
6536 && signal_print
[signo
] == 0
6537 && signal_program
[signo
] == 1
6538 && signal_catch
[signo
] == 0);
6542 signal_stop_update (int signo
, int state
)
6544 int ret
= signal_stop
[signo
];
6546 signal_stop
[signo
] = state
;
6547 signal_cache_update (signo
);
6552 signal_print_update (int signo
, int state
)
6554 int ret
= signal_print
[signo
];
6556 signal_print
[signo
] = state
;
6557 signal_cache_update (signo
);
6562 signal_pass_update (int signo
, int state
)
6564 int ret
= signal_program
[signo
];
6566 signal_program
[signo
] = state
;
6567 signal_cache_update (signo
);
6571 /* Update the global 'signal_catch' from INFO and notify the
6575 signal_catch_update (const unsigned int *info
)
6579 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
6580 signal_catch
[i
] = info
[i
] > 0;
6581 signal_cache_update (-1);
6582 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
6586 sig_print_header (void)
6588 printf_filtered (_("Signal Stop\tPrint\tPass "
6589 "to program\tDescription\n"));
6593 sig_print_info (enum gdb_signal oursig
)
6595 const char *name
= gdb_signal_to_name (oursig
);
6596 int name_padding
= 13 - strlen (name
);
6598 if (name_padding
<= 0)
6601 printf_filtered ("%s", name
);
6602 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
6603 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
6604 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
6605 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
6606 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
6609 /* Specify how various signals in the inferior should be handled. */
6612 handle_command (char *args
, int from_tty
)
6615 int digits
, wordlen
;
6616 int sigfirst
, signum
, siglast
;
6617 enum gdb_signal oursig
;
6620 unsigned char *sigs
;
6621 struct cleanup
*old_chain
;
6625 error_no_arg (_("signal to handle"));
6628 /* Allocate and zero an array of flags for which signals to handle. */
6630 nsigs
= (int) GDB_SIGNAL_LAST
;
6631 sigs
= (unsigned char *) alloca (nsigs
);
6632 memset (sigs
, 0, nsigs
);
6634 /* Break the command line up into args. */
6636 argv
= gdb_buildargv (args
);
6637 old_chain
= make_cleanup_freeargv (argv
);
6639 /* Walk through the args, looking for signal oursigs, signal names, and
6640 actions. Signal numbers and signal names may be interspersed with
6641 actions, with the actions being performed for all signals cumulatively
6642 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
6644 while (*argv
!= NULL
)
6646 wordlen
= strlen (*argv
);
6647 for (digits
= 0; isdigit ((*argv
)[digits
]); digits
++)
6651 sigfirst
= siglast
= -1;
6653 if (wordlen
>= 1 && !strncmp (*argv
, "all", wordlen
))
6655 /* Apply action to all signals except those used by the
6656 debugger. Silently skip those. */
6659 siglast
= nsigs
- 1;
6661 else if (wordlen
>= 1 && !strncmp (*argv
, "stop", wordlen
))
6663 SET_SIGS (nsigs
, sigs
, signal_stop
);
6664 SET_SIGS (nsigs
, sigs
, signal_print
);
6666 else if (wordlen
>= 1 && !strncmp (*argv
, "ignore", wordlen
))
6668 UNSET_SIGS (nsigs
, sigs
, signal_program
);
6670 else if (wordlen
>= 2 && !strncmp (*argv
, "print", wordlen
))
6672 SET_SIGS (nsigs
, sigs
, signal_print
);
6674 else if (wordlen
>= 2 && !strncmp (*argv
, "pass", wordlen
))
6676 SET_SIGS (nsigs
, sigs
, signal_program
);
6678 else if (wordlen
>= 3 && !strncmp (*argv
, "nostop", wordlen
))
6680 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
6682 else if (wordlen
>= 3 && !strncmp (*argv
, "noignore", wordlen
))
6684 SET_SIGS (nsigs
, sigs
, signal_program
);
6686 else if (wordlen
>= 4 && !strncmp (*argv
, "noprint", wordlen
))
6688 UNSET_SIGS (nsigs
, sigs
, signal_print
);
6689 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
6691 else if (wordlen
>= 4 && !strncmp (*argv
, "nopass", wordlen
))
6693 UNSET_SIGS (nsigs
, sigs
, signal_program
);
6695 else if (digits
> 0)
6697 /* It is numeric. The numeric signal refers to our own
6698 internal signal numbering from target.h, not to host/target
6699 signal number. This is a feature; users really should be
6700 using symbolic names anyway, and the common ones like
6701 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
6703 sigfirst
= siglast
= (int)
6704 gdb_signal_from_command (atoi (*argv
));
6705 if ((*argv
)[digits
] == '-')
6708 gdb_signal_from_command (atoi ((*argv
) + digits
+ 1));
6710 if (sigfirst
> siglast
)
6712 /* Bet he didn't figure we'd think of this case... */
6720 oursig
= gdb_signal_from_name (*argv
);
6721 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
6723 sigfirst
= siglast
= (int) oursig
;
6727 /* Not a number and not a recognized flag word => complain. */
6728 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv
);
6732 /* If any signal numbers or symbol names were found, set flags for
6733 which signals to apply actions to. */
6735 for (signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
6737 switch ((enum gdb_signal
) signum
)
6739 case GDB_SIGNAL_TRAP
:
6740 case GDB_SIGNAL_INT
:
6741 if (!allsigs
&& !sigs
[signum
])
6743 if (query (_("%s is used by the debugger.\n\
6744 Are you sure you want to change it? "),
6745 gdb_signal_to_name ((enum gdb_signal
) signum
)))
6751 printf_unfiltered (_("Not confirmed, unchanged.\n"));
6752 gdb_flush (gdb_stdout
);
6757 case GDB_SIGNAL_DEFAULT
:
6758 case GDB_SIGNAL_UNKNOWN
:
6759 /* Make sure that "all" doesn't print these. */
6770 for (signum
= 0; signum
< nsigs
; signum
++)
6773 signal_cache_update (-1);
6774 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
6775 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
6779 /* Show the results. */
6780 sig_print_header ();
6781 for (; signum
< nsigs
; signum
++)
6783 sig_print_info (signum
);
6789 do_cleanups (old_chain
);
6792 /* Complete the "handle" command. */
6794 static VEC (char_ptr
) *
6795 handle_completer (struct cmd_list_element
*ignore
,
6796 const char *text
, const char *word
)
6798 VEC (char_ptr
) *vec_signals
, *vec_keywords
, *return_val
;
6799 static const char * const keywords
[] =
6813 vec_signals
= signal_completer (ignore
, text
, word
);
6814 vec_keywords
= complete_on_enum (keywords
, word
, word
);
6816 return_val
= VEC_merge (char_ptr
, vec_signals
, vec_keywords
);
6817 VEC_free (char_ptr
, vec_signals
);
6818 VEC_free (char_ptr
, vec_keywords
);
6823 xdb_handle_command (char *args
, int from_tty
)
6826 struct cleanup
*old_chain
;
6829 error_no_arg (_("xdb command"));
6831 /* Break the command line up into args. */
6833 argv
= gdb_buildargv (args
);
6834 old_chain
= make_cleanup_freeargv (argv
);
6835 if (argv
[1] != (char *) NULL
)
6840 bufLen
= strlen (argv
[0]) + 20;
6841 argBuf
= (char *) xmalloc (bufLen
);
6845 enum gdb_signal oursig
;
6847 oursig
= gdb_signal_from_name (argv
[0]);
6848 memset (argBuf
, 0, bufLen
);
6849 if (strcmp (argv
[1], "Q") == 0)
6850 sprintf (argBuf
, "%s %s", argv
[0], "noprint");
6853 if (strcmp (argv
[1], "s") == 0)
6855 if (!signal_stop
[oursig
])
6856 sprintf (argBuf
, "%s %s", argv
[0], "stop");
6858 sprintf (argBuf
, "%s %s", argv
[0], "nostop");
6860 else if (strcmp (argv
[1], "i") == 0)
6862 if (!signal_program
[oursig
])
6863 sprintf (argBuf
, "%s %s", argv
[0], "pass");
6865 sprintf (argBuf
, "%s %s", argv
[0], "nopass");
6867 else if (strcmp (argv
[1], "r") == 0)
6869 if (!signal_print
[oursig
])
6870 sprintf (argBuf
, "%s %s", argv
[0], "print");
6872 sprintf (argBuf
, "%s %s", argv
[0], "noprint");
6878 handle_command (argBuf
, from_tty
);
6880 printf_filtered (_("Invalid signal handling flag.\n"));
6885 do_cleanups (old_chain
);
6889 gdb_signal_from_command (int num
)
6891 if (num
>= 1 && num
<= 15)
6892 return (enum gdb_signal
) num
;
6893 error (_("Only signals 1-15 are valid as numeric signals.\n\
6894 Use \"info signals\" for a list of symbolic signals."));
6897 /* Print current contents of the tables set by the handle command.
6898 It is possible we should just be printing signals actually used
6899 by the current target (but for things to work right when switching
6900 targets, all signals should be in the signal tables). */
6903 signals_info (char *signum_exp
, int from_tty
)
6905 enum gdb_signal oursig
;
6907 sig_print_header ();
6911 /* First see if this is a symbol name. */
6912 oursig
= gdb_signal_from_name (signum_exp
);
6913 if (oursig
== GDB_SIGNAL_UNKNOWN
)
6915 /* No, try numeric. */
6917 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
6919 sig_print_info (oursig
);
6923 printf_filtered ("\n");
6924 /* These ugly casts brought to you by the native VAX compiler. */
6925 for (oursig
= GDB_SIGNAL_FIRST
;
6926 (int) oursig
< (int) GDB_SIGNAL_LAST
;
6927 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
6931 if (oursig
!= GDB_SIGNAL_UNKNOWN
6932 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
6933 sig_print_info (oursig
);
6936 printf_filtered (_("\nUse the \"handle\" command "
6937 "to change these tables.\n"));
6940 /* Check if it makes sense to read $_siginfo from the current thread
6941 at this point. If not, throw an error. */
6944 validate_siginfo_access (void)
6946 /* No current inferior, no siginfo. */
6947 if (ptid_equal (inferior_ptid
, null_ptid
))
6948 error (_("No thread selected."));
6950 /* Don't try to read from a dead thread. */
6951 if (is_exited (inferior_ptid
))
6952 error (_("The current thread has terminated"));
6954 /* ... or from a spinning thread. */
6955 if (is_running (inferior_ptid
))
6956 error (_("Selected thread is running."));
6959 /* The $_siginfo convenience variable is a bit special. We don't know
6960 for sure the type of the value until we actually have a chance to
6961 fetch the data. The type can change depending on gdbarch, so it is
6962 also dependent on which thread you have selected.
6964 1. making $_siginfo be an internalvar that creates a new value on
6967 2. making the value of $_siginfo be an lval_computed value. */
6969 /* This function implements the lval_computed support for reading a
6973 siginfo_value_read (struct value
*v
)
6975 LONGEST transferred
;
6977 validate_siginfo_access ();
6980 target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
,
6982 value_contents_all_raw (v
),
6984 TYPE_LENGTH (value_type (v
)));
6986 if (transferred
!= TYPE_LENGTH (value_type (v
)))
6987 error (_("Unable to read siginfo"));
6990 /* This function implements the lval_computed support for writing a
6994 siginfo_value_write (struct value
*v
, struct value
*fromval
)
6996 LONGEST transferred
;
6998 validate_siginfo_access ();
7000 transferred
= target_write (¤t_target
,
7001 TARGET_OBJECT_SIGNAL_INFO
,
7003 value_contents_all_raw (fromval
),
7005 TYPE_LENGTH (value_type (fromval
)));
7007 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
7008 error (_("Unable to write siginfo"));
7011 static const struct lval_funcs siginfo_value_funcs
=
7017 /* Return a new value with the correct type for the siginfo object of
7018 the current thread using architecture GDBARCH. Return a void value
7019 if there's no object available. */
7021 static struct value
*
7022 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
7025 if (target_has_stack
7026 && !ptid_equal (inferior_ptid
, null_ptid
)
7027 && gdbarch_get_siginfo_type_p (gdbarch
))
7029 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
7031 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
7034 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
7038 /* infcall_suspend_state contains state about the program itself like its
7039 registers and any signal it received when it last stopped.
7040 This state must be restored regardless of how the inferior function call
7041 ends (either successfully, or after it hits a breakpoint or signal)
7042 if the program is to properly continue where it left off. */
7044 struct infcall_suspend_state
7046 struct thread_suspend_state thread_suspend
;
7047 #if 0 /* Currently unused and empty structures are not valid C. */
7048 struct inferior_suspend_state inferior_suspend
;
7053 struct regcache
*registers
;
7055 /* Format of SIGINFO_DATA or NULL if it is not present. */
7056 struct gdbarch
*siginfo_gdbarch
;
7058 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
7059 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
7060 content would be invalid. */
7061 gdb_byte
*siginfo_data
;
7064 struct infcall_suspend_state
*
7065 save_infcall_suspend_state (void)
7067 struct infcall_suspend_state
*inf_state
;
7068 struct thread_info
*tp
= inferior_thread ();
7070 struct inferior
*inf
= current_inferior ();
7072 struct regcache
*regcache
= get_current_regcache ();
7073 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7074 gdb_byte
*siginfo_data
= NULL
;
7076 if (gdbarch_get_siginfo_type_p (gdbarch
))
7078 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
7079 size_t len
= TYPE_LENGTH (type
);
7080 struct cleanup
*back_to
;
7082 siginfo_data
= xmalloc (len
);
7083 back_to
= make_cleanup (xfree
, siginfo_data
);
7085 if (target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
7086 siginfo_data
, 0, len
) == len
)
7087 discard_cleanups (back_to
);
7090 /* Errors ignored. */
7091 do_cleanups (back_to
);
7092 siginfo_data
= NULL
;
7096 inf_state
= XCNEW (struct infcall_suspend_state
);
7100 inf_state
->siginfo_gdbarch
= gdbarch
;
7101 inf_state
->siginfo_data
= siginfo_data
;
7104 inf_state
->thread_suspend
= tp
->suspend
;
7105 #if 0 /* Currently unused and empty structures are not valid C. */
7106 inf_state
->inferior_suspend
= inf
->suspend
;
7109 /* run_inferior_call will not use the signal due to its `proceed' call with
7110 GDB_SIGNAL_0 anyway. */
7111 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7113 inf_state
->stop_pc
= stop_pc
;
7115 inf_state
->registers
= regcache_dup (regcache
);
7120 /* Restore inferior session state to INF_STATE. */
7123 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
7125 struct thread_info
*tp
= inferior_thread ();
7127 struct inferior
*inf
= current_inferior ();
7129 struct regcache
*regcache
= get_current_regcache ();
7130 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7132 tp
->suspend
= inf_state
->thread_suspend
;
7133 #if 0 /* Currently unused and empty structures are not valid C. */
7134 inf
->suspend
= inf_state
->inferior_suspend
;
7137 stop_pc
= inf_state
->stop_pc
;
7139 if (inf_state
->siginfo_gdbarch
== gdbarch
)
7141 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
7143 /* Errors ignored. */
7144 target_write (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
7145 inf_state
->siginfo_data
, 0, TYPE_LENGTH (type
));
7148 /* The inferior can be gone if the user types "print exit(0)"
7149 (and perhaps other times). */
7150 if (target_has_execution
)
7151 /* NB: The register write goes through to the target. */
7152 regcache_cpy (regcache
, inf_state
->registers
);
7154 discard_infcall_suspend_state (inf_state
);
7158 do_restore_infcall_suspend_state_cleanup (void *state
)
7160 restore_infcall_suspend_state (state
);
7164 make_cleanup_restore_infcall_suspend_state
7165 (struct infcall_suspend_state
*inf_state
)
7167 return make_cleanup (do_restore_infcall_suspend_state_cleanup
, inf_state
);
7171 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
7173 regcache_xfree (inf_state
->registers
);
7174 xfree (inf_state
->siginfo_data
);
7179 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
7181 return inf_state
->registers
;
7184 /* infcall_control_state contains state regarding gdb's control of the
7185 inferior itself like stepping control. It also contains session state like
7186 the user's currently selected frame. */
7188 struct infcall_control_state
7190 struct thread_control_state thread_control
;
7191 struct inferior_control_state inferior_control
;
7194 enum stop_stack_kind stop_stack_dummy
;
7195 int stopped_by_random_signal
;
7196 int stop_after_trap
;
7198 /* ID if the selected frame when the inferior function call was made. */
7199 struct frame_id selected_frame_id
;
7202 /* Save all of the information associated with the inferior<==>gdb
7205 struct infcall_control_state
*
7206 save_infcall_control_state (void)
7208 struct infcall_control_state
*inf_status
= xmalloc (sizeof (*inf_status
));
7209 struct thread_info
*tp
= inferior_thread ();
7210 struct inferior
*inf
= current_inferior ();
7212 inf_status
->thread_control
= tp
->control
;
7213 inf_status
->inferior_control
= inf
->control
;
7215 tp
->control
.step_resume_breakpoint
= NULL
;
7216 tp
->control
.exception_resume_breakpoint
= NULL
;
7218 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
7219 chain. If caller's caller is walking the chain, they'll be happier if we
7220 hand them back the original chain when restore_infcall_control_state is
7222 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
7225 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
7226 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
7227 inf_status
->stop_after_trap
= stop_after_trap
;
7229 inf_status
->selected_frame_id
= get_frame_id (get_selected_frame (NULL
));
7235 restore_selected_frame (void *args
)
7237 struct frame_id
*fid
= (struct frame_id
*) args
;
7238 struct frame_info
*frame
;
7240 frame
= frame_find_by_id (*fid
);
7242 /* If inf_status->selected_frame_id is NULL, there was no previously
7246 warning (_("Unable to restore previously selected frame."));
7250 select_frame (frame
);
7255 /* Restore inferior session state to INF_STATUS. */
7258 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
7260 struct thread_info
*tp
= inferior_thread ();
7261 struct inferior
*inf
= current_inferior ();
7263 if (tp
->control
.step_resume_breakpoint
)
7264 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
7266 if (tp
->control
.exception_resume_breakpoint
)
7267 tp
->control
.exception_resume_breakpoint
->disposition
7268 = disp_del_at_next_stop
;
7270 /* Handle the bpstat_copy of the chain. */
7271 bpstat_clear (&tp
->control
.stop_bpstat
);
7273 tp
->control
= inf_status
->thread_control
;
7274 inf
->control
= inf_status
->inferior_control
;
7277 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
7278 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
7279 stop_after_trap
= inf_status
->stop_after_trap
;
7281 if (target_has_stack
)
7283 /* The point of catch_errors is that if the stack is clobbered,
7284 walking the stack might encounter a garbage pointer and
7285 error() trying to dereference it. */
7287 (restore_selected_frame
, &inf_status
->selected_frame_id
,
7288 "Unable to restore previously selected frame:\n",
7289 RETURN_MASK_ERROR
) == 0)
7290 /* Error in restoring the selected frame. Select the innermost
7292 select_frame (get_current_frame ());
7299 do_restore_infcall_control_state_cleanup (void *sts
)
7301 restore_infcall_control_state (sts
);
7305 make_cleanup_restore_infcall_control_state
7306 (struct infcall_control_state
*inf_status
)
7308 return make_cleanup (do_restore_infcall_control_state_cleanup
, inf_status
);
7312 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
7314 if (inf_status
->thread_control
.step_resume_breakpoint
)
7315 inf_status
->thread_control
.step_resume_breakpoint
->disposition
7316 = disp_del_at_next_stop
;
7318 if (inf_status
->thread_control
.exception_resume_breakpoint
)
7319 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
7320 = disp_del_at_next_stop
;
7322 /* See save_infcall_control_state for info on stop_bpstat. */
7323 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
7328 /* restore_inferior_ptid() will be used by the cleanup machinery
7329 to restore the inferior_ptid value saved in a call to
7330 save_inferior_ptid(). */
7333 restore_inferior_ptid (void *arg
)
7335 ptid_t
*saved_ptid_ptr
= arg
;
7337 inferior_ptid
= *saved_ptid_ptr
;
7341 /* Save the value of inferior_ptid so that it may be restored by a
7342 later call to do_cleanups(). Returns the struct cleanup pointer
7343 needed for later doing the cleanup. */
7346 save_inferior_ptid (void)
7348 ptid_t
*saved_ptid_ptr
;
7350 saved_ptid_ptr
= xmalloc (sizeof (ptid_t
));
7351 *saved_ptid_ptr
= inferior_ptid
;
7352 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
7358 clear_exit_convenience_vars (void)
7360 clear_internalvar (lookup_internalvar ("_exitsignal"));
7361 clear_internalvar (lookup_internalvar ("_exitcode"));
7365 /* User interface for reverse debugging:
7366 Set exec-direction / show exec-direction commands
7367 (returns error unless target implements to_set_exec_direction method). */
7369 int execution_direction
= EXEC_FORWARD
;
7370 static const char exec_forward
[] = "forward";
7371 static const char exec_reverse
[] = "reverse";
7372 static const char *exec_direction
= exec_forward
;
7373 static const char *const exec_direction_names
[] = {
7380 set_exec_direction_func (char *args
, int from_tty
,
7381 struct cmd_list_element
*cmd
)
7383 if (target_can_execute_reverse
)
7385 if (!strcmp (exec_direction
, exec_forward
))
7386 execution_direction
= EXEC_FORWARD
;
7387 else if (!strcmp (exec_direction
, exec_reverse
))
7388 execution_direction
= EXEC_REVERSE
;
7392 exec_direction
= exec_forward
;
7393 error (_("Target does not support this operation."));
7398 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
7399 struct cmd_list_element
*cmd
, const char *value
)
7401 switch (execution_direction
) {
7403 fprintf_filtered (out
, _("Forward.\n"));
7406 fprintf_filtered (out
, _("Reverse.\n"));
7409 internal_error (__FILE__
, __LINE__
,
7410 _("bogus execution_direction value: %d"),
7411 (int) execution_direction
);
7416 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
7417 struct cmd_list_element
*c
, const char *value
)
7419 fprintf_filtered (file
, _("Resuming the execution of threads "
7420 "of all processes is %s.\n"), value
);
7423 /* Implementation of `siginfo' variable. */
7425 static const struct internalvar_funcs siginfo_funcs
=
7433 _initialize_infrun (void)
7437 struct cmd_list_element
*c
;
7439 add_info ("signals", signals_info
, _("\
7440 What debugger does when program gets various signals.\n\
7441 Specify a signal as argument to print info on that signal only."));
7442 add_info_alias ("handle", "signals", 0);
7444 c
= add_com ("handle", class_run
, handle_command
, _("\
7445 Specify how to handle signals.\n\
7446 Usage: handle SIGNAL [ACTIONS]\n\
7447 Args are signals and actions to apply to those signals.\n\
7448 If no actions are specified, the current settings for the specified signals\n\
7449 will be displayed instead.\n\
7451 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7452 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7453 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7454 The special arg \"all\" is recognized to mean all signals except those\n\
7455 used by the debugger, typically SIGTRAP and SIGINT.\n\
7457 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7458 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7459 Stop means reenter debugger if this signal happens (implies print).\n\
7460 Print means print a message if this signal happens.\n\
7461 Pass means let program see this signal; otherwise program doesn't know.\n\
7462 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7463 Pass and Stop may be combined.\n\
7465 Multiple signals may be specified. Signal numbers and signal names\n\
7466 may be interspersed with actions, with the actions being performed for\n\
7467 all signals cumulatively specified."));
7468 set_cmd_completer (c
, handle_completer
);
7472 add_com ("lz", class_info
, signals_info
, _("\
7473 What debugger does when program gets various signals.\n\
7474 Specify a signal as argument to print info on that signal only."));
7475 add_com ("z", class_run
, xdb_handle_command
, _("\
7476 Specify how to handle a signal.\n\
7477 Args are signals and actions to apply to those signals.\n\
7478 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7479 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7480 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7481 The special arg \"all\" is recognized to mean all signals except those\n\
7482 used by the debugger, typically SIGTRAP and SIGINT.\n\
7483 Recognized actions include \"s\" (toggles between stop and nostop),\n\
7484 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
7485 nopass), \"Q\" (noprint)\n\
7486 Stop means reenter debugger if this signal happens (implies print).\n\
7487 Print means print a message if this signal happens.\n\
7488 Pass means let program see this signal; otherwise program doesn't know.\n\
7489 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7490 Pass and Stop may be combined."));
7494 stop_command
= add_cmd ("stop", class_obscure
,
7495 not_just_help_class_command
, _("\
7496 There is no `stop' command, but you can set a hook on `stop'.\n\
7497 This allows you to set a list of commands to be run each time execution\n\
7498 of the program stops."), &cmdlist
);
7500 add_setshow_zuinteger_cmd ("infrun", class_maintenance
, &debug_infrun
, _("\
7501 Set inferior debugging."), _("\
7502 Show inferior debugging."), _("\
7503 When non-zero, inferior specific debugging is enabled."),
7506 &setdebuglist
, &showdebuglist
);
7508 add_setshow_boolean_cmd ("displaced", class_maintenance
,
7509 &debug_displaced
, _("\
7510 Set displaced stepping debugging."), _("\
7511 Show displaced stepping debugging."), _("\
7512 When non-zero, displaced stepping specific debugging is enabled."),
7514 show_debug_displaced
,
7515 &setdebuglist
, &showdebuglist
);
7517 add_setshow_boolean_cmd ("non-stop", no_class
,
7519 Set whether gdb controls the inferior in non-stop mode."), _("\
7520 Show whether gdb controls the inferior in non-stop mode."), _("\
7521 When debugging a multi-threaded program and this setting is\n\
7522 off (the default, also called all-stop mode), when one thread stops\n\
7523 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7524 all other threads in the program while you interact with the thread of\n\
7525 interest. When you continue or step a thread, you can allow the other\n\
7526 threads to run, or have them remain stopped, but while you inspect any\n\
7527 thread's state, all threads stop.\n\
7529 In non-stop mode, when one thread stops, other threads can continue\n\
7530 to run freely. You'll be able to step each thread independently,\n\
7531 leave it stopped or free to run as needed."),
7537 numsigs
= (int) GDB_SIGNAL_LAST
;
7538 signal_stop
= (unsigned char *) xmalloc (sizeof (signal_stop
[0]) * numsigs
);
7539 signal_print
= (unsigned char *)
7540 xmalloc (sizeof (signal_print
[0]) * numsigs
);
7541 signal_program
= (unsigned char *)
7542 xmalloc (sizeof (signal_program
[0]) * numsigs
);
7543 signal_catch
= (unsigned char *)
7544 xmalloc (sizeof (signal_catch
[0]) * numsigs
);
7545 signal_pass
= (unsigned char *)
7546 xmalloc (sizeof (signal_pass
[0]) * numsigs
);
7547 for (i
= 0; i
< numsigs
; i
++)
7550 signal_print
[i
] = 1;
7551 signal_program
[i
] = 1;
7552 signal_catch
[i
] = 0;
7555 /* Signals caused by debugger's own actions
7556 should not be given to the program afterwards. */
7557 signal_program
[GDB_SIGNAL_TRAP
] = 0;
7558 signal_program
[GDB_SIGNAL_INT
] = 0;
7560 /* Signals that are not errors should not normally enter the debugger. */
7561 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
7562 signal_print
[GDB_SIGNAL_ALRM
] = 0;
7563 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
7564 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
7565 signal_stop
[GDB_SIGNAL_PROF
] = 0;
7566 signal_print
[GDB_SIGNAL_PROF
] = 0;
7567 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
7568 signal_print
[GDB_SIGNAL_CHLD
] = 0;
7569 signal_stop
[GDB_SIGNAL_IO
] = 0;
7570 signal_print
[GDB_SIGNAL_IO
] = 0;
7571 signal_stop
[GDB_SIGNAL_POLL
] = 0;
7572 signal_print
[GDB_SIGNAL_POLL
] = 0;
7573 signal_stop
[GDB_SIGNAL_URG
] = 0;
7574 signal_print
[GDB_SIGNAL_URG
] = 0;
7575 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
7576 signal_print
[GDB_SIGNAL_WINCH
] = 0;
7577 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
7578 signal_print
[GDB_SIGNAL_PRIO
] = 0;
7580 /* These signals are used internally by user-level thread
7581 implementations. (See signal(5) on Solaris.) Like the above
7582 signals, a healthy program receives and handles them as part of
7583 its normal operation. */
7584 signal_stop
[GDB_SIGNAL_LWP
] = 0;
7585 signal_print
[GDB_SIGNAL_LWP
] = 0;
7586 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
7587 signal_print
[GDB_SIGNAL_WAITING
] = 0;
7588 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
7589 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
7591 /* Update cached state. */
7592 signal_cache_update (-1);
7594 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
7595 &stop_on_solib_events
, _("\
7596 Set stopping for shared library events."), _("\
7597 Show stopping for shared library events."), _("\
7598 If nonzero, gdb will give control to the user when the dynamic linker\n\
7599 notifies gdb of shared library events. The most common event of interest\n\
7600 to the user would be loading/unloading of a new library."),
7601 set_stop_on_solib_events
,
7602 show_stop_on_solib_events
,
7603 &setlist
, &showlist
);
7605 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
7606 follow_fork_mode_kind_names
,
7607 &follow_fork_mode_string
, _("\
7608 Set debugger response to a program call of fork or vfork."), _("\
7609 Show debugger response to a program call of fork or vfork."), _("\
7610 A fork or vfork creates a new process. follow-fork-mode can be:\n\
7611 parent - the original process is debugged after a fork\n\
7612 child - the new process is debugged after a fork\n\
7613 The unfollowed process will continue to run.\n\
7614 By default, the debugger will follow the parent process."),
7616 show_follow_fork_mode_string
,
7617 &setlist
, &showlist
);
7619 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
7620 follow_exec_mode_names
,
7621 &follow_exec_mode_string
, _("\
7622 Set debugger response to a program call of exec."), _("\
7623 Show debugger response to a program call of exec."), _("\
7624 An exec call replaces the program image of a process.\n\
7626 follow-exec-mode can be:\n\
7628 new - the debugger creates a new inferior and rebinds the process\n\
7629 to this new inferior. The program the process was running before\n\
7630 the exec call can be restarted afterwards by restarting the original\n\
7633 same - the debugger keeps the process bound to the same inferior.\n\
7634 The new executable image replaces the previous executable loaded in\n\
7635 the inferior. Restarting the inferior after the exec call restarts\n\
7636 the executable the process was running after the exec call.\n\
7638 By default, the debugger will use the same inferior."),
7640 show_follow_exec_mode_string
,
7641 &setlist
, &showlist
);
7643 add_setshow_enum_cmd ("scheduler-locking", class_run
,
7644 scheduler_enums
, &scheduler_mode
, _("\
7645 Set mode for locking scheduler during execution."), _("\
7646 Show mode for locking scheduler during execution."), _("\
7647 off == no locking (threads may preempt at any time)\n\
7648 on == full locking (no thread except the current thread may run)\n\
7649 step == scheduler locked during every single-step operation.\n\
7650 In this mode, no other thread may run during a step command.\n\
7651 Other threads may run while stepping over a function call ('next')."),
7652 set_schedlock_func
, /* traps on target vector */
7653 show_scheduler_mode
,
7654 &setlist
, &showlist
);
7656 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
7657 Set mode for resuming threads of all processes."), _("\
7658 Show mode for resuming threads of all processes."), _("\
7659 When on, execution commands (such as 'continue' or 'next') resume all\n\
7660 threads of all processes. When off (which is the default), execution\n\
7661 commands only resume the threads of the current process. The set of\n\
7662 threads that are resumed is further refined by the scheduler-locking\n\
7663 mode (see help set scheduler-locking)."),
7665 show_schedule_multiple
,
7666 &setlist
, &showlist
);
7668 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
7669 Set mode of the step operation."), _("\
7670 Show mode of the step operation."), _("\
7671 When set, doing a step over a function without debug line information\n\
7672 will stop at the first instruction of that function. Otherwise, the\n\
7673 function is skipped and the step command stops at a different source line."),
7675 show_step_stop_if_no_debug
,
7676 &setlist
, &showlist
);
7678 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
7679 &can_use_displaced_stepping
, _("\
7680 Set debugger's willingness to use displaced stepping."), _("\
7681 Show debugger's willingness to use displaced stepping."), _("\
7682 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7683 supported by the target architecture. If off, gdb will not use displaced\n\
7684 stepping to step over breakpoints, even if such is supported by the target\n\
7685 architecture. If auto (which is the default), gdb will use displaced stepping\n\
7686 if the target architecture supports it and non-stop mode is active, but will not\n\
7687 use it in all-stop mode (see help set non-stop)."),
7689 show_can_use_displaced_stepping
,
7690 &setlist
, &showlist
);
7692 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
7693 &exec_direction
, _("Set direction of execution.\n\
7694 Options are 'forward' or 'reverse'."),
7695 _("Show direction of execution (forward/reverse)."),
7696 _("Tells gdb whether to execute forward or backward."),
7697 set_exec_direction_func
, show_exec_direction_func
,
7698 &setlist
, &showlist
);
7700 /* Set/show detach-on-fork: user-settable mode. */
7702 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
7703 Set whether gdb will detach the child of a fork."), _("\
7704 Show whether gdb will detach the child of a fork."), _("\
7705 Tells gdb whether to detach the child of a fork."),
7706 NULL
, NULL
, &setlist
, &showlist
);
7708 /* Set/show disable address space randomization mode. */
7710 add_setshow_boolean_cmd ("disable-randomization", class_support
,
7711 &disable_randomization
, _("\
7712 Set disabling of debuggee's virtual address space randomization."), _("\
7713 Show disabling of debuggee's virtual address space randomization."), _("\
7714 When this mode is on (which is the default), randomization of the virtual\n\
7715 address space is disabled. Standalone programs run with the randomization\n\
7716 enabled by default on some platforms."),
7717 &set_disable_randomization
,
7718 &show_disable_randomization
,
7719 &setlist
, &showlist
);
7721 /* ptid initializations */
7722 inferior_ptid
= null_ptid
;
7723 target_last_wait_ptid
= minus_one_ptid
;
7725 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed
);
7726 observer_attach_thread_stop_requested (infrun_thread_stop_requested
);
7727 observer_attach_thread_exit (infrun_thread_thread_exit
);
7728 observer_attach_inferior_exit (infrun_inferior_exit
);
7730 /* Explicitly create without lookup, since that tries to create a
7731 value with a void typed value, and when we get here, gdbarch
7732 isn't initialized yet. At this point, we're quite sure there
7733 isn't another convenience variable of the same name. */
7734 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
7736 add_setshow_boolean_cmd ("observer", no_class
,
7737 &observer_mode_1
, _("\
7738 Set whether gdb controls the inferior in observer mode."), _("\
7739 Show whether gdb controls the inferior in observer mode."), _("\
7740 In observer mode, GDB can get data from the inferior, but not\n\
7741 affect its execution. Registers and memory may not be changed,\n\
7742 breakpoints may not be set, and the program cannot be interrupted\n\