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 "exceptions.h"
28 #include "breakpoint.h"
32 #include "cli/cli-script.h"
34 #include "gdbthread.h"
46 #include "dictionary.h"
48 #include "gdb_assert.h"
49 #include "mi/mi-common.h"
50 #include "event-top.h"
52 #include "record-full.h"
53 #include "inline-frame.h"
55 #include "tracepoint.h"
56 #include "continuations.h"
61 #include "completer.h"
62 #include "target-descriptions.h"
63 #include "target-dcache.h"
65 /* Prototypes for local functions */
67 static void signals_info (char *, int);
69 static void handle_command (char *, int);
71 static void sig_print_info (enum gdb_signal);
73 static void sig_print_header (void);
75 static void resume_cleanups (void *);
77 static int hook_stop_stub (void *);
79 static int restore_selected_frame (void *);
81 static int follow_fork (void);
83 static void set_schedlock_func (char *args, int from_tty,
84 struct cmd_list_element *c);
86 static int currently_stepping (struct thread_info *tp);
88 static int currently_stepping_or_nexting_callback (struct thread_info *tp,
91 static void xdb_handle_command (char *args, int from_tty);
93 static int prepare_to_proceed (int);
95 static void print_exited_reason (int exitstatus);
97 static void print_signal_exited_reason (enum gdb_signal siggnal);
99 static void print_no_history_reason (void);
101 static void print_signal_received_reason (enum gdb_signal siggnal);
103 static void print_end_stepping_range_reason (void);
105 void _initialize_infrun (void);
107 void nullify_last_target_wait_ptid (void);
109 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
111 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
113 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
115 /* When set, stop the 'step' command if we enter a function which has
116 no line number information. The normal behavior is that we step
117 over such function. */
118 int step_stop_if_no_debug = 0;
120 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
121 struct cmd_list_element *c, const char *value)
123 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
126 /* In asynchronous mode, but simulating synchronous execution. */
128 int sync_execution = 0;
130 /* proceed and normal_stop use this to notify the user when the
131 inferior stopped in a different thread than it had been running
134 static ptid_t previous_inferior_ptid;
136 /* If set (default for legacy reasons), when following a fork, GDB
137 will detach from one of the fork branches, child or parent.
138 Exactly which branch is detached depends on 'set follow-fork-mode'
141 static int detach_fork = 1;
143 int debug_displaced = 0;
145 show_debug_displaced (struct ui_file *file, int from_tty,
146 struct cmd_list_element *c, const char *value)
148 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
151 unsigned int debug_infrun = 0;
153 show_debug_infrun (struct ui_file *file, int from_tty,
154 struct cmd_list_element *c, const char *value)
156 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
160 /* Support for disabling address space randomization. */
162 int disable_randomization = 1;
165 show_disable_randomization (struct ui_file *file, int from_tty,
166 struct cmd_list_element *c, const char *value)
168 if (target_supports_disable_randomization ())
169 fprintf_filtered (file,
170 _("Disabling randomization of debuggee's "
171 "virtual address space is %s.\n"),
174 fputs_filtered (_("Disabling randomization of debuggee's "
175 "virtual address space is unsupported on\n"
176 "this platform.\n"), file);
180 set_disable_randomization (char *args, int from_tty,
181 struct cmd_list_element *c)
183 if (!target_supports_disable_randomization ())
184 error (_("Disabling randomization of debuggee's "
185 "virtual address space is unsupported on\n"
189 /* User interface for non-stop mode. */
192 static int non_stop_1 = 0;
195 set_non_stop (char *args, int from_tty,
196 struct cmd_list_element *c)
198 if (target_has_execution)
200 non_stop_1 = non_stop;
201 error (_("Cannot change this setting while the inferior is running."));
204 non_stop = non_stop_1;
208 show_non_stop (struct ui_file *file, int from_tty,
209 struct cmd_list_element *c, const char *value)
211 fprintf_filtered (file,
212 _("Controlling the inferior in non-stop mode is %s.\n"),
216 /* "Observer mode" is somewhat like a more extreme version of
217 non-stop, in which all GDB operations that might affect the
218 target's execution have been disabled. */
220 int observer_mode = 0;
221 static int observer_mode_1 = 0;
224 set_observer_mode (char *args, int from_tty,
225 struct cmd_list_element *c)
227 if (target_has_execution)
229 observer_mode_1 = observer_mode;
230 error (_("Cannot change this setting while the inferior is running."));
233 observer_mode = observer_mode_1;
235 may_write_registers = !observer_mode;
236 may_write_memory = !observer_mode;
237 may_insert_breakpoints = !observer_mode;
238 may_insert_tracepoints = !observer_mode;
239 /* We can insert fast tracepoints in or out of observer mode,
240 but enable them if we're going into this mode. */
242 may_insert_fast_tracepoints = 1;
243 may_stop = !observer_mode;
244 update_target_permissions ();
246 /* Going *into* observer mode we must force non-stop, then
247 going out we leave it that way. */
250 target_async_permitted = 1;
251 pagination_enabled = 0;
252 non_stop = non_stop_1 = 1;
256 printf_filtered (_("Observer mode is now %s.\n"),
257 (observer_mode ? "on" : "off"));
261 show_observer_mode (struct ui_file *file, int from_tty,
262 struct cmd_list_element *c, const char *value)
264 fprintf_filtered (file, _("Observer mode is %s.\n"), value);
267 /* This updates the value of observer mode based on changes in
268 permissions. Note that we are deliberately ignoring the values of
269 may-write-registers and may-write-memory, since the user may have
270 reason to enable these during a session, for instance to turn on a
271 debugging-related global. */
274 update_observer_mode (void)
278 newval = (!may_insert_breakpoints
279 && !may_insert_tracepoints
280 && may_insert_fast_tracepoints
284 /* Let the user know if things change. */
285 if (newval != observer_mode)
286 printf_filtered (_("Observer mode is now %s.\n"),
287 (newval ? "on" : "off"));
289 observer_mode = observer_mode_1 = newval;
292 /* Tables of how to react to signals; the user sets them. */
294 static unsigned char *signal_stop;
295 static unsigned char *signal_print;
296 static unsigned char *signal_program;
298 /* Table of signals that are registered with "catch signal". A
299 non-zero entry indicates that the signal is caught by some "catch
300 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
302 static unsigned char *signal_catch;
304 /* Table of signals that the target may silently handle.
305 This is automatically determined from the flags above,
306 and simply cached here. */
307 static unsigned char *signal_pass;
309 #define SET_SIGS(nsigs,sigs,flags) \
311 int signum = (nsigs); \
312 while (signum-- > 0) \
313 if ((sigs)[signum]) \
314 (flags)[signum] = 1; \
317 #define UNSET_SIGS(nsigs,sigs,flags) \
319 int signum = (nsigs); \
320 while (signum-- > 0) \
321 if ((sigs)[signum]) \
322 (flags)[signum] = 0; \
325 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
326 this function is to avoid exporting `signal_program'. */
329 update_signals_program_target (void)
331 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
334 /* Value to pass to target_resume() to cause all threads to resume. */
336 #define RESUME_ALL minus_one_ptid
338 /* Command list pointer for the "stop" placeholder. */
340 static struct cmd_list_element *stop_command;
342 /* Function inferior was in as of last step command. */
344 static struct symbol *step_start_function;
346 /* Nonzero if we want to give control to the user when we're notified
347 of shared library events by the dynamic linker. */
348 int stop_on_solib_events;
350 /* Enable or disable optional shared library event breakpoints
351 as appropriate when the above flag is changed. */
354 set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
356 update_solib_breakpoints ();
360 show_stop_on_solib_events (struct ui_file *file, int from_tty,
361 struct cmd_list_element *c, const char *value)
363 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
367 /* Nonzero means expecting a trace trap
368 and should stop the inferior and return silently when it happens. */
372 /* Save register contents here when executing a "finish" command or are
373 about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set.
374 Thus this contains the return value from the called function (assuming
375 values are returned in a register). */
377 struct regcache *stop_registers;
379 /* Nonzero after stop if current stack frame should be printed. */
381 static int stop_print_frame;
383 /* This is a cached copy of the pid/waitstatus of the last event
384 returned by target_wait()/deprecated_target_wait_hook(). This
385 information is returned by get_last_target_status(). */
386 static ptid_t target_last_wait_ptid;
387 static struct target_waitstatus target_last_waitstatus;
389 static void context_switch (ptid_t ptid);
391 void init_thread_stepping_state (struct thread_info *tss);
393 static void init_infwait_state (void);
395 static const char follow_fork_mode_child[] = "child";
396 static const char follow_fork_mode_parent[] = "parent";
398 static const char *const follow_fork_mode_kind_names[] = {
399 follow_fork_mode_child,
400 follow_fork_mode_parent,
404 static const char *follow_fork_mode_string = follow_fork_mode_parent;
406 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
407 struct cmd_list_element *c, const char *value)
409 fprintf_filtered (file,
410 _("Debugger response to a program "
411 "call of fork or vfork is \"%s\".\n"),
416 /* Tell the target to follow the fork we're stopped at. Returns true
417 if the inferior should be resumed; false, if the target for some
418 reason decided it's best not to resume. */
423 int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
424 int should_resume = 1;
425 struct thread_info *tp;
427 /* Copy user stepping state to the new inferior thread. FIXME: the
428 followed fork child thread should have a copy of most of the
429 parent thread structure's run control related fields, not just these.
430 Initialized to avoid "may be used uninitialized" warnings from gcc. */
431 struct breakpoint *step_resume_breakpoint = NULL;
432 struct breakpoint *exception_resume_breakpoint = NULL;
433 CORE_ADDR step_range_start = 0;
434 CORE_ADDR step_range_end = 0;
435 struct frame_id step_frame_id = { 0 };
440 struct target_waitstatus wait_status;
442 /* Get the last target status returned by target_wait(). */
443 get_last_target_status (&wait_ptid, &wait_status);
445 /* If not stopped at a fork event, then there's nothing else to
447 if (wait_status.kind != TARGET_WAITKIND_FORKED
448 && wait_status.kind != TARGET_WAITKIND_VFORKED)
451 /* Check if we switched over from WAIT_PTID, since the event was
453 if (!ptid_equal (wait_ptid, minus_one_ptid)
454 && !ptid_equal (inferior_ptid, wait_ptid))
456 /* We did. Switch back to WAIT_PTID thread, to tell the
457 target to follow it (in either direction). We'll
458 afterwards refuse to resume, and inform the user what
460 switch_to_thread (wait_ptid);
465 tp = inferior_thread ();
467 /* If there were any forks/vforks that were caught and are now to be
468 followed, then do so now. */
469 switch (tp->pending_follow.kind)
471 case TARGET_WAITKIND_FORKED:
472 case TARGET_WAITKIND_VFORKED:
474 ptid_t parent, child;
476 /* If the user did a next/step, etc, over a fork call,
477 preserve the stepping state in the fork child. */
478 if (follow_child && should_resume)
480 step_resume_breakpoint = clone_momentary_breakpoint
481 (tp->control.step_resume_breakpoint);
482 step_range_start = tp->control.step_range_start;
483 step_range_end = tp->control.step_range_end;
484 step_frame_id = tp->control.step_frame_id;
485 exception_resume_breakpoint
486 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
488 /* For now, delete the parent's sr breakpoint, otherwise,
489 parent/child sr breakpoints are considered duplicates,
490 and the child version will not be installed. Remove
491 this when the breakpoints module becomes aware of
492 inferiors and address spaces. */
493 delete_step_resume_breakpoint (tp);
494 tp->control.step_range_start = 0;
495 tp->control.step_range_end = 0;
496 tp->control.step_frame_id = null_frame_id;
497 delete_exception_resume_breakpoint (tp);
500 parent = inferior_ptid;
501 child = tp->pending_follow.value.related_pid;
503 /* Tell the target to do whatever is necessary to follow
504 either parent or child. */
505 if (target_follow_fork (follow_child, detach_fork))
507 /* Target refused to follow, or there's some other reason
508 we shouldn't resume. */
513 /* This pending follow fork event is now handled, one way
514 or another. The previous selected thread may be gone
515 from the lists by now, but if it is still around, need
516 to clear the pending follow request. */
517 tp = find_thread_ptid (parent);
519 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
521 /* This makes sure we don't try to apply the "Switched
522 over from WAIT_PID" logic above. */
523 nullify_last_target_wait_ptid ();
525 /* If we followed the child, switch to it... */
528 switch_to_thread (child);
530 /* ... and preserve the stepping state, in case the
531 user was stepping over the fork call. */
534 tp = inferior_thread ();
535 tp->control.step_resume_breakpoint
536 = step_resume_breakpoint;
537 tp->control.step_range_start = step_range_start;
538 tp->control.step_range_end = step_range_end;
539 tp->control.step_frame_id = step_frame_id;
540 tp->control.exception_resume_breakpoint
541 = exception_resume_breakpoint;
545 /* If we get here, it was because we're trying to
546 resume from a fork catchpoint, but, the user
547 has switched threads away from the thread that
548 forked. In that case, the resume command
549 issued is most likely not applicable to the
550 child, so just warn, and refuse to resume. */
551 warning (_("Not resuming: switched threads "
552 "before following fork child.\n"));
555 /* Reset breakpoints in the child as appropriate. */
556 follow_inferior_reset_breakpoints ();
559 switch_to_thread (parent);
563 case TARGET_WAITKIND_SPURIOUS:
564 /* Nothing to follow. */
567 internal_error (__FILE__, __LINE__,
568 "Unexpected pending_follow.kind %d\n",
569 tp->pending_follow.kind);
573 return should_resume;
577 follow_inferior_reset_breakpoints (void)
579 struct thread_info *tp = inferior_thread ();
581 /* Was there a step_resume breakpoint? (There was if the user
582 did a "next" at the fork() call.) If so, explicitly reset its
585 step_resumes are a form of bp that are made to be per-thread.
586 Since we created the step_resume bp when the parent process
587 was being debugged, and now are switching to the child process,
588 from the breakpoint package's viewpoint, that's a switch of
589 "threads". We must update the bp's notion of which thread
590 it is for, or it'll be ignored when it triggers. */
592 if (tp->control.step_resume_breakpoint)
593 breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
595 if (tp->control.exception_resume_breakpoint)
596 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
598 /* Reinsert all breakpoints in the child. The user may have set
599 breakpoints after catching the fork, in which case those
600 were never set in the child, but only in the parent. This makes
601 sure the inserted breakpoints match the breakpoint list. */
603 breakpoint_re_set ();
604 insert_breakpoints ();
607 /* The child has exited or execed: resume threads of the parent the
608 user wanted to be executing. */
611 proceed_after_vfork_done (struct thread_info *thread,
614 int pid = * (int *) arg;
616 if (ptid_get_pid (thread->ptid) == pid
617 && is_running (thread->ptid)
618 && !is_executing (thread->ptid)
619 && !thread->stop_requested
620 && thread->suspend.stop_signal == GDB_SIGNAL_0)
623 fprintf_unfiltered (gdb_stdlog,
624 "infrun: resuming vfork parent thread %s\n",
625 target_pid_to_str (thread->ptid));
627 switch_to_thread (thread->ptid);
628 clear_proceed_status ();
629 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
635 /* Called whenever we notice an exec or exit event, to handle
636 detaching or resuming a vfork parent. */
639 handle_vfork_child_exec_or_exit (int exec)
641 struct inferior *inf = current_inferior ();
643 if (inf->vfork_parent)
645 int resume_parent = -1;
647 /* This exec or exit marks the end of the shared memory region
648 between the parent and the child. If the user wanted to
649 detach from the parent, now is the time. */
651 if (inf->vfork_parent->pending_detach)
653 struct thread_info *tp;
654 struct cleanup *old_chain;
655 struct program_space *pspace;
656 struct address_space *aspace;
658 /* follow-fork child, detach-on-fork on. */
660 inf->vfork_parent->pending_detach = 0;
664 /* If we're handling a child exit, then inferior_ptid
665 points at the inferior's pid, not to a thread. */
666 old_chain = save_inferior_ptid ();
667 save_current_program_space ();
668 save_current_inferior ();
671 old_chain = save_current_space_and_thread ();
673 /* We're letting loose of the parent. */
674 tp = any_live_thread_of_process (inf->vfork_parent->pid);
675 switch_to_thread (tp->ptid);
677 /* We're about to detach from the parent, which implicitly
678 removes breakpoints from its address space. There's a
679 catch here: we want to reuse the spaces for the child,
680 but, parent/child are still sharing the pspace at this
681 point, although the exec in reality makes the kernel give
682 the child a fresh set of new pages. The problem here is
683 that the breakpoints module being unaware of this, would
684 likely chose the child process to write to the parent
685 address space. Swapping the child temporarily away from
686 the spaces has the desired effect. Yes, this is "sort
689 pspace = inf->pspace;
690 aspace = inf->aspace;
694 if (debug_infrun || info_verbose)
696 target_terminal_ours ();
699 fprintf_filtered (gdb_stdlog,
700 "Detaching vfork parent process "
701 "%d after child exec.\n",
702 inf->vfork_parent->pid);
704 fprintf_filtered (gdb_stdlog,
705 "Detaching vfork parent process "
706 "%d after child exit.\n",
707 inf->vfork_parent->pid);
710 target_detach (NULL, 0);
713 inf->pspace = pspace;
714 inf->aspace = aspace;
716 do_cleanups (old_chain);
720 /* We're staying attached to the parent, so, really give the
721 child a new address space. */
722 inf->pspace = add_program_space (maybe_new_address_space ());
723 inf->aspace = inf->pspace->aspace;
725 set_current_program_space (inf->pspace);
727 resume_parent = inf->vfork_parent->pid;
729 /* Break the bonds. */
730 inf->vfork_parent->vfork_child = NULL;
734 struct cleanup *old_chain;
735 struct program_space *pspace;
737 /* If this is a vfork child exiting, then the pspace and
738 aspaces were shared with the parent. Since we're
739 reporting the process exit, we'll be mourning all that is
740 found in the address space, and switching to null_ptid,
741 preparing to start a new inferior. But, since we don't
742 want to clobber the parent's address/program spaces, we
743 go ahead and create a new one for this exiting
746 /* Switch to null_ptid, so that clone_program_space doesn't want
747 to read the selected frame of a dead process. */
748 old_chain = save_inferior_ptid ();
749 inferior_ptid = null_ptid;
751 /* This inferior is dead, so avoid giving the breakpoints
752 module the option to write through to it (cloning a
753 program space resets breakpoints). */
756 pspace = add_program_space (maybe_new_address_space ());
757 set_current_program_space (pspace);
759 inf->symfile_flags = SYMFILE_NO_READ;
760 clone_program_space (pspace, inf->vfork_parent->pspace);
761 inf->pspace = pspace;
762 inf->aspace = pspace->aspace;
764 /* Put back inferior_ptid. We'll continue mourning this
766 do_cleanups (old_chain);
768 resume_parent = inf->vfork_parent->pid;
769 /* Break the bonds. */
770 inf->vfork_parent->vfork_child = NULL;
773 inf->vfork_parent = NULL;
775 gdb_assert (current_program_space == inf->pspace);
777 if (non_stop && resume_parent != -1)
779 /* If the user wanted the parent to be running, let it go
781 struct cleanup *old_chain = make_cleanup_restore_current_thread ();
784 fprintf_unfiltered (gdb_stdlog,
785 "infrun: resuming vfork parent process %d\n",
788 iterate_over_threads (proceed_after_vfork_done, &resume_parent);
790 do_cleanups (old_chain);
795 /* Enum strings for "set|show follow-exec-mode". */
797 static const char follow_exec_mode_new[] = "new";
798 static const char follow_exec_mode_same[] = "same";
799 static const char *const follow_exec_mode_names[] =
801 follow_exec_mode_new,
802 follow_exec_mode_same,
806 static const char *follow_exec_mode_string = follow_exec_mode_same;
808 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
809 struct cmd_list_element *c, const char *value)
811 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
814 /* EXECD_PATHNAME is assumed to be non-NULL. */
817 follow_exec (ptid_t pid, char *execd_pathname)
819 struct thread_info *th = inferior_thread ();
820 struct inferior *inf = current_inferior ();
822 /* This is an exec event that we actually wish to pay attention to.
823 Refresh our symbol table to the newly exec'd program, remove any
826 If there are breakpoints, they aren't really inserted now,
827 since the exec() transformed our inferior into a fresh set
830 We want to preserve symbolic breakpoints on the list, since
831 we have hopes that they can be reset after the new a.out's
832 symbol table is read.
834 However, any "raw" breakpoints must be removed from the list
835 (e.g., the solib bp's), since their address is probably invalid
838 And, we DON'T want to call delete_breakpoints() here, since
839 that may write the bp's "shadow contents" (the instruction
840 value that was overwritten witha TRAP instruction). Since
841 we now have a new a.out, those shadow contents aren't valid. */
843 mark_breakpoints_out ();
845 update_breakpoints_after_exec ();
847 /* If there was one, it's gone now. We cannot truly step-to-next
848 statement through an exec(). */
849 th->control.step_resume_breakpoint = NULL;
850 th->control.exception_resume_breakpoint = NULL;
851 th->control.step_range_start = 0;
852 th->control.step_range_end = 0;
854 /* The target reports the exec event to the main thread, even if
855 some other thread does the exec, and even if the main thread was
856 already stopped --- if debugging in non-stop mode, it's possible
857 the user had the main thread held stopped in the previous image
858 --- release it now. This is the same behavior as step-over-exec
859 with scheduler-locking on in all-stop mode. */
860 th->stop_requested = 0;
862 /* What is this a.out's name? */
863 printf_unfiltered (_("%s is executing new program: %s\n"),
864 target_pid_to_str (inferior_ptid),
867 /* We've followed the inferior through an exec. Therefore, the
868 inferior has essentially been killed & reborn. */
870 gdb_flush (gdb_stdout);
872 breakpoint_init_inferior (inf_execd);
874 if (gdb_sysroot && *gdb_sysroot)
876 char *name = alloca (strlen (gdb_sysroot)
877 + strlen (execd_pathname)
880 strcpy (name, gdb_sysroot);
881 strcat (name, execd_pathname);
882 execd_pathname = name;
885 /* Reset the shared library package. This ensures that we get a
886 shlib event when the child reaches "_start", at which point the
887 dld will have had a chance to initialize the child. */
888 /* Also, loading a symbol file below may trigger symbol lookups, and
889 we don't want those to be satisfied by the libraries of the
890 previous incarnation of this process. */
891 no_shared_libraries (NULL, 0);
893 if (follow_exec_mode_string == follow_exec_mode_new)
895 struct program_space *pspace;
897 /* The user wants to keep the old inferior and program spaces
898 around. Create a new fresh one, and switch to it. */
900 inf = add_inferior (current_inferior ()->pid);
901 pspace = add_program_space (maybe_new_address_space ());
902 inf->pspace = pspace;
903 inf->aspace = pspace->aspace;
905 exit_inferior_num_silent (current_inferior ()->num);
907 set_current_inferior (inf);
908 set_current_program_space (pspace);
912 /* The old description may no longer be fit for the new image.
913 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
914 old description; we'll read a new one below. No need to do
915 this on "follow-exec-mode new", as the old inferior stays
916 around (its description is later cleared/refetched on
918 target_clear_description ();
921 gdb_assert (current_program_space == inf->pspace);
923 /* That a.out is now the one to use. */
924 exec_file_attach (execd_pathname, 0);
926 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
927 (Position Independent Executable) main symbol file will get applied by
928 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
929 the breakpoints with the zero displacement. */
931 symbol_file_add (execd_pathname,
933 | SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET),
936 if ((inf->symfile_flags & SYMFILE_NO_READ) == 0)
937 set_initial_language ();
939 /* If the target can specify a description, read it. Must do this
940 after flipping to the new executable (because the target supplied
941 description must be compatible with the executable's
942 architecture, and the old executable may e.g., be 32-bit, while
943 the new one 64-bit), and before anything involving memory or
945 target_find_description ();
947 solib_create_inferior_hook (0);
949 jit_inferior_created_hook ();
951 breakpoint_re_set ();
953 /* Reinsert all breakpoints. (Those which were symbolic have
954 been reset to the proper address in the new a.out, thanks
955 to symbol_file_command...). */
956 insert_breakpoints ();
958 /* The next resume of this inferior should bring it to the shlib
959 startup breakpoints. (If the user had also set bp's on
960 "main" from the old (parent) process, then they'll auto-
961 matically get reset there in the new process.). */
964 /* Non-zero if we just simulating a single-step. This is needed
965 because we cannot remove the breakpoints in the inferior process
966 until after the `wait' in `wait_for_inferior'. */
967 static int singlestep_breakpoints_inserted_p = 0;
969 /* The thread we inserted single-step breakpoints for. */
970 static ptid_t singlestep_ptid;
972 /* PC when we started this single-step. */
973 static CORE_ADDR singlestep_pc;
975 /* If another thread hit the singlestep breakpoint, we save the original
976 thread here so that we can resume single-stepping it later. */
977 static ptid_t saved_singlestep_ptid;
978 static int stepping_past_singlestep_breakpoint;
981 /* Displaced stepping. */
983 /* In non-stop debugging mode, we must take special care to manage
984 breakpoints properly; in particular, the traditional strategy for
985 stepping a thread past a breakpoint it has hit is unsuitable.
986 'Displaced stepping' is a tactic for stepping one thread past a
987 breakpoint it has hit while ensuring that other threads running
988 concurrently will hit the breakpoint as they should.
990 The traditional way to step a thread T off a breakpoint in a
991 multi-threaded program in all-stop mode is as follows:
993 a0) Initially, all threads are stopped, and breakpoints are not
995 a1) We single-step T, leaving breakpoints uninserted.
996 a2) We insert breakpoints, and resume all threads.
998 In non-stop debugging, however, this strategy is unsuitable: we
999 don't want to have to stop all threads in the system in order to
1000 continue or step T past a breakpoint. Instead, we use displaced
1003 n0) Initially, T is stopped, other threads are running, and
1004 breakpoints are inserted.
1005 n1) We copy the instruction "under" the breakpoint to a separate
1006 location, outside the main code stream, making any adjustments
1007 to the instruction, register, and memory state as directed by
1009 n2) We single-step T over the instruction at its new location.
1010 n3) We adjust the resulting register and memory state as directed
1011 by T's architecture. This includes resetting T's PC to point
1012 back into the main instruction stream.
1015 This approach depends on the following gdbarch methods:
1017 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1018 indicate where to copy the instruction, and how much space must
1019 be reserved there. We use these in step n1.
1021 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1022 address, and makes any necessary adjustments to the instruction,
1023 register contents, and memory. We use this in step n1.
1025 - gdbarch_displaced_step_fixup adjusts registers and memory after
1026 we have successfuly single-stepped the instruction, to yield the
1027 same effect the instruction would have had if we had executed it
1028 at its original address. We use this in step n3.
1030 - gdbarch_displaced_step_free_closure provides cleanup.
1032 The gdbarch_displaced_step_copy_insn and
1033 gdbarch_displaced_step_fixup functions must be written so that
1034 copying an instruction with gdbarch_displaced_step_copy_insn,
1035 single-stepping across the copied instruction, and then applying
1036 gdbarch_displaced_insn_fixup should have the same effects on the
1037 thread's memory and registers as stepping the instruction in place
1038 would have. Exactly which responsibilities fall to the copy and
1039 which fall to the fixup is up to the author of those functions.
1041 See the comments in gdbarch.sh for details.
1043 Note that displaced stepping and software single-step cannot
1044 currently be used in combination, although with some care I think
1045 they could be made to. Software single-step works by placing
1046 breakpoints on all possible subsequent instructions; if the
1047 displaced instruction is a PC-relative jump, those breakpoints
1048 could fall in very strange places --- on pages that aren't
1049 executable, or at addresses that are not proper instruction
1050 boundaries. (We do generally let other threads run while we wait
1051 to hit the software single-step breakpoint, and they might
1052 encounter such a corrupted instruction.) One way to work around
1053 this would be to have gdbarch_displaced_step_copy_insn fully
1054 simulate the effect of PC-relative instructions (and return NULL)
1055 on architectures that use software single-stepping.
1057 In non-stop mode, we can have independent and simultaneous step
1058 requests, so more than one thread may need to simultaneously step
1059 over a breakpoint. The current implementation assumes there is
1060 only one scratch space per process. In this case, we have to
1061 serialize access to the scratch space. If thread A wants to step
1062 over a breakpoint, but we are currently waiting for some other
1063 thread to complete a displaced step, we leave thread A stopped and
1064 place it in the displaced_step_request_queue. Whenever a displaced
1065 step finishes, we pick the next thread in the queue and start a new
1066 displaced step operation on it. See displaced_step_prepare and
1067 displaced_step_fixup for details. */
1069 struct displaced_step_request
1072 struct displaced_step_request *next;
1075 /* Per-inferior displaced stepping state. */
1076 struct displaced_step_inferior_state
1078 /* Pointer to next in linked list. */
1079 struct displaced_step_inferior_state *next;
1081 /* The process this displaced step state refers to. */
1084 /* A queue of pending displaced stepping requests. One entry per
1085 thread that needs to do a displaced step. */
1086 struct displaced_step_request *step_request_queue;
1088 /* If this is not null_ptid, this is the thread carrying out a
1089 displaced single-step in process PID. This thread's state will
1090 require fixing up once it has completed its step. */
1093 /* The architecture the thread had when we stepped it. */
1094 struct gdbarch *step_gdbarch;
1096 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1097 for post-step cleanup. */
1098 struct displaced_step_closure *step_closure;
1100 /* The address of the original instruction, and the copy we
1102 CORE_ADDR step_original, step_copy;
1104 /* Saved contents of copy area. */
1105 gdb_byte *step_saved_copy;
1108 /* The list of states of processes involved in displaced stepping
1110 static struct displaced_step_inferior_state *displaced_step_inferior_states;
1112 /* Get the displaced stepping state of process PID. */
1114 static struct displaced_step_inferior_state *
1115 get_displaced_stepping_state (int pid)
1117 struct displaced_step_inferior_state *state;
1119 for (state = displaced_step_inferior_states;
1121 state = state->next)
1122 if (state->pid == pid)
1128 /* Add a new displaced stepping state for process PID to the displaced
1129 stepping state list, or return a pointer to an already existing
1130 entry, if it already exists. Never returns NULL. */
1132 static struct displaced_step_inferior_state *
1133 add_displaced_stepping_state (int pid)
1135 struct displaced_step_inferior_state *state;
1137 for (state = displaced_step_inferior_states;
1139 state = state->next)
1140 if (state->pid == pid)
1143 state = xcalloc (1, sizeof (*state));
1145 state->next = displaced_step_inferior_states;
1146 displaced_step_inferior_states = state;
1151 /* If inferior is in displaced stepping, and ADDR equals to starting address
1152 of copy area, return corresponding displaced_step_closure. Otherwise,
1155 struct displaced_step_closure*
1156 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1158 struct displaced_step_inferior_state *displaced
1159 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1161 /* If checking the mode of displaced instruction in copy area. */
1162 if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1163 && (displaced->step_copy == addr))
1164 return displaced->step_closure;
1169 /* Remove the displaced stepping state of process PID. */
1172 remove_displaced_stepping_state (int pid)
1174 struct displaced_step_inferior_state *it, **prev_next_p;
1176 gdb_assert (pid != 0);
1178 it = displaced_step_inferior_states;
1179 prev_next_p = &displaced_step_inferior_states;
1184 *prev_next_p = it->next;
1189 prev_next_p = &it->next;
1195 infrun_inferior_exit (struct inferior *inf)
1197 remove_displaced_stepping_state (inf->pid);
1200 /* If ON, and the architecture supports it, GDB will use displaced
1201 stepping to step over breakpoints. If OFF, or if the architecture
1202 doesn't support it, GDB will instead use the traditional
1203 hold-and-step approach. If AUTO (which is the default), GDB will
1204 decide which technique to use to step over breakpoints depending on
1205 which of all-stop or non-stop mode is active --- displaced stepping
1206 in non-stop mode; hold-and-step in all-stop mode. */
1208 static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
1211 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1212 struct cmd_list_element *c,
1215 if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1216 fprintf_filtered (file,
1217 _("Debugger's willingness to use displaced stepping "
1218 "to step over breakpoints is %s (currently %s).\n"),
1219 value, non_stop ? "on" : "off");
1221 fprintf_filtered (file,
1222 _("Debugger's willingness to use displaced stepping "
1223 "to step over breakpoints is %s.\n"), value);
1226 /* Return non-zero if displaced stepping can/should be used to step
1227 over breakpoints. */
1230 use_displaced_stepping (struct gdbarch *gdbarch)
1232 return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO && non_stop)
1233 || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1234 && gdbarch_displaced_step_copy_insn_p (gdbarch)
1235 && find_record_target () == NULL);
1238 /* Clean out any stray displaced stepping state. */
1240 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1242 /* Indicate that there is no cleanup pending. */
1243 displaced->step_ptid = null_ptid;
1245 if (displaced->step_closure)
1247 gdbarch_displaced_step_free_closure (displaced->step_gdbarch,
1248 displaced->step_closure);
1249 displaced->step_closure = NULL;
1254 displaced_step_clear_cleanup (void *arg)
1256 struct displaced_step_inferior_state *state = arg;
1258 displaced_step_clear (state);
1261 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1263 displaced_step_dump_bytes (struct ui_file *file,
1264 const gdb_byte *buf,
1269 for (i = 0; i < len; i++)
1270 fprintf_unfiltered (file, "%02x ", buf[i]);
1271 fputs_unfiltered ("\n", file);
1274 /* Prepare to single-step, using displaced stepping.
1276 Note that we cannot use displaced stepping when we have a signal to
1277 deliver. If we have a signal to deliver and an instruction to step
1278 over, then after the step, there will be no indication from the
1279 target whether the thread entered a signal handler or ignored the
1280 signal and stepped over the instruction successfully --- both cases
1281 result in a simple SIGTRAP. In the first case we mustn't do a
1282 fixup, and in the second case we must --- but we can't tell which.
1283 Comments in the code for 'random signals' in handle_inferior_event
1284 explain how we handle this case instead.
1286 Returns 1 if preparing was successful -- this thread is going to be
1287 stepped now; or 0 if displaced stepping this thread got queued. */
1289 displaced_step_prepare (ptid_t ptid)
1291 struct cleanup *old_cleanups, *ignore_cleanups;
1292 struct thread_info *tp = find_thread_ptid (ptid);
1293 struct regcache *regcache = get_thread_regcache (ptid);
1294 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1295 CORE_ADDR original, copy;
1297 struct displaced_step_closure *closure;
1298 struct displaced_step_inferior_state *displaced;
1301 /* We should never reach this function if the architecture does not
1302 support displaced stepping. */
1303 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1305 /* Disable range stepping while executing in the scratch pad. We
1306 want a single-step even if executing the displaced instruction in
1307 the scratch buffer lands within the stepping range (e.g., a
1309 tp->control.may_range_step = 0;
1311 /* We have to displaced step one thread at a time, as we only have
1312 access to a single scratch space per inferior. */
1314 displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1316 if (!ptid_equal (displaced->step_ptid, null_ptid))
1318 /* Already waiting for a displaced step to finish. Defer this
1319 request and place in queue. */
1320 struct displaced_step_request *req, *new_req;
1322 if (debug_displaced)
1323 fprintf_unfiltered (gdb_stdlog,
1324 "displaced: defering step of %s\n",
1325 target_pid_to_str (ptid));
1327 new_req = xmalloc (sizeof (*new_req));
1328 new_req->ptid = ptid;
1329 new_req->next = NULL;
1331 if (displaced->step_request_queue)
1333 for (req = displaced->step_request_queue;
1337 req->next = new_req;
1340 displaced->step_request_queue = new_req;
1346 if (debug_displaced)
1347 fprintf_unfiltered (gdb_stdlog,
1348 "displaced: stepping %s now\n",
1349 target_pid_to_str (ptid));
1352 displaced_step_clear (displaced);
1354 old_cleanups = save_inferior_ptid ();
1355 inferior_ptid = ptid;
1357 original = regcache_read_pc (regcache);
1359 copy = gdbarch_displaced_step_location (gdbarch);
1360 len = gdbarch_max_insn_length (gdbarch);
1362 /* Save the original contents of the copy area. */
1363 displaced->step_saved_copy = xmalloc (len);
1364 ignore_cleanups = make_cleanup (free_current_contents,
1365 &displaced->step_saved_copy);
1366 status = target_read_memory (copy, displaced->step_saved_copy, len);
1368 throw_error (MEMORY_ERROR,
1369 _("Error accessing memory address %s (%s) for "
1370 "displaced-stepping scratch space."),
1371 paddress (gdbarch, copy), safe_strerror (status));
1372 if (debug_displaced)
1374 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1375 paddress (gdbarch, copy));
1376 displaced_step_dump_bytes (gdb_stdlog,
1377 displaced->step_saved_copy,
1381 closure = gdbarch_displaced_step_copy_insn (gdbarch,
1382 original, copy, regcache);
1384 /* We don't support the fully-simulated case at present. */
1385 gdb_assert (closure);
1387 /* Save the information we need to fix things up if the step
1389 displaced->step_ptid = ptid;
1390 displaced->step_gdbarch = gdbarch;
1391 displaced->step_closure = closure;
1392 displaced->step_original = original;
1393 displaced->step_copy = copy;
1395 make_cleanup (displaced_step_clear_cleanup, displaced);
1397 /* Resume execution at the copy. */
1398 regcache_write_pc (regcache, copy);
1400 discard_cleanups (ignore_cleanups);
1402 do_cleanups (old_cleanups);
1404 if (debug_displaced)
1405 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1406 paddress (gdbarch, copy));
1412 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1413 const gdb_byte *myaddr, int len)
1415 struct cleanup *ptid_cleanup = save_inferior_ptid ();
1417 inferior_ptid = ptid;
1418 write_memory (memaddr, myaddr, len);
1419 do_cleanups (ptid_cleanup);
1422 /* Restore the contents of the copy area for thread PTID. */
1425 displaced_step_restore (struct displaced_step_inferior_state *displaced,
1428 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1430 write_memory_ptid (ptid, displaced->step_copy,
1431 displaced->step_saved_copy, len);
1432 if (debug_displaced)
1433 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1434 target_pid_to_str (ptid),
1435 paddress (displaced->step_gdbarch,
1436 displaced->step_copy));
1440 displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
1442 struct cleanup *old_cleanups;
1443 struct displaced_step_inferior_state *displaced
1444 = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1446 /* Was any thread of this process doing a displaced step? */
1447 if (displaced == NULL)
1450 /* Was this event for the pid we displaced? */
1451 if (ptid_equal (displaced->step_ptid, null_ptid)
1452 || ! ptid_equal (displaced->step_ptid, event_ptid))
1455 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1457 displaced_step_restore (displaced, displaced->step_ptid);
1459 /* Did the instruction complete successfully? */
1460 if (signal == GDB_SIGNAL_TRAP)
1462 /* Fix up the resulting state. */
1463 gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1464 displaced->step_closure,
1465 displaced->step_original,
1466 displaced->step_copy,
1467 get_thread_regcache (displaced->step_ptid));
1471 /* Since the instruction didn't complete, all we can do is
1473 struct regcache *regcache = get_thread_regcache (event_ptid);
1474 CORE_ADDR pc = regcache_read_pc (regcache);
1476 pc = displaced->step_original + (pc - displaced->step_copy);
1477 regcache_write_pc (regcache, pc);
1480 do_cleanups (old_cleanups);
1482 displaced->step_ptid = null_ptid;
1484 /* Are there any pending displaced stepping requests? If so, run
1485 one now. Leave the state object around, since we're likely to
1486 need it again soon. */
1487 while (displaced->step_request_queue)
1489 struct displaced_step_request *head;
1491 struct regcache *regcache;
1492 struct gdbarch *gdbarch;
1493 CORE_ADDR actual_pc;
1494 struct address_space *aspace;
1496 head = displaced->step_request_queue;
1498 displaced->step_request_queue = head->next;
1501 context_switch (ptid);
1503 regcache = get_thread_regcache (ptid);
1504 actual_pc = regcache_read_pc (regcache);
1505 aspace = get_regcache_aspace (regcache);
1507 if (breakpoint_here_p (aspace, actual_pc))
1509 if (debug_displaced)
1510 fprintf_unfiltered (gdb_stdlog,
1511 "displaced: stepping queued %s now\n",
1512 target_pid_to_str (ptid));
1514 displaced_step_prepare (ptid);
1516 gdbarch = get_regcache_arch (regcache);
1518 if (debug_displaced)
1520 CORE_ADDR actual_pc = regcache_read_pc (regcache);
1523 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1524 paddress (gdbarch, actual_pc));
1525 read_memory (actual_pc, buf, sizeof (buf));
1526 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1529 if (gdbarch_displaced_step_hw_singlestep (gdbarch,
1530 displaced->step_closure))
1531 target_resume (ptid, 1, GDB_SIGNAL_0);
1533 target_resume (ptid, 0, GDB_SIGNAL_0);
1535 /* Done, we're stepping a thread. */
1541 struct thread_info *tp = inferior_thread ();
1543 /* The breakpoint we were sitting under has since been
1545 tp->control.trap_expected = 0;
1547 /* Go back to what we were trying to do. */
1548 step = currently_stepping (tp);
1550 if (debug_displaced)
1551 fprintf_unfiltered (gdb_stdlog,
1552 "displaced: breakpoint is gone: %s, step(%d)\n",
1553 target_pid_to_str (tp->ptid), step);
1555 target_resume (ptid, step, GDB_SIGNAL_0);
1556 tp->suspend.stop_signal = GDB_SIGNAL_0;
1558 /* This request was discarded. See if there's any other
1559 thread waiting for its turn. */
1564 /* Update global variables holding ptids to hold NEW_PTID if they were
1565 holding OLD_PTID. */
1567 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
1569 struct displaced_step_request *it;
1570 struct displaced_step_inferior_state *displaced;
1572 if (ptid_equal (inferior_ptid, old_ptid))
1573 inferior_ptid = new_ptid;
1575 if (ptid_equal (singlestep_ptid, old_ptid))
1576 singlestep_ptid = new_ptid;
1578 for (displaced = displaced_step_inferior_states;
1580 displaced = displaced->next)
1582 if (ptid_equal (displaced->step_ptid, old_ptid))
1583 displaced->step_ptid = new_ptid;
1585 for (it = displaced->step_request_queue; it; it = it->next)
1586 if (ptid_equal (it->ptid, old_ptid))
1587 it->ptid = new_ptid;
1594 /* Things to clean up if we QUIT out of resume (). */
1596 resume_cleanups (void *ignore)
1601 static const char schedlock_off[] = "off";
1602 static const char schedlock_on[] = "on";
1603 static const char schedlock_step[] = "step";
1604 static const char *const scheduler_enums[] = {
1610 static const char *scheduler_mode = schedlock_off;
1612 show_scheduler_mode (struct ui_file *file, int from_tty,
1613 struct cmd_list_element *c, const char *value)
1615 fprintf_filtered (file,
1616 _("Mode for locking scheduler "
1617 "during execution is \"%s\".\n"),
1622 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
1624 if (!target_can_lock_scheduler)
1626 scheduler_mode = schedlock_off;
1627 error (_("Target '%s' cannot support this command."), target_shortname);
1631 /* True if execution commands resume all threads of all processes by
1632 default; otherwise, resume only threads of the current inferior
1634 int sched_multi = 0;
1636 /* Try to setup for software single stepping over the specified location.
1637 Return 1 if target_resume() should use hardware single step.
1639 GDBARCH the current gdbarch.
1640 PC the location to step over. */
1643 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
1647 if (execution_direction == EXEC_FORWARD
1648 && gdbarch_software_single_step_p (gdbarch)
1649 && gdbarch_software_single_step (gdbarch, get_current_frame ()))
1652 /* Do not pull these breakpoints until after a `wait' in
1653 `wait_for_inferior'. */
1654 singlestep_breakpoints_inserted_p = 1;
1655 singlestep_ptid = inferior_ptid;
1661 /* Return a ptid representing the set of threads that we will proceed,
1662 in the perspective of the user/frontend. We may actually resume
1663 fewer threads at first, e.g., if a thread is stopped at a
1664 breakpoint that needs stepping-off, but that should not be visible
1665 to the user/frontend, and neither should the frontend/user be
1666 allowed to proceed any of the threads that happen to be stopped for
1667 internal run control handling, if a previous command wanted them
1671 user_visible_resume_ptid (int step)
1673 /* By default, resume all threads of all processes. */
1674 ptid_t resume_ptid = RESUME_ALL;
1676 /* Maybe resume only all threads of the current process. */
1677 if (!sched_multi && target_supports_multi_process ())
1679 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1682 /* Maybe resume a single thread after all. */
1685 /* With non-stop mode on, threads are always handled
1687 resume_ptid = inferior_ptid;
1689 else if ((scheduler_mode == schedlock_on)
1690 || (scheduler_mode == schedlock_step
1691 && (step || singlestep_breakpoints_inserted_p)))
1693 /* User-settable 'scheduler' mode requires solo thread resume. */
1694 resume_ptid = inferior_ptid;
1700 /* Resume the inferior, but allow a QUIT. This is useful if the user
1701 wants to interrupt some lengthy single-stepping operation
1702 (for child processes, the SIGINT goes to the inferior, and so
1703 we get a SIGINT random_signal, but for remote debugging and perhaps
1704 other targets, that's not true).
1706 STEP nonzero if we should step (zero to continue instead).
1707 SIG is the signal to give the inferior (zero for none). */
1709 resume (int step, enum gdb_signal sig)
1711 int should_resume = 1;
1712 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
1713 struct regcache *regcache = get_current_regcache ();
1714 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1715 struct thread_info *tp = inferior_thread ();
1716 CORE_ADDR pc = regcache_read_pc (regcache);
1717 struct address_space *aspace = get_regcache_aspace (regcache);
1721 if (current_inferior ()->waiting_for_vfork_done)
1723 /* Don't try to single-step a vfork parent that is waiting for
1724 the child to get out of the shared memory region (by exec'ing
1725 or exiting). This is particularly important on software
1726 single-step archs, as the child process would trip on the
1727 software single step breakpoint inserted for the parent
1728 process. Since the parent will not actually execute any
1729 instruction until the child is out of the shared region (such
1730 are vfork's semantics), it is safe to simply continue it.
1731 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
1732 the parent, and tell it to `keep_going', which automatically
1733 re-sets it stepping. */
1735 fprintf_unfiltered (gdb_stdlog,
1736 "infrun: resume : clear step\n");
1741 fprintf_unfiltered (gdb_stdlog,
1742 "infrun: resume (step=%d, signal=%s), "
1743 "trap_expected=%d, current thread [%s] at %s\n",
1744 step, gdb_signal_to_symbol_string (sig),
1745 tp->control.trap_expected,
1746 target_pid_to_str (inferior_ptid),
1747 paddress (gdbarch, pc));
1749 /* Normally, by the time we reach `resume', the breakpoints are either
1750 removed or inserted, as appropriate. The exception is if we're sitting
1751 at a permanent breakpoint; we need to step over it, but permanent
1752 breakpoints can't be removed. So we have to test for it here. */
1753 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
1755 if (gdbarch_skip_permanent_breakpoint_p (gdbarch))
1756 gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
1759 The program is stopped at a permanent breakpoint, but GDB does not know\n\
1760 how to step past a permanent breakpoint on this architecture. Try using\n\
1761 a command like `return' or `jump' to continue execution."));
1764 /* If we have a breakpoint to step over, make sure to do a single
1765 step only. Same if we have software watchpoints. */
1766 if (tp->control.trap_expected || bpstat_should_step ())
1767 tp->control.may_range_step = 0;
1769 /* If enabled, step over breakpoints by executing a copy of the
1770 instruction at a different address.
1772 We can't use displaced stepping when we have a signal to deliver;
1773 the comments for displaced_step_prepare explain why. The
1774 comments in the handle_inferior event for dealing with 'random
1775 signals' explain what we do instead.
1777 We can't use displaced stepping when we are waiting for vfork_done
1778 event, displaced stepping breaks the vfork child similarly as single
1779 step software breakpoint. */
1780 if (use_displaced_stepping (gdbarch)
1781 && (tp->control.trap_expected
1782 || (step && gdbarch_software_single_step_p (gdbarch)))
1783 && sig == GDB_SIGNAL_0
1784 && !current_inferior ()->waiting_for_vfork_done)
1786 struct displaced_step_inferior_state *displaced;
1788 if (!displaced_step_prepare (inferior_ptid))
1790 /* Got placed in displaced stepping queue. Will be resumed
1791 later when all the currently queued displaced stepping
1792 requests finish. The thread is not executing at this point,
1793 and the call to set_executing will be made later. But we
1794 need to call set_running here, since from frontend point of view,
1795 the thread is running. */
1796 set_running (inferior_ptid, 1);
1797 discard_cleanups (old_cleanups);
1801 /* Update pc to reflect the new address from which we will execute
1802 instructions due to displaced stepping. */
1803 pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
1805 displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1806 step = gdbarch_displaced_step_hw_singlestep (gdbarch,
1807 displaced->step_closure);
1810 /* Do we need to do it the hard way, w/temp breakpoints? */
1812 step = maybe_software_singlestep (gdbarch, pc);
1814 /* Currently, our software single-step implementation leads to different
1815 results than hardware single-stepping in one situation: when stepping
1816 into delivering a signal which has an associated signal handler,
1817 hardware single-step will stop at the first instruction of the handler,
1818 while software single-step will simply skip execution of the handler.
1820 For now, this difference in behavior is accepted since there is no
1821 easy way to actually implement single-stepping into a signal handler
1822 without kernel support.
1824 However, there is one scenario where this difference leads to follow-on
1825 problems: if we're stepping off a breakpoint by removing all breakpoints
1826 and then single-stepping. In this case, the software single-step
1827 behavior means that even if there is a *breakpoint* in the signal
1828 handler, GDB still would not stop.
1830 Fortunately, we can at least fix this particular issue. We detect
1831 here the case where we are about to deliver a signal while software
1832 single-stepping with breakpoints removed. In this situation, we
1833 revert the decisions to remove all breakpoints and insert single-
1834 step breakpoints, and instead we install a step-resume breakpoint
1835 at the current address, deliver the signal without stepping, and
1836 once we arrive back at the step-resume breakpoint, actually step
1837 over the breakpoint we originally wanted to step over. */
1838 if (singlestep_breakpoints_inserted_p
1839 && tp->control.trap_expected && sig != GDB_SIGNAL_0)
1841 /* If we have nested signals or a pending signal is delivered
1842 immediately after a handler returns, might might already have
1843 a step-resume breakpoint set on the earlier handler. We cannot
1844 set another step-resume breakpoint; just continue on until the
1845 original breakpoint is hit. */
1846 if (tp->control.step_resume_breakpoint == NULL)
1848 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
1849 tp->step_after_step_resume_breakpoint = 1;
1852 remove_single_step_breakpoints ();
1853 singlestep_breakpoints_inserted_p = 0;
1855 insert_breakpoints ();
1856 tp->control.trap_expected = 0;
1863 /* If STEP is set, it's a request to use hardware stepping
1864 facilities. But in that case, we should never
1865 use singlestep breakpoint. */
1866 gdb_assert (!(singlestep_breakpoints_inserted_p && step));
1868 /* Decide the set of threads to ask the target to resume. Start
1869 by assuming everything will be resumed, than narrow the set
1870 by applying increasingly restricting conditions. */
1871 resume_ptid = user_visible_resume_ptid (step);
1873 /* Maybe resume a single thread after all. */
1874 if (singlestep_breakpoints_inserted_p
1875 && stepping_past_singlestep_breakpoint)
1877 /* The situation here is as follows. In thread T1 we wanted to
1878 single-step. Lacking hardware single-stepping we've
1879 set breakpoint at the PC of the next instruction -- call it
1880 P. After resuming, we've hit that breakpoint in thread T2.
1881 Now we've removed original breakpoint, inserted breakpoint
1882 at P+1, and try to step to advance T2 past breakpoint.
1883 We need to step only T2, as if T1 is allowed to freely run,
1884 it can run past P, and if other threads are allowed to run,
1885 they can hit breakpoint at P+1, and nested hits of single-step
1886 breakpoints is not something we'd want -- that's complicated
1887 to support, and has no value. */
1888 resume_ptid = inferior_ptid;
1890 else if ((step || singlestep_breakpoints_inserted_p)
1891 && tp->control.trap_expected)
1893 /* We're allowing a thread to run past a breakpoint it has
1894 hit, by single-stepping the thread with the breakpoint
1895 removed. In which case, we need to single-step only this
1896 thread, and keep others stopped, as they can miss this
1897 breakpoint if allowed to run.
1899 The current code actually removes all breakpoints when
1900 doing this, not just the one being stepped over, so if we
1901 let other threads run, we can actually miss any
1902 breakpoint, not just the one at PC. */
1903 resume_ptid = inferior_ptid;
1906 if (gdbarch_cannot_step_breakpoint (gdbarch))
1908 /* Most targets can step a breakpoint instruction, thus
1909 executing it normally. But if this one cannot, just
1910 continue and we will hit it anyway. */
1911 if (step && breakpoint_inserted_here_p (aspace, pc))
1916 && use_displaced_stepping (gdbarch)
1917 && tp->control.trap_expected)
1919 struct regcache *resume_regcache = get_thread_regcache (resume_ptid);
1920 struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
1921 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
1924 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1925 paddress (resume_gdbarch, actual_pc));
1926 read_memory (actual_pc, buf, sizeof (buf));
1927 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1930 if (tp->control.may_range_step)
1932 /* If we're resuming a thread with the PC out of the step
1933 range, then we're doing some nested/finer run control
1934 operation, like stepping the thread out of the dynamic
1935 linker or the displaced stepping scratch pad. We
1936 shouldn't have allowed a range step then. */
1937 gdb_assert (pc_in_thread_step_range (pc, tp));
1940 /* Install inferior's terminal modes. */
1941 target_terminal_inferior ();
1943 /* Avoid confusing the next resume, if the next stop/resume
1944 happens to apply to another thread. */
1945 tp->suspend.stop_signal = GDB_SIGNAL_0;
1947 /* Advise target which signals may be handled silently. If we have
1948 removed breakpoints because we are stepping over one (which can
1949 happen only if we are not using displaced stepping), we need to
1950 receive all signals to avoid accidentally skipping a breakpoint
1951 during execution of a signal handler. */
1952 if ((step || singlestep_breakpoints_inserted_p)
1953 && tp->control.trap_expected
1954 && !use_displaced_stepping (gdbarch))
1955 target_pass_signals (0, NULL);
1957 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
1959 target_resume (resume_ptid, step, sig);
1962 discard_cleanups (old_cleanups);
1967 /* Clear out all variables saying what to do when inferior is continued.
1968 First do this, then set the ones you want, then call `proceed'. */
1971 clear_proceed_status_thread (struct thread_info *tp)
1974 fprintf_unfiltered (gdb_stdlog,
1975 "infrun: clear_proceed_status_thread (%s)\n",
1976 target_pid_to_str (tp->ptid));
1978 tp->control.trap_expected = 0;
1979 tp->control.step_range_start = 0;
1980 tp->control.step_range_end = 0;
1981 tp->control.may_range_step = 0;
1982 tp->control.step_frame_id = null_frame_id;
1983 tp->control.step_stack_frame_id = null_frame_id;
1984 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
1985 tp->stop_requested = 0;
1987 tp->control.stop_step = 0;
1989 tp->control.proceed_to_finish = 0;
1991 /* Discard any remaining commands or status from previous stop. */
1992 bpstat_clear (&tp->control.stop_bpstat);
1996 clear_proceed_status_callback (struct thread_info *tp, void *data)
1998 if (is_exited (tp->ptid))
2001 clear_proceed_status_thread (tp);
2006 clear_proceed_status (void)
2010 /* In all-stop mode, delete the per-thread status of all
2011 threads, even if inferior_ptid is null_ptid, there may be
2012 threads on the list. E.g., we may be launching a new
2013 process, while selecting the executable. */
2014 iterate_over_threads (clear_proceed_status_callback, NULL);
2017 if (!ptid_equal (inferior_ptid, null_ptid))
2019 struct inferior *inferior;
2023 /* If in non-stop mode, only delete the per-thread status of
2024 the current thread. */
2025 clear_proceed_status_thread (inferior_thread ());
2028 inferior = current_inferior ();
2029 inferior->control.stop_soon = NO_STOP_QUIETLY;
2032 stop_after_trap = 0;
2034 observer_notify_about_to_proceed ();
2038 regcache_xfree (stop_registers);
2039 stop_registers = NULL;
2043 /* Check the current thread against the thread that reported the most recent
2044 event. If a step-over is required return TRUE and set the current thread
2045 to the old thread. Otherwise return FALSE.
2047 This should be suitable for any targets that support threads. */
2050 prepare_to_proceed (int step)
2053 struct target_waitstatus wait_status;
2054 int schedlock_enabled;
2056 /* With non-stop mode on, threads are always handled individually. */
2057 gdb_assert (! non_stop);
2059 /* Get the last target status returned by target_wait(). */
2060 get_last_target_status (&wait_ptid, &wait_status);
2062 /* Make sure we were stopped at a breakpoint. */
2063 if (wait_status.kind != TARGET_WAITKIND_STOPPED
2064 || (wait_status.value.sig != GDB_SIGNAL_TRAP
2065 && wait_status.value.sig != GDB_SIGNAL_ILL
2066 && wait_status.value.sig != GDB_SIGNAL_SEGV
2067 && wait_status.value.sig != GDB_SIGNAL_EMT))
2072 schedlock_enabled = (scheduler_mode == schedlock_on
2073 || (scheduler_mode == schedlock_step
2076 /* Don't switch over to WAIT_PTID if scheduler locking is on. */
2077 if (schedlock_enabled)
2080 /* Don't switch over if we're about to resume some other process
2081 other than WAIT_PTID's, and schedule-multiple is off. */
2083 && ptid_get_pid (wait_ptid) != ptid_get_pid (inferior_ptid))
2086 /* Switched over from WAIT_PID. */
2087 if (!ptid_equal (wait_ptid, minus_one_ptid)
2088 && !ptid_equal (inferior_ptid, wait_ptid))
2090 struct regcache *regcache = get_thread_regcache (wait_ptid);
2092 if (breakpoint_here_p (get_regcache_aspace (regcache),
2093 regcache_read_pc (regcache)))
2095 /* Switch back to WAIT_PID thread. */
2096 switch_to_thread (wait_ptid);
2099 fprintf_unfiltered (gdb_stdlog,
2100 "infrun: prepare_to_proceed (step=%d), "
2101 "switched to [%s]\n",
2102 step, target_pid_to_str (inferior_ptid));
2104 /* We return 1 to indicate that there is a breakpoint here,
2105 so we need to step over it before continuing to avoid
2106 hitting it straight away. */
2114 /* Basic routine for continuing the program in various fashions.
2116 ADDR is the address to resume at, or -1 for resume where stopped.
2117 SIGGNAL is the signal to give it, or 0 for none,
2118 or -1 for act according to how it stopped.
2119 STEP is nonzero if should trap after one instruction.
2120 -1 means return after that and print nothing.
2121 You should probably set various step_... variables
2122 before calling here, if you are stepping.
2124 You should call clear_proceed_status before calling proceed. */
2127 proceed (CORE_ADDR addr, enum gdb_signal siggnal, int step)
2129 struct regcache *regcache;
2130 struct gdbarch *gdbarch;
2131 struct thread_info *tp;
2133 struct address_space *aspace;
2134 /* GDB may force the inferior to step due to various reasons. */
2137 /* If we're stopped at a fork/vfork, follow the branch set by the
2138 "set follow-fork-mode" command; otherwise, we'll just proceed
2139 resuming the current thread. */
2140 if (!follow_fork ())
2142 /* The target for some reason decided not to resume. */
2144 if (target_can_async_p ())
2145 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2149 /* We'll update this if & when we switch to a new thread. */
2150 previous_inferior_ptid = inferior_ptid;
2152 regcache = get_current_regcache ();
2153 gdbarch = get_regcache_arch (regcache);
2154 aspace = get_regcache_aspace (regcache);
2155 pc = regcache_read_pc (regcache);
2158 step_start_function = find_pc_function (pc);
2160 stop_after_trap = 1;
2162 if (addr == (CORE_ADDR) -1)
2164 if (pc == stop_pc && breakpoint_here_p (aspace, pc)
2165 && execution_direction != EXEC_REVERSE)
2166 /* There is a breakpoint at the address we will resume at,
2167 step one instruction before inserting breakpoints so that
2168 we do not stop right away (and report a second hit at this
2171 Note, we don't do this in reverse, because we won't
2172 actually be executing the breakpoint insn anyway.
2173 We'll be (un-)executing the previous instruction. */
2176 else if (gdbarch_single_step_through_delay_p (gdbarch)
2177 && gdbarch_single_step_through_delay (gdbarch,
2178 get_current_frame ()))
2179 /* We stepped onto an instruction that needs to be stepped
2180 again before re-inserting the breakpoint, do so. */
2185 regcache_write_pc (regcache, addr);
2189 fprintf_unfiltered (gdb_stdlog,
2190 "infrun: proceed (addr=%s, signal=%s, step=%d)\n",
2191 paddress (gdbarch, addr),
2192 gdb_signal_to_symbol_string (siggnal), step);
2195 /* In non-stop, each thread is handled individually. The context
2196 must already be set to the right thread here. */
2200 /* In a multi-threaded task we may select another thread and
2201 then continue or step.
2203 But if the old thread was stopped at a breakpoint, it will
2204 immediately cause another breakpoint stop without any
2205 execution (i.e. it will report a breakpoint hit incorrectly).
2206 So we must step over it first.
2208 prepare_to_proceed checks the current thread against the
2209 thread that reported the most recent event. If a step-over
2210 is required it returns TRUE and sets the current thread to
2212 if (prepare_to_proceed (step))
2216 /* prepare_to_proceed may change the current thread. */
2217 tp = inferior_thread ();
2221 tp->control.trap_expected = 1;
2222 /* If displaced stepping is enabled, we can step over the
2223 breakpoint without hitting it, so leave all breakpoints
2224 inserted. Otherwise we need to disable all breakpoints, step
2225 one instruction, and then re-add them when that step is
2227 if (!use_displaced_stepping (gdbarch))
2228 remove_breakpoints ();
2231 /* We can insert breakpoints if we're not trying to step over one,
2232 or if we are stepping over one but we're using displaced stepping
2234 if (! tp->control.trap_expected || use_displaced_stepping (gdbarch))
2235 insert_breakpoints ();
2239 /* Pass the last stop signal to the thread we're resuming,
2240 irrespective of whether the current thread is the thread that
2241 got the last event or not. This was historically GDB's
2242 behaviour before keeping a stop_signal per thread. */
2244 struct thread_info *last_thread;
2246 struct target_waitstatus last_status;
2248 get_last_target_status (&last_ptid, &last_status);
2249 if (!ptid_equal (inferior_ptid, last_ptid)
2250 && !ptid_equal (last_ptid, null_ptid)
2251 && !ptid_equal (last_ptid, minus_one_ptid))
2253 last_thread = find_thread_ptid (last_ptid);
2256 tp->suspend.stop_signal = last_thread->suspend.stop_signal;
2257 last_thread->suspend.stop_signal = GDB_SIGNAL_0;
2262 if (siggnal != GDB_SIGNAL_DEFAULT)
2263 tp->suspend.stop_signal = siggnal;
2264 /* If this signal should not be seen by program,
2265 give it zero. Used for debugging signals. */
2266 else if (!signal_program[tp->suspend.stop_signal])
2267 tp->suspend.stop_signal = GDB_SIGNAL_0;
2269 annotate_starting ();
2271 /* Make sure that output from GDB appears before output from the
2273 gdb_flush (gdb_stdout);
2275 /* Refresh prev_pc value just prior to resuming. This used to be
2276 done in stop_stepping, however, setting prev_pc there did not handle
2277 scenarios such as inferior function calls or returning from
2278 a function via the return command. In those cases, the prev_pc
2279 value was not set properly for subsequent commands. The prev_pc value
2280 is used to initialize the starting line number in the ecs. With an
2281 invalid value, the gdb next command ends up stopping at the position
2282 represented by the next line table entry past our start position.
2283 On platforms that generate one line table entry per line, this
2284 is not a problem. However, on the ia64, the compiler generates
2285 extraneous line table entries that do not increase the line number.
2286 When we issue the gdb next command on the ia64 after an inferior call
2287 or a return command, we often end up a few instructions forward, still
2288 within the original line we started.
2290 An attempt was made to refresh the prev_pc at the same time the
2291 execution_control_state is initialized (for instance, just before
2292 waiting for an inferior event). But this approach did not work
2293 because of platforms that use ptrace, where the pc register cannot
2294 be read unless the inferior is stopped. At that point, we are not
2295 guaranteed the inferior is stopped and so the regcache_read_pc() call
2296 can fail. Setting the prev_pc value here ensures the value is updated
2297 correctly when the inferior is stopped. */
2298 tp->prev_pc = regcache_read_pc (get_current_regcache ());
2300 /* Fill in with reasonable starting values. */
2301 init_thread_stepping_state (tp);
2303 /* Reset to normal state. */
2304 init_infwait_state ();
2306 /* Resume inferior. */
2307 resume (force_step || step || bpstat_should_step (),
2308 tp->suspend.stop_signal);
2310 /* Wait for it to stop (if not standalone)
2311 and in any case decode why it stopped, and act accordingly. */
2312 /* Do this only if we are not using the event loop, or if the target
2313 does not support asynchronous execution. */
2314 if (!target_can_async_p ())
2316 wait_for_inferior ();
2322 /* Start remote-debugging of a machine over a serial link. */
2325 start_remote (int from_tty)
2327 struct inferior *inferior;
2329 inferior = current_inferior ();
2330 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2332 /* Always go on waiting for the target, regardless of the mode. */
2333 /* FIXME: cagney/1999-09-23: At present it isn't possible to
2334 indicate to wait_for_inferior that a target should timeout if
2335 nothing is returned (instead of just blocking). Because of this,
2336 targets expecting an immediate response need to, internally, set
2337 things up so that the target_wait() is forced to eventually
2339 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
2340 differentiate to its caller what the state of the target is after
2341 the initial open has been performed. Here we're assuming that
2342 the target has stopped. It should be possible to eventually have
2343 target_open() return to the caller an indication that the target
2344 is currently running and GDB state should be set to the same as
2345 for an async run. */
2346 wait_for_inferior ();
2348 /* Now that the inferior has stopped, do any bookkeeping like
2349 loading shared libraries. We want to do this before normal_stop,
2350 so that the displayed frame is up to date. */
2351 post_create_inferior (¤t_target, from_tty);
2356 /* Initialize static vars when a new inferior begins. */
2359 init_wait_for_inferior (void)
2361 /* These are meaningless until the first time through wait_for_inferior. */
2363 breakpoint_init_inferior (inf_starting);
2365 clear_proceed_status ();
2367 stepping_past_singlestep_breakpoint = 0;
2369 target_last_wait_ptid = minus_one_ptid;
2371 previous_inferior_ptid = inferior_ptid;
2372 init_infwait_state ();
2374 /* Discard any skipped inlined frames. */
2375 clear_inline_frame_state (minus_one_ptid);
2379 /* This enum encodes possible reasons for doing a target_wait, so that
2380 wfi can call target_wait in one place. (Ultimately the call will be
2381 moved out of the infinite loop entirely.) */
2385 infwait_normal_state,
2386 infwait_thread_hop_state,
2387 infwait_step_watch_state,
2388 infwait_nonstep_watch_state
2391 /* The PTID we'll do a target_wait on.*/
2394 /* Current inferior wait state. */
2395 static enum infwait_states infwait_state;
2397 /* Data to be passed around while handling an event. This data is
2398 discarded between events. */
2399 struct execution_control_state
2402 /* The thread that got the event, if this was a thread event; NULL
2404 struct thread_info *event_thread;
2406 struct target_waitstatus ws;
2407 int stop_func_filled_in;
2408 CORE_ADDR stop_func_start;
2409 CORE_ADDR stop_func_end;
2410 const char *stop_func_name;
2413 /* We were in infwait_step_watch_state or
2414 infwait_nonstep_watch_state state, and the thread reported an
2416 int stepped_after_stopped_by_watchpoint;
2419 static void handle_inferior_event (struct execution_control_state *ecs);
2421 static void handle_step_into_function (struct gdbarch *gdbarch,
2422 struct execution_control_state *ecs);
2423 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
2424 struct execution_control_state *ecs);
2425 static void handle_signal_stop (struct execution_control_state *ecs);
2426 static void check_exception_resume (struct execution_control_state *,
2427 struct frame_info *);
2429 static void stop_stepping (struct execution_control_state *ecs);
2430 static void prepare_to_wait (struct execution_control_state *ecs);
2431 static void keep_going (struct execution_control_state *ecs);
2432 static void process_event_stop_test (struct execution_control_state *ecs);
2433 static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
2435 /* Callback for iterate over threads. If the thread is stopped, but
2436 the user/frontend doesn't know about that yet, go through
2437 normal_stop, as if the thread had just stopped now. ARG points at
2438 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
2439 ptid_is_pid(PTID) is true, applies to all threads of the process
2440 pointed at by PTID. Otherwise, apply only to the thread pointed by
2444 infrun_thread_stop_requested_callback (struct thread_info *info, void *arg)
2446 ptid_t ptid = * (ptid_t *) arg;
2448 if ((ptid_equal (info->ptid, ptid)
2449 || ptid_equal (minus_one_ptid, ptid)
2450 || (ptid_is_pid (ptid)
2451 && ptid_get_pid (ptid) == ptid_get_pid (info->ptid)))
2452 && is_running (info->ptid)
2453 && !is_executing (info->ptid))
2455 struct cleanup *old_chain;
2456 struct execution_control_state ecss;
2457 struct execution_control_state *ecs = &ecss;
2459 memset (ecs, 0, sizeof (*ecs));
2461 old_chain = make_cleanup_restore_current_thread ();
2463 overlay_cache_invalid = 1;
2464 /* Flush target cache before starting to handle each event.
2465 Target was running and cache could be stale. This is just a
2466 heuristic. Running threads may modify target memory, but we
2467 don't get any event. */
2468 target_dcache_invalidate ();
2470 /* Go through handle_inferior_event/normal_stop, so we always
2471 have consistent output as if the stop event had been
2473 ecs->ptid = info->ptid;
2474 ecs->event_thread = find_thread_ptid (info->ptid);
2475 ecs->ws.kind = TARGET_WAITKIND_STOPPED;
2476 ecs->ws.value.sig = GDB_SIGNAL_0;
2478 handle_inferior_event (ecs);
2480 if (!ecs->wait_some_more)
2482 struct thread_info *tp;
2486 /* Finish off the continuations. */
2487 tp = inferior_thread ();
2488 do_all_intermediate_continuations_thread (tp, 1);
2489 do_all_continuations_thread (tp, 1);
2492 do_cleanups (old_chain);
2498 /* This function is attached as a "thread_stop_requested" observer.
2499 Cleanup local state that assumed the PTID was to be resumed, and
2500 report the stop to the frontend. */
2503 infrun_thread_stop_requested (ptid_t ptid)
2505 struct displaced_step_inferior_state *displaced;
2507 /* PTID was requested to stop. Remove it from the displaced
2508 stepping queue, so we don't try to resume it automatically. */
2510 for (displaced = displaced_step_inferior_states;
2512 displaced = displaced->next)
2514 struct displaced_step_request *it, **prev_next_p;
2516 it = displaced->step_request_queue;
2517 prev_next_p = &displaced->step_request_queue;
2520 if (ptid_match (it->ptid, ptid))
2522 *prev_next_p = it->next;
2528 prev_next_p = &it->next;
2535 iterate_over_threads (infrun_thread_stop_requested_callback, &ptid);
2539 infrun_thread_thread_exit (struct thread_info *tp, int silent)
2541 if (ptid_equal (target_last_wait_ptid, tp->ptid))
2542 nullify_last_target_wait_ptid ();
2545 /* Callback for iterate_over_threads. */
2548 delete_step_resume_breakpoint_callback (struct thread_info *info, void *data)
2550 if (is_exited (info->ptid))
2553 delete_step_resume_breakpoint (info);
2554 delete_exception_resume_breakpoint (info);
2558 /* In all-stop, delete the step resume breakpoint of any thread that
2559 had one. In non-stop, delete the step resume breakpoint of the
2560 thread that just stopped. */
2563 delete_step_thread_step_resume_breakpoint (void)
2565 if (!target_has_execution
2566 || ptid_equal (inferior_ptid, null_ptid))
2567 /* If the inferior has exited, we have already deleted the step
2568 resume breakpoints out of GDB's lists. */
2573 /* If in non-stop mode, only delete the step-resume or
2574 longjmp-resume breakpoint of the thread that just stopped
2576 struct thread_info *tp = inferior_thread ();
2578 delete_step_resume_breakpoint (tp);
2579 delete_exception_resume_breakpoint (tp);
2582 /* In all-stop mode, delete all step-resume and longjmp-resume
2583 breakpoints of any thread that had them. */
2584 iterate_over_threads (delete_step_resume_breakpoint_callback, NULL);
2587 /* A cleanup wrapper. */
2590 delete_step_thread_step_resume_breakpoint_cleanup (void *arg)
2592 delete_step_thread_step_resume_breakpoint ();
2595 /* Pretty print the results of target_wait, for debugging purposes. */
2598 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
2599 const struct target_waitstatus *ws)
2601 char *status_string = target_waitstatus_to_string (ws);
2602 struct ui_file *tmp_stream = mem_fileopen ();
2605 /* The text is split over several lines because it was getting too long.
2606 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
2607 output as a unit; we want only one timestamp printed if debug_timestamp
2610 fprintf_unfiltered (tmp_stream,
2611 "infrun: target_wait (%d", ptid_get_pid (waiton_ptid));
2612 if (ptid_get_pid (waiton_ptid) != -1)
2613 fprintf_unfiltered (tmp_stream,
2614 " [%s]", target_pid_to_str (waiton_ptid));
2615 fprintf_unfiltered (tmp_stream, ", status) =\n");
2616 fprintf_unfiltered (tmp_stream,
2617 "infrun: %d [%s],\n",
2618 ptid_get_pid (result_ptid),
2619 target_pid_to_str (result_ptid));
2620 fprintf_unfiltered (tmp_stream,
2624 text = ui_file_xstrdup (tmp_stream, NULL);
2626 /* This uses %s in part to handle %'s in the text, but also to avoid
2627 a gcc error: the format attribute requires a string literal. */
2628 fprintf_unfiltered (gdb_stdlog, "%s", text);
2630 xfree (status_string);
2632 ui_file_delete (tmp_stream);
2635 /* Prepare and stabilize the inferior for detaching it. E.g.,
2636 detaching while a thread is displaced stepping is a recipe for
2637 crashing it, as nothing would readjust the PC out of the scratch
2641 prepare_for_detach (void)
2643 struct inferior *inf = current_inferior ();
2644 ptid_t pid_ptid = pid_to_ptid (inf->pid);
2645 struct cleanup *old_chain_1;
2646 struct displaced_step_inferior_state *displaced;
2648 displaced = get_displaced_stepping_state (inf->pid);
2650 /* Is any thread of this process displaced stepping? If not,
2651 there's nothing else to do. */
2652 if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
2656 fprintf_unfiltered (gdb_stdlog,
2657 "displaced-stepping in-process while detaching");
2659 old_chain_1 = make_cleanup_restore_integer (&inf->detaching);
2662 while (!ptid_equal (displaced->step_ptid, null_ptid))
2664 struct cleanup *old_chain_2;
2665 struct execution_control_state ecss;
2666 struct execution_control_state *ecs;
2669 memset (ecs, 0, sizeof (*ecs));
2671 overlay_cache_invalid = 1;
2672 /* Flush target cache before starting to handle each event.
2673 Target was running and cache could be stale. This is just a
2674 heuristic. Running threads may modify target memory, but we
2675 don't get any event. */
2676 target_dcache_invalidate ();
2678 if (deprecated_target_wait_hook)
2679 ecs->ptid = deprecated_target_wait_hook (pid_ptid, &ecs->ws, 0);
2681 ecs->ptid = target_wait (pid_ptid, &ecs->ws, 0);
2684 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
2686 /* If an error happens while handling the event, propagate GDB's
2687 knowledge of the executing state to the frontend/user running
2689 old_chain_2 = make_cleanup (finish_thread_state_cleanup,
2692 /* Now figure out what to do with the result of the result. */
2693 handle_inferior_event (ecs);
2695 /* No error, don't finish the state yet. */
2696 discard_cleanups (old_chain_2);
2698 /* Breakpoints and watchpoints are not installed on the target
2699 at this point, and signals are passed directly to the
2700 inferior, so this must mean the process is gone. */
2701 if (!ecs->wait_some_more)
2703 discard_cleanups (old_chain_1);
2704 error (_("Program exited while detaching"));
2708 discard_cleanups (old_chain_1);
2711 /* Wait for control to return from inferior to debugger.
2713 If inferior gets a signal, we may decide to start it up again
2714 instead of returning. That is why there is a loop in this function.
2715 When this function actually returns it means the inferior
2716 should be left stopped and GDB should read more commands. */
2719 wait_for_inferior (void)
2721 struct cleanup *old_cleanups;
2725 (gdb_stdlog, "infrun: wait_for_inferior ()\n");
2728 make_cleanup (delete_step_thread_step_resume_breakpoint_cleanup, NULL);
2732 struct execution_control_state ecss;
2733 struct execution_control_state *ecs = &ecss;
2734 struct cleanup *old_chain;
2736 memset (ecs, 0, sizeof (*ecs));
2738 overlay_cache_invalid = 1;
2740 /* Flush target cache before starting to handle each event.
2741 Target was running and cache could be stale. This is just a
2742 heuristic. Running threads may modify target memory, but we
2743 don't get any event. */
2744 target_dcache_invalidate ();
2746 if (deprecated_target_wait_hook)
2747 ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0);
2749 ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0);
2752 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
2754 /* If an error happens while handling the event, propagate GDB's
2755 knowledge of the executing state to the frontend/user running
2757 old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
2759 /* Now figure out what to do with the result of the result. */
2760 handle_inferior_event (ecs);
2762 /* No error, don't finish the state yet. */
2763 discard_cleanups (old_chain);
2765 if (!ecs->wait_some_more)
2769 do_cleanups (old_cleanups);
2772 /* Asynchronous version of wait_for_inferior. It is called by the
2773 event loop whenever a change of state is detected on the file
2774 descriptor corresponding to the target. It can be called more than
2775 once to complete a single execution command. In such cases we need
2776 to keep the state in a global variable ECSS. If it is the last time
2777 that this function is called for a single execution command, then
2778 report to the user that the inferior has stopped, and do the
2779 necessary cleanups. */
2782 fetch_inferior_event (void *client_data)
2784 struct execution_control_state ecss;
2785 struct execution_control_state *ecs = &ecss;
2786 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
2787 struct cleanup *ts_old_chain;
2788 int was_sync = sync_execution;
2791 memset (ecs, 0, sizeof (*ecs));
2793 /* We're handling a live event, so make sure we're doing live
2794 debugging. If we're looking at traceframes while the target is
2795 running, we're going to need to get back to that mode after
2796 handling the event. */
2799 make_cleanup_restore_current_traceframe ();
2800 set_current_traceframe (-1);
2804 /* In non-stop mode, the user/frontend should not notice a thread
2805 switch due to internal events. Make sure we reverse to the
2806 user selected thread and frame after handling the event and
2807 running any breakpoint commands. */
2808 make_cleanup_restore_current_thread ();
2810 overlay_cache_invalid = 1;
2811 /* Flush target cache before starting to handle each event. Target
2812 was running and cache could be stale. This is just a heuristic.
2813 Running threads may modify target memory, but we don't get any
2815 target_dcache_invalidate ();
2817 make_cleanup_restore_integer (&execution_direction);
2818 execution_direction = target_execution_direction ();
2820 if (deprecated_target_wait_hook)
2822 deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
2824 ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
2827 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
2829 /* If an error happens while handling the event, propagate GDB's
2830 knowledge of the executing state to the frontend/user running
2833 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
2835 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
2837 /* Get executed before make_cleanup_restore_current_thread above to apply
2838 still for the thread which has thrown the exception. */
2839 make_bpstat_clear_actions_cleanup ();
2841 /* Now figure out what to do with the result of the result. */
2842 handle_inferior_event (ecs);
2844 if (!ecs->wait_some_more)
2846 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
2848 delete_step_thread_step_resume_breakpoint ();
2850 /* We may not find an inferior if this was a process exit. */
2851 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
2854 if (target_has_execution
2855 && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED
2856 && ecs->ws.kind != TARGET_WAITKIND_EXITED
2857 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
2858 && ecs->event_thread->step_multi
2859 && ecs->event_thread->control.stop_step)
2860 inferior_event_handler (INF_EXEC_CONTINUE, NULL);
2863 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2868 /* No error, don't finish the thread states yet. */
2869 discard_cleanups (ts_old_chain);
2871 /* Revert thread and frame. */
2872 do_cleanups (old_chain);
2874 /* If the inferior was in sync execution mode, and now isn't,
2875 restore the prompt (a synchronous execution command has finished,
2876 and we're ready for input). */
2877 if (interpreter_async && was_sync && !sync_execution)
2878 display_gdb_prompt (0);
2882 && exec_done_display_p
2883 && (ptid_equal (inferior_ptid, null_ptid)
2884 || !is_running (inferior_ptid)))
2885 printf_unfiltered (_("completed.\n"));
2888 /* Record the frame and location we're currently stepping through. */
2890 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
2892 struct thread_info *tp = inferior_thread ();
2894 tp->control.step_frame_id = get_frame_id (frame);
2895 tp->control.step_stack_frame_id = get_stack_frame_id (frame);
2897 tp->current_symtab = sal.symtab;
2898 tp->current_line = sal.line;
2901 /* Clear context switchable stepping state. */
2904 init_thread_stepping_state (struct thread_info *tss)
2906 tss->stepping_over_breakpoint = 0;
2907 tss->step_after_step_resume_breakpoint = 0;
2910 /* Return the cached copy of the last pid/waitstatus returned by
2911 target_wait()/deprecated_target_wait_hook(). The data is actually
2912 cached by handle_inferior_event(), which gets called immediately
2913 after target_wait()/deprecated_target_wait_hook(). */
2916 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
2918 *ptidp = target_last_wait_ptid;
2919 *status = target_last_waitstatus;
2923 nullify_last_target_wait_ptid (void)
2925 target_last_wait_ptid = minus_one_ptid;
2928 /* Switch thread contexts. */
2931 context_switch (ptid_t ptid)
2933 if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
2935 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
2936 target_pid_to_str (inferior_ptid));
2937 fprintf_unfiltered (gdb_stdlog, "to %s\n",
2938 target_pid_to_str (ptid));
2941 switch_to_thread (ptid);
2945 adjust_pc_after_break (struct execution_control_state *ecs)
2947 struct regcache *regcache;
2948 struct gdbarch *gdbarch;
2949 struct address_space *aspace;
2950 CORE_ADDR breakpoint_pc, decr_pc;
2952 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
2953 we aren't, just return.
2955 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
2956 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
2957 implemented by software breakpoints should be handled through the normal
2960 NOTE drow/2004-01-31: On some targets, breakpoints may generate
2961 different signals (SIGILL or SIGEMT for instance), but it is less
2962 clear where the PC is pointing afterwards. It may not match
2963 gdbarch_decr_pc_after_break. I don't know any specific target that
2964 generates these signals at breakpoints (the code has been in GDB since at
2965 least 1992) so I can not guess how to handle them here.
2967 In earlier versions of GDB, a target with
2968 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
2969 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
2970 target with both of these set in GDB history, and it seems unlikely to be
2971 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
2973 if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
2976 if (ecs->ws.value.sig != GDB_SIGNAL_TRAP)
2979 /* In reverse execution, when a breakpoint is hit, the instruction
2980 under it has already been de-executed. The reported PC always
2981 points at the breakpoint address, so adjusting it further would
2982 be wrong. E.g., consider this case on a decr_pc_after_break == 1
2985 B1 0x08000000 : INSN1
2986 B2 0x08000001 : INSN2
2988 PC -> 0x08000003 : INSN4
2990 Say you're stopped at 0x08000003 as above. Reverse continuing
2991 from that point should hit B2 as below. Reading the PC when the
2992 SIGTRAP is reported should read 0x08000001 and INSN2 should have
2993 been de-executed already.
2995 B1 0x08000000 : INSN1
2996 B2 PC -> 0x08000001 : INSN2
3000 We can't apply the same logic as for forward execution, because
3001 we would wrongly adjust the PC to 0x08000000, since there's a
3002 breakpoint at PC - 1. We'd then report a hit on B1, although
3003 INSN1 hadn't been de-executed yet. Doing nothing is the correct
3005 if (execution_direction == EXEC_REVERSE)
3008 /* If this target does not decrement the PC after breakpoints, then
3009 we have nothing to do. */
3010 regcache = get_thread_regcache (ecs->ptid);
3011 gdbarch = get_regcache_arch (regcache);
3013 decr_pc = target_decr_pc_after_break (gdbarch);
3017 aspace = get_regcache_aspace (regcache);
3019 /* Find the location where (if we've hit a breakpoint) the
3020 breakpoint would be. */
3021 breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
3023 /* Check whether there actually is a software breakpoint inserted at
3026 If in non-stop mode, a race condition is possible where we've
3027 removed a breakpoint, but stop events for that breakpoint were
3028 already queued and arrive later. To suppress those spurious
3029 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
3030 and retire them after a number of stop events are reported. */
3031 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
3032 || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
3034 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
3036 if (record_full_is_used ())
3037 record_full_gdb_operation_disable_set ();
3039 /* When using hardware single-step, a SIGTRAP is reported for both
3040 a completed single-step and a software breakpoint. Need to
3041 differentiate between the two, as the latter needs adjusting
3042 but the former does not.
3044 The SIGTRAP can be due to a completed hardware single-step only if
3045 - we didn't insert software single-step breakpoints
3046 - the thread to be examined is still the current thread
3047 - this thread is currently being stepped
3049 If any of these events did not occur, we must have stopped due
3050 to hitting a software breakpoint, and have to back up to the
3053 As a special case, we could have hardware single-stepped a
3054 software breakpoint. In this case (prev_pc == breakpoint_pc),
3055 we also need to back up to the breakpoint address. */
3057 if (singlestep_breakpoints_inserted_p
3058 || !ptid_equal (ecs->ptid, inferior_ptid)
3059 || !currently_stepping (ecs->event_thread)
3060 || ecs->event_thread->prev_pc == breakpoint_pc)
3061 regcache_write_pc (regcache, breakpoint_pc);
3063 do_cleanups (old_cleanups);
3068 init_infwait_state (void)
3070 waiton_ptid = pid_to_ptid (-1);
3071 infwait_state = infwait_normal_state;
3075 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
3077 for (frame = get_prev_frame (frame);
3079 frame = get_prev_frame (frame))
3081 if (frame_id_eq (get_frame_id (frame), step_frame_id))
3083 if (get_frame_type (frame) != INLINE_FRAME)
3090 /* Auxiliary function that handles syscall entry/return events.
3091 It returns 1 if the inferior should keep going (and GDB
3092 should ignore the event), or 0 if the event deserves to be
3096 handle_syscall_event (struct execution_control_state *ecs)
3098 struct regcache *regcache;
3101 if (!ptid_equal (ecs->ptid, inferior_ptid))
3102 context_switch (ecs->ptid);
3104 regcache = get_thread_regcache (ecs->ptid);
3105 syscall_number = ecs->ws.value.syscall_number;
3106 stop_pc = regcache_read_pc (regcache);
3108 if (catch_syscall_enabled () > 0
3109 && catching_syscall_number (syscall_number) > 0)
3112 fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
3115 ecs->event_thread->control.stop_bpstat
3116 = bpstat_stop_status (get_regcache_aspace (regcache),
3117 stop_pc, ecs->ptid, &ecs->ws);
3119 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3121 /* Catchpoint hit. */
3126 /* If no catchpoint triggered for this, then keep going. */
3131 /* Lazily fill in the execution_control_state's stop_func_* fields. */
3134 fill_in_stop_func (struct gdbarch *gdbarch,
3135 struct execution_control_state *ecs)
3137 if (!ecs->stop_func_filled_in)
3139 /* Don't care about return value; stop_func_start and stop_func_name
3140 will both be 0 if it doesn't work. */
3141 find_pc_partial_function (stop_pc, &ecs->stop_func_name,
3142 &ecs->stop_func_start, &ecs->stop_func_end);
3143 ecs->stop_func_start
3144 += gdbarch_deprecated_function_start_offset (gdbarch);
3146 if (gdbarch_skip_entrypoint_p (gdbarch))
3147 ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
3148 ecs->stop_func_start);
3150 ecs->stop_func_filled_in = 1;
3155 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
3157 static enum stop_kind
3158 get_inferior_stop_soon (ptid_t ptid)
3160 struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
3162 gdb_assert (inf != NULL);
3163 return inf->control.stop_soon;
3166 /* Given an execution control state that has been freshly filled in by
3167 an event from the inferior, figure out what it means and take
3170 The alternatives are:
3172 1) stop_stepping and return; to really stop and return to the
3175 2) keep_going and return; to wait for the next event (set
3176 ecs->event_thread->stepping_over_breakpoint to 1 to single step
3180 handle_inferior_event (struct execution_control_state *ecs)
3182 enum stop_kind stop_soon;
3184 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
3186 /* We had an event in the inferior, but we are not interested in
3187 handling it at this level. The lower layers have already
3188 done what needs to be done, if anything.
3190 One of the possible circumstances for this is when the
3191 inferior produces output for the console. The inferior has
3192 not stopped, and we are ignoring the event. Another possible
3193 circumstance is any event which the lower level knows will be
3194 reported multiple times without an intervening resume. */
3196 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
3197 prepare_to_wait (ecs);
3201 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
3202 && target_can_async_p () && !sync_execution)
3204 /* There were no unwaited-for children left in the target, but,
3205 we're not synchronously waiting for events either. Just
3206 ignore. Otherwise, if we were running a synchronous
3207 execution command, we need to cancel it and give the user
3208 back the terminal. */
3210 fprintf_unfiltered (gdb_stdlog,
3211 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
3212 prepare_to_wait (ecs);
3216 /* Cache the last pid/waitstatus. */
3217 target_last_wait_ptid = ecs->ptid;
3218 target_last_waitstatus = ecs->ws;
3220 /* Always clear state belonging to the previous time we stopped. */
3221 stop_stack_dummy = STOP_NONE;
3223 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
3225 /* No unwaited-for children left. IOW, all resumed children
3228 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
3230 stop_print_frame = 0;
3231 stop_stepping (ecs);
3235 if (ecs->ws.kind != TARGET_WAITKIND_EXITED
3236 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
3238 ecs->event_thread = find_thread_ptid (ecs->ptid);
3239 /* If it's a new thread, add it to the thread database. */
3240 if (ecs->event_thread == NULL)
3241 ecs->event_thread = add_thread (ecs->ptid);
3243 /* Disable range stepping. If the next step request could use a
3244 range, this will be end up re-enabled then. */
3245 ecs->event_thread->control.may_range_step = 0;
3248 /* Dependent on valid ECS->EVENT_THREAD. */
3249 adjust_pc_after_break (ecs);
3251 /* Dependent on the current PC value modified by adjust_pc_after_break. */
3252 reinit_frame_cache ();
3254 breakpoint_retire_moribund ();
3256 /* First, distinguish signals caused by the debugger from signals
3257 that have to do with the program's own actions. Note that
3258 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
3259 on the operating system version. Here we detect when a SIGILL or
3260 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
3261 something similar for SIGSEGV, since a SIGSEGV will be generated
3262 when we're trying to execute a breakpoint instruction on a
3263 non-executable stack. This happens for call dummy breakpoints
3264 for architectures like SPARC that place call dummies on the
3266 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
3267 && (ecs->ws.value.sig == GDB_SIGNAL_ILL
3268 || ecs->ws.value.sig == GDB_SIGNAL_SEGV
3269 || ecs->ws.value.sig == GDB_SIGNAL_EMT))
3271 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3273 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache),
3274 regcache_read_pc (regcache)))
3277 fprintf_unfiltered (gdb_stdlog,
3278 "infrun: Treating signal as SIGTRAP\n");
3279 ecs->ws.value.sig = GDB_SIGNAL_TRAP;
3283 /* Mark the non-executing threads accordingly. In all-stop, all
3284 threads of all processes are stopped when we get any event
3285 reported. In non-stop mode, only the event thread stops. If
3286 we're handling a process exit in non-stop mode, there's nothing
3287 to do, as threads of the dead process are gone, and threads of
3288 any other process were left running. */
3290 set_executing (minus_one_ptid, 0);
3291 else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3292 && ecs->ws.kind != TARGET_WAITKIND_EXITED)
3293 set_executing (ecs->ptid, 0);
3295 switch (infwait_state)
3297 case infwait_thread_hop_state:
3299 fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n");
3302 case infwait_normal_state:
3304 fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n");
3307 case infwait_step_watch_state:
3309 fprintf_unfiltered (gdb_stdlog,
3310 "infrun: infwait_step_watch_state\n");
3312 ecs->stepped_after_stopped_by_watchpoint = 1;
3315 case infwait_nonstep_watch_state:
3317 fprintf_unfiltered (gdb_stdlog,
3318 "infrun: infwait_nonstep_watch_state\n");
3319 insert_breakpoints ();
3321 /* FIXME-maybe: is this cleaner than setting a flag? Does it
3322 handle things like signals arriving and other things happening
3323 in combination correctly? */
3324 ecs->stepped_after_stopped_by_watchpoint = 1;
3328 internal_error (__FILE__, __LINE__, _("bad switch"));
3331 infwait_state = infwait_normal_state;
3332 waiton_ptid = pid_to_ptid (-1);
3334 switch (ecs->ws.kind)
3336 case TARGET_WAITKIND_LOADED:
3338 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
3339 if (!ptid_equal (ecs->ptid, inferior_ptid))
3340 context_switch (ecs->ptid);
3341 /* Ignore gracefully during startup of the inferior, as it might
3342 be the shell which has just loaded some objects, otherwise
3343 add the symbols for the newly loaded objects. Also ignore at
3344 the beginning of an attach or remote session; we will query
3345 the full list of libraries once the connection is
3348 stop_soon = get_inferior_stop_soon (ecs->ptid);
3349 if (stop_soon == NO_STOP_QUIETLY)
3351 struct regcache *regcache;
3353 regcache = get_thread_regcache (ecs->ptid);
3355 handle_solib_event ();
3357 ecs->event_thread->control.stop_bpstat
3358 = bpstat_stop_status (get_regcache_aspace (regcache),
3359 stop_pc, ecs->ptid, &ecs->ws);
3361 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3363 /* A catchpoint triggered. */
3364 process_event_stop_test (ecs);
3368 /* If requested, stop when the dynamic linker notifies
3369 gdb of events. This allows the user to get control
3370 and place breakpoints in initializer routines for
3371 dynamically loaded objects (among other things). */
3372 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3373 if (stop_on_solib_events)
3375 /* Make sure we print "Stopped due to solib-event" in
3377 stop_print_frame = 1;
3379 stop_stepping (ecs);
3384 /* If we are skipping through a shell, or through shared library
3385 loading that we aren't interested in, resume the program. If
3386 we're running the program normally, also resume. */
3387 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
3389 /* Loading of shared libraries might have changed breakpoint
3390 addresses. Make sure new breakpoints are inserted. */
3391 if (stop_soon == NO_STOP_QUIETLY
3392 && !breakpoints_always_inserted_mode ())
3393 insert_breakpoints ();
3394 resume (0, GDB_SIGNAL_0);
3395 prepare_to_wait (ecs);
3399 /* But stop if we're attaching or setting up a remote
3401 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
3402 || stop_soon == STOP_QUIETLY_REMOTE)
3405 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
3406 stop_stepping (ecs);
3410 internal_error (__FILE__, __LINE__,
3411 _("unhandled stop_soon: %d"), (int) stop_soon);
3413 case TARGET_WAITKIND_SPURIOUS:
3415 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
3416 if (!ptid_equal (ecs->ptid, inferior_ptid))
3417 context_switch (ecs->ptid);
3418 resume (0, GDB_SIGNAL_0);
3419 prepare_to_wait (ecs);
3422 case TARGET_WAITKIND_EXITED:
3423 case TARGET_WAITKIND_SIGNALLED:
3426 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3427 fprintf_unfiltered (gdb_stdlog,
3428 "infrun: TARGET_WAITKIND_EXITED\n");
3430 fprintf_unfiltered (gdb_stdlog,
3431 "infrun: TARGET_WAITKIND_SIGNALLED\n");
3434 inferior_ptid = ecs->ptid;
3435 set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid)));
3436 set_current_program_space (current_inferior ()->pspace);
3437 handle_vfork_child_exec_or_exit (0);
3438 target_terminal_ours (); /* Must do this before mourn anyway. */
3440 /* Clearing any previous state of convenience variables. */
3441 clear_exit_convenience_vars ();
3443 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3445 /* Record the exit code in the convenience variable $_exitcode, so
3446 that the user can inspect this again later. */
3447 set_internalvar_integer (lookup_internalvar ("_exitcode"),
3448 (LONGEST) ecs->ws.value.integer);
3450 /* Also record this in the inferior itself. */
3451 current_inferior ()->has_exit_code = 1;
3452 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
3454 print_exited_reason (ecs->ws.value.integer);
3458 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3459 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3461 if (gdbarch_gdb_signal_to_target_p (gdbarch))
3463 /* Set the value of the internal variable $_exitsignal,
3464 which holds the signal uncaught by the inferior. */
3465 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
3466 gdbarch_gdb_signal_to_target (gdbarch,
3467 ecs->ws.value.sig));
3471 /* We don't have access to the target's method used for
3472 converting between signal numbers (GDB's internal
3473 representation <-> target's representation).
3474 Therefore, we cannot do a good job at displaying this
3475 information to the user. It's better to just warn
3476 her about it (if infrun debugging is enabled), and
3479 fprintf_filtered (gdb_stdlog, _("\
3480 Cannot fill $_exitsignal with the correct signal number.\n"));
3483 print_signal_exited_reason (ecs->ws.value.sig);
3486 gdb_flush (gdb_stdout);
3487 target_mourn_inferior ();
3488 singlestep_breakpoints_inserted_p = 0;
3489 cancel_single_step_breakpoints ();
3490 stop_print_frame = 0;
3491 stop_stepping (ecs);
3494 /* The following are the only cases in which we keep going;
3495 the above cases end in a continue or goto. */
3496 case TARGET_WAITKIND_FORKED:
3497 case TARGET_WAITKIND_VFORKED:
3500 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3501 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
3503 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
3506 /* Check whether the inferior is displaced stepping. */
3508 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3509 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3510 struct displaced_step_inferior_state *displaced
3511 = get_displaced_stepping_state (ptid_get_pid (ecs->ptid));
3513 /* If checking displaced stepping is supported, and thread
3514 ecs->ptid is displaced stepping. */
3515 if (displaced && ptid_equal (displaced->step_ptid, ecs->ptid))
3517 struct inferior *parent_inf
3518 = find_inferior_pid (ptid_get_pid (ecs->ptid));
3519 struct regcache *child_regcache;
3520 CORE_ADDR parent_pc;
3522 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
3523 indicating that the displaced stepping of syscall instruction
3524 has been done. Perform cleanup for parent process here. Note
3525 that this operation also cleans up the child process for vfork,
3526 because their pages are shared. */
3527 displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
3529 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3531 /* Restore scratch pad for child process. */
3532 displaced_step_restore (displaced, ecs->ws.value.related_pid);
3535 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
3536 the child's PC is also within the scratchpad. Set the child's PC
3537 to the parent's PC value, which has already been fixed up.
3538 FIXME: we use the parent's aspace here, although we're touching
3539 the child, because the child hasn't been added to the inferior
3540 list yet at this point. */
3543 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
3545 parent_inf->aspace);
3546 /* Read PC value of parent process. */
3547 parent_pc = regcache_read_pc (regcache);
3549 if (debug_displaced)
3550 fprintf_unfiltered (gdb_stdlog,
3551 "displaced: write child pc from %s to %s\n",
3553 regcache_read_pc (child_regcache)),
3554 paddress (gdbarch, parent_pc));
3556 regcache_write_pc (child_regcache, parent_pc);
3560 if (!ptid_equal (ecs->ptid, inferior_ptid))
3561 context_switch (ecs->ptid);
3563 /* Immediately detach breakpoints from the child before there's
3564 any chance of letting the user delete breakpoints from the
3565 breakpoint lists. If we don't do this early, it's easy to
3566 leave left over traps in the child, vis: "break foo; catch
3567 fork; c; <fork>; del; c; <child calls foo>". We only follow
3568 the fork on the last `continue', and by that time the
3569 breakpoint at "foo" is long gone from the breakpoint table.
3570 If we vforked, then we don't need to unpatch here, since both
3571 parent and child are sharing the same memory pages; we'll
3572 need to unpatch at follow/detach time instead to be certain
3573 that new breakpoints added between catchpoint hit time and
3574 vfork follow are detached. */
3575 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
3577 /* This won't actually modify the breakpoint list, but will
3578 physically remove the breakpoints from the child. */
3579 detach_breakpoints (ecs->ws.value.related_pid);
3582 if (singlestep_breakpoints_inserted_p)
3584 /* Pull the single step breakpoints out of the target. */
3585 remove_single_step_breakpoints ();
3586 singlestep_breakpoints_inserted_p = 0;
3589 /* In case the event is caught by a catchpoint, remember that
3590 the event is to be followed at the next resume of the thread,
3591 and not immediately. */
3592 ecs->event_thread->pending_follow = ecs->ws;
3594 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3596 ecs->event_thread->control.stop_bpstat
3597 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3598 stop_pc, ecs->ptid, &ecs->ws);
3600 /* If no catchpoint triggered for this, then keep going. Note
3601 that we're interested in knowing the bpstat actually causes a
3602 stop, not just if it may explain the signal. Software
3603 watchpoints, for example, always appear in the bpstat. */
3604 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3610 = (follow_fork_mode_string == follow_fork_mode_child);
3612 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3614 should_resume = follow_fork ();
3617 child = ecs->ws.value.related_pid;
3619 /* In non-stop mode, also resume the other branch. */
3620 if (non_stop && !detach_fork)
3623 switch_to_thread (parent);
3625 switch_to_thread (child);
3627 ecs->event_thread = inferior_thread ();
3628 ecs->ptid = inferior_ptid;
3633 switch_to_thread (child);
3635 switch_to_thread (parent);
3637 ecs->event_thread = inferior_thread ();
3638 ecs->ptid = inferior_ptid;
3643 stop_stepping (ecs);
3646 process_event_stop_test (ecs);
3649 case TARGET_WAITKIND_VFORK_DONE:
3650 /* Done with the shared memory region. Re-insert breakpoints in
3651 the parent, and keep going. */
3654 fprintf_unfiltered (gdb_stdlog,
3655 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
3657 if (!ptid_equal (ecs->ptid, inferior_ptid))
3658 context_switch (ecs->ptid);
3660 current_inferior ()->waiting_for_vfork_done = 0;
3661 current_inferior ()->pspace->breakpoints_not_allowed = 0;
3662 /* This also takes care of reinserting breakpoints in the
3663 previously locked inferior. */
3667 case TARGET_WAITKIND_EXECD:
3669 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
3671 if (!ptid_equal (ecs->ptid, inferior_ptid))
3672 context_switch (ecs->ptid);
3674 singlestep_breakpoints_inserted_p = 0;
3675 cancel_single_step_breakpoints ();
3677 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3679 /* Do whatever is necessary to the parent branch of the vfork. */
3680 handle_vfork_child_exec_or_exit (1);
3682 /* This causes the eventpoints and symbol table to be reset.
3683 Must do this now, before trying to determine whether to
3685 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
3687 ecs->event_thread->control.stop_bpstat
3688 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3689 stop_pc, ecs->ptid, &ecs->ws);
3691 /* Note that this may be referenced from inside
3692 bpstat_stop_status above, through inferior_has_execd. */
3693 xfree (ecs->ws.value.execd_pathname);
3694 ecs->ws.value.execd_pathname = NULL;
3696 /* If no catchpoint triggered for this, then keep going. */
3697 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3699 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3703 process_event_stop_test (ecs);
3706 /* Be careful not to try to gather much state about a thread
3707 that's in a syscall. It's frequently a losing proposition. */
3708 case TARGET_WAITKIND_SYSCALL_ENTRY:
3710 fprintf_unfiltered (gdb_stdlog,
3711 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
3712 /* Getting the current syscall number. */
3713 if (handle_syscall_event (ecs) == 0)
3714 process_event_stop_test (ecs);
3717 /* Before examining the threads further, step this thread to
3718 get it entirely out of the syscall. (We get notice of the
3719 event when the thread is just on the verge of exiting a
3720 syscall. Stepping one instruction seems to get it back
3722 case TARGET_WAITKIND_SYSCALL_RETURN:
3724 fprintf_unfiltered (gdb_stdlog,
3725 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
3726 if (handle_syscall_event (ecs) == 0)
3727 process_event_stop_test (ecs);
3730 case TARGET_WAITKIND_STOPPED:
3732 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
3733 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
3734 handle_signal_stop (ecs);
3737 case TARGET_WAITKIND_NO_HISTORY:
3739 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
3740 /* Reverse execution: target ran out of history info. */
3742 /* Pull the single step breakpoints out of the target. */
3743 if (singlestep_breakpoints_inserted_p)
3745 if (!ptid_equal (ecs->ptid, inferior_ptid))
3746 context_switch (ecs->ptid);
3747 remove_single_step_breakpoints ();
3748 singlestep_breakpoints_inserted_p = 0;
3750 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3751 print_no_history_reason ();
3752 stop_stepping (ecs);
3757 /* Come here when the program has stopped with a signal. */
3760 handle_signal_stop (struct execution_control_state *ecs)
3762 struct frame_info *frame;
3763 struct gdbarch *gdbarch;
3764 int stopped_by_watchpoint;
3765 enum stop_kind stop_soon;
3768 gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
3770 /* Do we need to clean up the state of a thread that has
3771 completed a displaced single-step? (Doing so usually affects
3772 the PC, so do it here, before we set stop_pc.) */
3773 displaced_step_fixup (ecs->ptid,
3774 ecs->event_thread->suspend.stop_signal);
3776 /* If we either finished a single-step or hit a breakpoint, but
3777 the user wanted this thread to be stopped, pretend we got a
3778 SIG0 (generic unsignaled stop). */
3779 if (ecs->event_thread->stop_requested
3780 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
3781 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3783 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3787 struct regcache *regcache = get_thread_regcache (ecs->ptid);
3788 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3789 struct cleanup *old_chain = save_inferior_ptid ();
3791 inferior_ptid = ecs->ptid;
3793 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
3794 paddress (gdbarch, stop_pc));
3795 if (target_stopped_by_watchpoint ())
3799 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
3801 if (target_stopped_data_address (¤t_target, &addr))
3802 fprintf_unfiltered (gdb_stdlog,
3803 "infrun: stopped data address = %s\n",
3804 paddress (gdbarch, addr));
3806 fprintf_unfiltered (gdb_stdlog,
3807 "infrun: (no data address available)\n");
3810 do_cleanups (old_chain);
3813 /* This is originated from start_remote(), start_inferior() and
3814 shared libraries hook functions. */
3815 stop_soon = get_inferior_stop_soon (ecs->ptid);
3816 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
3818 if (!ptid_equal (ecs->ptid, inferior_ptid))
3819 context_switch (ecs->ptid);
3821 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
3822 stop_print_frame = 1;
3823 stop_stepping (ecs);
3827 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
3830 if (!ptid_equal (ecs->ptid, inferior_ptid))
3831 context_switch (ecs->ptid);
3833 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
3834 stop_print_frame = 0;
3835 stop_stepping (ecs);
3839 /* This originates from attach_command(). We need to overwrite
3840 the stop_signal here, because some kernels don't ignore a
3841 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
3842 See more comments in inferior.h. On the other hand, if we
3843 get a non-SIGSTOP, report it to the user - assume the backend
3844 will handle the SIGSTOP if it should show up later.
3846 Also consider that the attach is complete when we see a
3847 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
3848 target extended-remote report it instead of a SIGSTOP
3849 (e.g. gdbserver). We already rely on SIGTRAP being our
3850 signal, so this is no exception.
3852 Also consider that the attach is complete when we see a
3853 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
3854 the target to stop all threads of the inferior, in case the
3855 low level attach operation doesn't stop them implicitly. If
3856 they weren't stopped implicitly, then the stub will report a
3857 GDB_SIGNAL_0, meaning: stopped for no particular reason
3858 other than GDB's request. */
3859 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
3860 && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
3861 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
3862 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
3864 stop_print_frame = 1;
3865 stop_stepping (ecs);
3866 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3870 if (stepping_past_singlestep_breakpoint)
3872 gdb_assert (singlestep_breakpoints_inserted_p);
3873 gdb_assert (ptid_equal (singlestep_ptid, ecs->ptid));
3874 gdb_assert (!ptid_equal (singlestep_ptid, saved_singlestep_ptid));
3876 stepping_past_singlestep_breakpoint = 0;
3878 /* We've either finished single-stepping past the single-step
3879 breakpoint, or stopped for some other reason. It would be nice if
3880 we could tell, but we can't reliably. */
3881 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
3884 fprintf_unfiltered (gdb_stdlog,
3885 "infrun: stepping_past_"
3886 "singlestep_breakpoint\n");
3887 /* Pull the single step breakpoints out of the target. */
3888 if (!ptid_equal (ecs->ptid, inferior_ptid))
3889 context_switch (ecs->ptid);
3890 remove_single_step_breakpoints ();
3891 singlestep_breakpoints_inserted_p = 0;
3893 ecs->event_thread->control.trap_expected = 0;
3895 context_switch (saved_singlestep_ptid);
3896 if (deprecated_context_hook)
3897 deprecated_context_hook (pid_to_thread_id (saved_singlestep_ptid));
3899 resume (1, GDB_SIGNAL_0);
3900 prepare_to_wait (ecs);
3905 /* See if a thread hit a thread-specific breakpoint that was meant for
3906 another thread. If so, then step that thread past the breakpoint,
3909 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
3911 int thread_hop_needed = 0;
3912 struct address_space *aspace =
3913 get_regcache_aspace (get_thread_regcache (ecs->ptid));
3915 /* Check if a regular breakpoint has been hit before checking
3916 for a potential single step breakpoint. Otherwise, GDB will
3917 not see this breakpoint hit when stepping onto breakpoints. */
3918 if (regular_breakpoint_inserted_here_p (aspace, stop_pc))
3920 if (!breakpoint_thread_match (aspace, stop_pc, ecs->ptid))
3921 thread_hop_needed = 1;
3923 else if (singlestep_breakpoints_inserted_p)
3925 /* We have not context switched yet, so this should be true
3926 no matter which thread hit the singlestep breakpoint. */
3927 gdb_assert (ptid_equal (inferior_ptid, singlestep_ptid));
3929 fprintf_unfiltered (gdb_stdlog, "infrun: software single step "
3931 target_pid_to_str (ecs->ptid));
3933 /* The call to in_thread_list is necessary because PTIDs sometimes
3934 change when we go from single-threaded to multi-threaded. If
3935 the singlestep_ptid is still in the list, assume that it is
3936 really different from ecs->ptid. */
3937 if (!ptid_equal (singlestep_ptid, ecs->ptid)
3938 && in_thread_list (singlestep_ptid))
3940 /* If the PC of the thread we were trying to single-step
3941 has changed, discard this event (which we were going
3942 to ignore anyway), and pretend we saw that thread
3943 trap. This prevents us continuously moving the
3944 single-step breakpoint forward, one instruction at a
3945 time. If the PC has changed, then the thread we were
3946 trying to single-step has trapped or been signalled,
3947 but the event has not been reported to GDB yet.
3949 There might be some cases where this loses signal
3950 information, if a signal has arrived at exactly the
3951 same time that the PC changed, but this is the best
3952 we can do with the information available. Perhaps we
3953 should arrange to report all events for all threads
3954 when they stop, or to re-poll the remote looking for
3955 this particular thread (i.e. temporarily enable
3958 CORE_ADDR new_singlestep_pc
3959 = regcache_read_pc (get_thread_regcache (singlestep_ptid));
3961 if (new_singlestep_pc != singlestep_pc)
3963 enum gdb_signal stop_signal;
3966 fprintf_unfiltered (gdb_stdlog, "infrun: unexpected thread,"
3967 " but expected thread advanced also\n");
3969 /* The current context still belongs to
3970 singlestep_ptid. Don't swap here, since that's
3971 the context we want to use. Just fudge our
3972 state and continue. */
3973 stop_signal = ecs->event_thread->suspend.stop_signal;
3974 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3975 ecs->ptid = singlestep_ptid;
3976 ecs->event_thread = find_thread_ptid (ecs->ptid);
3977 ecs->event_thread->suspend.stop_signal = stop_signal;
3978 stop_pc = new_singlestep_pc;
3983 fprintf_unfiltered (gdb_stdlog,
3984 "infrun: unexpected thread\n");
3986 thread_hop_needed = 1;
3987 stepping_past_singlestep_breakpoint = 1;
3988 saved_singlestep_ptid = singlestep_ptid;
3993 if (thread_hop_needed)
3995 struct regcache *thread_regcache;
3996 int remove_status = 0;
3999 fprintf_unfiltered (gdb_stdlog, "infrun: thread_hop_needed\n");
4001 /* Switch context before touching inferior memory, the
4002 previous thread may have exited. */
4003 if (!ptid_equal (inferior_ptid, ecs->ptid))
4004 context_switch (ecs->ptid);
4006 /* Saw a breakpoint, but it was hit by the wrong thread.
4009 if (singlestep_breakpoints_inserted_p)
4011 /* Pull the single step breakpoints out of the target. */
4012 remove_single_step_breakpoints ();
4013 singlestep_breakpoints_inserted_p = 0;
4016 /* If the arch can displace step, don't remove the
4018 thread_regcache = get_thread_regcache (ecs->ptid);
4019 if (!use_displaced_stepping (get_regcache_arch (thread_regcache)))
4020 remove_status = remove_breakpoints ();
4022 /* Did we fail to remove breakpoints? If so, try
4023 to set the PC past the bp. (There's at least
4024 one situation in which we can fail to remove
4025 the bp's: On HP-UX's that use ttrace, we can't
4026 change the address space of a vforking child
4027 process until the child exits (well, okay, not
4028 then either :-) or execs. */
4029 if (remove_status != 0)
4030 error (_("Cannot step over breakpoint hit in wrong thread"));
4035 /* Only need to require the next event from this
4036 thread in all-stop mode. */
4037 waiton_ptid = ecs->ptid;
4038 infwait_state = infwait_thread_hop_state;
4041 ecs->event_thread->stepping_over_breakpoint = 1;
4048 /* See if something interesting happened to the non-current thread. If
4049 so, then switch to that thread. */
4050 if (!ptid_equal (ecs->ptid, inferior_ptid))
4053 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
4055 context_switch (ecs->ptid);
4057 if (deprecated_context_hook)
4058 deprecated_context_hook (pid_to_thread_id (ecs->ptid));
4061 /* At this point, get hold of the now-current thread's frame. */
4062 frame = get_current_frame ();
4063 gdbarch = get_frame_arch (frame);
4065 if (singlestep_breakpoints_inserted_p)
4067 /* Pull the single step breakpoints out of the target. */
4068 remove_single_step_breakpoints ();
4069 singlestep_breakpoints_inserted_p = 0;
4072 if (ecs->stepped_after_stopped_by_watchpoint)
4073 stopped_by_watchpoint = 0;
4075 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
4077 /* If necessary, step over this watchpoint. We'll be back to display
4079 if (stopped_by_watchpoint
4080 && (target_have_steppable_watchpoint
4081 || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
4083 /* At this point, we are stopped at an instruction which has
4084 attempted to write to a piece of memory under control of
4085 a watchpoint. The instruction hasn't actually executed
4086 yet. If we were to evaluate the watchpoint expression
4087 now, we would get the old value, and therefore no change
4088 would seem to have occurred.
4090 In order to make watchpoints work `right', we really need
4091 to complete the memory write, and then evaluate the
4092 watchpoint expression. We do this by single-stepping the
4095 It may not be necessary to disable the watchpoint to stop over
4096 it. For example, the PA can (with some kernel cooperation)
4097 single step over a watchpoint without disabling the watchpoint.
4099 It is far more common to need to disable a watchpoint to step
4100 the inferior over it. If we have non-steppable watchpoints,
4101 we must disable the current watchpoint; it's simplest to
4102 disable all watchpoints and breakpoints. */
4105 if (!target_have_steppable_watchpoint)
4107 remove_breakpoints ();
4108 /* See comment in resume why we need to stop bypassing signals
4109 while breakpoints have been removed. */
4110 target_pass_signals (0, NULL);
4113 hw_step = maybe_software_singlestep (gdbarch, stop_pc);
4114 target_resume (ecs->ptid, hw_step, GDB_SIGNAL_0);
4115 waiton_ptid = ecs->ptid;
4116 if (target_have_steppable_watchpoint)
4117 infwait_state = infwait_step_watch_state;
4119 infwait_state = infwait_nonstep_watch_state;
4120 prepare_to_wait (ecs);
4124 ecs->event_thread->stepping_over_breakpoint = 0;
4125 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
4126 ecs->event_thread->control.stop_step = 0;
4127 stop_print_frame = 1;
4128 stopped_by_random_signal = 0;
4130 /* Hide inlined functions starting here, unless we just performed stepi or
4131 nexti. After stepi and nexti, always show the innermost frame (not any
4132 inline function call sites). */
4133 if (ecs->event_thread->control.step_range_end != 1)
4135 struct address_space *aspace =
4136 get_regcache_aspace (get_thread_regcache (ecs->ptid));
4138 /* skip_inline_frames is expensive, so we avoid it if we can
4139 determine that the address is one where functions cannot have
4140 been inlined. This improves performance with inferiors that
4141 load a lot of shared libraries, because the solib event
4142 breakpoint is defined as the address of a function (i.e. not
4143 inline). Note that we have to check the previous PC as well
4144 as the current one to catch cases when we have just
4145 single-stepped off a breakpoint prior to reinstating it.
4146 Note that we're assuming that the code we single-step to is
4147 not inline, but that's not definitive: there's nothing
4148 preventing the event breakpoint function from containing
4149 inlined code, and the single-step ending up there. If the
4150 user had set a breakpoint on that inlined code, the missing
4151 skip_inline_frames call would break things. Fortunately
4152 that's an extremely unlikely scenario. */
4153 if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
4154 && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4155 && ecs->event_thread->control.trap_expected
4156 && pc_at_non_inline_function (aspace,
4157 ecs->event_thread->prev_pc,
4160 skip_inline_frames (ecs->ptid);
4162 /* Re-fetch current thread's frame in case that invalidated
4164 frame = get_current_frame ();
4165 gdbarch = get_frame_arch (frame);
4169 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4170 && ecs->event_thread->control.trap_expected
4171 && gdbarch_single_step_through_delay_p (gdbarch)
4172 && currently_stepping (ecs->event_thread))
4174 /* We're trying to step off a breakpoint. Turns out that we're
4175 also on an instruction that needs to be stepped multiple
4176 times before it's been fully executing. E.g., architectures
4177 with a delay slot. It needs to be stepped twice, once for
4178 the instruction and once for the delay slot. */
4179 int step_through_delay
4180 = gdbarch_single_step_through_delay (gdbarch, frame);
4182 if (debug_infrun && step_through_delay)
4183 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
4184 if (ecs->event_thread->control.step_range_end == 0
4185 && step_through_delay)
4187 /* The user issued a continue when stopped at a breakpoint.
4188 Set up for another trap and get out of here. */
4189 ecs->event_thread->stepping_over_breakpoint = 1;
4193 else if (step_through_delay)
4195 /* The user issued a step when stopped at a breakpoint.
4196 Maybe we should stop, maybe we should not - the delay
4197 slot *might* correspond to a line of source. In any
4198 case, don't decide that here, just set
4199 ecs->stepping_over_breakpoint, making sure we
4200 single-step again before breakpoints are re-inserted. */
4201 ecs->event_thread->stepping_over_breakpoint = 1;
4205 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
4206 handles this event. */
4207 ecs->event_thread->control.stop_bpstat
4208 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4209 stop_pc, ecs->ptid, &ecs->ws);
4211 /* Following in case break condition called a
4213 stop_print_frame = 1;
4215 /* This is where we handle "moribund" watchpoints. Unlike
4216 software breakpoints traps, hardware watchpoint traps are
4217 always distinguishable from random traps. If no high-level
4218 watchpoint is associated with the reported stop data address
4219 anymore, then the bpstat does not explain the signal ---
4220 simply make sure to ignore it if `stopped_by_watchpoint' is
4224 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4225 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
4227 && stopped_by_watchpoint)
4228 fprintf_unfiltered (gdb_stdlog,
4229 "infrun: no user watchpoint explains "
4230 "watchpoint SIGTRAP, ignoring\n");
4232 /* NOTE: cagney/2003-03-29: These checks for a random signal
4233 at one stage in the past included checks for an inferior
4234 function call's call dummy's return breakpoint. The original
4235 comment, that went with the test, read:
4237 ``End of a stack dummy. Some systems (e.g. Sony news) give
4238 another signal besides SIGTRAP, so check here as well as
4241 If someone ever tries to get call dummys on a
4242 non-executable stack to work (where the target would stop
4243 with something like a SIGSEGV), then those tests might need
4244 to be re-instated. Given, however, that the tests were only
4245 enabled when momentary breakpoints were not being used, I
4246 suspect that it won't be the case.
4248 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
4249 be necessary for call dummies on a non-executable stack on
4252 /* See if the breakpoints module can explain the signal. */
4254 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
4255 ecs->event_thread->suspend.stop_signal);
4257 /* If not, perhaps stepping/nexting can. */
4259 random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4260 && currently_stepping (ecs->event_thread));
4262 /* No? Perhaps we got a moribund watchpoint. */
4264 random_signal = !stopped_by_watchpoint;
4266 /* For the program's own signals, act according to
4267 the signal handling tables. */
4271 /* Signal not for debugging purposes. */
4273 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
4274 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
4277 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
4278 gdb_signal_to_symbol_string (stop_signal));
4280 stopped_by_random_signal = 1;
4282 if (signal_print[ecs->event_thread->suspend.stop_signal])
4285 target_terminal_ours_for_output ();
4286 print_signal_received_reason
4287 (ecs->event_thread->suspend.stop_signal);
4289 /* Always stop on signals if we're either just gaining control
4290 of the program, or the user explicitly requested this thread
4291 to remain stopped. */
4292 if (stop_soon != NO_STOP_QUIETLY
4293 || ecs->event_thread->stop_requested
4295 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
4297 stop_stepping (ecs);
4300 /* If not going to stop, give terminal back
4301 if we took it away. */
4303 target_terminal_inferior ();
4305 /* Clear the signal if it should not be passed. */
4306 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
4307 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4309 if (ecs->event_thread->prev_pc == stop_pc
4310 && ecs->event_thread->control.trap_expected
4311 && ecs->event_thread->control.step_resume_breakpoint == NULL)
4313 /* We were just starting a new sequence, attempting to
4314 single-step off of a breakpoint and expecting a SIGTRAP.
4315 Instead this signal arrives. This signal will take us out
4316 of the stepping range so GDB needs to remember to, when
4317 the signal handler returns, resume stepping off that
4319 /* To simplify things, "continue" is forced to use the same
4320 code paths as single-step - set a breakpoint at the
4321 signal return address and then, once hit, step off that
4324 fprintf_unfiltered (gdb_stdlog,
4325 "infrun: signal arrived while stepping over "
4328 insert_hp_step_resume_breakpoint_at_frame (frame);
4329 ecs->event_thread->step_after_step_resume_breakpoint = 1;
4330 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4331 ecs->event_thread->control.trap_expected = 0;
4333 /* If we were nexting/stepping some other thread, switch to
4334 it, so that we don't continue it, losing control. */
4335 if (!switch_back_to_stepped_thread (ecs))
4340 if (ecs->event_thread->control.step_range_end != 0
4341 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
4342 && pc_in_thread_step_range (stop_pc, ecs->event_thread)
4343 && frame_id_eq (get_stack_frame_id (frame),
4344 ecs->event_thread->control.step_stack_frame_id)
4345 && ecs->event_thread->control.step_resume_breakpoint == NULL)
4347 /* The inferior is about to take a signal that will take it
4348 out of the single step range. Set a breakpoint at the
4349 current PC (which is presumably where the signal handler
4350 will eventually return) and then allow the inferior to
4353 Note that this is only needed for a signal delivered
4354 while in the single-step range. Nested signals aren't a
4355 problem as they eventually all return. */
4357 fprintf_unfiltered (gdb_stdlog,
4358 "infrun: signal may take us out of "
4359 "single-step range\n");
4361 insert_hp_step_resume_breakpoint_at_frame (frame);
4362 /* Reset trap_expected to ensure breakpoints are re-inserted. */
4363 ecs->event_thread->control.trap_expected = 0;
4368 /* Note: step_resume_breakpoint may be non-NULL. This occures
4369 when either there's a nested signal, or when there's a
4370 pending signal enabled just as the signal handler returns
4371 (leaving the inferior at the step-resume-breakpoint without
4372 actually executing it). Either way continue until the
4373 breakpoint is really hit. */
4375 if (!switch_back_to_stepped_thread (ecs))
4378 fprintf_unfiltered (gdb_stdlog,
4379 "infrun: random signal, keep going\n");
4386 process_event_stop_test (ecs);
4389 /* Come here when we've got some debug event / signal we can explain
4390 (IOW, not a random signal), and test whether it should cause a
4391 stop, or whether we should resume the inferior (transparently).
4392 E.g., could be a breakpoint whose condition evaluates false; we
4393 could be still stepping within the line; etc. */
4396 process_event_stop_test (struct execution_control_state *ecs)
4398 struct symtab_and_line stop_pc_sal;
4399 struct frame_info *frame;
4400 struct gdbarch *gdbarch;
4401 CORE_ADDR jmp_buf_pc;
4402 struct bpstat_what what;
4404 /* Handle cases caused by hitting a breakpoint. */
4406 frame = get_current_frame ();
4407 gdbarch = get_frame_arch (frame);
4409 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
4411 if (what.call_dummy)
4413 stop_stack_dummy = what.call_dummy;
4416 /* If we hit an internal event that triggers symbol changes, the
4417 current frame will be invalidated within bpstat_what (e.g., if we
4418 hit an internal solib event). Re-fetch it. */
4419 frame = get_current_frame ();
4420 gdbarch = get_frame_arch (frame);
4422 switch (what.main_action)
4424 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
4425 /* If we hit the breakpoint at longjmp while stepping, we
4426 install a momentary breakpoint at the target of the
4430 fprintf_unfiltered (gdb_stdlog,
4431 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4433 ecs->event_thread->stepping_over_breakpoint = 1;
4435 if (what.is_longjmp)
4437 struct value *arg_value;
4439 /* If we set the longjmp breakpoint via a SystemTap probe,
4440 then use it to extract the arguments. The destination PC
4441 is the third argument to the probe. */
4442 arg_value = probe_safe_evaluate_at_pc (frame, 2);
4444 jmp_buf_pc = value_as_address (arg_value);
4445 else if (!gdbarch_get_longjmp_target_p (gdbarch)
4446 || !gdbarch_get_longjmp_target (gdbarch,
4447 frame, &jmp_buf_pc))
4450 fprintf_unfiltered (gdb_stdlog,
4451 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4452 "(!gdbarch_get_longjmp_target)\n");
4457 /* Insert a breakpoint at resume address. */
4458 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
4461 check_exception_resume (ecs, frame);
4465 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
4467 struct frame_info *init_frame;
4469 /* There are several cases to consider.
4471 1. The initiating frame no longer exists. In this case we
4472 must stop, because the exception or longjmp has gone too
4475 2. The initiating frame exists, and is the same as the
4476 current frame. We stop, because the exception or longjmp
4479 3. The initiating frame exists and is different from the
4480 current frame. This means the exception or longjmp has
4481 been caught beneath the initiating frame, so keep going.
4483 4. longjmp breakpoint has been placed just to protect
4484 against stale dummy frames and user is not interested in
4485 stopping around longjmps. */
4488 fprintf_unfiltered (gdb_stdlog,
4489 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4491 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
4493 delete_exception_resume_breakpoint (ecs->event_thread);
4495 if (what.is_longjmp)
4497 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread->num);
4499 if (!frame_id_p (ecs->event_thread->initiating_frame))
4507 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
4511 struct frame_id current_id
4512 = get_frame_id (get_current_frame ());
4513 if (frame_id_eq (current_id,
4514 ecs->event_thread->initiating_frame))
4516 /* Case 2. Fall through. */
4526 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
4528 delete_step_resume_breakpoint (ecs->event_thread);
4530 ecs->event_thread->control.stop_step = 1;
4531 print_end_stepping_range_reason ();
4532 stop_stepping (ecs);
4536 case BPSTAT_WHAT_SINGLE:
4538 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
4539 ecs->event_thread->stepping_over_breakpoint = 1;
4540 /* Still need to check other stuff, at least the case where we
4541 are stepping and step out of the right range. */
4544 case BPSTAT_WHAT_STEP_RESUME:
4546 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
4548 delete_step_resume_breakpoint (ecs->event_thread);
4549 if (ecs->event_thread->control.proceed_to_finish
4550 && execution_direction == EXEC_REVERSE)
4552 struct thread_info *tp = ecs->event_thread;
4554 /* We are finishing a function in reverse, and just hit the
4555 step-resume breakpoint at the start address of the
4556 function, and we're almost there -- just need to back up
4557 by one more single-step, which should take us back to the
4559 tp->control.step_range_start = tp->control.step_range_end = 1;
4563 fill_in_stop_func (gdbarch, ecs);
4564 if (stop_pc == ecs->stop_func_start
4565 && execution_direction == EXEC_REVERSE)
4567 /* We are stepping over a function call in reverse, and just
4568 hit the step-resume breakpoint at the start address of
4569 the function. Go back to single-stepping, which should
4570 take us back to the function call. */
4571 ecs->event_thread->stepping_over_breakpoint = 1;
4577 case BPSTAT_WHAT_STOP_NOISY:
4579 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
4580 stop_print_frame = 1;
4582 /* We are about to nuke the step_resume_breakpointt via the
4583 cleanup chain, so no need to worry about it here. */
4585 stop_stepping (ecs);
4588 case BPSTAT_WHAT_STOP_SILENT:
4590 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
4591 stop_print_frame = 0;
4593 /* We are about to nuke the step_resume_breakpoin via the
4594 cleanup chain, so no need to worry about it here. */
4596 stop_stepping (ecs);
4599 case BPSTAT_WHAT_HP_STEP_RESUME:
4601 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
4603 delete_step_resume_breakpoint (ecs->event_thread);
4604 if (ecs->event_thread->step_after_step_resume_breakpoint)
4606 /* Back when the step-resume breakpoint was inserted, we
4607 were trying to single-step off a breakpoint. Go back to
4609 ecs->event_thread->step_after_step_resume_breakpoint = 0;
4610 ecs->event_thread->stepping_over_breakpoint = 1;
4616 case BPSTAT_WHAT_KEEP_CHECKING:
4620 /* We come here if we hit a breakpoint but should not stop for it.
4621 Possibly we also were stepping and should stop for that. So fall
4622 through and test for stepping. But, if not stepping, do not
4625 /* In all-stop mode, if we're currently stepping but have stopped in
4626 some other thread, we need to switch back to the stepped thread. */
4627 if (switch_back_to_stepped_thread (ecs))
4630 if (ecs->event_thread->control.step_resume_breakpoint)
4633 fprintf_unfiltered (gdb_stdlog,
4634 "infrun: step-resume breakpoint is inserted\n");
4636 /* Having a step-resume breakpoint overrides anything
4637 else having to do with stepping commands until
4638 that breakpoint is reached. */
4643 if (ecs->event_thread->control.step_range_end == 0)
4646 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
4647 /* Likewise if we aren't even stepping. */
4652 /* Re-fetch current thread's frame in case the code above caused
4653 the frame cache to be re-initialized, making our FRAME variable
4654 a dangling pointer. */
4655 frame = get_current_frame ();
4656 gdbarch = get_frame_arch (frame);
4657 fill_in_stop_func (gdbarch, ecs);
4659 /* If stepping through a line, keep going if still within it.
4661 Note that step_range_end is the address of the first instruction
4662 beyond the step range, and NOT the address of the last instruction
4665 Note also that during reverse execution, we may be stepping
4666 through a function epilogue and therefore must detect when
4667 the current-frame changes in the middle of a line. */
4669 if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
4670 && (execution_direction != EXEC_REVERSE
4671 || frame_id_eq (get_frame_id (frame),
4672 ecs->event_thread->control.step_frame_id)))
4676 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
4677 paddress (gdbarch, ecs->event_thread->control.step_range_start),
4678 paddress (gdbarch, ecs->event_thread->control.step_range_end));
4680 /* Tentatively re-enable range stepping; `resume' disables it if
4681 necessary (e.g., if we're stepping over a breakpoint or we
4682 have software watchpoints). */
4683 ecs->event_thread->control.may_range_step = 1;
4685 /* When stepping backward, stop at beginning of line range
4686 (unless it's the function entry point, in which case
4687 keep going back to the call point). */
4688 if (stop_pc == ecs->event_thread->control.step_range_start
4689 && stop_pc != ecs->stop_func_start
4690 && execution_direction == EXEC_REVERSE)
4692 ecs->event_thread->control.stop_step = 1;
4693 print_end_stepping_range_reason ();
4694 stop_stepping (ecs);
4702 /* We stepped out of the stepping range. */
4704 /* If we are stepping at the source level and entered the runtime
4705 loader dynamic symbol resolution code...
4707 EXEC_FORWARD: we keep on single stepping until we exit the run
4708 time loader code and reach the callee's address.
4710 EXEC_REVERSE: we've already executed the callee (backward), and
4711 the runtime loader code is handled just like any other
4712 undebuggable function call. Now we need only keep stepping
4713 backward through the trampoline code, and that's handled further
4714 down, so there is nothing for us to do here. */
4716 if (execution_direction != EXEC_REVERSE
4717 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4718 && in_solib_dynsym_resolve_code (stop_pc))
4720 CORE_ADDR pc_after_resolver =
4721 gdbarch_skip_solib_resolver (gdbarch, stop_pc);
4724 fprintf_unfiltered (gdb_stdlog,
4725 "infrun: stepped into dynsym resolve code\n");
4727 if (pc_after_resolver)
4729 /* Set up a step-resume breakpoint at the address
4730 indicated by SKIP_SOLIB_RESOLVER. */
4731 struct symtab_and_line sr_sal;
4734 sr_sal.pc = pc_after_resolver;
4735 sr_sal.pspace = get_frame_program_space (frame);
4737 insert_step_resume_breakpoint_at_sal (gdbarch,
4738 sr_sal, null_frame_id);
4745 if (ecs->event_thread->control.step_range_end != 1
4746 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4747 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
4748 && get_frame_type (frame) == SIGTRAMP_FRAME)
4751 fprintf_unfiltered (gdb_stdlog,
4752 "infrun: stepped into signal trampoline\n");
4753 /* The inferior, while doing a "step" or "next", has ended up in
4754 a signal trampoline (either by a signal being delivered or by
4755 the signal handler returning). Just single-step until the
4756 inferior leaves the trampoline (either by calling the handler
4762 /* If we're in the return path from a shared library trampoline,
4763 we want to proceed through the trampoline when stepping. */
4764 /* macro/2012-04-25: This needs to come before the subroutine
4765 call check below as on some targets return trampolines look
4766 like subroutine calls (MIPS16 return thunks). */
4767 if (gdbarch_in_solib_return_trampoline (gdbarch,
4768 stop_pc, ecs->stop_func_name)
4769 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
4771 /* Determine where this trampoline returns. */
4772 CORE_ADDR real_stop_pc;
4774 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
4777 fprintf_unfiltered (gdb_stdlog,
4778 "infrun: stepped into solib return tramp\n");
4780 /* Only proceed through if we know where it's going. */
4783 /* And put the step-breakpoint there and go until there. */
4784 struct symtab_and_line sr_sal;
4786 init_sal (&sr_sal); /* initialize to zeroes */
4787 sr_sal.pc = real_stop_pc;
4788 sr_sal.section = find_pc_overlay (sr_sal.pc);
4789 sr_sal.pspace = get_frame_program_space (frame);
4791 /* Do not specify what the fp should be when we stop since
4792 on some machines the prologue is where the new fp value
4794 insert_step_resume_breakpoint_at_sal (gdbarch,
4795 sr_sal, null_frame_id);
4797 /* Restart without fiddling with the step ranges or
4804 /* Check for subroutine calls. The check for the current frame
4805 equalling the step ID is not necessary - the check of the
4806 previous frame's ID is sufficient - but it is a common case and
4807 cheaper than checking the previous frame's ID.
4809 NOTE: frame_id_eq will never report two invalid frame IDs as
4810 being equal, so to get into this block, both the current and
4811 previous frame must have valid frame IDs. */
4812 /* The outer_frame_id check is a heuristic to detect stepping
4813 through startup code. If we step over an instruction which
4814 sets the stack pointer from an invalid value to a valid value,
4815 we may detect that as a subroutine call from the mythical
4816 "outermost" function. This could be fixed by marking
4817 outermost frames as !stack_p,code_p,special_p. Then the
4818 initial outermost frame, before sp was valid, would
4819 have code_addr == &_start. See the comment in frame_id_eq
4821 if (!frame_id_eq (get_stack_frame_id (frame),
4822 ecs->event_thread->control.step_stack_frame_id)
4823 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
4824 ecs->event_thread->control.step_stack_frame_id)
4825 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
4827 || step_start_function != find_pc_function (stop_pc))))
4829 CORE_ADDR real_stop_pc;
4832 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
4834 if ((ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
4835 || ((ecs->event_thread->control.step_range_end == 1)
4836 && in_prologue (gdbarch, ecs->event_thread->prev_pc,
4837 ecs->stop_func_start)))
4839 /* I presume that step_over_calls is only 0 when we're
4840 supposed to be stepping at the assembly language level
4841 ("stepi"). Just stop. */
4842 /* Also, maybe we just did a "nexti" inside a prolog, so we
4843 thought it was a subroutine call but it was not. Stop as
4845 /* And this works the same backward as frontward. MVS */
4846 ecs->event_thread->control.stop_step = 1;
4847 print_end_stepping_range_reason ();
4848 stop_stepping (ecs);
4852 /* Reverse stepping through solib trampolines. */
4854 if (execution_direction == EXEC_REVERSE
4855 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
4856 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
4857 || (ecs->stop_func_start == 0
4858 && in_solib_dynsym_resolve_code (stop_pc))))
4860 /* Any solib trampoline code can be handled in reverse
4861 by simply continuing to single-step. We have already
4862 executed the solib function (backwards), and a few
4863 steps will take us back through the trampoline to the
4869 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
4871 /* We're doing a "next".
4873 Normal (forward) execution: set a breakpoint at the
4874 callee's return address (the address at which the caller
4877 Reverse (backward) execution. set the step-resume
4878 breakpoint at the start of the function that we just
4879 stepped into (backwards), and continue to there. When we
4880 get there, we'll need to single-step back to the caller. */
4882 if (execution_direction == EXEC_REVERSE)
4884 /* If we're already at the start of the function, we've either
4885 just stepped backward into a single instruction function,
4886 or stepped back out of a signal handler to the first instruction
4887 of the function. Just keep going, which will single-step back
4889 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
4891 struct symtab_and_line sr_sal;
4893 /* Normal function call return (static or dynamic). */
4895 sr_sal.pc = ecs->stop_func_start;
4896 sr_sal.pspace = get_frame_program_space (frame);
4897 insert_step_resume_breakpoint_at_sal (gdbarch,
4898 sr_sal, null_frame_id);
4902 insert_step_resume_breakpoint_at_caller (frame);
4908 /* If we are in a function call trampoline (a stub between the
4909 calling routine and the real function), locate the real
4910 function. That's what tells us (a) whether we want to step
4911 into it at all, and (b) what prologue we want to run to the
4912 end of, if we do step into it. */
4913 real_stop_pc = skip_language_trampoline (frame, stop_pc);
4914 if (real_stop_pc == 0)
4915 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
4916 if (real_stop_pc != 0)
4917 ecs->stop_func_start = real_stop_pc;
4919 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
4921 struct symtab_and_line sr_sal;
4924 sr_sal.pc = ecs->stop_func_start;
4925 sr_sal.pspace = get_frame_program_space (frame);
4927 insert_step_resume_breakpoint_at_sal (gdbarch,
4928 sr_sal, null_frame_id);
4933 /* If we have line number information for the function we are
4934 thinking of stepping into and the function isn't on the skip
4937 If there are several symtabs at that PC (e.g. with include
4938 files), just want to know whether *any* of them have line
4939 numbers. find_pc_line handles this. */
4941 struct symtab_and_line tmp_sal;
4943 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
4944 if (tmp_sal.line != 0
4945 && !function_name_is_marked_for_skip (ecs->stop_func_name,
4948 if (execution_direction == EXEC_REVERSE)
4949 handle_step_into_function_backward (gdbarch, ecs);
4951 handle_step_into_function (gdbarch, ecs);
4956 /* If we have no line number and the step-stop-if-no-debug is
4957 set, we stop the step so that the user has a chance to switch
4958 in assembly mode. */
4959 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4960 && step_stop_if_no_debug)
4962 ecs->event_thread->control.stop_step = 1;
4963 print_end_stepping_range_reason ();
4964 stop_stepping (ecs);
4968 if (execution_direction == EXEC_REVERSE)
4970 /* If we're already at the start of the function, we've either just
4971 stepped backward into a single instruction function without line
4972 number info, or stepped back out of a signal handler to the first
4973 instruction of the function without line number info. Just keep
4974 going, which will single-step back to the caller. */
4975 if (ecs->stop_func_start != stop_pc)
4977 /* Set a breakpoint at callee's start address.
4978 From there we can step once and be back in the caller. */
4979 struct symtab_and_line sr_sal;
4982 sr_sal.pc = ecs->stop_func_start;
4983 sr_sal.pspace = get_frame_program_space (frame);
4984 insert_step_resume_breakpoint_at_sal (gdbarch,
4985 sr_sal, null_frame_id);
4989 /* Set a breakpoint at callee's return address (the address
4990 at which the caller will resume). */
4991 insert_step_resume_breakpoint_at_caller (frame);
4997 /* Reverse stepping through solib trampolines. */
4999 if (execution_direction == EXEC_REVERSE
5000 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
5002 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5003 || (ecs->stop_func_start == 0
5004 && in_solib_dynsym_resolve_code (stop_pc)))
5006 /* Any solib trampoline code can be handled in reverse
5007 by simply continuing to single-step. We have already
5008 executed the solib function (backwards), and a few
5009 steps will take us back through the trampoline to the
5014 else if (in_solib_dynsym_resolve_code (stop_pc))
5016 /* Stepped backward into the solib dynsym resolver.
5017 Set a breakpoint at its start and continue, then
5018 one more step will take us out. */
5019 struct symtab_and_line sr_sal;
5022 sr_sal.pc = ecs->stop_func_start;
5023 sr_sal.pspace = get_frame_program_space (frame);
5024 insert_step_resume_breakpoint_at_sal (gdbarch,
5025 sr_sal, null_frame_id);
5031 stop_pc_sal = find_pc_line (stop_pc, 0);
5033 /* NOTE: tausq/2004-05-24: This if block used to be done before all
5034 the trampoline processing logic, however, there are some trampolines
5035 that have no names, so we should do trampoline handling first. */
5036 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5037 && ecs->stop_func_name == NULL
5038 && stop_pc_sal.line == 0)
5041 fprintf_unfiltered (gdb_stdlog,
5042 "infrun: stepped into undebuggable function\n");
5044 /* The inferior just stepped into, or returned to, an
5045 undebuggable function (where there is no debugging information
5046 and no line number corresponding to the address where the
5047 inferior stopped). Since we want to skip this kind of code,
5048 we keep going until the inferior returns from this
5049 function - unless the user has asked us not to (via
5050 set step-mode) or we no longer know how to get back
5051 to the call site. */
5052 if (step_stop_if_no_debug
5053 || !frame_id_p (frame_unwind_caller_id (frame)))
5055 /* If we have no line number and the step-stop-if-no-debug
5056 is set, we stop the step so that the user has a chance to
5057 switch in assembly mode. */
5058 ecs->event_thread->control.stop_step = 1;
5059 print_end_stepping_range_reason ();
5060 stop_stepping (ecs);
5065 /* Set a breakpoint at callee's return address (the address
5066 at which the caller will resume). */
5067 insert_step_resume_breakpoint_at_caller (frame);
5073 if (ecs->event_thread->control.step_range_end == 1)
5075 /* It is stepi or nexti. We always want to stop stepping after
5078 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
5079 ecs->event_thread->control.stop_step = 1;
5080 print_end_stepping_range_reason ();
5081 stop_stepping (ecs);
5085 if (stop_pc_sal.line == 0)
5087 /* We have no line number information. That means to stop
5088 stepping (does this always happen right after one instruction,
5089 when we do "s" in a function with no line numbers,
5090 or can this happen as a result of a return or longjmp?). */
5092 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
5093 ecs->event_thread->control.stop_step = 1;
5094 print_end_stepping_range_reason ();
5095 stop_stepping (ecs);
5099 /* Look for "calls" to inlined functions, part one. If the inline
5100 frame machinery detected some skipped call sites, we have entered
5101 a new inline function. */
5103 if (frame_id_eq (get_frame_id (get_current_frame ()),
5104 ecs->event_thread->control.step_frame_id)
5105 && inline_skipped_frames (ecs->ptid))
5107 struct symtab_and_line call_sal;
5110 fprintf_unfiltered (gdb_stdlog,
5111 "infrun: stepped into inlined function\n");
5113 find_frame_sal (get_current_frame (), &call_sal);
5115 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
5117 /* For "step", we're going to stop. But if the call site
5118 for this inlined function is on the same source line as
5119 we were previously stepping, go down into the function
5120 first. Otherwise stop at the call site. */
5122 if (call_sal.line == ecs->event_thread->current_line
5123 && call_sal.symtab == ecs->event_thread->current_symtab)
5124 step_into_inline_frame (ecs->ptid);
5126 ecs->event_thread->control.stop_step = 1;
5127 print_end_stepping_range_reason ();
5128 stop_stepping (ecs);
5133 /* For "next", we should stop at the call site if it is on a
5134 different source line. Otherwise continue through the
5135 inlined function. */
5136 if (call_sal.line == ecs->event_thread->current_line
5137 && call_sal.symtab == ecs->event_thread->current_symtab)
5141 ecs->event_thread->control.stop_step = 1;
5142 print_end_stepping_range_reason ();
5143 stop_stepping (ecs);
5149 /* Look for "calls" to inlined functions, part two. If we are still
5150 in the same real function we were stepping through, but we have
5151 to go further up to find the exact frame ID, we are stepping
5152 through a more inlined call beyond its call site. */
5154 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
5155 && !frame_id_eq (get_frame_id (get_current_frame ()),
5156 ecs->event_thread->control.step_frame_id)
5157 && stepped_in_from (get_current_frame (),
5158 ecs->event_thread->control.step_frame_id))
5161 fprintf_unfiltered (gdb_stdlog,
5162 "infrun: stepping through inlined function\n");
5164 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5168 ecs->event_thread->control.stop_step = 1;
5169 print_end_stepping_range_reason ();
5170 stop_stepping (ecs);
5175 if ((stop_pc == stop_pc_sal.pc)
5176 && (ecs->event_thread->current_line != stop_pc_sal.line
5177 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
5179 /* We are at the start of a different line. So stop. Note that
5180 we don't stop if we step into the middle of a different line.
5181 That is said to make things like for (;;) statements work
5184 fprintf_unfiltered (gdb_stdlog,
5185 "infrun: stepped to a different line\n");
5186 ecs->event_thread->control.stop_step = 1;
5187 print_end_stepping_range_reason ();
5188 stop_stepping (ecs);
5192 /* We aren't done stepping.
5194 Optimize by setting the stepping range to the line.
5195 (We might not be in the original line, but if we entered a
5196 new line in mid-statement, we continue stepping. This makes
5197 things like for(;;) statements work better.) */
5199 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
5200 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
5201 ecs->event_thread->control.may_range_step = 1;
5202 set_step_info (frame, stop_pc_sal);
5205 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
5209 /* In all-stop mode, if we're currently stepping but have stopped in
5210 some other thread, we may need to switch back to the stepped
5211 thread. Returns true we set the inferior running, false if we left
5212 it stopped (and the event needs further processing). */
5215 switch_back_to_stepped_thread (struct execution_control_state *ecs)
5219 struct thread_info *tp;
5221 tp = iterate_over_threads (currently_stepping_or_nexting_callback,
5225 /* However, if the current thread is blocked on some internal
5226 breakpoint, and we simply need to step over that breakpoint
5227 to get it going again, do that first. */
5228 if ((ecs->event_thread->control.trap_expected
5229 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5230 || ecs->event_thread->stepping_over_breakpoint)
5236 /* If the stepping thread exited, then don't try to switch
5237 back and resume it, which could fail in several different
5238 ways depending on the target. Instead, just keep going.
5240 We can find a stepping dead thread in the thread list in
5243 - The target supports thread exit events, and when the
5244 target tries to delete the thread from the thread list,
5245 inferior_ptid pointed at the exiting thread. In such
5246 case, calling delete_thread does not really remove the
5247 thread from the list; instead, the thread is left listed,
5248 with 'exited' state.
5250 - The target's debug interface does not support thread
5251 exit events, and so we have no idea whatsoever if the
5252 previously stepping thread is still alive. For that
5253 reason, we need to synchronously query the target
5255 if (is_exited (tp->ptid)
5256 || !target_thread_alive (tp->ptid))
5259 fprintf_unfiltered (gdb_stdlog,
5260 "infrun: not switching back to "
5261 "stepped thread, it has vanished\n");
5263 delete_thread (tp->ptid);
5268 /* Otherwise, we no longer expect a trap in the current thread.
5269 Clear the trap_expected flag before switching back -- this is
5270 what keep_going would do as well, if we called it. */
5271 ecs->event_thread->control.trap_expected = 0;
5274 fprintf_unfiltered (gdb_stdlog,
5275 "infrun: switching back to stepped thread\n");
5277 ecs->event_thread = tp;
5278 ecs->ptid = tp->ptid;
5279 context_switch (ecs->ptid);
5287 /* Is thread TP in the middle of single-stepping? */
5290 currently_stepping (struct thread_info *tp)
5292 return ((tp->control.step_range_end
5293 && tp->control.step_resume_breakpoint == NULL)
5294 || tp->control.trap_expected
5295 || bpstat_should_step ());
5298 /* Returns true if any thread *but* the one passed in "data" is in the
5299 middle of stepping or of handling a "next". */
5302 currently_stepping_or_nexting_callback (struct thread_info *tp, void *data)
5307 return (tp->control.step_range_end
5308 || tp->control.trap_expected);
5311 /* Inferior has stepped into a subroutine call with source code that
5312 we should not step over. Do step to the first line of code in
5316 handle_step_into_function (struct gdbarch *gdbarch,
5317 struct execution_control_state *ecs)
5320 struct symtab_and_line stop_func_sal, sr_sal;
5322 fill_in_stop_func (gdbarch, ecs);
5324 s = find_pc_symtab (stop_pc);
5325 if (s && s->language != language_asm)
5326 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5327 ecs->stop_func_start);
5329 stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
5330 /* Use the step_resume_break to step until the end of the prologue,
5331 even if that involves jumps (as it seems to on the vax under
5333 /* If the prologue ends in the middle of a source line, continue to
5334 the end of that source line (if it is still within the function).
5335 Otherwise, just go to end of prologue. */
5336 if (stop_func_sal.end
5337 && stop_func_sal.pc != ecs->stop_func_start
5338 && stop_func_sal.end < ecs->stop_func_end)
5339 ecs->stop_func_start = stop_func_sal.end;
5341 /* Architectures which require breakpoint adjustment might not be able
5342 to place a breakpoint at the computed address. If so, the test
5343 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
5344 ecs->stop_func_start to an address at which a breakpoint may be
5345 legitimately placed.
5347 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
5348 made, GDB will enter an infinite loop when stepping through
5349 optimized code consisting of VLIW instructions which contain
5350 subinstructions corresponding to different source lines. On
5351 FR-V, it's not permitted to place a breakpoint on any but the
5352 first subinstruction of a VLIW instruction. When a breakpoint is
5353 set, GDB will adjust the breakpoint address to the beginning of
5354 the VLIW instruction. Thus, we need to make the corresponding
5355 adjustment here when computing the stop address. */
5357 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
5359 ecs->stop_func_start
5360 = gdbarch_adjust_breakpoint_address (gdbarch,
5361 ecs->stop_func_start);
5364 if (ecs->stop_func_start == stop_pc)
5366 /* We are already there: stop now. */
5367 ecs->event_thread->control.stop_step = 1;
5368 print_end_stepping_range_reason ();
5369 stop_stepping (ecs);
5374 /* Put the step-breakpoint there and go until there. */
5375 init_sal (&sr_sal); /* initialize to zeroes */
5376 sr_sal.pc = ecs->stop_func_start;
5377 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
5378 sr_sal.pspace = get_frame_program_space (get_current_frame ());
5380 /* Do not specify what the fp should be when we stop since on
5381 some machines the prologue is where the new fp value is
5383 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
5385 /* And make sure stepping stops right away then. */
5386 ecs->event_thread->control.step_range_end
5387 = ecs->event_thread->control.step_range_start;
5392 /* Inferior has stepped backward into a subroutine call with source
5393 code that we should not step over. Do step to the beginning of the
5394 last line of code in it. */
5397 handle_step_into_function_backward (struct gdbarch *gdbarch,
5398 struct execution_control_state *ecs)
5401 struct symtab_and_line stop_func_sal;
5403 fill_in_stop_func (gdbarch, ecs);
5405 s = find_pc_symtab (stop_pc);
5406 if (s && s->language != language_asm)
5407 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5408 ecs->stop_func_start);
5410 stop_func_sal = find_pc_line (stop_pc, 0);
5412 /* OK, we're just going to keep stepping here. */
5413 if (stop_func_sal.pc == stop_pc)
5415 /* We're there already. Just stop stepping now. */
5416 ecs->event_thread->control.stop_step = 1;
5417 print_end_stepping_range_reason ();
5418 stop_stepping (ecs);
5422 /* Else just reset the step range and keep going.
5423 No step-resume breakpoint, they don't work for
5424 epilogues, which can have multiple entry paths. */
5425 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
5426 ecs->event_thread->control.step_range_end = stop_func_sal.end;
5432 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
5433 This is used to both functions and to skip over code. */
5436 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
5437 struct symtab_and_line sr_sal,
5438 struct frame_id sr_id,
5439 enum bptype sr_type)
5441 /* There should never be more than one step-resume or longjmp-resume
5442 breakpoint per thread, so we should never be setting a new
5443 step_resume_breakpoint when one is already active. */
5444 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
5445 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
5448 fprintf_unfiltered (gdb_stdlog,
5449 "infrun: inserting step-resume breakpoint at %s\n",
5450 paddress (gdbarch, sr_sal.pc));
5452 inferior_thread ()->control.step_resume_breakpoint
5453 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
5457 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
5458 struct symtab_and_line sr_sal,
5459 struct frame_id sr_id)
5461 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
5466 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
5467 This is used to skip a potential signal handler.
5469 This is called with the interrupted function's frame. The signal
5470 handler, when it returns, will resume the interrupted function at
5474 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
5476 struct symtab_and_line sr_sal;
5477 struct gdbarch *gdbarch;
5479 gdb_assert (return_frame != NULL);
5480 init_sal (&sr_sal); /* initialize to zeros */
5482 gdbarch = get_frame_arch (return_frame);
5483 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
5484 sr_sal.section = find_pc_overlay (sr_sal.pc);
5485 sr_sal.pspace = get_frame_program_space (return_frame);
5487 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
5488 get_stack_frame_id (return_frame),
5492 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
5493 is used to skip a function after stepping into it (for "next" or if
5494 the called function has no debugging information).
5496 The current function has almost always been reached by single
5497 stepping a call or return instruction. NEXT_FRAME belongs to the
5498 current function, and the breakpoint will be set at the caller's
5501 This is a separate function rather than reusing
5502 insert_hp_step_resume_breakpoint_at_frame in order to avoid
5503 get_prev_frame, which may stop prematurely (see the implementation
5504 of frame_unwind_caller_id for an example). */
5507 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
5509 struct symtab_and_line sr_sal;
5510 struct gdbarch *gdbarch;
5512 /* We shouldn't have gotten here if we don't know where the call site
5514 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
5516 init_sal (&sr_sal); /* initialize to zeros */
5518 gdbarch = frame_unwind_caller_arch (next_frame);
5519 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
5520 frame_unwind_caller_pc (next_frame));
5521 sr_sal.section = find_pc_overlay (sr_sal.pc);
5522 sr_sal.pspace = frame_unwind_program_space (next_frame);
5524 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
5525 frame_unwind_caller_id (next_frame));
5528 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
5529 new breakpoint at the target of a jmp_buf. The handling of
5530 longjmp-resume uses the same mechanisms used for handling
5531 "step-resume" breakpoints. */
5534 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
5536 /* There should never be more than one longjmp-resume breakpoint per
5537 thread, so we should never be setting a new
5538 longjmp_resume_breakpoint when one is already active. */
5539 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
5542 fprintf_unfiltered (gdb_stdlog,
5543 "infrun: inserting longjmp-resume breakpoint at %s\n",
5544 paddress (gdbarch, pc));
5546 inferior_thread ()->control.exception_resume_breakpoint =
5547 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
5550 /* Insert an exception resume breakpoint. TP is the thread throwing
5551 the exception. The block B is the block of the unwinder debug hook
5552 function. FRAME is the frame corresponding to the call to this
5553 function. SYM is the symbol of the function argument holding the
5554 target PC of the exception. */
5557 insert_exception_resume_breakpoint (struct thread_info *tp,
5559 struct frame_info *frame,
5562 volatile struct gdb_exception e;
5564 /* We want to ignore errors here. */
5565 TRY_CATCH (e, RETURN_MASK_ERROR)
5567 struct symbol *vsym;
5568 struct value *value;
5570 struct breakpoint *bp;
5572 vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
5573 value = read_var_value (vsym, frame);
5574 /* If the value was optimized out, revert to the old behavior. */
5575 if (! value_optimized_out (value))
5577 handler = value_as_address (value);
5580 fprintf_unfiltered (gdb_stdlog,
5581 "infrun: exception resume at %lx\n",
5582 (unsigned long) handler);
5584 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5585 handler, bp_exception_resume);
5587 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
5590 bp->thread = tp->num;
5591 inferior_thread ()->control.exception_resume_breakpoint = bp;
5596 /* A helper for check_exception_resume that sets an
5597 exception-breakpoint based on a SystemTap probe. */
5600 insert_exception_resume_from_probe (struct thread_info *tp,
5601 const struct bound_probe *probe,
5602 struct frame_info *frame)
5604 struct value *arg_value;
5606 struct breakpoint *bp;
5608 arg_value = probe_safe_evaluate_at_pc (frame, 1);
5612 handler = value_as_address (arg_value);
5615 fprintf_unfiltered (gdb_stdlog,
5616 "infrun: exception resume at %s\n",
5617 paddress (get_objfile_arch (probe->objfile),
5620 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5621 handler, bp_exception_resume);
5622 bp->thread = tp->num;
5623 inferior_thread ()->control.exception_resume_breakpoint = bp;
5626 /* This is called when an exception has been intercepted. Check to
5627 see whether the exception's destination is of interest, and if so,
5628 set an exception resume breakpoint there. */
5631 check_exception_resume (struct execution_control_state *ecs,
5632 struct frame_info *frame)
5634 volatile struct gdb_exception e;
5635 struct bound_probe probe;
5636 struct symbol *func;
5638 /* First see if this exception unwinding breakpoint was set via a
5639 SystemTap probe point. If so, the probe has two arguments: the
5640 CFA and the HANDLER. We ignore the CFA, extract the handler, and
5641 set a breakpoint there. */
5642 probe = find_probe_by_pc (get_frame_pc (frame));
5645 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
5649 func = get_frame_function (frame);
5653 TRY_CATCH (e, RETURN_MASK_ERROR)
5656 struct block_iterator iter;
5660 /* The exception breakpoint is a thread-specific breakpoint on
5661 the unwinder's debug hook, declared as:
5663 void _Unwind_DebugHook (void *cfa, void *handler);
5665 The CFA argument indicates the frame to which control is
5666 about to be transferred. HANDLER is the destination PC.
5668 We ignore the CFA and set a temporary breakpoint at HANDLER.
5669 This is not extremely efficient but it avoids issues in gdb
5670 with computing the DWARF CFA, and it also works even in weird
5671 cases such as throwing an exception from inside a signal
5674 b = SYMBOL_BLOCK_VALUE (func);
5675 ALL_BLOCK_SYMBOLS (b, iter, sym)
5677 if (!SYMBOL_IS_ARGUMENT (sym))
5684 insert_exception_resume_breakpoint (ecs->event_thread,
5693 stop_stepping (struct execution_control_state *ecs)
5696 fprintf_unfiltered (gdb_stdlog, "infrun: stop_stepping\n");
5698 /* Let callers know we don't want to wait for the inferior anymore. */
5699 ecs->wait_some_more = 0;
5702 /* Called when we should continue running the inferior, because the
5703 current event doesn't cause a user visible stop. This does the
5704 resuming part; waiting for the next event is done elsewhere. */
5707 keep_going (struct execution_control_state *ecs)
5709 /* Make sure normal_stop is called if we get a QUIT handled before
5711 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
5713 /* Save the pc before execution, to compare with pc after stop. */
5714 ecs->event_thread->prev_pc
5715 = regcache_read_pc (get_thread_regcache (ecs->ptid));
5717 if (ecs->event_thread->control.trap_expected
5718 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5720 /* We haven't yet gotten our trap, and either: intercepted a
5721 non-signal event (e.g., a fork); or took a signal which we
5722 are supposed to pass through to the inferior. Simply
5724 discard_cleanups (old_cleanups);
5725 resume (currently_stepping (ecs->event_thread),
5726 ecs->event_thread->suspend.stop_signal);
5730 /* Either the trap was not expected, but we are continuing
5731 anyway (if we got a signal, the user asked it be passed to
5734 We got our expected trap, but decided we should resume from
5737 We're going to run this baby now!
5739 Note that insert_breakpoints won't try to re-insert
5740 already inserted breakpoints. Therefore, we don't
5741 care if breakpoints were already inserted, or not. */
5743 if (ecs->event_thread->stepping_over_breakpoint)
5745 struct regcache *thread_regcache = get_thread_regcache (ecs->ptid);
5747 if (!use_displaced_stepping (get_regcache_arch (thread_regcache)))
5749 /* Since we can't do a displaced step, we have to remove
5750 the breakpoint while we step it. To keep things
5751 simple, we remove them all. */
5752 remove_breakpoints ();
5757 volatile struct gdb_exception e;
5759 /* Stop stepping if inserting breakpoints fails. */
5760 TRY_CATCH (e, RETURN_MASK_ERROR)
5762 insert_breakpoints ();
5766 exception_print (gdb_stderr, e);
5767 stop_stepping (ecs);
5772 ecs->event_thread->control.trap_expected
5773 = ecs->event_thread->stepping_over_breakpoint;
5775 /* Do not deliver GDB_SIGNAL_TRAP (except when the user
5776 explicitly specifies that such a signal should be delivered
5777 to the target program). Typically, that would occur when a
5778 user is debugging a target monitor on a simulator: the target
5779 monitor sets a breakpoint; the simulator encounters this
5780 breakpoint and halts the simulation handing control to GDB;
5781 GDB, noting that the stop address doesn't map to any known
5782 breakpoint, returns control back to the simulator; the
5783 simulator then delivers the hardware equivalent of a
5784 GDB_SIGNAL_TRAP to the program being debugged. */
5785 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5786 && !signal_program[ecs->event_thread->suspend.stop_signal])
5787 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5789 discard_cleanups (old_cleanups);
5790 resume (currently_stepping (ecs->event_thread),
5791 ecs->event_thread->suspend.stop_signal);
5794 prepare_to_wait (ecs);
5797 /* This function normally comes after a resume, before
5798 handle_inferior_event exits. It takes care of any last bits of
5799 housekeeping, and sets the all-important wait_some_more flag. */
5802 prepare_to_wait (struct execution_control_state *ecs)
5805 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
5807 /* This is the old end of the while loop. Let everybody know we
5808 want to wait for the inferior some more and get called again
5810 ecs->wait_some_more = 1;
5813 /* Several print_*_reason functions to print why the inferior has stopped.
5814 We always print something when the inferior exits, or receives a signal.
5815 The rest of the cases are dealt with later on in normal_stop and
5816 print_it_typical. Ideally there should be a call to one of these
5817 print_*_reason functions functions from handle_inferior_event each time
5818 stop_stepping is called. */
5820 /* Print why the inferior has stopped.
5821 We are done with a step/next/si/ni command, print why the inferior has
5822 stopped. For now print nothing. Print a message only if not in the middle
5823 of doing a "step n" operation for n > 1. */
5826 print_end_stepping_range_reason (void)
5828 if ((!inferior_thread ()->step_multi
5829 || !inferior_thread ()->control.stop_step)
5830 && ui_out_is_mi_like_p (current_uiout))
5831 ui_out_field_string (current_uiout, "reason",
5832 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
5835 /* The inferior was terminated by a signal, print why it stopped. */
5838 print_signal_exited_reason (enum gdb_signal siggnal)
5840 struct ui_out *uiout = current_uiout;
5842 annotate_signalled ();
5843 if (ui_out_is_mi_like_p (uiout))
5845 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
5846 ui_out_text (uiout, "\nProgram terminated with signal ");
5847 annotate_signal_name ();
5848 ui_out_field_string (uiout, "signal-name",
5849 gdb_signal_to_name (siggnal));
5850 annotate_signal_name_end ();
5851 ui_out_text (uiout, ", ");
5852 annotate_signal_string ();
5853 ui_out_field_string (uiout, "signal-meaning",
5854 gdb_signal_to_string (siggnal));
5855 annotate_signal_string_end ();
5856 ui_out_text (uiout, ".\n");
5857 ui_out_text (uiout, "The program no longer exists.\n");
5860 /* The inferior program is finished, print why it stopped. */
5863 print_exited_reason (int exitstatus)
5865 struct inferior *inf = current_inferior ();
5866 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
5867 struct ui_out *uiout = current_uiout;
5869 annotate_exited (exitstatus);
5872 if (ui_out_is_mi_like_p (uiout))
5873 ui_out_field_string (uiout, "reason",
5874 async_reason_lookup (EXEC_ASYNC_EXITED));
5875 ui_out_text (uiout, "[Inferior ");
5876 ui_out_text (uiout, plongest (inf->num));
5877 ui_out_text (uiout, " (");
5878 ui_out_text (uiout, pidstr);
5879 ui_out_text (uiout, ") exited with code ");
5880 ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
5881 ui_out_text (uiout, "]\n");
5885 if (ui_out_is_mi_like_p (uiout))
5887 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
5888 ui_out_text (uiout, "[Inferior ");
5889 ui_out_text (uiout, plongest (inf->num));
5890 ui_out_text (uiout, " (");
5891 ui_out_text (uiout, pidstr);
5892 ui_out_text (uiout, ") exited normally]\n");
5894 /* Support the --return-child-result option. */
5895 return_child_result_value = exitstatus;
5898 /* Signal received, print why the inferior has stopped. The signal table
5899 tells us to print about it. */
5902 print_signal_received_reason (enum gdb_signal siggnal)
5904 struct ui_out *uiout = current_uiout;
5908 if (siggnal == GDB_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
5910 struct thread_info *t = inferior_thread ();
5912 ui_out_text (uiout, "\n[");
5913 ui_out_field_string (uiout, "thread-name",
5914 target_pid_to_str (t->ptid));
5915 ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
5916 ui_out_text (uiout, " stopped");
5920 ui_out_text (uiout, "\nProgram received signal ");
5921 annotate_signal_name ();
5922 if (ui_out_is_mi_like_p (uiout))
5924 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
5925 ui_out_field_string (uiout, "signal-name",
5926 gdb_signal_to_name (siggnal));
5927 annotate_signal_name_end ();
5928 ui_out_text (uiout, ", ");
5929 annotate_signal_string ();
5930 ui_out_field_string (uiout, "signal-meaning",
5931 gdb_signal_to_string (siggnal));
5932 annotate_signal_string_end ();
5934 ui_out_text (uiout, ".\n");
5937 /* Reverse execution: target ran out of history info, print why the inferior
5941 print_no_history_reason (void)
5943 ui_out_text (current_uiout, "\nNo more reverse-execution history.\n");
5946 /* Print current location without a level number, if we have changed
5947 functions or hit a breakpoint. Print source line if we have one.
5948 bpstat_print contains the logic deciding in detail what to print,
5949 based on the event(s) that just occurred. */
5952 print_stop_event (struct target_waitstatus *ws)
5956 int do_frame_printing = 1;
5957 struct thread_info *tp = inferior_thread ();
5959 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
5963 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
5964 should) carry around the function and does (or should) use
5965 that when doing a frame comparison. */
5966 if (tp->control.stop_step
5967 && frame_id_eq (tp->control.step_frame_id,
5968 get_frame_id (get_current_frame ()))
5969 && step_start_function == find_pc_function (stop_pc))
5971 /* Finished step, just print source line. */
5972 source_flag = SRC_LINE;
5976 /* Print location and source line. */
5977 source_flag = SRC_AND_LOC;
5980 case PRINT_SRC_AND_LOC:
5981 /* Print location and source line. */
5982 source_flag = SRC_AND_LOC;
5984 case PRINT_SRC_ONLY:
5985 source_flag = SRC_LINE;
5988 /* Something bogus. */
5989 source_flag = SRC_LINE;
5990 do_frame_printing = 0;
5993 internal_error (__FILE__, __LINE__, _("Unknown value."));
5996 /* The behavior of this routine with respect to the source
5998 SRC_LINE: Print only source line
5999 LOCATION: Print only location
6000 SRC_AND_LOC: Print location and source line. */
6001 if (do_frame_printing)
6002 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
6004 /* Display the auto-display expressions. */
6008 /* Here to return control to GDB when the inferior stops for real.
6009 Print appropriate messages, remove breakpoints, give terminal our modes.
6011 STOP_PRINT_FRAME nonzero means print the executing frame
6012 (pc, function, args, file, line number and line text).
6013 BREAKPOINTS_FAILED nonzero means stop was due to error
6014 attempting to insert breakpoints. */
6019 struct target_waitstatus last;
6021 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
6023 get_last_target_status (&last_ptid, &last);
6025 /* If an exception is thrown from this point on, make sure to
6026 propagate GDB's knowledge of the executing state to the
6027 frontend/user running state. A QUIT is an easy exception to see
6028 here, so do this before any filtered output. */
6030 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
6031 else if (last.kind != TARGET_WAITKIND_SIGNALLED
6032 && last.kind != TARGET_WAITKIND_EXITED
6033 && last.kind != TARGET_WAITKIND_NO_RESUMED)
6034 make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
6036 /* In non-stop mode, we don't want GDB to switch threads behind the
6037 user's back, to avoid races where the user is typing a command to
6038 apply to thread x, but GDB switches to thread y before the user
6039 finishes entering the command. */
6041 /* As with the notification of thread events, we want to delay
6042 notifying the user that we've switched thread context until
6043 the inferior actually stops.
6045 There's no point in saying anything if the inferior has exited.
6046 Note that SIGNALLED here means "exited with a signal", not
6047 "received a signal". */
6049 && !ptid_equal (previous_inferior_ptid, inferior_ptid)
6050 && target_has_execution
6051 && last.kind != TARGET_WAITKIND_SIGNALLED
6052 && last.kind != TARGET_WAITKIND_EXITED
6053 && last.kind != TARGET_WAITKIND_NO_RESUMED)
6055 target_terminal_ours_for_output ();
6056 printf_filtered (_("[Switching to %s]\n"),
6057 target_pid_to_str (inferior_ptid));
6058 annotate_thread_changed ();
6059 previous_inferior_ptid = inferior_ptid;
6062 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
6064 gdb_assert (sync_execution || !target_can_async_p ());
6066 target_terminal_ours_for_output ();
6067 printf_filtered (_("No unwaited-for children left.\n"));
6070 if (!breakpoints_always_inserted_mode () && target_has_execution)
6072 if (remove_breakpoints ())
6074 target_terminal_ours_for_output ();
6075 printf_filtered (_("Cannot remove breakpoints because "
6076 "program is no longer writable.\nFurther "
6077 "execution is probably impossible.\n"));
6081 /* If an auto-display called a function and that got a signal,
6082 delete that auto-display to avoid an infinite recursion. */
6084 if (stopped_by_random_signal)
6085 disable_current_display ();
6087 /* Don't print a message if in the middle of doing a "step n"
6088 operation for n > 1 */
6089 if (target_has_execution
6090 && last.kind != TARGET_WAITKIND_SIGNALLED
6091 && last.kind != TARGET_WAITKIND_EXITED
6092 && inferior_thread ()->step_multi
6093 && inferior_thread ()->control.stop_step)
6096 target_terminal_ours ();
6097 async_enable_stdin ();
6099 /* Set the current source location. This will also happen if we
6100 display the frame below, but the current SAL will be incorrect
6101 during a user hook-stop function. */
6102 if (has_stack_frames () && !stop_stack_dummy)
6103 set_current_sal_from_frame (get_current_frame (), 1);
6105 /* Let the user/frontend see the threads as stopped. */
6106 do_cleanups (old_chain);
6108 /* Look up the hook_stop and run it (CLI internally handles problem
6109 of stop_command's pre-hook not existing). */
6111 catch_errors (hook_stop_stub, stop_command,
6112 "Error while running hook_stop:\n", RETURN_MASK_ALL);
6114 if (!has_stack_frames ())
6117 if (last.kind == TARGET_WAITKIND_SIGNALLED
6118 || last.kind == TARGET_WAITKIND_EXITED)
6121 /* Select innermost stack frame - i.e., current frame is frame 0,
6122 and current location is based on that.
6123 Don't do this on return from a stack dummy routine,
6124 or if the program has exited. */
6126 if (!stop_stack_dummy)
6128 select_frame (get_current_frame ());
6130 /* If --batch-silent is enabled then there's no need to print the current
6131 source location, and to try risks causing an error message about
6132 missing source files. */
6133 if (stop_print_frame && !batch_silent)
6134 print_stop_event (&last);
6137 /* Save the function value return registers, if we care.
6138 We might be about to restore their previous contents. */
6139 if (inferior_thread ()->control.proceed_to_finish
6140 && execution_direction != EXEC_REVERSE)
6142 /* This should not be necessary. */
6144 regcache_xfree (stop_registers);
6146 /* NB: The copy goes through to the target picking up the value of
6147 all the registers. */
6148 stop_registers = regcache_dup (get_current_regcache ());
6151 if (stop_stack_dummy == STOP_STACK_DUMMY)
6153 /* Pop the empty frame that contains the stack dummy.
6154 This also restores inferior state prior to the call
6155 (struct infcall_suspend_state). */
6156 struct frame_info *frame = get_current_frame ();
6158 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
6160 /* frame_pop() calls reinit_frame_cache as the last thing it
6161 does which means there's currently no selected frame. We
6162 don't need to re-establish a selected frame if the dummy call
6163 returns normally, that will be done by
6164 restore_infcall_control_state. However, we do have to handle
6165 the case where the dummy call is returning after being
6166 stopped (e.g. the dummy call previously hit a breakpoint).
6167 We can't know which case we have so just always re-establish
6168 a selected frame here. */
6169 select_frame (get_current_frame ());
6173 annotate_stopped ();
6175 /* Suppress the stop observer if we're in the middle of:
6177 - a step n (n > 1), as there still more steps to be done.
6179 - a "finish" command, as the observer will be called in
6180 finish_command_continuation, so it can include the inferior
6181 function's return value.
6183 - calling an inferior function, as we pretend we inferior didn't
6184 run at all. The return value of the call is handled by the
6185 expression evaluator, through call_function_by_hand. */
6187 if (!target_has_execution
6188 || last.kind == TARGET_WAITKIND_SIGNALLED
6189 || last.kind == TARGET_WAITKIND_EXITED
6190 || last.kind == TARGET_WAITKIND_NO_RESUMED
6191 || (!(inferior_thread ()->step_multi
6192 && inferior_thread ()->control.stop_step)
6193 && !(inferior_thread ()->control.stop_bpstat
6194 && inferior_thread ()->control.proceed_to_finish)
6195 && !inferior_thread ()->control.in_infcall))
6197 if (!ptid_equal (inferior_ptid, null_ptid))
6198 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
6201 observer_notify_normal_stop (NULL, stop_print_frame);
6204 if (target_has_execution)
6206 if (last.kind != TARGET_WAITKIND_SIGNALLED
6207 && last.kind != TARGET_WAITKIND_EXITED)
6208 /* Delete the breakpoint we stopped at, if it wants to be deleted.
6209 Delete any breakpoint that is to be deleted at the next stop. */
6210 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
6213 /* Try to get rid of automatically added inferiors that are no
6214 longer needed. Keeping those around slows down things linearly.
6215 Note that this never removes the current inferior. */
6220 hook_stop_stub (void *cmd)
6222 execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
6227 signal_stop_state (int signo)
6229 return signal_stop[signo];
6233 signal_print_state (int signo)
6235 return signal_print[signo];
6239 signal_pass_state (int signo)
6241 return signal_program[signo];
6245 signal_cache_update (int signo)
6249 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
6250 signal_cache_update (signo);
6255 signal_pass[signo] = (signal_stop[signo] == 0
6256 && signal_print[signo] == 0
6257 && signal_program[signo] == 1
6258 && signal_catch[signo] == 0);
6262 signal_stop_update (int signo, int state)
6264 int ret = signal_stop[signo];
6266 signal_stop[signo] = state;
6267 signal_cache_update (signo);
6272 signal_print_update (int signo, int state)
6274 int ret = signal_print[signo];
6276 signal_print[signo] = state;
6277 signal_cache_update (signo);
6282 signal_pass_update (int signo, int state)
6284 int ret = signal_program[signo];
6286 signal_program[signo] = state;
6287 signal_cache_update (signo);
6291 /* Update the global 'signal_catch' from INFO and notify the
6295 signal_catch_update (const unsigned int *info)
6299 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
6300 signal_catch[i] = info[i] > 0;
6301 signal_cache_update (-1);
6302 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6306 sig_print_header (void)
6308 printf_filtered (_("Signal Stop\tPrint\tPass "
6309 "to program\tDescription\n"));
6313 sig_print_info (enum gdb_signal oursig)
6315 const char *name = gdb_signal_to_name (oursig);
6316 int name_padding = 13 - strlen (name);
6318 if (name_padding <= 0)
6321 printf_filtered ("%s", name);
6322 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
6323 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
6324 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
6325 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
6326 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
6329 /* Specify how various signals in the inferior should be handled. */
6332 handle_command (char *args, int from_tty)
6335 int digits, wordlen;
6336 int sigfirst, signum, siglast;
6337 enum gdb_signal oursig;
6340 unsigned char *sigs;
6341 struct cleanup *old_chain;
6345 error_no_arg (_("signal to handle"));
6348 /* Allocate and zero an array of flags for which signals to handle. */
6350 nsigs = (int) GDB_SIGNAL_LAST;
6351 sigs = (unsigned char *) alloca (nsigs);
6352 memset (sigs, 0, nsigs);
6354 /* Break the command line up into args. */
6356 argv = gdb_buildargv (args);
6357 old_chain = make_cleanup_freeargv (argv);
6359 /* Walk through the args, looking for signal oursigs, signal names, and
6360 actions. Signal numbers and signal names may be interspersed with
6361 actions, with the actions being performed for all signals cumulatively
6362 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
6364 while (*argv != NULL)
6366 wordlen = strlen (*argv);
6367 for (digits = 0; isdigit ((*argv)[digits]); digits++)
6371 sigfirst = siglast = -1;
6373 if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
6375 /* Apply action to all signals except those used by the
6376 debugger. Silently skip those. */
6379 siglast = nsigs - 1;
6381 else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
6383 SET_SIGS (nsigs, sigs, signal_stop);
6384 SET_SIGS (nsigs, sigs, signal_print);
6386 else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
6388 UNSET_SIGS (nsigs, sigs, signal_program);
6390 else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
6392 SET_SIGS (nsigs, sigs, signal_print);
6394 else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
6396 SET_SIGS (nsigs, sigs, signal_program);
6398 else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
6400 UNSET_SIGS (nsigs, sigs, signal_stop);
6402 else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
6404 SET_SIGS (nsigs, sigs, signal_program);
6406 else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
6408 UNSET_SIGS (nsigs, sigs, signal_print);
6409 UNSET_SIGS (nsigs, sigs, signal_stop);
6411 else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
6413 UNSET_SIGS (nsigs, sigs, signal_program);
6415 else if (digits > 0)
6417 /* It is numeric. The numeric signal refers to our own
6418 internal signal numbering from target.h, not to host/target
6419 signal number. This is a feature; users really should be
6420 using symbolic names anyway, and the common ones like
6421 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
6423 sigfirst = siglast = (int)
6424 gdb_signal_from_command (atoi (*argv));
6425 if ((*argv)[digits] == '-')
6428 gdb_signal_from_command (atoi ((*argv) + digits + 1));
6430 if (sigfirst > siglast)
6432 /* Bet he didn't figure we'd think of this case... */
6440 oursig = gdb_signal_from_name (*argv);
6441 if (oursig != GDB_SIGNAL_UNKNOWN)
6443 sigfirst = siglast = (int) oursig;
6447 /* Not a number and not a recognized flag word => complain. */
6448 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv);
6452 /* If any signal numbers or symbol names were found, set flags for
6453 which signals to apply actions to. */
6455 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
6457 switch ((enum gdb_signal) signum)
6459 case GDB_SIGNAL_TRAP:
6460 case GDB_SIGNAL_INT:
6461 if (!allsigs && !sigs[signum])
6463 if (query (_("%s is used by the debugger.\n\
6464 Are you sure you want to change it? "),
6465 gdb_signal_to_name ((enum gdb_signal) signum)))
6471 printf_unfiltered (_("Not confirmed, unchanged.\n"));
6472 gdb_flush (gdb_stdout);
6477 case GDB_SIGNAL_DEFAULT:
6478 case GDB_SIGNAL_UNKNOWN:
6479 /* Make sure that "all" doesn't print these. */
6490 for (signum = 0; signum < nsigs; signum++)
6493 signal_cache_update (-1);
6494 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6495 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
6499 /* Show the results. */
6500 sig_print_header ();
6501 for (; signum < nsigs; signum++)
6503 sig_print_info (signum);
6509 do_cleanups (old_chain);
6512 /* Complete the "handle" command. */
6514 static VEC (char_ptr) *
6515 handle_completer (struct cmd_list_element *ignore,
6516 const char *text, const char *word)
6518 VEC (char_ptr) *vec_signals, *vec_keywords, *return_val;
6519 static const char * const keywords[] =
6533 vec_signals = signal_completer (ignore, text, word);
6534 vec_keywords = complete_on_enum (keywords, word, word);
6536 return_val = VEC_merge (char_ptr, vec_signals, vec_keywords);
6537 VEC_free (char_ptr, vec_signals);
6538 VEC_free (char_ptr, vec_keywords);
6543 xdb_handle_command (char *args, int from_tty)
6546 struct cleanup *old_chain;
6549 error_no_arg (_("xdb command"));
6551 /* Break the command line up into args. */
6553 argv = gdb_buildargv (args);
6554 old_chain = make_cleanup_freeargv (argv);
6555 if (argv[1] != (char *) NULL)
6560 bufLen = strlen (argv[0]) + 20;
6561 argBuf = (char *) xmalloc (bufLen);
6565 enum gdb_signal oursig;
6567 oursig = gdb_signal_from_name (argv[0]);
6568 memset (argBuf, 0, bufLen);
6569 if (strcmp (argv[1], "Q") == 0)
6570 sprintf (argBuf, "%s %s", argv[0], "noprint");
6573 if (strcmp (argv[1], "s") == 0)
6575 if (!signal_stop[oursig])
6576 sprintf (argBuf, "%s %s", argv[0], "stop");
6578 sprintf (argBuf, "%s %s", argv[0], "nostop");
6580 else if (strcmp (argv[1], "i") == 0)
6582 if (!signal_program[oursig])
6583 sprintf (argBuf, "%s %s", argv[0], "pass");
6585 sprintf (argBuf, "%s %s", argv[0], "nopass");
6587 else if (strcmp (argv[1], "r") == 0)
6589 if (!signal_print[oursig])
6590 sprintf (argBuf, "%s %s", argv[0], "print");
6592 sprintf (argBuf, "%s %s", argv[0], "noprint");
6598 handle_command (argBuf, from_tty);
6600 printf_filtered (_("Invalid signal handling flag.\n"));
6605 do_cleanups (old_chain);
6609 gdb_signal_from_command (int num)
6611 if (num >= 1 && num <= 15)
6612 return (enum gdb_signal) num;
6613 error (_("Only signals 1-15 are valid as numeric signals.\n\
6614 Use \"info signals\" for a list of symbolic signals."));
6617 /* Print current contents of the tables set by the handle command.
6618 It is possible we should just be printing signals actually used
6619 by the current target (but for things to work right when switching
6620 targets, all signals should be in the signal tables). */
6623 signals_info (char *signum_exp, int from_tty)
6625 enum gdb_signal oursig;
6627 sig_print_header ();
6631 /* First see if this is a symbol name. */
6632 oursig = gdb_signal_from_name (signum_exp);
6633 if (oursig == GDB_SIGNAL_UNKNOWN)
6635 /* No, try numeric. */
6637 gdb_signal_from_command (parse_and_eval_long (signum_exp));
6639 sig_print_info (oursig);
6643 printf_filtered ("\n");
6644 /* These ugly casts brought to you by the native VAX compiler. */
6645 for (oursig = GDB_SIGNAL_FIRST;
6646 (int) oursig < (int) GDB_SIGNAL_LAST;
6647 oursig = (enum gdb_signal) ((int) oursig + 1))
6651 if (oursig != GDB_SIGNAL_UNKNOWN
6652 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
6653 sig_print_info (oursig);
6656 printf_filtered (_("\nUse the \"handle\" command "
6657 "to change these tables.\n"));
6660 /* Check if it makes sense to read $_siginfo from the current thread
6661 at this point. If not, throw an error. */
6664 validate_siginfo_access (void)
6666 /* No current inferior, no siginfo. */
6667 if (ptid_equal (inferior_ptid, null_ptid))
6668 error (_("No thread selected."));
6670 /* Don't try to read from a dead thread. */
6671 if (is_exited (inferior_ptid))
6672 error (_("The current thread has terminated"));
6674 /* ... or from a spinning thread. */
6675 if (is_running (inferior_ptid))
6676 error (_("Selected thread is running."));
6679 /* The $_siginfo convenience variable is a bit special. We don't know
6680 for sure the type of the value until we actually have a chance to
6681 fetch the data. The type can change depending on gdbarch, so it is
6682 also dependent on which thread you have selected.
6684 1. making $_siginfo be an internalvar that creates a new value on
6687 2. making the value of $_siginfo be an lval_computed value. */
6689 /* This function implements the lval_computed support for reading a
6693 siginfo_value_read (struct value *v)
6695 LONGEST transferred;
6697 validate_siginfo_access ();
6700 target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO,
6702 value_contents_all_raw (v),
6704 TYPE_LENGTH (value_type (v)));
6706 if (transferred != TYPE_LENGTH (value_type (v)))
6707 error (_("Unable to read siginfo"));
6710 /* This function implements the lval_computed support for writing a
6714 siginfo_value_write (struct value *v, struct value *fromval)
6716 LONGEST transferred;
6718 validate_siginfo_access ();
6720 transferred = target_write (¤t_target,
6721 TARGET_OBJECT_SIGNAL_INFO,
6723 value_contents_all_raw (fromval),
6725 TYPE_LENGTH (value_type (fromval)));
6727 if (transferred != TYPE_LENGTH (value_type (fromval)))
6728 error (_("Unable to write siginfo"));
6731 static const struct lval_funcs siginfo_value_funcs =
6737 /* Return a new value with the correct type for the siginfo object of
6738 the current thread using architecture GDBARCH. Return a void value
6739 if there's no object available. */
6741 static struct value *
6742 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
6745 if (target_has_stack
6746 && !ptid_equal (inferior_ptid, null_ptid)
6747 && gdbarch_get_siginfo_type_p (gdbarch))
6749 struct type *type = gdbarch_get_siginfo_type (gdbarch);
6751 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
6754 return allocate_value (builtin_type (gdbarch)->builtin_void);
6758 /* infcall_suspend_state contains state about the program itself like its
6759 registers and any signal it received when it last stopped.
6760 This state must be restored regardless of how the inferior function call
6761 ends (either successfully, or after it hits a breakpoint or signal)
6762 if the program is to properly continue where it left off. */
6764 struct infcall_suspend_state
6766 struct thread_suspend_state thread_suspend;
6767 #if 0 /* Currently unused and empty structures are not valid C. */
6768 struct inferior_suspend_state inferior_suspend;
6773 struct regcache *registers;
6775 /* Format of SIGINFO_DATA or NULL if it is not present. */
6776 struct gdbarch *siginfo_gdbarch;
6778 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
6779 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
6780 content would be invalid. */
6781 gdb_byte *siginfo_data;
6784 struct infcall_suspend_state *
6785 save_infcall_suspend_state (void)
6787 struct infcall_suspend_state *inf_state;
6788 struct thread_info *tp = inferior_thread ();
6790 struct inferior *inf = current_inferior ();
6792 struct regcache *regcache = get_current_regcache ();
6793 struct gdbarch *gdbarch = get_regcache_arch (regcache);
6794 gdb_byte *siginfo_data = NULL;
6796 if (gdbarch_get_siginfo_type_p (gdbarch))
6798 struct type *type = gdbarch_get_siginfo_type (gdbarch);
6799 size_t len = TYPE_LENGTH (type);
6800 struct cleanup *back_to;
6802 siginfo_data = xmalloc (len);
6803 back_to = make_cleanup (xfree, siginfo_data);
6805 if (target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
6806 siginfo_data, 0, len) == len)
6807 discard_cleanups (back_to);
6810 /* Errors ignored. */
6811 do_cleanups (back_to);
6812 siginfo_data = NULL;
6816 inf_state = XCNEW (struct infcall_suspend_state);
6820 inf_state->siginfo_gdbarch = gdbarch;
6821 inf_state->siginfo_data = siginfo_data;
6824 inf_state->thread_suspend = tp->suspend;
6825 #if 0 /* Currently unused and empty structures are not valid C. */
6826 inf_state->inferior_suspend = inf->suspend;
6829 /* run_inferior_call will not use the signal due to its `proceed' call with
6830 GDB_SIGNAL_0 anyway. */
6831 tp->suspend.stop_signal = GDB_SIGNAL_0;
6833 inf_state->stop_pc = stop_pc;
6835 inf_state->registers = regcache_dup (regcache);
6840 /* Restore inferior session state to INF_STATE. */
6843 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
6845 struct thread_info *tp = inferior_thread ();
6847 struct inferior *inf = current_inferior ();
6849 struct regcache *regcache = get_current_regcache ();
6850 struct gdbarch *gdbarch = get_regcache_arch (regcache);
6852 tp->suspend = inf_state->thread_suspend;
6853 #if 0 /* Currently unused and empty structures are not valid C. */
6854 inf->suspend = inf_state->inferior_suspend;
6857 stop_pc = inf_state->stop_pc;
6859 if (inf_state->siginfo_gdbarch == gdbarch)
6861 struct type *type = gdbarch_get_siginfo_type (gdbarch);
6863 /* Errors ignored. */
6864 target_write (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
6865 inf_state->siginfo_data, 0, TYPE_LENGTH (type));
6868 /* The inferior can be gone if the user types "print exit(0)"
6869 (and perhaps other times). */
6870 if (target_has_execution)
6871 /* NB: The register write goes through to the target. */
6872 regcache_cpy (regcache, inf_state->registers);
6874 discard_infcall_suspend_state (inf_state);
6878 do_restore_infcall_suspend_state_cleanup (void *state)
6880 restore_infcall_suspend_state (state);
6884 make_cleanup_restore_infcall_suspend_state
6885 (struct infcall_suspend_state *inf_state)
6887 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
6891 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
6893 regcache_xfree (inf_state->registers);
6894 xfree (inf_state->siginfo_data);
6899 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
6901 return inf_state->registers;
6904 /* infcall_control_state contains state regarding gdb's control of the
6905 inferior itself like stepping control. It also contains session state like
6906 the user's currently selected frame. */
6908 struct infcall_control_state
6910 struct thread_control_state thread_control;
6911 struct inferior_control_state inferior_control;
6914 enum stop_stack_kind stop_stack_dummy;
6915 int stopped_by_random_signal;
6916 int stop_after_trap;
6918 /* ID if the selected frame when the inferior function call was made. */
6919 struct frame_id selected_frame_id;
6922 /* Save all of the information associated with the inferior<==>gdb
6925 struct infcall_control_state *
6926 save_infcall_control_state (void)
6928 struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status));
6929 struct thread_info *tp = inferior_thread ();
6930 struct inferior *inf = current_inferior ();
6932 inf_status->thread_control = tp->control;
6933 inf_status->inferior_control = inf->control;
6935 tp->control.step_resume_breakpoint = NULL;
6936 tp->control.exception_resume_breakpoint = NULL;
6938 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
6939 chain. If caller's caller is walking the chain, they'll be happier if we
6940 hand them back the original chain when restore_infcall_control_state is
6942 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
6945 inf_status->stop_stack_dummy = stop_stack_dummy;
6946 inf_status->stopped_by_random_signal = stopped_by_random_signal;
6947 inf_status->stop_after_trap = stop_after_trap;
6949 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
6955 restore_selected_frame (void *args)
6957 struct frame_id *fid = (struct frame_id *) args;
6958 struct frame_info *frame;
6960 frame = frame_find_by_id (*fid);
6962 /* If inf_status->selected_frame_id is NULL, there was no previously
6966 warning (_("Unable to restore previously selected frame."));
6970 select_frame (frame);
6975 /* Restore inferior session state to INF_STATUS. */
6978 restore_infcall_control_state (struct infcall_control_state *inf_status)
6980 struct thread_info *tp = inferior_thread ();
6981 struct inferior *inf = current_inferior ();
6983 if (tp->control.step_resume_breakpoint)
6984 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
6986 if (tp->control.exception_resume_breakpoint)
6987 tp->control.exception_resume_breakpoint->disposition
6988 = disp_del_at_next_stop;
6990 /* Handle the bpstat_copy of the chain. */
6991 bpstat_clear (&tp->control.stop_bpstat);
6993 tp->control = inf_status->thread_control;
6994 inf->control = inf_status->inferior_control;
6997 stop_stack_dummy = inf_status->stop_stack_dummy;
6998 stopped_by_random_signal = inf_status->stopped_by_random_signal;
6999 stop_after_trap = inf_status->stop_after_trap;
7001 if (target_has_stack)
7003 /* The point of catch_errors is that if the stack is clobbered,
7004 walking the stack might encounter a garbage pointer and
7005 error() trying to dereference it. */
7007 (restore_selected_frame, &inf_status->selected_frame_id,
7008 "Unable to restore previously selected frame:\n",
7009 RETURN_MASK_ERROR) == 0)
7010 /* Error in restoring the selected frame. Select the innermost
7012 select_frame (get_current_frame ());
7019 do_restore_infcall_control_state_cleanup (void *sts)
7021 restore_infcall_control_state (sts);
7025 make_cleanup_restore_infcall_control_state
7026 (struct infcall_control_state *inf_status)
7028 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
7032 discard_infcall_control_state (struct infcall_control_state *inf_status)
7034 if (inf_status->thread_control.step_resume_breakpoint)
7035 inf_status->thread_control.step_resume_breakpoint->disposition
7036 = disp_del_at_next_stop;
7038 if (inf_status->thread_control.exception_resume_breakpoint)
7039 inf_status->thread_control.exception_resume_breakpoint->disposition
7040 = disp_del_at_next_stop;
7042 /* See save_infcall_control_state for info on stop_bpstat. */
7043 bpstat_clear (&inf_status->thread_control.stop_bpstat);
7048 /* restore_inferior_ptid() will be used by the cleanup machinery
7049 to restore the inferior_ptid value saved in a call to
7050 save_inferior_ptid(). */
7053 restore_inferior_ptid (void *arg)
7055 ptid_t *saved_ptid_ptr = arg;
7057 inferior_ptid = *saved_ptid_ptr;
7061 /* Save the value of inferior_ptid so that it may be restored by a
7062 later call to do_cleanups(). Returns the struct cleanup pointer
7063 needed for later doing the cleanup. */
7066 save_inferior_ptid (void)
7068 ptid_t *saved_ptid_ptr;
7070 saved_ptid_ptr = xmalloc (sizeof (ptid_t));
7071 *saved_ptid_ptr = inferior_ptid;
7072 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
7075 /* See inferior.h. */
7078 clear_exit_convenience_vars (void)
7080 clear_internalvar (lookup_internalvar ("_exitsignal"));
7081 clear_internalvar (lookup_internalvar ("_exitcode"));
7085 /* User interface for reverse debugging:
7086 Set exec-direction / show exec-direction commands
7087 (returns error unless target implements to_set_exec_direction method). */
7089 int execution_direction = EXEC_FORWARD;
7090 static const char exec_forward[] = "forward";
7091 static const char exec_reverse[] = "reverse";
7092 static const char *exec_direction = exec_forward;
7093 static const char *const exec_direction_names[] = {
7100 set_exec_direction_func (char *args, int from_tty,
7101 struct cmd_list_element *cmd)
7103 if (target_can_execute_reverse)
7105 if (!strcmp (exec_direction, exec_forward))
7106 execution_direction = EXEC_FORWARD;
7107 else if (!strcmp (exec_direction, exec_reverse))
7108 execution_direction = EXEC_REVERSE;
7112 exec_direction = exec_forward;
7113 error (_("Target does not support this operation."));
7118 show_exec_direction_func (struct ui_file *out, int from_tty,
7119 struct cmd_list_element *cmd, const char *value)
7121 switch (execution_direction) {
7123 fprintf_filtered (out, _("Forward.\n"));
7126 fprintf_filtered (out, _("Reverse.\n"));
7129 internal_error (__FILE__, __LINE__,
7130 _("bogus execution_direction value: %d"),
7131 (int) execution_direction);
7136 show_schedule_multiple (struct ui_file *file, int from_tty,
7137 struct cmd_list_element *c, const char *value)
7139 fprintf_filtered (file, _("Resuming the execution of threads "
7140 "of all processes is %s.\n"), value);
7143 /* Implementation of `siginfo' variable. */
7145 static const struct internalvar_funcs siginfo_funcs =
7153 _initialize_infrun (void)
7157 struct cmd_list_element *c;
7159 add_info ("signals", signals_info, _("\
7160 What debugger does when program gets various signals.\n\
7161 Specify a signal as argument to print info on that signal only."));
7162 add_info_alias ("handle", "signals", 0);
7164 c = add_com ("handle", class_run, handle_command, _("\
7165 Specify how to handle signals.\n\
7166 Usage: handle SIGNAL [ACTIONS]\n\
7167 Args are signals and actions to apply to those signals.\n\
7168 If no actions are specified, the current settings for the specified signals\n\
7169 will be displayed instead.\n\
7171 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7172 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7173 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7174 The special arg \"all\" is recognized to mean all signals except those\n\
7175 used by the debugger, typically SIGTRAP and SIGINT.\n\
7177 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7178 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7179 Stop means reenter debugger if this signal happens (implies print).\n\
7180 Print means print a message if this signal happens.\n\
7181 Pass means let program see this signal; otherwise program doesn't know.\n\
7182 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7183 Pass and Stop may be combined.\n\
7185 Multiple signals may be specified. Signal numbers and signal names\n\
7186 may be interspersed with actions, with the actions being performed for\n\
7187 all signals cumulatively specified."));
7188 set_cmd_completer (c, handle_completer);
7192 add_com ("lz", class_info, signals_info, _("\
7193 What debugger does when program gets various signals.\n\
7194 Specify a signal as argument to print info on that signal only."));
7195 add_com ("z", class_run, xdb_handle_command, _("\
7196 Specify how to handle a signal.\n\
7197 Args are signals and actions to apply to those signals.\n\
7198 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7199 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7200 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7201 The special arg \"all\" is recognized to mean all signals except those\n\
7202 used by the debugger, typically SIGTRAP and SIGINT.\n\
7203 Recognized actions include \"s\" (toggles between stop and nostop),\n\
7204 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
7205 nopass), \"Q\" (noprint)\n\
7206 Stop means reenter debugger if this signal happens (implies print).\n\
7207 Print means print a message if this signal happens.\n\
7208 Pass means let program see this signal; otherwise program doesn't know.\n\
7209 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7210 Pass and Stop may be combined."));
7214 stop_command = add_cmd ("stop", class_obscure,
7215 not_just_help_class_command, _("\
7216 There is no `stop' command, but you can set a hook on `stop'.\n\
7217 This allows you to set a list of commands to be run each time execution\n\
7218 of the program stops."), &cmdlist);
7220 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
7221 Set inferior debugging."), _("\
7222 Show inferior debugging."), _("\
7223 When non-zero, inferior specific debugging is enabled."),
7226 &setdebuglist, &showdebuglist);
7228 add_setshow_boolean_cmd ("displaced", class_maintenance,
7229 &debug_displaced, _("\
7230 Set displaced stepping debugging."), _("\
7231 Show displaced stepping debugging."), _("\
7232 When non-zero, displaced stepping specific debugging is enabled."),
7234 show_debug_displaced,
7235 &setdebuglist, &showdebuglist);
7237 add_setshow_boolean_cmd ("non-stop", no_class,
7239 Set whether gdb controls the inferior in non-stop mode."), _("\
7240 Show whether gdb controls the inferior in non-stop mode."), _("\
7241 When debugging a multi-threaded program and this setting is\n\
7242 off (the default, also called all-stop mode), when one thread stops\n\
7243 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7244 all other threads in the program while you interact with the thread of\n\
7245 interest. When you continue or step a thread, you can allow the other\n\
7246 threads to run, or have them remain stopped, but while you inspect any\n\
7247 thread's state, all threads stop.\n\
7249 In non-stop mode, when one thread stops, other threads can continue\n\
7250 to run freely. You'll be able to step each thread independently,\n\
7251 leave it stopped or free to run as needed."),
7257 numsigs = (int) GDB_SIGNAL_LAST;
7258 signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
7259 signal_print = (unsigned char *)
7260 xmalloc (sizeof (signal_print[0]) * numsigs);
7261 signal_program = (unsigned char *)
7262 xmalloc (sizeof (signal_program[0]) * numsigs);
7263 signal_catch = (unsigned char *)
7264 xmalloc (sizeof (signal_catch[0]) * numsigs);
7265 signal_pass = (unsigned char *)
7266 xmalloc (sizeof (signal_program[0]) * numsigs);
7267 for (i = 0; i < numsigs; i++)
7270 signal_print[i] = 1;
7271 signal_program[i] = 1;
7272 signal_catch[i] = 0;
7275 /* Signals caused by debugger's own actions
7276 should not be given to the program afterwards. */
7277 signal_program[GDB_SIGNAL_TRAP] = 0;
7278 signal_program[GDB_SIGNAL_INT] = 0;
7280 /* Signals that are not errors should not normally enter the debugger. */
7281 signal_stop[GDB_SIGNAL_ALRM] = 0;
7282 signal_print[GDB_SIGNAL_ALRM] = 0;
7283 signal_stop[GDB_SIGNAL_VTALRM] = 0;
7284 signal_print[GDB_SIGNAL_VTALRM] = 0;
7285 signal_stop[GDB_SIGNAL_PROF] = 0;
7286 signal_print[GDB_SIGNAL_PROF] = 0;
7287 signal_stop[GDB_SIGNAL_CHLD] = 0;
7288 signal_print[GDB_SIGNAL_CHLD] = 0;
7289 signal_stop[GDB_SIGNAL_IO] = 0;
7290 signal_print[GDB_SIGNAL_IO] = 0;
7291 signal_stop[GDB_SIGNAL_POLL] = 0;
7292 signal_print[GDB_SIGNAL_POLL] = 0;
7293 signal_stop[GDB_SIGNAL_URG] = 0;
7294 signal_print[GDB_SIGNAL_URG] = 0;
7295 signal_stop[GDB_SIGNAL_WINCH] = 0;
7296 signal_print[GDB_SIGNAL_WINCH] = 0;
7297 signal_stop[GDB_SIGNAL_PRIO] = 0;
7298 signal_print[GDB_SIGNAL_PRIO] = 0;
7300 /* These signals are used internally by user-level thread
7301 implementations. (See signal(5) on Solaris.) Like the above
7302 signals, a healthy program receives and handles them as part of
7303 its normal operation. */
7304 signal_stop[GDB_SIGNAL_LWP] = 0;
7305 signal_print[GDB_SIGNAL_LWP] = 0;
7306 signal_stop[GDB_SIGNAL_WAITING] = 0;
7307 signal_print[GDB_SIGNAL_WAITING] = 0;
7308 signal_stop[GDB_SIGNAL_CANCEL] = 0;
7309 signal_print[GDB_SIGNAL_CANCEL] = 0;
7311 /* Update cached state. */
7312 signal_cache_update (-1);
7314 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
7315 &stop_on_solib_events, _("\
7316 Set stopping for shared library events."), _("\
7317 Show stopping for shared library events."), _("\
7318 If nonzero, gdb will give control to the user when the dynamic linker\n\
7319 notifies gdb of shared library events. The most common event of interest\n\
7320 to the user would be loading/unloading of a new library."),
7321 set_stop_on_solib_events,
7322 show_stop_on_solib_events,
7323 &setlist, &showlist);
7325 add_setshow_enum_cmd ("follow-fork-mode", class_run,
7326 follow_fork_mode_kind_names,
7327 &follow_fork_mode_string, _("\
7328 Set debugger response to a program call of fork or vfork."), _("\
7329 Show debugger response to a program call of fork or vfork."), _("\
7330 A fork or vfork creates a new process. follow-fork-mode can be:\n\
7331 parent - the original process is debugged after a fork\n\
7332 child - the new process is debugged after a fork\n\
7333 The unfollowed process will continue to run.\n\
7334 By default, the debugger will follow the parent process."),
7336 show_follow_fork_mode_string,
7337 &setlist, &showlist);
7339 add_setshow_enum_cmd ("follow-exec-mode", class_run,
7340 follow_exec_mode_names,
7341 &follow_exec_mode_string, _("\
7342 Set debugger response to a program call of exec."), _("\
7343 Show debugger response to a program call of exec."), _("\
7344 An exec call replaces the program image of a process.\n\
7346 follow-exec-mode can be:\n\
7348 new - the debugger creates a new inferior and rebinds the process\n\
7349 to this new inferior. The program the process was running before\n\
7350 the exec call can be restarted afterwards by restarting the original\n\
7353 same - the debugger keeps the process bound to the same inferior.\n\
7354 The new executable image replaces the previous executable loaded in\n\
7355 the inferior. Restarting the inferior after the exec call restarts\n\
7356 the executable the process was running after the exec call.\n\
7358 By default, the debugger will use the same inferior."),
7360 show_follow_exec_mode_string,
7361 &setlist, &showlist);
7363 add_setshow_enum_cmd ("scheduler-locking", class_run,
7364 scheduler_enums, &scheduler_mode, _("\
7365 Set mode for locking scheduler during execution."), _("\
7366 Show mode for locking scheduler during execution."), _("\
7367 off == no locking (threads may preempt at any time)\n\
7368 on == full locking (no thread except the current thread may run)\n\
7369 step == scheduler locked during every single-step operation.\n\
7370 In this mode, no other thread may run during a step command.\n\
7371 Other threads may run while stepping over a function call ('next')."),
7372 set_schedlock_func, /* traps on target vector */
7373 show_scheduler_mode,
7374 &setlist, &showlist);
7376 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
7377 Set mode for resuming threads of all processes."), _("\
7378 Show mode for resuming threads of all processes."), _("\
7379 When on, execution commands (such as 'continue' or 'next') resume all\n\
7380 threads of all processes. When off (which is the default), execution\n\
7381 commands only resume the threads of the current process. The set of\n\
7382 threads that are resumed is further refined by the scheduler-locking\n\
7383 mode (see help set scheduler-locking)."),
7385 show_schedule_multiple,
7386 &setlist, &showlist);
7388 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
7389 Set mode of the step operation."), _("\
7390 Show mode of the step operation."), _("\
7391 When set, doing a step over a function without debug line information\n\
7392 will stop at the first instruction of that function. Otherwise, the\n\
7393 function is skipped and the step command stops at a different source line."),
7395 show_step_stop_if_no_debug,
7396 &setlist, &showlist);
7398 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
7399 &can_use_displaced_stepping, _("\
7400 Set debugger's willingness to use displaced stepping."), _("\
7401 Show debugger's willingness to use displaced stepping."), _("\
7402 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7403 supported by the target architecture. If off, gdb will not use displaced\n\
7404 stepping to step over breakpoints, even if such is supported by the target\n\
7405 architecture. If auto (which is the default), gdb will use displaced stepping\n\
7406 if the target architecture supports it and non-stop mode is active, but will not\n\
7407 use it in all-stop mode (see help set non-stop)."),
7409 show_can_use_displaced_stepping,
7410 &setlist, &showlist);
7412 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
7413 &exec_direction, _("Set direction of execution.\n\
7414 Options are 'forward' or 'reverse'."),
7415 _("Show direction of execution (forward/reverse)."),
7416 _("Tells gdb whether to execute forward or backward."),
7417 set_exec_direction_func, show_exec_direction_func,
7418 &setlist, &showlist);
7420 /* Set/show detach-on-fork: user-settable mode. */
7422 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
7423 Set whether gdb will detach the child of a fork."), _("\
7424 Show whether gdb will detach the child of a fork."), _("\
7425 Tells gdb whether to detach the child of a fork."),
7426 NULL, NULL, &setlist, &showlist);
7428 /* Set/show disable address space randomization mode. */
7430 add_setshow_boolean_cmd ("disable-randomization", class_support,
7431 &disable_randomization, _("\
7432 Set disabling of debuggee's virtual address space randomization."), _("\
7433 Show disabling of debuggee's virtual address space randomization."), _("\
7434 When this mode is on (which is the default), randomization of the virtual\n\
7435 address space is disabled. Standalone programs run with the randomization\n\
7436 enabled by default on some platforms."),
7437 &set_disable_randomization,
7438 &show_disable_randomization,
7439 &setlist, &showlist);
7441 /* ptid initializations */
7442 inferior_ptid = null_ptid;
7443 target_last_wait_ptid = minus_one_ptid;
7445 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
7446 observer_attach_thread_stop_requested (infrun_thread_stop_requested);
7447 observer_attach_thread_exit (infrun_thread_thread_exit);
7448 observer_attach_inferior_exit (infrun_inferior_exit);
7450 /* Explicitly create without lookup, since that tries to create a
7451 value with a void typed value, and when we get here, gdbarch
7452 isn't initialized yet. At this point, we're quite sure there
7453 isn't another convenience variable of the same name. */
7454 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
7456 add_setshow_boolean_cmd ("observer", no_class,
7457 &observer_mode_1, _("\
7458 Set whether gdb controls the inferior in observer mode."), _("\
7459 Show whether gdb controls the inferior in observer mode."), _("\
7460 In observer mode, GDB can get data from the inferior, but not\n\
7461 affect its execution. Registers and memory may not be changed,\n\
7462 breakpoints may not be set, and the program cannot be interrupted\n\