1 /* Target-struct-independent code to start (run) and stop an inferior
4 Copyright (C) 1986-2015 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
31 #include "cli/cli-script.h"
33 #include "gdbthread.h"
45 #include "dictionary.h"
47 #include "mi/mi-common.h"
48 #include "event-top.h"
50 #include "record-full.h"
51 #include "inline-frame.h"
53 #include "tracepoint.h"
54 #include "continuations.h"
59 #include "completer.h"
60 #include "target-descriptions.h"
61 #include "target-dcache.h"
64 #include "event-loop.h"
66 /* Prototypes for local functions */
68 static void signals_info (char *, int);
70 static void handle_command (char *, int);
72 static void sig_print_info (enum gdb_signal
);
74 static void sig_print_header (void);
76 static void resume_cleanups (void *);
78 static int hook_stop_stub (void *);
80 static int restore_selected_frame (void *);
82 static int follow_fork (void);
84 static int follow_fork_inferior (int follow_child
, int detach_fork
);
86 static void follow_inferior_reset_breakpoints (void);
88 static void set_schedlock_func (char *args
, int from_tty
,
89 struct cmd_list_element
*c
);
91 static int currently_stepping (struct thread_info
*tp
);
93 void _initialize_infrun (void);
95 void nullify_last_target_wait_ptid (void);
97 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*);
99 static void insert_step_resume_breakpoint_at_caller (struct frame_info
*);
101 static void insert_longjmp_resume_breakpoint (struct gdbarch
*, CORE_ADDR
);
103 static int maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
);
105 /* Asynchronous signal handler registered as event loop source for
106 when we have pending events ready to be passed to the core. */
107 static struct async_event_handler
*infrun_async_inferior_event_token
;
109 /* Stores whether infrun_async was previously enabled or disabled.
110 Starts off as -1, indicating "never enabled/disabled". */
111 static int infrun_is_async
= -1;
116 infrun_async (int enable
)
118 if (infrun_is_async
!= enable
)
120 infrun_is_async
= enable
;
123 fprintf_unfiltered (gdb_stdlog
,
124 "infrun: infrun_async(%d)\n",
128 mark_async_event_handler (infrun_async_inferior_event_token
);
130 clear_async_event_handler (infrun_async_inferior_event_token
);
137 mark_infrun_async_event_handler (void)
139 mark_async_event_handler (infrun_async_inferior_event_token
);
142 /* When set, stop the 'step' command if we enter a function which has
143 no line number information. The normal behavior is that we step
144 over such function. */
145 int step_stop_if_no_debug
= 0;
147 show_step_stop_if_no_debug (struct ui_file
*file
, int from_tty
,
148 struct cmd_list_element
*c
, const char *value
)
150 fprintf_filtered (file
, _("Mode of the step operation is %s.\n"), value
);
153 /* In asynchronous mode, but simulating synchronous execution. */
155 int sync_execution
= 0;
157 /* proceed and normal_stop use this to notify the user when the
158 inferior stopped in a different thread than it had been running
161 static ptid_t previous_inferior_ptid
;
163 /* If set (default for legacy reasons), when following a fork, GDB
164 will detach from one of the fork branches, child or parent.
165 Exactly which branch is detached depends on 'set follow-fork-mode'
168 static int detach_fork
= 1;
170 int debug_displaced
= 0;
172 show_debug_displaced (struct ui_file
*file
, int from_tty
,
173 struct cmd_list_element
*c
, const char *value
)
175 fprintf_filtered (file
, _("Displace stepping debugging is %s.\n"), value
);
178 unsigned int debug_infrun
= 0;
180 show_debug_infrun (struct ui_file
*file
, int from_tty
,
181 struct cmd_list_element
*c
, const char *value
)
183 fprintf_filtered (file
, _("Inferior debugging is %s.\n"), value
);
187 /* Support for disabling address space randomization. */
189 int disable_randomization
= 1;
192 show_disable_randomization (struct ui_file
*file
, int from_tty
,
193 struct cmd_list_element
*c
, const char *value
)
195 if (target_supports_disable_randomization ())
196 fprintf_filtered (file
,
197 _("Disabling randomization of debuggee's "
198 "virtual address space is %s.\n"),
201 fputs_filtered (_("Disabling randomization of debuggee's "
202 "virtual address space is unsupported on\n"
203 "this platform.\n"), file
);
207 set_disable_randomization (char *args
, int from_tty
,
208 struct cmd_list_element
*c
)
210 if (!target_supports_disable_randomization ())
211 error (_("Disabling randomization of debuggee's "
212 "virtual address space is unsupported on\n"
216 /* User interface for non-stop mode. */
219 static int non_stop_1
= 0;
222 set_non_stop (char *args
, int from_tty
,
223 struct cmd_list_element
*c
)
225 if (target_has_execution
)
227 non_stop_1
= non_stop
;
228 error (_("Cannot change this setting while the inferior is running."));
231 non_stop
= non_stop_1
;
235 show_non_stop (struct ui_file
*file
, int from_tty
,
236 struct cmd_list_element
*c
, const char *value
)
238 fprintf_filtered (file
,
239 _("Controlling the inferior in non-stop mode is %s.\n"),
243 /* "Observer mode" is somewhat like a more extreme version of
244 non-stop, in which all GDB operations that might affect the
245 target's execution have been disabled. */
247 int observer_mode
= 0;
248 static int observer_mode_1
= 0;
251 set_observer_mode (char *args
, int from_tty
,
252 struct cmd_list_element
*c
)
254 if (target_has_execution
)
256 observer_mode_1
= observer_mode
;
257 error (_("Cannot change this setting while the inferior is running."));
260 observer_mode
= observer_mode_1
;
262 may_write_registers
= !observer_mode
;
263 may_write_memory
= !observer_mode
;
264 may_insert_breakpoints
= !observer_mode
;
265 may_insert_tracepoints
= !observer_mode
;
266 /* We can insert fast tracepoints in or out of observer mode,
267 but enable them if we're going into this mode. */
269 may_insert_fast_tracepoints
= 1;
270 may_stop
= !observer_mode
;
271 update_target_permissions ();
273 /* Going *into* observer mode we must force non-stop, then
274 going out we leave it that way. */
277 pagination_enabled
= 0;
278 non_stop
= non_stop_1
= 1;
282 printf_filtered (_("Observer mode is now %s.\n"),
283 (observer_mode
? "on" : "off"));
287 show_observer_mode (struct ui_file
*file
, int from_tty
,
288 struct cmd_list_element
*c
, const char *value
)
290 fprintf_filtered (file
, _("Observer mode is %s.\n"), value
);
293 /* This updates the value of observer mode based on changes in
294 permissions. Note that we are deliberately ignoring the values of
295 may-write-registers and may-write-memory, since the user may have
296 reason to enable these during a session, for instance to turn on a
297 debugging-related global. */
300 update_observer_mode (void)
304 newval
= (!may_insert_breakpoints
305 && !may_insert_tracepoints
306 && may_insert_fast_tracepoints
310 /* Let the user know if things change. */
311 if (newval
!= observer_mode
)
312 printf_filtered (_("Observer mode is now %s.\n"),
313 (newval
? "on" : "off"));
315 observer_mode
= observer_mode_1
= newval
;
318 /* Tables of how to react to signals; the user sets them. */
320 static unsigned char *signal_stop
;
321 static unsigned char *signal_print
;
322 static unsigned char *signal_program
;
324 /* Table of signals that are registered with "catch signal". A
325 non-zero entry indicates that the signal is caught by some "catch
326 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
328 static unsigned char *signal_catch
;
330 /* Table of signals that the target may silently handle.
331 This is automatically determined from the flags above,
332 and simply cached here. */
333 static unsigned char *signal_pass
;
335 #define SET_SIGS(nsigs,sigs,flags) \
337 int signum = (nsigs); \
338 while (signum-- > 0) \
339 if ((sigs)[signum]) \
340 (flags)[signum] = 1; \
343 #define UNSET_SIGS(nsigs,sigs,flags) \
345 int signum = (nsigs); \
346 while (signum-- > 0) \
347 if ((sigs)[signum]) \
348 (flags)[signum] = 0; \
351 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
352 this function is to avoid exporting `signal_program'. */
355 update_signals_program_target (void)
357 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
360 /* Value to pass to target_resume() to cause all threads to resume. */
362 #define RESUME_ALL minus_one_ptid
364 /* Command list pointer for the "stop" placeholder. */
366 static struct cmd_list_element
*stop_command
;
368 /* Nonzero if we want to give control to the user when we're notified
369 of shared library events by the dynamic linker. */
370 int stop_on_solib_events
;
372 /* Enable or disable optional shared library event breakpoints
373 as appropriate when the above flag is changed. */
376 set_stop_on_solib_events (char *args
, int from_tty
, struct cmd_list_element
*c
)
378 update_solib_breakpoints ();
382 show_stop_on_solib_events (struct ui_file
*file
, int from_tty
,
383 struct cmd_list_element
*c
, const char *value
)
385 fprintf_filtered (file
, _("Stopping for shared library events is %s.\n"),
389 /* Nonzero means expecting a trace trap
390 and should stop the inferior and return silently when it happens. */
394 /* Nonzero after stop if current stack frame should be printed. */
396 static int stop_print_frame
;
398 /* This is a cached copy of the pid/waitstatus of the last event
399 returned by target_wait()/deprecated_target_wait_hook(). This
400 information is returned by get_last_target_status(). */
401 static ptid_t target_last_wait_ptid
;
402 static struct target_waitstatus target_last_waitstatus
;
404 static void context_switch (ptid_t ptid
);
406 void init_thread_stepping_state (struct thread_info
*tss
);
408 static const char follow_fork_mode_child
[] = "child";
409 static const char follow_fork_mode_parent
[] = "parent";
411 static const char *const follow_fork_mode_kind_names
[] = {
412 follow_fork_mode_child
,
413 follow_fork_mode_parent
,
417 static const char *follow_fork_mode_string
= follow_fork_mode_parent
;
419 show_follow_fork_mode_string (struct ui_file
*file
, int from_tty
,
420 struct cmd_list_element
*c
, const char *value
)
422 fprintf_filtered (file
,
423 _("Debugger response to a program "
424 "call of fork or vfork is \"%s\".\n"),
429 /* Handle changes to the inferior list based on the type of fork,
430 which process is being followed, and whether the other process
431 should be detached. On entry inferior_ptid must be the ptid of
432 the fork parent. At return inferior_ptid is the ptid of the
433 followed inferior. */
436 follow_fork_inferior (int follow_child
, int detach_fork
)
439 ptid_t parent_ptid
, child_ptid
;
441 has_vforked
= (inferior_thread ()->pending_follow
.kind
442 == TARGET_WAITKIND_VFORKED
);
443 parent_ptid
= inferior_ptid
;
444 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
447 && !non_stop
/* Non-stop always resumes both branches. */
448 && (!target_is_async_p () || sync_execution
)
449 && !(follow_child
|| detach_fork
|| sched_multi
))
451 /* The parent stays blocked inside the vfork syscall until the
452 child execs or exits. If we don't let the child run, then
453 the parent stays blocked. If we're telling the parent to run
454 in the foreground, the user will not be able to ctrl-c to get
455 back the terminal, effectively hanging the debug session. */
456 fprintf_filtered (gdb_stderr
, _("\
457 Can not resume the parent process over vfork in the foreground while\n\
458 holding the child stopped. Try \"set detach-on-fork\" or \
459 \"set schedule-multiple\".\n"));
460 /* FIXME output string > 80 columns. */
466 /* Detach new forked process? */
469 struct cleanup
*old_chain
;
471 /* Before detaching from the child, remove all breakpoints
472 from it. If we forked, then this has already been taken
473 care of by infrun.c. If we vforked however, any
474 breakpoint inserted in the parent is visible in the
475 child, even those added while stopped in a vfork
476 catchpoint. This will remove the breakpoints from the
477 parent also, but they'll be reinserted below. */
480 /* Keep breakpoints list in sync. */
481 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
484 if (info_verbose
|| debug_infrun
)
486 /* Ensure that we have a process ptid. */
487 ptid_t process_ptid
= pid_to_ptid (ptid_get_pid (child_ptid
));
489 target_terminal_ours_for_output ();
490 fprintf_filtered (gdb_stdlog
,
491 _("Detaching after %s from child %s.\n"),
492 has_vforked
? "vfork" : "fork",
493 target_pid_to_str (process_ptid
));
498 struct inferior
*parent_inf
, *child_inf
;
499 struct cleanup
*old_chain
;
501 /* Add process to GDB's tables. */
502 child_inf
= add_inferior (ptid_get_pid (child_ptid
));
504 parent_inf
= current_inferior ();
505 child_inf
->attach_flag
= parent_inf
->attach_flag
;
506 copy_terminal_info (child_inf
, parent_inf
);
507 child_inf
->gdbarch
= parent_inf
->gdbarch
;
508 copy_inferior_target_desc_info (child_inf
, parent_inf
);
510 old_chain
= save_inferior_ptid ();
511 save_current_program_space ();
513 inferior_ptid
= child_ptid
;
514 add_thread (inferior_ptid
);
515 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
517 /* If this is a vfork child, then the address-space is
518 shared with the parent. */
521 child_inf
->pspace
= parent_inf
->pspace
;
522 child_inf
->aspace
= parent_inf
->aspace
;
524 /* The parent will be frozen until the child is done
525 with the shared region. Keep track of the
527 child_inf
->vfork_parent
= parent_inf
;
528 child_inf
->pending_detach
= 0;
529 parent_inf
->vfork_child
= child_inf
;
530 parent_inf
->pending_detach
= 0;
534 child_inf
->aspace
= new_address_space ();
535 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
536 child_inf
->removable
= 1;
537 set_current_program_space (child_inf
->pspace
);
538 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
540 /* Let the shared library layer (e.g., solib-svr4) learn
541 about this new process, relocate the cloned exec, pull
542 in shared libraries, and install the solib event
543 breakpoint. If a "cloned-VM" event was propagated
544 better throughout the core, this wouldn't be
546 solib_create_inferior_hook (0);
549 do_cleanups (old_chain
);
554 struct inferior
*parent_inf
;
556 parent_inf
= current_inferior ();
558 /* If we detached from the child, then we have to be careful
559 to not insert breakpoints in the parent until the child
560 is done with the shared memory region. However, if we're
561 staying attached to the child, then we can and should
562 insert breakpoints, so that we can debug it. A
563 subsequent child exec or exit is enough to know when does
564 the child stops using the parent's address space. */
565 parent_inf
->waiting_for_vfork_done
= detach_fork
;
566 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
571 /* Follow the child. */
572 struct inferior
*parent_inf
, *child_inf
;
573 struct program_space
*parent_pspace
;
575 if (info_verbose
|| debug_infrun
)
577 target_terminal_ours_for_output ();
578 fprintf_filtered (gdb_stdlog
,
579 _("Attaching after %s %s to child %s.\n"),
580 target_pid_to_str (parent_ptid
),
581 has_vforked
? "vfork" : "fork",
582 target_pid_to_str (child_ptid
));
585 /* Add the new inferior first, so that the target_detach below
586 doesn't unpush the target. */
588 child_inf
= add_inferior (ptid_get_pid (child_ptid
));
590 parent_inf
= current_inferior ();
591 child_inf
->attach_flag
= parent_inf
->attach_flag
;
592 copy_terminal_info (child_inf
, parent_inf
);
593 child_inf
->gdbarch
= parent_inf
->gdbarch
;
594 copy_inferior_target_desc_info (child_inf
, parent_inf
);
596 parent_pspace
= parent_inf
->pspace
;
598 /* If we're vforking, we want to hold on to the parent until the
599 child exits or execs. At child exec or exit time we can
600 remove the old breakpoints from the parent and detach or
601 resume debugging it. Otherwise, detach the parent now; we'll
602 want to reuse it's program/address spaces, but we can't set
603 them to the child before removing breakpoints from the
604 parent, otherwise, the breakpoints module could decide to
605 remove breakpoints from the wrong process (since they'd be
606 assigned to the same address space). */
610 gdb_assert (child_inf
->vfork_parent
== NULL
);
611 gdb_assert (parent_inf
->vfork_child
== NULL
);
612 child_inf
->vfork_parent
= parent_inf
;
613 child_inf
->pending_detach
= 0;
614 parent_inf
->vfork_child
= child_inf
;
615 parent_inf
->pending_detach
= detach_fork
;
616 parent_inf
->waiting_for_vfork_done
= 0;
618 else if (detach_fork
)
620 if (info_verbose
|| debug_infrun
)
622 /* Ensure that we have a process ptid. */
623 ptid_t process_ptid
= pid_to_ptid (ptid_get_pid (child_ptid
));
625 target_terminal_ours_for_output ();
626 fprintf_filtered (gdb_stdlog
,
627 _("Detaching after fork from "
629 target_pid_to_str (process_ptid
));
632 target_detach (NULL
, 0);
635 /* Note that the detach above makes PARENT_INF dangling. */
637 /* Add the child thread to the appropriate lists, and switch to
638 this new thread, before cloning the program space, and
639 informing the solib layer about this new process. */
641 inferior_ptid
= child_ptid
;
642 add_thread (inferior_ptid
);
644 /* If this is a vfork child, then the address-space is shared
645 with the parent. If we detached from the parent, then we can
646 reuse the parent's program/address spaces. */
647 if (has_vforked
|| detach_fork
)
649 child_inf
->pspace
= parent_pspace
;
650 child_inf
->aspace
= child_inf
->pspace
->aspace
;
654 child_inf
->aspace
= new_address_space ();
655 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
656 child_inf
->removable
= 1;
657 child_inf
->symfile_flags
= SYMFILE_NO_READ
;
658 set_current_program_space (child_inf
->pspace
);
659 clone_program_space (child_inf
->pspace
, parent_pspace
);
661 /* Let the shared library layer (e.g., solib-svr4) learn
662 about this new process, relocate the cloned exec, pull in
663 shared libraries, and install the solib event breakpoint.
664 If a "cloned-VM" event was propagated better throughout
665 the core, this wouldn't be required. */
666 solib_create_inferior_hook (0);
670 return target_follow_fork (follow_child
, detach_fork
);
673 /* Tell the target to follow the fork we're stopped at. Returns true
674 if the inferior should be resumed; false, if the target for some
675 reason decided it's best not to resume. */
680 int follow_child
= (follow_fork_mode_string
== follow_fork_mode_child
);
681 int should_resume
= 1;
682 struct thread_info
*tp
;
684 /* Copy user stepping state to the new inferior thread. FIXME: the
685 followed fork child thread should have a copy of most of the
686 parent thread structure's run control related fields, not just these.
687 Initialized to avoid "may be used uninitialized" warnings from gcc. */
688 struct breakpoint
*step_resume_breakpoint
= NULL
;
689 struct breakpoint
*exception_resume_breakpoint
= NULL
;
690 CORE_ADDR step_range_start
= 0;
691 CORE_ADDR step_range_end
= 0;
692 struct frame_id step_frame_id
= { 0 };
693 struct interp
*command_interp
= NULL
;
698 struct target_waitstatus wait_status
;
700 /* Get the last target status returned by target_wait(). */
701 get_last_target_status (&wait_ptid
, &wait_status
);
703 /* If not stopped at a fork event, then there's nothing else to
705 if (wait_status
.kind
!= TARGET_WAITKIND_FORKED
706 && wait_status
.kind
!= TARGET_WAITKIND_VFORKED
)
709 /* Check if we switched over from WAIT_PTID, since the event was
711 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
712 && !ptid_equal (inferior_ptid
, wait_ptid
))
714 /* We did. Switch back to WAIT_PTID thread, to tell the
715 target to follow it (in either direction). We'll
716 afterwards refuse to resume, and inform the user what
718 switch_to_thread (wait_ptid
);
723 tp
= inferior_thread ();
725 /* If there were any forks/vforks that were caught and are now to be
726 followed, then do so now. */
727 switch (tp
->pending_follow
.kind
)
729 case TARGET_WAITKIND_FORKED
:
730 case TARGET_WAITKIND_VFORKED
:
732 ptid_t parent
, child
;
734 /* If the user did a next/step, etc, over a fork call,
735 preserve the stepping state in the fork child. */
736 if (follow_child
&& should_resume
)
738 step_resume_breakpoint
= clone_momentary_breakpoint
739 (tp
->control
.step_resume_breakpoint
);
740 step_range_start
= tp
->control
.step_range_start
;
741 step_range_end
= tp
->control
.step_range_end
;
742 step_frame_id
= tp
->control
.step_frame_id
;
743 exception_resume_breakpoint
744 = clone_momentary_breakpoint (tp
->control
.exception_resume_breakpoint
);
745 command_interp
= tp
->control
.command_interp
;
747 /* For now, delete the parent's sr breakpoint, otherwise,
748 parent/child sr breakpoints are considered duplicates,
749 and the child version will not be installed. Remove
750 this when the breakpoints module becomes aware of
751 inferiors and address spaces. */
752 delete_step_resume_breakpoint (tp
);
753 tp
->control
.step_range_start
= 0;
754 tp
->control
.step_range_end
= 0;
755 tp
->control
.step_frame_id
= null_frame_id
;
756 delete_exception_resume_breakpoint (tp
);
757 tp
->control
.command_interp
= NULL
;
760 parent
= inferior_ptid
;
761 child
= tp
->pending_follow
.value
.related_pid
;
763 /* Set up inferior(s) as specified by the caller, and tell the
764 target to do whatever is necessary to follow either parent
766 if (follow_fork_inferior (follow_child
, detach_fork
))
768 /* Target refused to follow, or there's some other reason
769 we shouldn't resume. */
774 /* This pending follow fork event is now handled, one way
775 or another. The previous selected thread may be gone
776 from the lists by now, but if it is still around, need
777 to clear the pending follow request. */
778 tp
= find_thread_ptid (parent
);
780 tp
->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
782 /* This makes sure we don't try to apply the "Switched
783 over from WAIT_PID" logic above. */
784 nullify_last_target_wait_ptid ();
786 /* If we followed the child, switch to it... */
789 switch_to_thread (child
);
791 /* ... and preserve the stepping state, in case the
792 user was stepping over the fork call. */
795 tp
= inferior_thread ();
796 tp
->control
.step_resume_breakpoint
797 = step_resume_breakpoint
;
798 tp
->control
.step_range_start
= step_range_start
;
799 tp
->control
.step_range_end
= step_range_end
;
800 tp
->control
.step_frame_id
= step_frame_id
;
801 tp
->control
.exception_resume_breakpoint
802 = exception_resume_breakpoint
;
803 tp
->control
.command_interp
= command_interp
;
807 /* If we get here, it was because we're trying to
808 resume from a fork catchpoint, but, the user
809 has switched threads away from the thread that
810 forked. In that case, the resume command
811 issued is most likely not applicable to the
812 child, so just warn, and refuse to resume. */
813 warning (_("Not resuming: switched threads "
814 "before following fork child."));
817 /* Reset breakpoints in the child as appropriate. */
818 follow_inferior_reset_breakpoints ();
821 switch_to_thread (parent
);
825 case TARGET_WAITKIND_SPURIOUS
:
826 /* Nothing to follow. */
829 internal_error (__FILE__
, __LINE__
,
830 "Unexpected pending_follow.kind %d\n",
831 tp
->pending_follow
.kind
);
835 return should_resume
;
839 follow_inferior_reset_breakpoints (void)
841 struct thread_info
*tp
= inferior_thread ();
843 /* Was there a step_resume breakpoint? (There was if the user
844 did a "next" at the fork() call.) If so, explicitly reset its
845 thread number. Cloned step_resume breakpoints are disabled on
846 creation, so enable it here now that it is associated with the
849 step_resumes are a form of bp that are made to be per-thread.
850 Since we created the step_resume bp when the parent process
851 was being debugged, and now are switching to the child process,
852 from the breakpoint package's viewpoint, that's a switch of
853 "threads". We must update the bp's notion of which thread
854 it is for, or it'll be ignored when it triggers. */
856 if (tp
->control
.step_resume_breakpoint
)
858 breakpoint_re_set_thread (tp
->control
.step_resume_breakpoint
);
859 tp
->control
.step_resume_breakpoint
->loc
->enabled
= 1;
862 /* Treat exception_resume breakpoints like step_resume breakpoints. */
863 if (tp
->control
.exception_resume_breakpoint
)
865 breakpoint_re_set_thread (tp
->control
.exception_resume_breakpoint
);
866 tp
->control
.exception_resume_breakpoint
->loc
->enabled
= 1;
869 /* Reinsert all breakpoints in the child. The user may have set
870 breakpoints after catching the fork, in which case those
871 were never set in the child, but only in the parent. This makes
872 sure the inserted breakpoints match the breakpoint list. */
874 breakpoint_re_set ();
875 insert_breakpoints ();
878 /* The child has exited or execed: resume threads of the parent the
879 user wanted to be executing. */
882 proceed_after_vfork_done (struct thread_info
*thread
,
885 int pid
= * (int *) arg
;
887 if (ptid_get_pid (thread
->ptid
) == pid
888 && is_running (thread
->ptid
)
889 && !is_executing (thread
->ptid
)
890 && !thread
->stop_requested
891 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
894 fprintf_unfiltered (gdb_stdlog
,
895 "infrun: resuming vfork parent thread %s\n",
896 target_pid_to_str (thread
->ptid
));
898 switch_to_thread (thread
->ptid
);
899 clear_proceed_status (0);
900 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
906 /* Called whenever we notice an exec or exit event, to handle
907 detaching or resuming a vfork parent. */
910 handle_vfork_child_exec_or_exit (int exec
)
912 struct inferior
*inf
= current_inferior ();
914 if (inf
->vfork_parent
)
916 int resume_parent
= -1;
918 /* This exec or exit marks the end of the shared memory region
919 between the parent and the child. If the user wanted to
920 detach from the parent, now is the time. */
922 if (inf
->vfork_parent
->pending_detach
)
924 struct thread_info
*tp
;
925 struct cleanup
*old_chain
;
926 struct program_space
*pspace
;
927 struct address_space
*aspace
;
929 /* follow-fork child, detach-on-fork on. */
931 inf
->vfork_parent
->pending_detach
= 0;
935 /* If we're handling a child exit, then inferior_ptid
936 points at the inferior's pid, not to a thread. */
937 old_chain
= save_inferior_ptid ();
938 save_current_program_space ();
939 save_current_inferior ();
942 old_chain
= save_current_space_and_thread ();
944 /* We're letting loose of the parent. */
945 tp
= any_live_thread_of_process (inf
->vfork_parent
->pid
);
946 switch_to_thread (tp
->ptid
);
948 /* We're about to detach from the parent, which implicitly
949 removes breakpoints from its address space. There's a
950 catch here: we want to reuse the spaces for the child,
951 but, parent/child are still sharing the pspace at this
952 point, although the exec in reality makes the kernel give
953 the child a fresh set of new pages. The problem here is
954 that the breakpoints module being unaware of this, would
955 likely chose the child process to write to the parent
956 address space. Swapping the child temporarily away from
957 the spaces has the desired effect. Yes, this is "sort
960 pspace
= inf
->pspace
;
961 aspace
= inf
->aspace
;
965 if (debug_infrun
|| info_verbose
)
967 target_terminal_ours_for_output ();
971 fprintf_filtered (gdb_stdlog
,
972 _("Detaching vfork parent process "
973 "%d after child exec.\n"),
974 inf
->vfork_parent
->pid
);
978 fprintf_filtered (gdb_stdlog
,
979 _("Detaching vfork parent process "
980 "%d after child exit.\n"),
981 inf
->vfork_parent
->pid
);
985 target_detach (NULL
, 0);
988 inf
->pspace
= pspace
;
989 inf
->aspace
= aspace
;
991 do_cleanups (old_chain
);
995 /* We're staying attached to the parent, so, really give the
996 child a new address space. */
997 inf
->pspace
= add_program_space (maybe_new_address_space ());
998 inf
->aspace
= inf
->pspace
->aspace
;
1000 set_current_program_space (inf
->pspace
);
1002 resume_parent
= inf
->vfork_parent
->pid
;
1004 /* Break the bonds. */
1005 inf
->vfork_parent
->vfork_child
= NULL
;
1009 struct cleanup
*old_chain
;
1010 struct program_space
*pspace
;
1012 /* If this is a vfork child exiting, then the pspace and
1013 aspaces were shared with the parent. Since we're
1014 reporting the process exit, we'll be mourning all that is
1015 found in the address space, and switching to null_ptid,
1016 preparing to start a new inferior. But, since we don't
1017 want to clobber the parent's address/program spaces, we
1018 go ahead and create a new one for this exiting
1021 /* Switch to null_ptid, so that clone_program_space doesn't want
1022 to read the selected frame of a dead process. */
1023 old_chain
= save_inferior_ptid ();
1024 inferior_ptid
= null_ptid
;
1026 /* This inferior is dead, so avoid giving the breakpoints
1027 module the option to write through to it (cloning a
1028 program space resets breakpoints). */
1031 pspace
= add_program_space (maybe_new_address_space ());
1032 set_current_program_space (pspace
);
1034 inf
->symfile_flags
= SYMFILE_NO_READ
;
1035 clone_program_space (pspace
, inf
->vfork_parent
->pspace
);
1036 inf
->pspace
= pspace
;
1037 inf
->aspace
= pspace
->aspace
;
1039 /* Put back inferior_ptid. We'll continue mourning this
1041 do_cleanups (old_chain
);
1043 resume_parent
= inf
->vfork_parent
->pid
;
1044 /* Break the bonds. */
1045 inf
->vfork_parent
->vfork_child
= NULL
;
1048 inf
->vfork_parent
= NULL
;
1050 gdb_assert (current_program_space
== inf
->pspace
);
1052 if (non_stop
&& resume_parent
!= -1)
1054 /* If the user wanted the parent to be running, let it go
1056 struct cleanup
*old_chain
= make_cleanup_restore_current_thread ();
1059 fprintf_unfiltered (gdb_stdlog
,
1060 "infrun: resuming vfork parent process %d\n",
1063 iterate_over_threads (proceed_after_vfork_done
, &resume_parent
);
1065 do_cleanups (old_chain
);
1070 /* Enum strings for "set|show follow-exec-mode". */
1072 static const char follow_exec_mode_new
[] = "new";
1073 static const char follow_exec_mode_same
[] = "same";
1074 static const char *const follow_exec_mode_names
[] =
1076 follow_exec_mode_new
,
1077 follow_exec_mode_same
,
1081 static const char *follow_exec_mode_string
= follow_exec_mode_same
;
1083 show_follow_exec_mode_string (struct ui_file
*file
, int from_tty
,
1084 struct cmd_list_element
*c
, const char *value
)
1086 fprintf_filtered (file
, _("Follow exec mode is \"%s\".\n"), value
);
1089 /* EXECD_PATHNAME is assumed to be non-NULL. */
1092 follow_exec (ptid_t ptid
, char *execd_pathname
)
1094 struct thread_info
*th
, *tmp
;
1095 struct inferior
*inf
= current_inferior ();
1096 int pid
= ptid_get_pid (ptid
);
1098 /* This is an exec event that we actually wish to pay attention to.
1099 Refresh our symbol table to the newly exec'd program, remove any
1100 momentary bp's, etc.
1102 If there are breakpoints, they aren't really inserted now,
1103 since the exec() transformed our inferior into a fresh set
1106 We want to preserve symbolic breakpoints on the list, since
1107 we have hopes that they can be reset after the new a.out's
1108 symbol table is read.
1110 However, any "raw" breakpoints must be removed from the list
1111 (e.g., the solib bp's), since their address is probably invalid
1114 And, we DON'T want to call delete_breakpoints() here, since
1115 that may write the bp's "shadow contents" (the instruction
1116 value that was overwritten witha TRAP instruction). Since
1117 we now have a new a.out, those shadow contents aren't valid. */
1119 mark_breakpoints_out ();
1121 /* The target reports the exec event to the main thread, even if
1122 some other thread does the exec, and even if the main thread was
1123 stopped or already gone. We may still have non-leader threads of
1124 the process on our list. E.g., on targets that don't have thread
1125 exit events (like remote); or on native Linux in non-stop mode if
1126 there were only two threads in the inferior and the non-leader
1127 one is the one that execs (and nothing forces an update of the
1128 thread list up to here). When debugging remotely, it's best to
1129 avoid extra traffic, when possible, so avoid syncing the thread
1130 list with the target, and instead go ahead and delete all threads
1131 of the process but one that reported the event. Note this must
1132 be done before calling update_breakpoints_after_exec, as
1133 otherwise clearing the threads' resources would reference stale
1134 thread breakpoints -- it may have been one of these threads that
1135 stepped across the exec. We could just clear their stepping
1136 states, but as long as we're iterating, might as well delete
1137 them. Deleting them now rather than at the next user-visible
1138 stop provides a nicer sequence of events for user and MI
1140 ALL_THREADS_SAFE (th
, tmp
)
1141 if (ptid_get_pid (th
->ptid
) == pid
&& !ptid_equal (th
->ptid
, ptid
))
1142 delete_thread (th
->ptid
);
1144 /* We also need to clear any left over stale state for the
1145 leader/event thread. E.g., if there was any step-resume
1146 breakpoint or similar, it's gone now. We cannot truly
1147 step-to-next statement through an exec(). */
1148 th
= inferior_thread ();
1149 th
->control
.step_resume_breakpoint
= NULL
;
1150 th
->control
.exception_resume_breakpoint
= NULL
;
1151 th
->control
.single_step_breakpoints
= NULL
;
1152 th
->control
.step_range_start
= 0;
1153 th
->control
.step_range_end
= 0;
1155 /* The user may have had the main thread held stopped in the
1156 previous image (e.g., schedlock on, or non-stop). Release
1158 th
->stop_requested
= 0;
1160 update_breakpoints_after_exec ();
1162 /* What is this a.out's name? */
1163 printf_unfiltered (_("%s is executing new program: %s\n"),
1164 target_pid_to_str (inferior_ptid
),
1167 /* We've followed the inferior through an exec. Therefore, the
1168 inferior has essentially been killed & reborn. */
1170 gdb_flush (gdb_stdout
);
1172 breakpoint_init_inferior (inf_execd
);
1174 if (*gdb_sysroot
!= '\0')
1176 char *name
= exec_file_find (execd_pathname
, NULL
);
1178 execd_pathname
= alloca (strlen (name
) + 1);
1179 strcpy (execd_pathname
, name
);
1183 /* Reset the shared library package. This ensures that we get a
1184 shlib event when the child reaches "_start", at which point the
1185 dld will have had a chance to initialize the child. */
1186 /* Also, loading a symbol file below may trigger symbol lookups, and
1187 we don't want those to be satisfied by the libraries of the
1188 previous incarnation of this process. */
1189 no_shared_libraries (NULL
, 0);
1191 if (follow_exec_mode_string
== follow_exec_mode_new
)
1193 struct program_space
*pspace
;
1195 /* The user wants to keep the old inferior and program spaces
1196 around. Create a new fresh one, and switch to it. */
1198 /* Do exit processing for the original inferior before adding
1199 the new inferior so we don't have two active inferiors with
1200 the same ptid, which can confuse find_inferior_ptid. */
1201 exit_inferior_num_silent (current_inferior ()->num
);
1203 inf
= add_inferior (pid
);
1204 pspace
= add_program_space (maybe_new_address_space ());
1205 inf
->pspace
= pspace
;
1206 inf
->aspace
= pspace
->aspace
;
1209 set_current_inferior (inf
);
1210 set_current_program_space (pspace
);
1214 /* The old description may no longer be fit for the new image.
1215 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1216 old description; we'll read a new one below. No need to do
1217 this on "follow-exec-mode new", as the old inferior stays
1218 around (its description is later cleared/refetched on
1220 target_clear_description ();
1223 gdb_assert (current_program_space
== inf
->pspace
);
1225 /* That a.out is now the one to use. */
1226 exec_file_attach (execd_pathname
, 0);
1228 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1229 (Position Independent Executable) main symbol file will get applied by
1230 solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1231 the breakpoints with the zero displacement. */
1233 symbol_file_add (execd_pathname
,
1235 | SYMFILE_MAINLINE
| SYMFILE_DEFER_BP_RESET
),
1238 if ((inf
->symfile_flags
& SYMFILE_NO_READ
) == 0)
1239 set_initial_language ();
1241 /* If the target can specify a description, read it. Must do this
1242 after flipping to the new executable (because the target supplied
1243 description must be compatible with the executable's
1244 architecture, and the old executable may e.g., be 32-bit, while
1245 the new one 64-bit), and before anything involving memory or
1247 target_find_description ();
1249 solib_create_inferior_hook (0);
1251 jit_inferior_created_hook ();
1253 breakpoint_re_set ();
1255 /* Reinsert all breakpoints. (Those which were symbolic have
1256 been reset to the proper address in the new a.out, thanks
1257 to symbol_file_command...). */
1258 insert_breakpoints ();
1260 /* The next resume of this inferior should bring it to the shlib
1261 startup breakpoints. (If the user had also set bp's on
1262 "main" from the old (parent) process, then they'll auto-
1263 matically get reset there in the new process.). */
1266 /* The queue of threads that need to do a step-over operation to get
1267 past e.g., a breakpoint. What technique is used to step over the
1268 breakpoint/watchpoint does not matter -- all threads end up in the
1269 same queue, to maintain rough temporal order of execution, in order
1270 to avoid starvation, otherwise, we could e.g., find ourselves
1271 constantly stepping the same couple threads past their breakpoints
1272 over and over, if the single-step finish fast enough. */
1273 struct thread_info
*step_over_queue_head
;
1275 /* Bit flags indicating what the thread needs to step over. */
1279 /* Step over a breakpoint. */
1280 STEP_OVER_BREAKPOINT
= 1,
1282 /* Step past a non-continuable watchpoint, in order to let the
1283 instruction execute so we can evaluate the watchpoint
1285 STEP_OVER_WATCHPOINT
= 2
1288 /* Info about an instruction that is being stepped over. */
1290 struct step_over_info
1292 /* If we're stepping past a breakpoint, this is the address space
1293 and address of the instruction the breakpoint is set at. We'll
1294 skip inserting all breakpoints here. Valid iff ASPACE is
1296 struct address_space
*aspace
;
1299 /* The instruction being stepped over triggers a nonsteppable
1300 watchpoint. If true, we'll skip inserting watchpoints. */
1301 int nonsteppable_watchpoint_p
;
1304 /* The step-over info of the location that is being stepped over.
1306 Note that with async/breakpoint always-inserted mode, a user might
1307 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1308 being stepped over. As setting a new breakpoint inserts all
1309 breakpoints, we need to make sure the breakpoint being stepped over
1310 isn't inserted then. We do that by only clearing the step-over
1311 info when the step-over is actually finished (or aborted).
1313 Presently GDB can only step over one breakpoint at any given time.
1314 Given threads that can't run code in the same address space as the
1315 breakpoint's can't really miss the breakpoint, GDB could be taught
1316 to step-over at most one breakpoint per address space (so this info
1317 could move to the address space object if/when GDB is extended).
1318 The set of breakpoints being stepped over will normally be much
1319 smaller than the set of all breakpoints, so a flag in the
1320 breakpoint location structure would be wasteful. A separate list
1321 also saves complexity and run-time, as otherwise we'd have to go
1322 through all breakpoint locations clearing their flag whenever we
1323 start a new sequence. Similar considerations weigh against storing
1324 this info in the thread object. Plus, not all step overs actually
1325 have breakpoint locations -- e.g., stepping past a single-step
1326 breakpoint, or stepping to complete a non-continuable
1328 static struct step_over_info step_over_info
;
1330 /* Record the address of the breakpoint/instruction we're currently
1334 set_step_over_info (struct address_space
*aspace
, CORE_ADDR address
,
1335 int nonsteppable_watchpoint_p
)
1337 step_over_info
.aspace
= aspace
;
1338 step_over_info
.address
= address
;
1339 step_over_info
.nonsteppable_watchpoint_p
= nonsteppable_watchpoint_p
;
1342 /* Called when we're not longer stepping over a breakpoint / an
1343 instruction, so all breakpoints are free to be (re)inserted. */
1346 clear_step_over_info (void)
1349 fprintf_unfiltered (gdb_stdlog
,
1350 "infrun: clear_step_over_info\n");
1351 step_over_info
.aspace
= NULL
;
1352 step_over_info
.address
= 0;
1353 step_over_info
.nonsteppable_watchpoint_p
= 0;
1359 stepping_past_instruction_at (struct address_space
*aspace
,
1362 return (step_over_info
.aspace
!= NULL
1363 && breakpoint_address_match (aspace
, address
,
1364 step_over_info
.aspace
,
1365 step_over_info
.address
));
1371 stepping_past_nonsteppable_watchpoint (void)
1373 return step_over_info
.nonsteppable_watchpoint_p
;
1376 /* Returns true if step-over info is valid. */
1379 step_over_info_valid_p (void)
1381 return (step_over_info
.aspace
!= NULL
1382 || stepping_past_nonsteppable_watchpoint ());
1386 /* Displaced stepping. */
1388 /* In non-stop debugging mode, we must take special care to manage
1389 breakpoints properly; in particular, the traditional strategy for
1390 stepping a thread past a breakpoint it has hit is unsuitable.
1391 'Displaced stepping' is a tactic for stepping one thread past a
1392 breakpoint it has hit while ensuring that other threads running
1393 concurrently will hit the breakpoint as they should.
1395 The traditional way to step a thread T off a breakpoint in a
1396 multi-threaded program in all-stop mode is as follows:
1398 a0) Initially, all threads are stopped, and breakpoints are not
1400 a1) We single-step T, leaving breakpoints uninserted.
1401 a2) We insert breakpoints, and resume all threads.
1403 In non-stop debugging, however, this strategy is unsuitable: we
1404 don't want to have to stop all threads in the system in order to
1405 continue or step T past a breakpoint. Instead, we use displaced
1408 n0) Initially, T is stopped, other threads are running, and
1409 breakpoints are inserted.
1410 n1) We copy the instruction "under" the breakpoint to a separate
1411 location, outside the main code stream, making any adjustments
1412 to the instruction, register, and memory state as directed by
1414 n2) We single-step T over the instruction at its new location.
1415 n3) We adjust the resulting register and memory state as directed
1416 by T's architecture. This includes resetting T's PC to point
1417 back into the main instruction stream.
1420 This approach depends on the following gdbarch methods:
1422 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1423 indicate where to copy the instruction, and how much space must
1424 be reserved there. We use these in step n1.
1426 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1427 address, and makes any necessary adjustments to the instruction,
1428 register contents, and memory. We use this in step n1.
1430 - gdbarch_displaced_step_fixup adjusts registers and memory after
1431 we have successfuly single-stepped the instruction, to yield the
1432 same effect the instruction would have had if we had executed it
1433 at its original address. We use this in step n3.
1435 - gdbarch_displaced_step_free_closure provides cleanup.
1437 The gdbarch_displaced_step_copy_insn and
1438 gdbarch_displaced_step_fixup functions must be written so that
1439 copying an instruction with gdbarch_displaced_step_copy_insn,
1440 single-stepping across the copied instruction, and then applying
1441 gdbarch_displaced_insn_fixup should have the same effects on the
1442 thread's memory and registers as stepping the instruction in place
1443 would have. Exactly which responsibilities fall to the copy and
1444 which fall to the fixup is up to the author of those functions.
1446 See the comments in gdbarch.sh for details.
1448 Note that displaced stepping and software single-step cannot
1449 currently be used in combination, although with some care I think
1450 they could be made to. Software single-step works by placing
1451 breakpoints on all possible subsequent instructions; if the
1452 displaced instruction is a PC-relative jump, those breakpoints
1453 could fall in very strange places --- on pages that aren't
1454 executable, or at addresses that are not proper instruction
1455 boundaries. (We do generally let other threads run while we wait
1456 to hit the software single-step breakpoint, and they might
1457 encounter such a corrupted instruction.) One way to work around
1458 this would be to have gdbarch_displaced_step_copy_insn fully
1459 simulate the effect of PC-relative instructions (and return NULL)
1460 on architectures that use software single-stepping.
1462 In non-stop mode, we can have independent and simultaneous step
1463 requests, so more than one thread may need to simultaneously step
1464 over a breakpoint. The current implementation assumes there is
1465 only one scratch space per process. In this case, we have to
1466 serialize access to the scratch space. If thread A wants to step
1467 over a breakpoint, but we are currently waiting for some other
1468 thread to complete a displaced step, we leave thread A stopped and
1469 place it in the displaced_step_request_queue. Whenever a displaced
1470 step finishes, we pick the next thread in the queue and start a new
1471 displaced step operation on it. See displaced_step_prepare and
1472 displaced_step_fixup for details. */
1474 /* Per-inferior displaced stepping state. */
1475 struct displaced_step_inferior_state
1477 /* Pointer to next in linked list. */
1478 struct displaced_step_inferior_state
*next
;
1480 /* The process this displaced step state refers to. */
1483 /* True if preparing a displaced step ever failed. If so, we won't
1484 try displaced stepping for this inferior again. */
1487 /* If this is not null_ptid, this is the thread carrying out a
1488 displaced single-step in process PID. This thread's state will
1489 require fixing up once it has completed its step. */
1492 /* The architecture the thread had when we stepped it. */
1493 struct gdbarch
*step_gdbarch
;
1495 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1496 for post-step cleanup. */
1497 struct displaced_step_closure
*step_closure
;
1499 /* The address of the original instruction, and the copy we
1501 CORE_ADDR step_original
, step_copy
;
1503 /* Saved contents of copy area. */
1504 gdb_byte
*step_saved_copy
;
1507 /* The list of states of processes involved in displaced stepping
1509 static struct displaced_step_inferior_state
*displaced_step_inferior_states
;
1511 /* Get the displaced stepping state of process PID. */
1513 static struct displaced_step_inferior_state
*
1514 get_displaced_stepping_state (int pid
)
1516 struct displaced_step_inferior_state
*state
;
1518 for (state
= displaced_step_inferior_states
;
1520 state
= state
->next
)
1521 if (state
->pid
== pid
)
1527 /* Returns true if any inferior has a thread doing a displaced
1531 displaced_step_in_progress_any_inferior (void)
1533 struct displaced_step_inferior_state
*state
;
1535 for (state
= displaced_step_inferior_states
;
1537 state
= state
->next
)
1538 if (!ptid_equal (state
->step_ptid
, null_ptid
))
1544 /* Return true if process PID has a thread doing a displaced step. */
1547 displaced_step_in_progress (int pid
)
1549 struct displaced_step_inferior_state
*displaced
;
1551 displaced
= get_displaced_stepping_state (pid
);
1552 if (displaced
!= NULL
&& !ptid_equal (displaced
->step_ptid
, null_ptid
))
1558 /* Add a new displaced stepping state for process PID to the displaced
1559 stepping state list, or return a pointer to an already existing
1560 entry, if it already exists. Never returns NULL. */
1562 static struct displaced_step_inferior_state
*
1563 add_displaced_stepping_state (int pid
)
1565 struct displaced_step_inferior_state
*state
;
1567 for (state
= displaced_step_inferior_states
;
1569 state
= state
->next
)
1570 if (state
->pid
== pid
)
1573 state
= XCNEW (struct displaced_step_inferior_state
);
1575 state
->next
= displaced_step_inferior_states
;
1576 displaced_step_inferior_states
= state
;
1581 /* If inferior is in displaced stepping, and ADDR equals to starting address
1582 of copy area, return corresponding displaced_step_closure. Otherwise,
1585 struct displaced_step_closure
*
1586 get_displaced_step_closure_by_addr (CORE_ADDR addr
)
1588 struct displaced_step_inferior_state
*displaced
1589 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
1591 /* If checking the mode of displaced instruction in copy area. */
1592 if (displaced
&& !ptid_equal (displaced
->step_ptid
, null_ptid
)
1593 && (displaced
->step_copy
== addr
))
1594 return displaced
->step_closure
;
1599 /* Remove the displaced stepping state of process PID. */
1602 remove_displaced_stepping_state (int pid
)
1604 struct displaced_step_inferior_state
*it
, **prev_next_p
;
1606 gdb_assert (pid
!= 0);
1608 it
= displaced_step_inferior_states
;
1609 prev_next_p
= &displaced_step_inferior_states
;
1614 *prev_next_p
= it
->next
;
1619 prev_next_p
= &it
->next
;
1625 infrun_inferior_exit (struct inferior
*inf
)
1627 remove_displaced_stepping_state (inf
->pid
);
1630 /* If ON, and the architecture supports it, GDB will use displaced
1631 stepping to step over breakpoints. If OFF, or if the architecture
1632 doesn't support it, GDB will instead use the traditional
1633 hold-and-step approach. If AUTO (which is the default), GDB will
1634 decide which technique to use to step over breakpoints depending on
1635 which of all-stop or non-stop mode is active --- displaced stepping
1636 in non-stop mode; hold-and-step in all-stop mode. */
1638 static enum auto_boolean can_use_displaced_stepping
= AUTO_BOOLEAN_AUTO
;
1641 show_can_use_displaced_stepping (struct ui_file
*file
, int from_tty
,
1642 struct cmd_list_element
*c
,
1645 if (can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
)
1646 fprintf_filtered (file
,
1647 _("Debugger's willingness to use displaced stepping "
1648 "to step over breakpoints is %s (currently %s).\n"),
1649 value
, target_is_non_stop_p () ? "on" : "off");
1651 fprintf_filtered (file
,
1652 _("Debugger's willingness to use displaced stepping "
1653 "to step over breakpoints is %s.\n"), value
);
1656 /* Return non-zero if displaced stepping can/should be used to step
1657 over breakpoints of thread TP. */
1660 use_displaced_stepping (struct thread_info
*tp
)
1662 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
1663 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1664 struct displaced_step_inferior_state
*displaced_state
;
1666 displaced_state
= get_displaced_stepping_state (ptid_get_pid (tp
->ptid
));
1668 return (((can_use_displaced_stepping
== AUTO_BOOLEAN_AUTO
1669 && target_is_non_stop_p ())
1670 || can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1671 && gdbarch_displaced_step_copy_insn_p (gdbarch
)
1672 && find_record_target () == NULL
1673 && (displaced_state
== NULL
1674 || !displaced_state
->failed_before
));
1677 /* Clean out any stray displaced stepping state. */
1679 displaced_step_clear (struct displaced_step_inferior_state
*displaced
)
1681 /* Indicate that there is no cleanup pending. */
1682 displaced
->step_ptid
= null_ptid
;
1684 if (displaced
->step_closure
)
1686 gdbarch_displaced_step_free_closure (displaced
->step_gdbarch
,
1687 displaced
->step_closure
);
1688 displaced
->step_closure
= NULL
;
1693 displaced_step_clear_cleanup (void *arg
)
1695 struct displaced_step_inferior_state
*state
= arg
;
1697 displaced_step_clear (state
);
1700 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1702 displaced_step_dump_bytes (struct ui_file
*file
,
1703 const gdb_byte
*buf
,
1708 for (i
= 0; i
< len
; i
++)
1709 fprintf_unfiltered (file
, "%02x ", buf
[i
]);
1710 fputs_unfiltered ("\n", file
);
1713 /* Prepare to single-step, using displaced stepping.
1715 Note that we cannot use displaced stepping when we have a signal to
1716 deliver. If we have a signal to deliver and an instruction to step
1717 over, then after the step, there will be no indication from the
1718 target whether the thread entered a signal handler or ignored the
1719 signal and stepped over the instruction successfully --- both cases
1720 result in a simple SIGTRAP. In the first case we mustn't do a
1721 fixup, and in the second case we must --- but we can't tell which.
1722 Comments in the code for 'random signals' in handle_inferior_event
1723 explain how we handle this case instead.
1725 Returns 1 if preparing was successful -- this thread is going to be
1726 stepped now; 0 if displaced stepping this thread got queued; or -1
1727 if this instruction can't be displaced stepped. */
1730 displaced_step_prepare_throw (ptid_t ptid
)
1732 struct cleanup
*old_cleanups
, *ignore_cleanups
;
1733 struct thread_info
*tp
= find_thread_ptid (ptid
);
1734 struct regcache
*regcache
= get_thread_regcache (ptid
);
1735 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1736 CORE_ADDR original
, copy
;
1738 struct displaced_step_closure
*closure
;
1739 struct displaced_step_inferior_state
*displaced
;
1742 /* We should never reach this function if the architecture does not
1743 support displaced stepping. */
1744 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch
));
1746 /* Nor if the thread isn't meant to step over a breakpoint. */
1747 gdb_assert (tp
->control
.trap_expected
);
1749 /* Disable range stepping while executing in the scratch pad. We
1750 want a single-step even if executing the displaced instruction in
1751 the scratch buffer lands within the stepping range (e.g., a
1753 tp
->control
.may_range_step
= 0;
1755 /* We have to displaced step one thread at a time, as we only have
1756 access to a single scratch space per inferior. */
1758 displaced
= add_displaced_stepping_state (ptid_get_pid (ptid
));
1760 if (!ptid_equal (displaced
->step_ptid
, null_ptid
))
1762 /* Already waiting for a displaced step to finish. Defer this
1763 request and place in queue. */
1765 if (debug_displaced
)
1766 fprintf_unfiltered (gdb_stdlog
,
1767 "displaced: deferring step of %s\n",
1768 target_pid_to_str (ptid
));
1770 thread_step_over_chain_enqueue (tp
);
1775 if (debug_displaced
)
1776 fprintf_unfiltered (gdb_stdlog
,
1777 "displaced: stepping %s now\n",
1778 target_pid_to_str (ptid
));
1781 displaced_step_clear (displaced
);
1783 old_cleanups
= save_inferior_ptid ();
1784 inferior_ptid
= ptid
;
1786 original
= regcache_read_pc (regcache
);
1788 copy
= gdbarch_displaced_step_location (gdbarch
);
1789 len
= gdbarch_max_insn_length (gdbarch
);
1791 /* Save the original contents of the copy area. */
1792 displaced
->step_saved_copy
= xmalloc (len
);
1793 ignore_cleanups
= make_cleanup (free_current_contents
,
1794 &displaced
->step_saved_copy
);
1795 status
= target_read_memory (copy
, displaced
->step_saved_copy
, len
);
1797 throw_error (MEMORY_ERROR
,
1798 _("Error accessing memory address %s (%s) for "
1799 "displaced-stepping scratch space."),
1800 paddress (gdbarch
, copy
), safe_strerror (status
));
1801 if (debug_displaced
)
1803 fprintf_unfiltered (gdb_stdlog
, "displaced: saved %s: ",
1804 paddress (gdbarch
, copy
));
1805 displaced_step_dump_bytes (gdb_stdlog
,
1806 displaced
->step_saved_copy
,
1810 closure
= gdbarch_displaced_step_copy_insn (gdbarch
,
1811 original
, copy
, regcache
);
1812 if (closure
== NULL
)
1814 /* The architecture doesn't know how or want to displaced step
1815 this instruction or instruction sequence. Fallback to
1816 stepping over the breakpoint in-line. */
1817 do_cleanups (old_cleanups
);
1821 /* Save the information we need to fix things up if the step
1823 displaced
->step_ptid
= ptid
;
1824 displaced
->step_gdbarch
= gdbarch
;
1825 displaced
->step_closure
= closure
;
1826 displaced
->step_original
= original
;
1827 displaced
->step_copy
= copy
;
1829 make_cleanup (displaced_step_clear_cleanup
, displaced
);
1831 /* Resume execution at the copy. */
1832 regcache_write_pc (regcache
, copy
);
1834 discard_cleanups (ignore_cleanups
);
1836 do_cleanups (old_cleanups
);
1838 if (debug_displaced
)
1839 fprintf_unfiltered (gdb_stdlog
, "displaced: displaced pc to %s\n",
1840 paddress (gdbarch
, copy
));
1845 /* Wrapper for displaced_step_prepare_throw that disabled further
1846 attempts at displaced stepping if we get a memory error. */
1849 displaced_step_prepare (ptid_t ptid
)
1855 prepared
= displaced_step_prepare_throw (ptid
);
1857 CATCH (ex
, RETURN_MASK_ERROR
)
1859 struct displaced_step_inferior_state
*displaced_state
;
1861 if (ex
.error
!= MEMORY_ERROR
)
1862 throw_exception (ex
);
1866 fprintf_unfiltered (gdb_stdlog
,
1867 "infrun: disabling displaced stepping: %s\n",
1871 /* Be verbose if "set displaced-stepping" is "on", silent if
1873 if (can_use_displaced_stepping
== AUTO_BOOLEAN_TRUE
)
1875 warning (_("disabling displaced stepping: %s"),
1879 /* Disable further displaced stepping attempts. */
1881 = get_displaced_stepping_state (ptid_get_pid (ptid
));
1882 displaced_state
->failed_before
= 1;
1890 write_memory_ptid (ptid_t ptid
, CORE_ADDR memaddr
,
1891 const gdb_byte
*myaddr
, int len
)
1893 struct cleanup
*ptid_cleanup
= save_inferior_ptid ();
1895 inferior_ptid
= ptid
;
1896 write_memory (memaddr
, myaddr
, len
);
1897 do_cleanups (ptid_cleanup
);
1900 /* Restore the contents of the copy area for thread PTID. */
1903 displaced_step_restore (struct displaced_step_inferior_state
*displaced
,
1906 ULONGEST len
= gdbarch_max_insn_length (displaced
->step_gdbarch
);
1908 write_memory_ptid (ptid
, displaced
->step_copy
,
1909 displaced
->step_saved_copy
, len
);
1910 if (debug_displaced
)
1911 fprintf_unfiltered (gdb_stdlog
, "displaced: restored %s %s\n",
1912 target_pid_to_str (ptid
),
1913 paddress (displaced
->step_gdbarch
,
1914 displaced
->step_copy
));
1917 /* If we displaced stepped an instruction successfully, adjust
1918 registers and memory to yield the same effect the instruction would
1919 have had if we had executed it at its original address, and return
1920 1. If the instruction didn't complete, relocate the PC and return
1921 -1. If the thread wasn't displaced stepping, return 0. */
1924 displaced_step_fixup (ptid_t event_ptid
, enum gdb_signal signal
)
1926 struct cleanup
*old_cleanups
;
1927 struct displaced_step_inferior_state
*displaced
1928 = get_displaced_stepping_state (ptid_get_pid (event_ptid
));
1931 /* Was any thread of this process doing a displaced step? */
1932 if (displaced
== NULL
)
1935 /* Was this event for the pid we displaced? */
1936 if (ptid_equal (displaced
->step_ptid
, null_ptid
)
1937 || ! ptid_equal (displaced
->step_ptid
, event_ptid
))
1940 old_cleanups
= make_cleanup (displaced_step_clear_cleanup
, displaced
);
1942 displaced_step_restore (displaced
, displaced
->step_ptid
);
1944 /* Fixup may need to read memory/registers. Switch to the thread
1945 that we're fixing up. Also, target_stopped_by_watchpoint checks
1946 the current thread. */
1947 switch_to_thread (event_ptid
);
1949 /* Did the instruction complete successfully? */
1950 if (signal
== GDB_SIGNAL_TRAP
1951 && !(target_stopped_by_watchpoint ()
1952 && (gdbarch_have_nonsteppable_watchpoint (displaced
->step_gdbarch
)
1953 || target_have_steppable_watchpoint
)))
1955 /* Fix up the resulting state. */
1956 gdbarch_displaced_step_fixup (displaced
->step_gdbarch
,
1957 displaced
->step_closure
,
1958 displaced
->step_original
,
1959 displaced
->step_copy
,
1960 get_thread_regcache (displaced
->step_ptid
));
1965 /* Since the instruction didn't complete, all we can do is
1967 struct regcache
*regcache
= get_thread_regcache (event_ptid
);
1968 CORE_ADDR pc
= regcache_read_pc (regcache
);
1970 pc
= displaced
->step_original
+ (pc
- displaced
->step_copy
);
1971 regcache_write_pc (regcache
, pc
);
1975 do_cleanups (old_cleanups
);
1977 displaced
->step_ptid
= null_ptid
;
1982 /* Data to be passed around while handling an event. This data is
1983 discarded between events. */
1984 struct execution_control_state
1987 /* The thread that got the event, if this was a thread event; NULL
1989 struct thread_info
*event_thread
;
1991 struct target_waitstatus ws
;
1992 int stop_func_filled_in
;
1993 CORE_ADDR stop_func_start
;
1994 CORE_ADDR stop_func_end
;
1995 const char *stop_func_name
;
1998 /* True if the event thread hit the single-step breakpoint of
1999 another thread. Thus the event doesn't cause a stop, the thread
2000 needs to be single-stepped past the single-step breakpoint before
2001 we can switch back to the original stepping thread. */
2002 int hit_singlestep_breakpoint
;
2005 /* Clear ECS and set it to point at TP. */
2008 reset_ecs (struct execution_control_state
*ecs
, struct thread_info
*tp
)
2010 memset (ecs
, 0, sizeof (*ecs
));
2011 ecs
->event_thread
= tp
;
2012 ecs
->ptid
= tp
->ptid
;
2015 static void keep_going_pass_signal (struct execution_control_state
*ecs
);
2016 static void prepare_to_wait (struct execution_control_state
*ecs
);
2017 static int keep_going_stepped_thread (struct thread_info
*tp
);
2018 static int thread_still_needs_step_over (struct thread_info
*tp
);
2019 static void stop_all_threads (void);
2021 /* Are there any pending step-over requests? If so, run all we can
2022 now and return true. Otherwise, return false. */
2025 start_step_over (void)
2027 struct thread_info
*tp
, *next
;
2029 /* Don't start a new step-over if we already have an in-line
2030 step-over operation ongoing. */
2031 if (step_over_info_valid_p ())
2034 for (tp
= step_over_queue_head
; tp
!= NULL
; tp
= next
)
2036 struct execution_control_state ecss
;
2037 struct execution_control_state
*ecs
= &ecss
;
2038 enum step_over_what step_what
;
2039 int must_be_in_line
;
2041 next
= thread_step_over_chain_next (tp
);
2043 /* If this inferior already has a displaced step in process,
2044 don't start a new one. */
2045 if (displaced_step_in_progress (ptid_get_pid (tp
->ptid
)))
2048 step_what
= thread_still_needs_step_over (tp
);
2049 must_be_in_line
= ((step_what
& STEP_OVER_WATCHPOINT
)
2050 || ((step_what
& STEP_OVER_BREAKPOINT
)
2051 && !use_displaced_stepping (tp
)));
2053 /* We currently stop all threads of all processes to step-over
2054 in-line. If we need to start a new in-line step-over, let
2055 any pending displaced steps finish first. */
2056 if (must_be_in_line
&& displaced_step_in_progress_any_inferior ())
2059 thread_step_over_chain_remove (tp
);
2061 if (step_over_queue_head
== NULL
)
2064 fprintf_unfiltered (gdb_stdlog
,
2065 "infrun: step-over queue now empty\n");
2068 if (tp
->control
.trap_expected
2072 internal_error (__FILE__
, __LINE__
,
2073 "[%s] has inconsistent state: "
2074 "trap_expected=%d, resumed=%d, executing=%d\n",
2075 target_pid_to_str (tp
->ptid
),
2076 tp
->control
.trap_expected
,
2082 fprintf_unfiltered (gdb_stdlog
,
2083 "infrun: resuming [%s] for step-over\n",
2084 target_pid_to_str (tp
->ptid
));
2086 /* keep_going_pass_signal skips the step-over if the breakpoint
2087 is no longer inserted. In all-stop, we want to keep looking
2088 for a thread that needs a step-over instead of resuming TP,
2089 because we wouldn't be able to resume anything else until the
2090 target stops again. In non-stop, the resume always resumes
2091 only TP, so it's OK to let the thread resume freely. */
2092 if (!target_is_non_stop_p () && !step_what
)
2095 switch_to_thread (tp
->ptid
);
2096 reset_ecs (ecs
, tp
);
2097 keep_going_pass_signal (ecs
);
2099 if (!ecs
->wait_some_more
)
2100 error (_("Command aborted."));
2102 gdb_assert (tp
->resumed
);
2104 /* If we started a new in-line step-over, we're done. */
2105 if (step_over_info_valid_p ())
2107 gdb_assert (tp
->control
.trap_expected
);
2111 if (!target_is_non_stop_p ())
2113 /* On all-stop, shouldn't have resumed unless we needed a
2115 gdb_assert (tp
->control
.trap_expected
2116 || tp
->step_after_step_resume_breakpoint
);
2118 /* With remote targets (at least), in all-stop, we can't
2119 issue any further remote commands until the program stops
2124 /* Either the thread no longer needed a step-over, or a new
2125 displaced stepping sequence started. Even in the latter
2126 case, continue looking. Maybe we can also start another
2127 displaced step on a thread of other process. */
2133 /* Update global variables holding ptids to hold NEW_PTID if they were
2134 holding OLD_PTID. */
2136 infrun_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
2138 struct displaced_step_request
*it
;
2139 struct displaced_step_inferior_state
*displaced
;
2141 if (ptid_equal (inferior_ptid
, old_ptid
))
2142 inferior_ptid
= new_ptid
;
2144 for (displaced
= displaced_step_inferior_states
;
2146 displaced
= displaced
->next
)
2148 if (ptid_equal (displaced
->step_ptid
, old_ptid
))
2149 displaced
->step_ptid
= new_ptid
;
2156 /* Things to clean up if we QUIT out of resume (). */
2158 resume_cleanups (void *ignore
)
2160 if (!ptid_equal (inferior_ptid
, null_ptid
))
2161 delete_single_step_breakpoints (inferior_thread ());
2166 static const char schedlock_off
[] = "off";
2167 static const char schedlock_on
[] = "on";
2168 static const char schedlock_step
[] = "step";
2169 static const char *const scheduler_enums
[] = {
2175 static const char *scheduler_mode
= schedlock_off
;
2177 show_scheduler_mode (struct ui_file
*file
, int from_tty
,
2178 struct cmd_list_element
*c
, const char *value
)
2180 fprintf_filtered (file
,
2181 _("Mode for locking scheduler "
2182 "during execution is \"%s\".\n"),
2187 set_schedlock_func (char *args
, int from_tty
, struct cmd_list_element
*c
)
2189 if (!target_can_lock_scheduler
)
2191 scheduler_mode
= schedlock_off
;
2192 error (_("Target '%s' cannot support this command."), target_shortname
);
2196 /* True if execution commands resume all threads of all processes by
2197 default; otherwise, resume only threads of the current inferior
2199 int sched_multi
= 0;
2201 /* Try to setup for software single stepping over the specified location.
2202 Return 1 if target_resume() should use hardware single step.
2204 GDBARCH the current gdbarch.
2205 PC the location to step over. */
2208 maybe_software_singlestep (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2212 if (execution_direction
== EXEC_FORWARD
2213 && gdbarch_software_single_step_p (gdbarch
)
2214 && gdbarch_software_single_step (gdbarch
, get_current_frame ()))
2224 user_visible_resume_ptid (int step
)
2230 /* With non-stop mode on, threads are always handled
2232 resume_ptid
= inferior_ptid
;
2234 else if ((scheduler_mode
== schedlock_on
)
2235 || (scheduler_mode
== schedlock_step
&& step
))
2237 /* User-settable 'scheduler' mode requires solo thread
2239 resume_ptid
= inferior_ptid
;
2241 else if (!sched_multi
&& target_supports_multi_process ())
2243 /* Resume all threads of the current process (and none of other
2245 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
2249 /* Resume all threads of all processes. */
2250 resume_ptid
= RESUME_ALL
;
2256 /* Return a ptid representing the set of threads that we will resume,
2257 in the perspective of the target, assuming run control handling
2258 does not require leaving some threads stopped (e.g., stepping past
2259 breakpoint). USER_STEP indicates whether we're about to start the
2260 target for a stepping command. */
2263 internal_resume_ptid (int user_step
)
2265 /* In non-stop, we always control threads individually. Note that
2266 the target may always work in non-stop mode even with "set
2267 non-stop off", in which case user_visible_resume_ptid could
2268 return a wildcard ptid. */
2269 if (target_is_non_stop_p ())
2270 return inferior_ptid
;
2272 return user_visible_resume_ptid (user_step
);
2275 /* Wrapper for target_resume, that handles infrun-specific
2279 do_target_resume (ptid_t resume_ptid
, int step
, enum gdb_signal sig
)
2281 struct thread_info
*tp
= inferior_thread ();
2283 /* Install inferior's terminal modes. */
2284 target_terminal_inferior ();
2286 /* Avoid confusing the next resume, if the next stop/resume
2287 happens to apply to another thread. */
2288 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2290 /* Advise target which signals may be handled silently.
2292 If we have removed breakpoints because we are stepping over one
2293 in-line (in any thread), we need to receive all signals to avoid
2294 accidentally skipping a breakpoint during execution of a signal
2297 Likewise if we're displaced stepping, otherwise a trap for a
2298 breakpoint in a signal handler might be confused with the
2299 displaced step finishing. We don't make the displaced_step_fixup
2300 step distinguish the cases instead, because:
2302 - a backtrace while stopped in the signal handler would show the
2303 scratch pad as frame older than the signal handler, instead of
2304 the real mainline code.
2306 - when the thread is later resumed, the signal handler would
2307 return to the scratch pad area, which would no longer be
2309 if (step_over_info_valid_p ()
2310 || displaced_step_in_progress (ptid_get_pid (tp
->ptid
)))
2311 target_pass_signals (0, NULL
);
2313 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
2315 target_resume (resume_ptid
, step
, sig
);
2318 /* Resume the inferior, but allow a QUIT. This is useful if the user
2319 wants to interrupt some lengthy single-stepping operation
2320 (for child processes, the SIGINT goes to the inferior, and so
2321 we get a SIGINT random_signal, but for remote debugging and perhaps
2322 other targets, that's not true).
2324 SIG is the signal to give the inferior (zero for none). */
2326 resume (enum gdb_signal sig
)
2328 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
2329 struct regcache
*regcache
= get_current_regcache ();
2330 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2331 struct thread_info
*tp
= inferior_thread ();
2332 CORE_ADDR pc
= regcache_read_pc (regcache
);
2333 struct address_space
*aspace
= get_regcache_aspace (regcache
);
2335 /* This represents the user's step vs continue request. When
2336 deciding whether "set scheduler-locking step" applies, it's the
2337 user's intention that counts. */
2338 const int user_step
= tp
->control
.stepping_command
;
2339 /* This represents what we'll actually request the target to do.
2340 This can decay from a step to a continue, if e.g., we need to
2341 implement single-stepping with breakpoints (software
2345 gdb_assert (!thread_is_in_step_over_chain (tp
));
2349 if (tp
->suspend
.waitstatus_pending_p
)
2355 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2356 fprintf_unfiltered (gdb_stdlog
,
2357 "infrun: resume: thread %s has pending wait status %s "
2358 "(currently_stepping=%d).\n",
2359 target_pid_to_str (tp
->ptid
), statstr
,
2360 currently_stepping (tp
));
2366 /* FIXME: What should we do if we are supposed to resume this
2367 thread with a signal? Maybe we should maintain a queue of
2368 pending signals to deliver. */
2369 if (sig
!= GDB_SIGNAL_0
)
2371 warning (_("Couldn't deliver signal %s to %s."),
2372 gdb_signal_to_name (sig
), target_pid_to_str (tp
->ptid
));
2375 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2376 discard_cleanups (old_cleanups
);
2378 if (target_can_async_p ())
2383 tp
->stepped_breakpoint
= 0;
2385 /* Depends on stepped_breakpoint. */
2386 step
= currently_stepping (tp
);
2388 if (current_inferior ()->waiting_for_vfork_done
)
2390 /* Don't try to single-step a vfork parent that is waiting for
2391 the child to get out of the shared memory region (by exec'ing
2392 or exiting). This is particularly important on software
2393 single-step archs, as the child process would trip on the
2394 software single step breakpoint inserted for the parent
2395 process. Since the parent will not actually execute any
2396 instruction until the child is out of the shared region (such
2397 are vfork's semantics), it is safe to simply continue it.
2398 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2399 the parent, and tell it to `keep_going', which automatically
2400 re-sets it stepping. */
2402 fprintf_unfiltered (gdb_stdlog
,
2403 "infrun: resume : clear step\n");
2408 fprintf_unfiltered (gdb_stdlog
,
2409 "infrun: resume (step=%d, signal=%s), "
2410 "trap_expected=%d, current thread [%s] at %s\n",
2411 step
, gdb_signal_to_symbol_string (sig
),
2412 tp
->control
.trap_expected
,
2413 target_pid_to_str (inferior_ptid
),
2414 paddress (gdbarch
, pc
));
2416 /* Normally, by the time we reach `resume', the breakpoints are either
2417 removed or inserted, as appropriate. The exception is if we're sitting
2418 at a permanent breakpoint; we need to step over it, but permanent
2419 breakpoints can't be removed. So we have to test for it here. */
2420 if (breakpoint_here_p (aspace
, pc
) == permanent_breakpoint_here
)
2422 if (sig
!= GDB_SIGNAL_0
)
2424 /* We have a signal to pass to the inferior. The resume
2425 may, or may not take us to the signal handler. If this
2426 is a step, we'll need to stop in the signal handler, if
2427 there's one, (if the target supports stepping into
2428 handlers), or in the next mainline instruction, if
2429 there's no handler. If this is a continue, we need to be
2430 sure to run the handler with all breakpoints inserted.
2431 In all cases, set a breakpoint at the current address
2432 (where the handler returns to), and once that breakpoint
2433 is hit, resume skipping the permanent breakpoint. If
2434 that breakpoint isn't hit, then we've stepped into the
2435 signal handler (or hit some other event). We'll delete
2436 the step-resume breakpoint then. */
2439 fprintf_unfiltered (gdb_stdlog
,
2440 "infrun: resume: skipping permanent breakpoint, "
2441 "deliver signal first\n");
2443 clear_step_over_info ();
2444 tp
->control
.trap_expected
= 0;
2446 if (tp
->control
.step_resume_breakpoint
== NULL
)
2448 /* Set a "high-priority" step-resume, as we don't want
2449 user breakpoints at PC to trigger (again) when this
2451 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2452 gdb_assert (tp
->control
.step_resume_breakpoint
->loc
->permanent
);
2454 tp
->step_after_step_resume_breakpoint
= step
;
2457 insert_breakpoints ();
2461 /* There's no signal to pass, we can go ahead and skip the
2462 permanent breakpoint manually. */
2464 fprintf_unfiltered (gdb_stdlog
,
2465 "infrun: resume: skipping permanent breakpoint\n");
2466 gdbarch_skip_permanent_breakpoint (gdbarch
, regcache
);
2467 /* Update pc to reflect the new address from which we will
2468 execute instructions. */
2469 pc
= regcache_read_pc (regcache
);
2473 /* We've already advanced the PC, so the stepping part
2474 is done. Now we need to arrange for a trap to be
2475 reported to handle_inferior_event. Set a breakpoint
2476 at the current PC, and run to it. Don't update
2477 prev_pc, because if we end in
2478 switch_back_to_stepped_thread, we want the "expected
2479 thread advanced also" branch to be taken. IOW, we
2480 don't want this thread to step further from PC
2482 gdb_assert (!step_over_info_valid_p ());
2483 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
2484 insert_breakpoints ();
2486 resume_ptid
= internal_resume_ptid (user_step
);
2487 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
2488 discard_cleanups (old_cleanups
);
2495 /* If we have a breakpoint to step over, make sure to do a single
2496 step only. Same if we have software watchpoints. */
2497 if (tp
->control
.trap_expected
|| bpstat_should_step ())
2498 tp
->control
.may_range_step
= 0;
2500 /* If enabled, step over breakpoints by executing a copy of the
2501 instruction at a different address.
2503 We can't use displaced stepping when we have a signal to deliver;
2504 the comments for displaced_step_prepare explain why. The
2505 comments in the handle_inferior event for dealing with 'random
2506 signals' explain what we do instead.
2508 We can't use displaced stepping when we are waiting for vfork_done
2509 event, displaced stepping breaks the vfork child similarly as single
2510 step software breakpoint. */
2511 if (tp
->control
.trap_expected
2512 && use_displaced_stepping (tp
)
2513 && !step_over_info_valid_p ()
2514 && sig
== GDB_SIGNAL_0
2515 && !current_inferior ()->waiting_for_vfork_done
)
2517 int prepared
= displaced_step_prepare (inferior_ptid
);
2522 fprintf_unfiltered (gdb_stdlog
,
2523 "Got placed in step-over queue\n");
2525 tp
->control
.trap_expected
= 0;
2526 discard_cleanups (old_cleanups
);
2529 else if (prepared
< 0)
2531 /* Fallback to stepping over the breakpoint in-line. */
2533 if (target_is_non_stop_p ())
2534 stop_all_threads ();
2536 set_step_over_info (get_regcache_aspace (regcache
),
2537 regcache_read_pc (regcache
), 0);
2539 step
= maybe_software_singlestep (gdbarch
, pc
);
2541 insert_breakpoints ();
2543 else if (prepared
> 0)
2545 struct displaced_step_inferior_state
*displaced
;
2547 /* Update pc to reflect the new address from which we will
2548 execute instructions due to displaced stepping. */
2549 pc
= regcache_read_pc (get_thread_regcache (inferior_ptid
));
2551 displaced
= get_displaced_stepping_state (ptid_get_pid (inferior_ptid
));
2552 step
= gdbarch_displaced_step_hw_singlestep (gdbarch
,
2553 displaced
->step_closure
);
2557 /* Do we need to do it the hard way, w/temp breakpoints? */
2559 step
= maybe_software_singlestep (gdbarch
, pc
);
2561 /* Currently, our software single-step implementation leads to different
2562 results than hardware single-stepping in one situation: when stepping
2563 into delivering a signal which has an associated signal handler,
2564 hardware single-step will stop at the first instruction of the handler,
2565 while software single-step will simply skip execution of the handler.
2567 For now, this difference in behavior is accepted since there is no
2568 easy way to actually implement single-stepping into a signal handler
2569 without kernel support.
2571 However, there is one scenario where this difference leads to follow-on
2572 problems: if we're stepping off a breakpoint by removing all breakpoints
2573 and then single-stepping. In this case, the software single-step
2574 behavior means that even if there is a *breakpoint* in the signal
2575 handler, GDB still would not stop.
2577 Fortunately, we can at least fix this particular issue. We detect
2578 here the case where we are about to deliver a signal while software
2579 single-stepping with breakpoints removed. In this situation, we
2580 revert the decisions to remove all breakpoints and insert single-
2581 step breakpoints, and instead we install a step-resume breakpoint
2582 at the current address, deliver the signal without stepping, and
2583 once we arrive back at the step-resume breakpoint, actually step
2584 over the breakpoint we originally wanted to step over. */
2585 if (thread_has_single_step_breakpoints_set (tp
)
2586 && sig
!= GDB_SIGNAL_0
2587 && step_over_info_valid_p ())
2589 /* If we have nested signals or a pending signal is delivered
2590 immediately after a handler returns, might might already have
2591 a step-resume breakpoint set on the earlier handler. We cannot
2592 set another step-resume breakpoint; just continue on until the
2593 original breakpoint is hit. */
2594 if (tp
->control
.step_resume_breakpoint
== NULL
)
2596 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2597 tp
->step_after_step_resume_breakpoint
= 1;
2600 delete_single_step_breakpoints (tp
);
2602 clear_step_over_info ();
2603 tp
->control
.trap_expected
= 0;
2605 insert_breakpoints ();
2608 /* If STEP is set, it's a request to use hardware stepping
2609 facilities. But in that case, we should never
2610 use singlestep breakpoint. */
2611 gdb_assert (!(thread_has_single_step_breakpoints_set (tp
) && step
));
2613 /* Decide the set of threads to ask the target to resume. */
2614 if ((step
|| thread_has_single_step_breakpoints_set (tp
))
2615 && tp
->control
.trap_expected
)
2617 /* We're allowing a thread to run past a breakpoint it has
2618 hit, by single-stepping the thread with the breakpoint
2619 removed. In which case, we need to single-step only this
2620 thread, and keep others stopped, as they can miss this
2621 breakpoint if allowed to run. */
2622 resume_ptid
= inferior_ptid
;
2625 resume_ptid
= internal_resume_ptid (user_step
);
2627 if (execution_direction
!= EXEC_REVERSE
2628 && step
&& breakpoint_inserted_here_p (aspace
, pc
))
2630 /* There are two cases where we currently need to step a
2631 breakpoint instruction when we have a signal to deliver:
2633 - See handle_signal_stop where we handle random signals that
2634 could take out us out of the stepping range. Normally, in
2635 that case we end up continuing (instead of stepping) over the
2636 signal handler with a breakpoint at PC, but there are cases
2637 where we should _always_ single-step, even if we have a
2638 step-resume breakpoint, like when a software watchpoint is
2639 set. Assuming single-stepping and delivering a signal at the
2640 same time would takes us to the signal handler, then we could
2641 have removed the breakpoint at PC to step over it. However,
2642 some hardware step targets (like e.g., Mac OS) can't step
2643 into signal handlers, and for those, we need to leave the
2644 breakpoint at PC inserted, as otherwise if the handler
2645 recurses and executes PC again, it'll miss the breakpoint.
2646 So we leave the breakpoint inserted anyway, but we need to
2647 record that we tried to step a breakpoint instruction, so
2648 that adjust_pc_after_break doesn't end up confused.
2650 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2651 in one thread after another thread that was stepping had been
2652 momentarily paused for a step-over. When we re-resume the
2653 stepping thread, it may be resumed from that address with a
2654 breakpoint that hasn't trapped yet. Seen with
2655 gdb.threads/non-stop-fair-events.exp, on targets that don't
2656 do displaced stepping. */
2659 fprintf_unfiltered (gdb_stdlog
,
2660 "infrun: resume: [%s] stepped breakpoint\n",
2661 target_pid_to_str (tp
->ptid
));
2663 tp
->stepped_breakpoint
= 1;
2665 /* Most targets can step a breakpoint instruction, thus
2666 executing it normally. But if this one cannot, just
2667 continue and we will hit it anyway. */
2668 if (gdbarch_cannot_step_breakpoint (gdbarch
))
2673 && tp
->control
.trap_expected
2674 && use_displaced_stepping (tp
)
2675 && !step_over_info_valid_p ())
2677 struct regcache
*resume_regcache
= get_thread_regcache (tp
->ptid
);
2678 struct gdbarch
*resume_gdbarch
= get_regcache_arch (resume_regcache
);
2679 CORE_ADDR actual_pc
= regcache_read_pc (resume_regcache
);
2682 fprintf_unfiltered (gdb_stdlog
, "displaced: run %s: ",
2683 paddress (resume_gdbarch
, actual_pc
));
2684 read_memory (actual_pc
, buf
, sizeof (buf
));
2685 displaced_step_dump_bytes (gdb_stdlog
, buf
, sizeof (buf
));
2688 if (tp
->control
.may_range_step
)
2690 /* If we're resuming a thread with the PC out of the step
2691 range, then we're doing some nested/finer run control
2692 operation, like stepping the thread out of the dynamic
2693 linker or the displaced stepping scratch pad. We
2694 shouldn't have allowed a range step then. */
2695 gdb_assert (pc_in_thread_step_range (pc
, tp
));
2698 do_target_resume (resume_ptid
, step
, sig
);
2700 discard_cleanups (old_cleanups
);
2705 /* Clear out all variables saying what to do when inferior is continued.
2706 First do this, then set the ones you want, then call `proceed'. */
2709 clear_proceed_status_thread (struct thread_info
*tp
)
2712 fprintf_unfiltered (gdb_stdlog
,
2713 "infrun: clear_proceed_status_thread (%s)\n",
2714 target_pid_to_str (tp
->ptid
));
2716 /* If we're starting a new sequence, then the previous finished
2717 single-step is no longer relevant. */
2718 if (tp
->suspend
.waitstatus_pending_p
)
2720 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
2723 fprintf_unfiltered (gdb_stdlog
,
2724 "infrun: clear_proceed_status: pending "
2725 "event of %s was a finished step. "
2727 target_pid_to_str (tp
->ptid
));
2729 tp
->suspend
.waitstatus_pending_p
= 0;
2730 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
2732 else if (debug_infrun
)
2736 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
2737 fprintf_unfiltered (gdb_stdlog
,
2738 "infrun: clear_proceed_status_thread: thread %s "
2739 "has pending wait status %s "
2740 "(currently_stepping=%d).\n",
2741 target_pid_to_str (tp
->ptid
), statstr
,
2742 currently_stepping (tp
));
2747 /* If this signal should not be seen by program, give it zero.
2748 Used for debugging signals. */
2749 if (!signal_pass_state (tp
->suspend
.stop_signal
))
2750 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
2752 tp
->control
.trap_expected
= 0;
2753 tp
->control
.step_range_start
= 0;
2754 tp
->control
.step_range_end
= 0;
2755 tp
->control
.may_range_step
= 0;
2756 tp
->control
.step_frame_id
= null_frame_id
;
2757 tp
->control
.step_stack_frame_id
= null_frame_id
;
2758 tp
->control
.step_over_calls
= STEP_OVER_UNDEBUGGABLE
;
2759 tp
->control
.step_start_function
= NULL
;
2760 tp
->stop_requested
= 0;
2762 tp
->control
.stop_step
= 0;
2764 tp
->control
.proceed_to_finish
= 0;
2766 tp
->control
.command_interp
= NULL
;
2767 tp
->control
.stepping_command
= 0;
2769 /* Discard any remaining commands or status from previous stop. */
2770 bpstat_clear (&tp
->control
.stop_bpstat
);
2774 clear_proceed_status (int step
)
2778 struct thread_info
*tp
;
2781 resume_ptid
= user_visible_resume_ptid (step
);
2783 /* In all-stop mode, delete the per-thread status of all threads
2784 we're about to resume, implicitly and explicitly. */
2785 ALL_NON_EXITED_THREADS (tp
)
2787 if (!ptid_match (tp
->ptid
, resume_ptid
))
2789 clear_proceed_status_thread (tp
);
2793 if (!ptid_equal (inferior_ptid
, null_ptid
))
2795 struct inferior
*inferior
;
2799 /* If in non-stop mode, only delete the per-thread status of
2800 the current thread. */
2801 clear_proceed_status_thread (inferior_thread ());
2804 inferior
= current_inferior ();
2805 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2808 stop_after_trap
= 0;
2810 observer_notify_about_to_proceed ();
2813 /* Returns true if TP is still stopped at a breakpoint that needs
2814 stepping-over in order to make progress. If the breakpoint is gone
2815 meanwhile, we can skip the whole step-over dance. */
2818 thread_still_needs_step_over_bp (struct thread_info
*tp
)
2820 if (tp
->stepping_over_breakpoint
)
2822 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
2824 if (breakpoint_here_p (get_regcache_aspace (regcache
),
2825 regcache_read_pc (regcache
))
2826 == ordinary_breakpoint_here
)
2829 tp
->stepping_over_breakpoint
= 0;
2835 /* Check whether thread TP still needs to start a step-over in order
2836 to make progress when resumed. Returns an bitwise or of enum
2837 step_over_what bits, indicating what needs to be stepped over. */
2840 thread_still_needs_step_over (struct thread_info
*tp
)
2842 struct inferior
*inf
= find_inferior_ptid (tp
->ptid
);
2845 if (thread_still_needs_step_over_bp (tp
))
2846 what
|= STEP_OVER_BREAKPOINT
;
2848 if (tp
->stepping_over_watchpoint
2849 && !target_have_steppable_watchpoint
)
2850 what
|= STEP_OVER_WATCHPOINT
;
2855 /* Returns true if scheduler locking applies. STEP indicates whether
2856 we're about to do a step/next-like command to a thread. */
2859 schedlock_applies (struct thread_info
*tp
)
2861 return (scheduler_mode
== schedlock_on
2862 || (scheduler_mode
== schedlock_step
2863 && tp
->control
.stepping_command
));
2866 /* Basic routine for continuing the program in various fashions.
2868 ADDR is the address to resume at, or -1 for resume where stopped.
2869 SIGGNAL is the signal to give it, or 0 for none,
2870 or -1 for act according to how it stopped.
2871 STEP is nonzero if should trap after one instruction.
2872 -1 means return after that and print nothing.
2873 You should probably set various step_... variables
2874 before calling here, if you are stepping.
2876 You should call clear_proceed_status before calling proceed. */
2879 proceed (CORE_ADDR addr
, enum gdb_signal siggnal
)
2881 struct regcache
*regcache
;
2882 struct gdbarch
*gdbarch
;
2883 struct thread_info
*tp
;
2885 struct address_space
*aspace
;
2887 struct execution_control_state ecss
;
2888 struct execution_control_state
*ecs
= &ecss
;
2889 struct cleanup
*old_chain
;
2892 /* If we're stopped at a fork/vfork, follow the branch set by the
2893 "set follow-fork-mode" command; otherwise, we'll just proceed
2894 resuming the current thread. */
2895 if (!follow_fork ())
2897 /* The target for some reason decided not to resume. */
2899 if (target_can_async_p ())
2900 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
2904 /* We'll update this if & when we switch to a new thread. */
2905 previous_inferior_ptid
= inferior_ptid
;
2907 regcache
= get_current_regcache ();
2908 gdbarch
= get_regcache_arch (regcache
);
2909 aspace
= get_regcache_aspace (regcache
);
2910 pc
= regcache_read_pc (regcache
);
2911 tp
= inferior_thread ();
2913 /* Fill in with reasonable starting values. */
2914 init_thread_stepping_state (tp
);
2916 gdb_assert (!thread_is_in_step_over_chain (tp
));
2918 if (addr
== (CORE_ADDR
) -1)
2921 && breakpoint_here_p (aspace
, pc
) == ordinary_breakpoint_here
2922 && execution_direction
!= EXEC_REVERSE
)
2923 /* There is a breakpoint at the address we will resume at,
2924 step one instruction before inserting breakpoints so that
2925 we do not stop right away (and report a second hit at this
2928 Note, we don't do this in reverse, because we won't
2929 actually be executing the breakpoint insn anyway.
2930 We'll be (un-)executing the previous instruction. */
2931 tp
->stepping_over_breakpoint
= 1;
2932 else if (gdbarch_single_step_through_delay_p (gdbarch
)
2933 && gdbarch_single_step_through_delay (gdbarch
,
2934 get_current_frame ()))
2935 /* We stepped onto an instruction that needs to be stepped
2936 again before re-inserting the breakpoint, do so. */
2937 tp
->stepping_over_breakpoint
= 1;
2941 regcache_write_pc (regcache
, addr
);
2944 if (siggnal
!= GDB_SIGNAL_DEFAULT
)
2945 tp
->suspend
.stop_signal
= siggnal
;
2947 /* Record the interpreter that issued the execution command that
2948 caused this thread to resume. If the top level interpreter is
2949 MI/async, and the execution command was a CLI command
2950 (next/step/etc.), we'll want to print stop event output to the MI
2951 console channel (the stepped-to line, etc.), as if the user
2952 entered the execution command on a real GDB console. */
2953 tp
->control
.command_interp
= command_interp ();
2955 resume_ptid
= user_visible_resume_ptid (tp
->control
.stepping_command
);
2957 /* If an exception is thrown from this point on, make sure to
2958 propagate GDB's knowledge of the executing state to the
2959 frontend/user running state. */
2960 old_chain
= make_cleanup (finish_thread_state_cleanup
, &resume_ptid
);
2962 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
2963 threads (e.g., we might need to set threads stepping over
2964 breakpoints first), from the user/frontend's point of view, all
2965 threads in RESUME_PTID are now running. Unless we're calling an
2966 inferior function, as in that case we pretend the inferior
2967 doesn't run at all. */
2968 if (!tp
->control
.in_infcall
)
2969 set_running (resume_ptid
, 1);
2972 fprintf_unfiltered (gdb_stdlog
,
2973 "infrun: proceed (addr=%s, signal=%s)\n",
2974 paddress (gdbarch
, addr
),
2975 gdb_signal_to_symbol_string (siggnal
));
2977 annotate_starting ();
2979 /* Make sure that output from GDB appears before output from the
2981 gdb_flush (gdb_stdout
);
2983 /* In a multi-threaded task we may select another thread and
2984 then continue or step.
2986 But if a thread that we're resuming had stopped at a breakpoint,
2987 it will immediately cause another breakpoint stop without any
2988 execution (i.e. it will report a breakpoint hit incorrectly). So
2989 we must step over it first.
2991 Look for threads other than the current (TP) that reported a
2992 breakpoint hit and haven't been resumed yet since. */
2994 /* If scheduler locking applies, we can avoid iterating over all
2996 if (!non_stop
&& !schedlock_applies (tp
))
2998 struct thread_info
*current
= tp
;
3000 ALL_NON_EXITED_THREADS (tp
)
3002 /* Ignore the current thread here. It's handled
3007 /* Ignore threads of processes we're not resuming. */
3008 if (!ptid_match (tp
->ptid
, resume_ptid
))
3011 if (!thread_still_needs_step_over (tp
))
3014 gdb_assert (!thread_is_in_step_over_chain (tp
));
3017 fprintf_unfiltered (gdb_stdlog
,
3018 "infrun: need to step-over [%s] first\n",
3019 target_pid_to_str (tp
->ptid
));
3021 thread_step_over_chain_enqueue (tp
);
3027 /* Enqueue the current thread last, so that we move all other
3028 threads over their breakpoints first. */
3029 if (tp
->stepping_over_breakpoint
)
3030 thread_step_over_chain_enqueue (tp
);
3032 /* If the thread isn't started, we'll still need to set its prev_pc,
3033 so that switch_back_to_stepped_thread knows the thread hasn't
3034 advanced. Must do this before resuming any thread, as in
3035 all-stop/remote, once we resume we can't send any other packet
3036 until the target stops again. */
3037 tp
->prev_pc
= regcache_read_pc (regcache
);
3039 started
= start_step_over ();
3041 if (step_over_info_valid_p ())
3043 /* Either this thread started a new in-line step over, or some
3044 other thread was already doing one. In either case, don't
3045 resume anything else until the step-over is finished. */
3047 else if (started
&& !target_is_non_stop_p ())
3049 /* A new displaced stepping sequence was started. In all-stop,
3050 we can't talk to the target anymore until it next stops. */
3052 else if (!non_stop
&& target_is_non_stop_p ())
3054 /* In all-stop, but the target is always in non-stop mode.
3055 Start all other threads that are implicitly resumed too. */
3056 ALL_NON_EXITED_THREADS (tp
)
3058 /* Ignore threads of processes we're not resuming. */
3059 if (!ptid_match (tp
->ptid
, resume_ptid
))
3065 fprintf_unfiltered (gdb_stdlog
,
3066 "infrun: proceed: [%s] resumed\n",
3067 target_pid_to_str (tp
->ptid
));
3068 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
3072 if (thread_is_in_step_over_chain (tp
))
3075 fprintf_unfiltered (gdb_stdlog
,
3076 "infrun: proceed: [%s] needs step-over\n",
3077 target_pid_to_str (tp
->ptid
));
3082 fprintf_unfiltered (gdb_stdlog
,
3083 "infrun: proceed: resuming %s\n",
3084 target_pid_to_str (tp
->ptid
));
3086 reset_ecs (ecs
, tp
);
3087 switch_to_thread (tp
->ptid
);
3088 keep_going_pass_signal (ecs
);
3089 if (!ecs
->wait_some_more
)
3090 error (_("Command aborted."));
3093 else if (!tp
->resumed
&& !thread_is_in_step_over_chain (tp
))
3095 /* The thread wasn't started, and isn't queued, run it now. */
3096 reset_ecs (ecs
, tp
);
3097 switch_to_thread (tp
->ptid
);
3098 keep_going_pass_signal (ecs
);
3099 if (!ecs
->wait_some_more
)
3100 error (_("Command aborted."));
3103 discard_cleanups (old_chain
);
3105 /* Tell the event loop to wait for it to stop. If the target
3106 supports asynchronous execution, it'll do this from within
3108 if (!target_can_async_p ())
3109 mark_async_event_handler (infrun_async_inferior_event_token
);
3113 /* Start remote-debugging of a machine over a serial link. */
3116 start_remote (int from_tty
)
3118 struct inferior
*inferior
;
3120 inferior
= current_inferior ();
3121 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
3123 /* Always go on waiting for the target, regardless of the mode. */
3124 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3125 indicate to wait_for_inferior that a target should timeout if
3126 nothing is returned (instead of just blocking). Because of this,
3127 targets expecting an immediate response need to, internally, set
3128 things up so that the target_wait() is forced to eventually
3130 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3131 differentiate to its caller what the state of the target is after
3132 the initial open has been performed. Here we're assuming that
3133 the target has stopped. It should be possible to eventually have
3134 target_open() return to the caller an indication that the target
3135 is currently running and GDB state should be set to the same as
3136 for an async run. */
3137 wait_for_inferior ();
3139 /* Now that the inferior has stopped, do any bookkeeping like
3140 loading shared libraries. We want to do this before normal_stop,
3141 so that the displayed frame is up to date. */
3142 post_create_inferior (¤t_target
, from_tty
);
3147 /* Initialize static vars when a new inferior begins. */
3150 init_wait_for_inferior (void)
3152 /* These are meaningless until the first time through wait_for_inferior. */
3154 breakpoint_init_inferior (inf_starting
);
3156 clear_proceed_status (0);
3158 target_last_wait_ptid
= minus_one_ptid
;
3160 previous_inferior_ptid
= inferior_ptid
;
3162 /* Discard any skipped inlined frames. */
3163 clear_inline_frame_state (minus_one_ptid
);
3168 static void handle_inferior_event (struct execution_control_state
*ecs
);
3170 static void handle_step_into_function (struct gdbarch
*gdbarch
,
3171 struct execution_control_state
*ecs
);
3172 static void handle_step_into_function_backward (struct gdbarch
*gdbarch
,
3173 struct execution_control_state
*ecs
);
3174 static void handle_signal_stop (struct execution_control_state
*ecs
);
3175 static void check_exception_resume (struct execution_control_state
*,
3176 struct frame_info
*);
3178 static void end_stepping_range (struct execution_control_state
*ecs
);
3179 static void stop_waiting (struct execution_control_state
*ecs
);
3180 static void keep_going (struct execution_control_state
*ecs
);
3181 static void process_event_stop_test (struct execution_control_state
*ecs
);
3182 static int switch_back_to_stepped_thread (struct execution_control_state
*ecs
);
3184 /* Callback for iterate over threads. If the thread is stopped, but
3185 the user/frontend doesn't know about that yet, go through
3186 normal_stop, as if the thread had just stopped now. ARG points at
3187 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
3188 ptid_is_pid(PTID) is true, applies to all threads of the process
3189 pointed at by PTID. Otherwise, apply only to the thread pointed by
3193 infrun_thread_stop_requested_callback (struct thread_info
*info
, void *arg
)
3195 ptid_t ptid
= * (ptid_t
*) arg
;
3197 if ((ptid_equal (info
->ptid
, ptid
)
3198 || ptid_equal (minus_one_ptid
, ptid
)
3199 || (ptid_is_pid (ptid
)
3200 && ptid_get_pid (ptid
) == ptid_get_pid (info
->ptid
)))
3201 && is_running (info
->ptid
)
3202 && !is_executing (info
->ptid
))
3204 struct cleanup
*old_chain
;
3205 struct execution_control_state ecss
;
3206 struct execution_control_state
*ecs
= &ecss
;
3208 memset (ecs
, 0, sizeof (*ecs
));
3210 old_chain
= make_cleanup_restore_current_thread ();
3212 overlay_cache_invalid
= 1;
3213 /* Flush target cache before starting to handle each event.
3214 Target was running and cache could be stale. This is just a
3215 heuristic. Running threads may modify target memory, but we
3216 don't get any event. */
3217 target_dcache_invalidate ();
3219 /* Go through handle_inferior_event/normal_stop, so we always
3220 have consistent output as if the stop event had been
3222 ecs
->ptid
= info
->ptid
;
3223 ecs
->event_thread
= find_thread_ptid (info
->ptid
);
3224 ecs
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
3225 ecs
->ws
.value
.sig
= GDB_SIGNAL_0
;
3227 handle_inferior_event (ecs
);
3229 if (!ecs
->wait_some_more
)
3231 struct thread_info
*tp
;
3235 /* Finish off the continuations. */
3236 tp
= inferior_thread ();
3237 do_all_intermediate_continuations_thread (tp
, 1);
3238 do_all_continuations_thread (tp
, 1);
3241 do_cleanups (old_chain
);
3247 /* This function is attached as a "thread_stop_requested" observer.
3248 Cleanup local state that assumed the PTID was to be resumed, and
3249 report the stop to the frontend. */
3252 infrun_thread_stop_requested (ptid_t ptid
)
3254 struct thread_info
*tp
;
3256 /* PTID was requested to stop. Remove matching threads from the
3257 step-over queue, so we don't try to resume them
3259 ALL_NON_EXITED_THREADS (tp
)
3260 if (ptid_match (tp
->ptid
, ptid
))
3262 if (thread_is_in_step_over_chain (tp
))
3263 thread_step_over_chain_remove (tp
);
3266 iterate_over_threads (infrun_thread_stop_requested_callback
, &ptid
);
3270 infrun_thread_thread_exit (struct thread_info
*tp
, int silent
)
3272 if (ptid_equal (target_last_wait_ptid
, tp
->ptid
))
3273 nullify_last_target_wait_ptid ();
3276 /* Delete the step resume, single-step and longjmp/exception resume
3277 breakpoints of TP. */
3280 delete_thread_infrun_breakpoints (struct thread_info
*tp
)
3282 delete_step_resume_breakpoint (tp
);
3283 delete_exception_resume_breakpoint (tp
);
3284 delete_single_step_breakpoints (tp
);
3287 /* If the target still has execution, call FUNC for each thread that
3288 just stopped. In all-stop, that's all the non-exited threads; in
3289 non-stop, that's the current thread, only. */
3291 typedef void (*for_each_just_stopped_thread_callback_func
)
3292 (struct thread_info
*tp
);
3295 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func
)
3297 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
3300 if (target_is_non_stop_p ())
3302 /* If in non-stop mode, only the current thread stopped. */
3303 func (inferior_thread ());
3307 struct thread_info
*tp
;
3309 /* In all-stop mode, all threads have stopped. */
3310 ALL_NON_EXITED_THREADS (tp
)
3317 /* Delete the step resume and longjmp/exception resume breakpoints of
3318 the threads that just stopped. */
3321 delete_just_stopped_threads_infrun_breakpoints (void)
3323 for_each_just_stopped_thread (delete_thread_infrun_breakpoints
);
3326 /* Delete the single-step breakpoints of the threads that just
3330 delete_just_stopped_threads_single_step_breakpoints (void)
3332 for_each_just_stopped_thread (delete_single_step_breakpoints
);
3335 /* A cleanup wrapper. */
3338 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg
)
3340 delete_just_stopped_threads_infrun_breakpoints ();
3346 print_target_wait_results (ptid_t waiton_ptid
, ptid_t result_ptid
,
3347 const struct target_waitstatus
*ws
)
3349 char *status_string
= target_waitstatus_to_string (ws
);
3350 struct ui_file
*tmp_stream
= mem_fileopen ();
3353 /* The text is split over several lines because it was getting too long.
3354 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3355 output as a unit; we want only one timestamp printed if debug_timestamp
3358 fprintf_unfiltered (tmp_stream
,
3359 "infrun: target_wait (%d.%ld.%ld",
3360 ptid_get_pid (waiton_ptid
),
3361 ptid_get_lwp (waiton_ptid
),
3362 ptid_get_tid (waiton_ptid
));
3363 if (ptid_get_pid (waiton_ptid
) != -1)
3364 fprintf_unfiltered (tmp_stream
,
3365 " [%s]", target_pid_to_str (waiton_ptid
));
3366 fprintf_unfiltered (tmp_stream
, ", status) =\n");
3367 fprintf_unfiltered (tmp_stream
,
3368 "infrun: %d.%ld.%ld [%s],\n",
3369 ptid_get_pid (result_ptid
),
3370 ptid_get_lwp (result_ptid
),
3371 ptid_get_tid (result_ptid
),
3372 target_pid_to_str (result_ptid
));
3373 fprintf_unfiltered (tmp_stream
,
3377 text
= ui_file_xstrdup (tmp_stream
, NULL
);
3379 /* This uses %s in part to handle %'s in the text, but also to avoid
3380 a gcc error: the format attribute requires a string literal. */
3381 fprintf_unfiltered (gdb_stdlog
, "%s", text
);
3383 xfree (status_string
);
3385 ui_file_delete (tmp_stream
);
3388 /* Select a thread at random, out of those which are resumed and have
3391 static struct thread_info
*
3392 random_pending_event_thread (ptid_t waiton_ptid
)
3394 struct thread_info
*event_tp
;
3396 int random_selector
;
3398 /* First see how many events we have. Count only resumed threads
3399 that have an event pending. */
3400 ALL_NON_EXITED_THREADS (event_tp
)
3401 if (ptid_match (event_tp
->ptid
, waiton_ptid
)
3402 && event_tp
->resumed
3403 && event_tp
->suspend
.waitstatus_pending_p
)
3406 if (num_events
== 0)
3409 /* Now randomly pick a thread out of those that have had events. */
3410 random_selector
= (int)
3411 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
3413 if (debug_infrun
&& num_events
> 1)
3414 fprintf_unfiltered (gdb_stdlog
,
3415 "infrun: Found %d events, selecting #%d\n",
3416 num_events
, random_selector
);
3418 /* Select the Nth thread that has had an event. */
3419 ALL_NON_EXITED_THREADS (event_tp
)
3420 if (ptid_match (event_tp
->ptid
, waiton_ptid
)
3421 && event_tp
->resumed
3422 && event_tp
->suspend
.waitstatus_pending_p
)
3423 if (random_selector
-- == 0)
3429 /* Wrapper for target_wait that first checks whether threads have
3430 pending statuses to report before actually asking the target for
3434 do_target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3437 struct thread_info
*tp
;
3439 /* First check if there is a resumed thread with a wait status
3441 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
3443 tp
= random_pending_event_thread (ptid
);
3448 fprintf_unfiltered (gdb_stdlog
,
3449 "infrun: Waiting for specific thread %s.\n",
3450 target_pid_to_str (ptid
));
3452 /* We have a specific thread to check. */
3453 tp
= find_thread_ptid (ptid
);
3454 gdb_assert (tp
!= NULL
);
3455 if (!tp
->suspend
.waitstatus_pending_p
)
3460 && (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3461 || tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
3463 struct regcache
*regcache
= get_thread_regcache (tp
->ptid
);
3464 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3468 pc
= regcache_read_pc (regcache
);
3470 if (pc
!= tp
->suspend
.stop_pc
)
3473 fprintf_unfiltered (gdb_stdlog
,
3474 "infrun: PC of %s changed. was=%s, now=%s\n",
3475 target_pid_to_str (tp
->ptid
),
3476 paddress (gdbarch
, tp
->prev_pc
),
3477 paddress (gdbarch
, pc
));
3480 else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
3483 fprintf_unfiltered (gdb_stdlog
,
3484 "infrun: previous breakpoint of %s, at %s gone\n",
3485 target_pid_to_str (tp
->ptid
),
3486 paddress (gdbarch
, pc
));
3494 fprintf_unfiltered (gdb_stdlog
,
3495 "infrun: pending event of %s cancelled.\n",
3496 target_pid_to_str (tp
->ptid
));
3498 tp
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_SPURIOUS
;
3499 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3509 statstr
= target_waitstatus_to_string (&tp
->suspend
.waitstatus
);
3510 fprintf_unfiltered (gdb_stdlog
,
3511 "infrun: Using pending wait status %s for %s.\n",
3513 target_pid_to_str (tp
->ptid
));
3517 /* Now that we've selected our final event LWP, un-adjust its PC
3518 if it was a software breakpoint (and the target doesn't
3519 always adjust the PC itself). */
3520 if (tp
->suspend
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3521 && !target_supports_stopped_by_sw_breakpoint ())
3523 struct regcache
*regcache
;
3524 struct gdbarch
*gdbarch
;
3527 regcache
= get_thread_regcache (tp
->ptid
);
3528 gdbarch
= get_regcache_arch (regcache
);
3530 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3535 pc
= regcache_read_pc (regcache
);
3536 regcache_write_pc (regcache
, pc
+ decr_pc
);
3540 tp
->suspend
.stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3541 *status
= tp
->suspend
.waitstatus
;
3542 tp
->suspend
.waitstatus_pending_p
= 0;
3544 /* Wake up the event loop again, until all pending events are
3546 if (target_is_async_p ())
3547 mark_async_event_handler (infrun_async_inferior_event_token
);
3551 /* But if we don't find one, we'll have to wait. */
3553 if (deprecated_target_wait_hook
)
3554 event_ptid
= deprecated_target_wait_hook (ptid
, status
, options
);
3556 event_ptid
= target_wait (ptid
, status
, options
);
3561 /* Prepare and stabilize the inferior for detaching it. E.g.,
3562 detaching while a thread is displaced stepping is a recipe for
3563 crashing it, as nothing would readjust the PC out of the scratch
3567 prepare_for_detach (void)
3569 struct inferior
*inf
= current_inferior ();
3570 ptid_t pid_ptid
= pid_to_ptid (inf
->pid
);
3571 struct cleanup
*old_chain_1
;
3572 struct displaced_step_inferior_state
*displaced
;
3574 displaced
= get_displaced_stepping_state (inf
->pid
);
3576 /* Is any thread of this process displaced stepping? If not,
3577 there's nothing else to do. */
3578 if (displaced
== NULL
|| ptid_equal (displaced
->step_ptid
, null_ptid
))
3582 fprintf_unfiltered (gdb_stdlog
,
3583 "displaced-stepping in-process while detaching");
3585 old_chain_1
= make_cleanup_restore_integer (&inf
->detaching
);
3588 while (!ptid_equal (displaced
->step_ptid
, null_ptid
))
3590 struct cleanup
*old_chain_2
;
3591 struct execution_control_state ecss
;
3592 struct execution_control_state
*ecs
;
3595 memset (ecs
, 0, sizeof (*ecs
));
3597 overlay_cache_invalid
= 1;
3598 /* Flush target cache before starting to handle each event.
3599 Target was running and cache could be stale. This is just a
3600 heuristic. Running threads may modify target memory, but we
3601 don't get any event. */
3602 target_dcache_invalidate ();
3604 ecs
->ptid
= do_target_wait (pid_ptid
, &ecs
->ws
, 0);
3607 print_target_wait_results (pid_ptid
, ecs
->ptid
, &ecs
->ws
);
3609 /* If an error happens while handling the event, propagate GDB's
3610 knowledge of the executing state to the frontend/user running
3612 old_chain_2
= make_cleanup (finish_thread_state_cleanup
,
3615 /* Now figure out what to do with the result of the result. */
3616 handle_inferior_event (ecs
);
3618 /* No error, don't finish the state yet. */
3619 discard_cleanups (old_chain_2
);
3621 /* Breakpoints and watchpoints are not installed on the target
3622 at this point, and signals are passed directly to the
3623 inferior, so this must mean the process is gone. */
3624 if (!ecs
->wait_some_more
)
3626 discard_cleanups (old_chain_1
);
3627 error (_("Program exited while detaching"));
3631 discard_cleanups (old_chain_1
);
3634 /* Wait for control to return from inferior to debugger.
3636 If inferior gets a signal, we may decide to start it up again
3637 instead of returning. That is why there is a loop in this function.
3638 When this function actually returns it means the inferior
3639 should be left stopped and GDB should read more commands. */
3642 wait_for_inferior (void)
3644 struct cleanup
*old_cleanups
;
3645 struct cleanup
*thread_state_chain
;
3649 (gdb_stdlog
, "infrun: wait_for_inferior ()\n");
3652 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
,
3655 /* If an error happens while handling the event, propagate GDB's
3656 knowledge of the executing state to the frontend/user running
3658 thread_state_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3662 struct execution_control_state ecss
;
3663 struct execution_control_state
*ecs
= &ecss
;
3664 ptid_t waiton_ptid
= minus_one_ptid
;
3666 memset (ecs
, 0, sizeof (*ecs
));
3668 overlay_cache_invalid
= 1;
3670 /* Flush target cache before starting to handle each event.
3671 Target was running and cache could be stale. This is just a
3672 heuristic. Running threads may modify target memory, but we
3673 don't get any event. */
3674 target_dcache_invalidate ();
3676 ecs
->ptid
= do_target_wait (waiton_ptid
, &ecs
->ws
, 0);
3679 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3681 /* Now figure out what to do with the result of the result. */
3682 handle_inferior_event (ecs
);
3684 if (!ecs
->wait_some_more
)
3688 /* No error, don't finish the state yet. */
3689 discard_cleanups (thread_state_chain
);
3691 do_cleanups (old_cleanups
);
3694 /* Cleanup that reinstalls the readline callback handler, if the
3695 target is running in the background. If while handling the target
3696 event something triggered a secondary prompt, like e.g., a
3697 pagination prompt, we'll have removed the callback handler (see
3698 gdb_readline_wrapper_line). Need to do this as we go back to the
3699 event loop, ready to process further input. Note this has no
3700 effect if the handler hasn't actually been removed, because calling
3701 rl_callback_handler_install resets the line buffer, thus losing
3705 reinstall_readline_callback_handler_cleanup (void *arg
)
3707 if (!interpreter_async
)
3709 /* We're not going back to the top level event loop yet. Don't
3710 install the readline callback, as it'd prep the terminal,
3711 readline-style (raw, noecho) (e.g., --batch). We'll install
3712 it the next time the prompt is displayed, when we're ready
3717 if (async_command_editing_p
&& !sync_execution
)
3718 gdb_rl_callback_handler_reinstall ();
3721 /* Asynchronous version of wait_for_inferior. It is called by the
3722 event loop whenever a change of state is detected on the file
3723 descriptor corresponding to the target. It can be called more than
3724 once to complete a single execution command. In such cases we need
3725 to keep the state in a global variable ECSS. If it is the last time
3726 that this function is called for a single execution command, then
3727 report to the user that the inferior has stopped, and do the
3728 necessary cleanups. */
3731 fetch_inferior_event (void *client_data
)
3733 struct execution_control_state ecss
;
3734 struct execution_control_state
*ecs
= &ecss
;
3735 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3736 struct cleanup
*ts_old_chain
;
3737 int was_sync
= sync_execution
;
3739 ptid_t waiton_ptid
= minus_one_ptid
;
3741 memset (ecs
, 0, sizeof (*ecs
));
3743 /* End up with readline processing input, if necessary. */
3744 make_cleanup (reinstall_readline_callback_handler_cleanup
, NULL
);
3746 /* We're handling a live event, so make sure we're doing live
3747 debugging. If we're looking at traceframes while the target is
3748 running, we're going to need to get back to that mode after
3749 handling the event. */
3752 make_cleanup_restore_current_traceframe ();
3753 set_current_traceframe (-1);
3757 /* In non-stop mode, the user/frontend should not notice a thread
3758 switch due to internal events. Make sure we reverse to the
3759 user selected thread and frame after handling the event and
3760 running any breakpoint commands. */
3761 make_cleanup_restore_current_thread ();
3763 overlay_cache_invalid
= 1;
3764 /* Flush target cache before starting to handle each event. Target
3765 was running and cache could be stale. This is just a heuristic.
3766 Running threads may modify target memory, but we don't get any
3768 target_dcache_invalidate ();
3770 make_cleanup_restore_integer (&execution_direction
);
3771 execution_direction
= target_execution_direction ();
3773 ecs
->ptid
= do_target_wait (waiton_ptid
, &ecs
->ws
,
3774 target_can_async_p () ? TARGET_WNOHANG
: 0);
3777 print_target_wait_results (waiton_ptid
, ecs
->ptid
, &ecs
->ws
);
3779 /* If an error happens while handling the event, propagate GDB's
3780 knowledge of the executing state to the frontend/user running
3782 if (!target_is_non_stop_p ())
3783 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
3785 ts_old_chain
= make_cleanup (finish_thread_state_cleanup
, &ecs
->ptid
);
3787 /* Get executed before make_cleanup_restore_current_thread above to apply
3788 still for the thread which has thrown the exception. */
3789 make_bpstat_clear_actions_cleanup ();
3791 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup
, NULL
);
3793 /* Now figure out what to do with the result of the result. */
3794 handle_inferior_event (ecs
);
3796 if (!ecs
->wait_some_more
)
3798 struct inferior
*inf
= find_inferior_ptid (ecs
->ptid
);
3800 delete_just_stopped_threads_infrun_breakpoints ();
3802 /* We may not find an inferior if this was a process exit. */
3803 if (inf
== NULL
|| inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
3806 if (target_has_execution
3807 && ecs
->ws
.kind
!= TARGET_WAITKIND_NO_RESUMED
3808 && ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
3809 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
3810 && ecs
->event_thread
->step_multi
3811 && ecs
->event_thread
->control
.stop_step
)
3812 inferior_event_handler (INF_EXEC_CONTINUE
, NULL
);
3815 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
3820 /* No error, don't finish the thread states yet. */
3821 discard_cleanups (ts_old_chain
);
3823 /* Revert thread and frame. */
3824 do_cleanups (old_chain
);
3826 /* If the inferior was in sync execution mode, and now isn't,
3827 restore the prompt (a synchronous execution command has finished,
3828 and we're ready for input). */
3829 if (interpreter_async
&& was_sync
&& !sync_execution
)
3830 observer_notify_sync_execution_done ();
3834 && exec_done_display_p
3835 && (ptid_equal (inferior_ptid
, null_ptid
)
3836 || !is_running (inferior_ptid
)))
3837 printf_unfiltered (_("completed.\n"));
3840 /* Record the frame and location we're currently stepping through. */
3842 set_step_info (struct frame_info
*frame
, struct symtab_and_line sal
)
3844 struct thread_info
*tp
= inferior_thread ();
3846 tp
->control
.step_frame_id
= get_frame_id (frame
);
3847 tp
->control
.step_stack_frame_id
= get_stack_frame_id (frame
);
3849 tp
->current_symtab
= sal
.symtab
;
3850 tp
->current_line
= sal
.line
;
3853 /* Clear context switchable stepping state. */
3856 init_thread_stepping_state (struct thread_info
*tss
)
3858 tss
->stepped_breakpoint
= 0;
3859 tss
->stepping_over_breakpoint
= 0;
3860 tss
->stepping_over_watchpoint
= 0;
3861 tss
->step_after_step_resume_breakpoint
= 0;
3864 /* Set the cached copy of the last ptid/waitstatus. */
3867 set_last_target_status (ptid_t ptid
, struct target_waitstatus status
)
3869 target_last_wait_ptid
= ptid
;
3870 target_last_waitstatus
= status
;
3873 /* Return the cached copy of the last pid/waitstatus returned by
3874 target_wait()/deprecated_target_wait_hook(). The data is actually
3875 cached by handle_inferior_event(), which gets called immediately
3876 after target_wait()/deprecated_target_wait_hook(). */
3879 get_last_target_status (ptid_t
*ptidp
, struct target_waitstatus
*status
)
3881 *ptidp
= target_last_wait_ptid
;
3882 *status
= target_last_waitstatus
;
3886 nullify_last_target_wait_ptid (void)
3888 target_last_wait_ptid
= minus_one_ptid
;
3891 /* Switch thread contexts. */
3894 context_switch (ptid_t ptid
)
3896 if (debug_infrun
&& !ptid_equal (ptid
, inferior_ptid
))
3898 fprintf_unfiltered (gdb_stdlog
, "infrun: Switching context from %s ",
3899 target_pid_to_str (inferior_ptid
));
3900 fprintf_unfiltered (gdb_stdlog
, "to %s\n",
3901 target_pid_to_str (ptid
));
3904 switch_to_thread (ptid
);
3907 /* If the target can't tell whether we've hit breakpoints
3908 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
3909 check whether that could have been caused by a breakpoint. If so,
3910 adjust the PC, per gdbarch_decr_pc_after_break. */
3913 adjust_pc_after_break (struct thread_info
*thread
,
3914 struct target_waitstatus
*ws
)
3916 struct regcache
*regcache
;
3917 struct gdbarch
*gdbarch
;
3918 struct address_space
*aspace
;
3919 CORE_ADDR breakpoint_pc
, decr_pc
;
3921 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
3922 we aren't, just return.
3924 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3925 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
3926 implemented by software breakpoints should be handled through the normal
3929 NOTE drow/2004-01-31: On some targets, breakpoints may generate
3930 different signals (SIGILL or SIGEMT for instance), but it is less
3931 clear where the PC is pointing afterwards. It may not match
3932 gdbarch_decr_pc_after_break. I don't know any specific target that
3933 generates these signals at breakpoints (the code has been in GDB since at
3934 least 1992) so I can not guess how to handle them here.
3936 In earlier versions of GDB, a target with
3937 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3938 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
3939 target with both of these set in GDB history, and it seems unlikely to be
3940 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
3942 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
3945 if (ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
3948 /* In reverse execution, when a breakpoint is hit, the instruction
3949 under it has already been de-executed. The reported PC always
3950 points at the breakpoint address, so adjusting it further would
3951 be wrong. E.g., consider this case on a decr_pc_after_break == 1
3954 B1 0x08000000 : INSN1
3955 B2 0x08000001 : INSN2
3957 PC -> 0x08000003 : INSN4
3959 Say you're stopped at 0x08000003 as above. Reverse continuing
3960 from that point should hit B2 as below. Reading the PC when the
3961 SIGTRAP is reported should read 0x08000001 and INSN2 should have
3962 been de-executed already.
3964 B1 0x08000000 : INSN1
3965 B2 PC -> 0x08000001 : INSN2
3969 We can't apply the same logic as for forward execution, because
3970 we would wrongly adjust the PC to 0x08000000, since there's a
3971 breakpoint at PC - 1. We'd then report a hit on B1, although
3972 INSN1 hadn't been de-executed yet. Doing nothing is the correct
3974 if (execution_direction
== EXEC_REVERSE
)
3977 /* If the target can tell whether the thread hit a SW breakpoint,
3978 trust it. Targets that can tell also adjust the PC
3980 if (target_supports_stopped_by_sw_breakpoint ())
3983 /* Note that relying on whether a breakpoint is planted in memory to
3984 determine this can fail. E.g,. the breakpoint could have been
3985 removed since. Or the thread could have been told to step an
3986 instruction the size of a breakpoint instruction, and only
3987 _after_ was a breakpoint inserted at its address. */
3989 /* If this target does not decrement the PC after breakpoints, then
3990 we have nothing to do. */
3991 regcache
= get_thread_regcache (thread
->ptid
);
3992 gdbarch
= get_regcache_arch (regcache
);
3994 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3998 aspace
= get_regcache_aspace (regcache
);
4000 /* Find the location where (if we've hit a breakpoint) the
4001 breakpoint would be. */
4002 breakpoint_pc
= regcache_read_pc (regcache
) - decr_pc
;
4004 /* If the target can't tell whether a software breakpoint triggered,
4005 fallback to figuring it out based on breakpoints we think were
4006 inserted in the target, and on whether the thread was stepped or
4009 /* Check whether there actually is a software breakpoint inserted at
4012 If in non-stop mode, a race condition is possible where we've
4013 removed a breakpoint, but stop events for that breakpoint were
4014 already queued and arrive later. To suppress those spurious
4015 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4016 and retire them after a number of stop events are reported. Note
4017 this is an heuristic and can thus get confused. The real fix is
4018 to get the "stopped by SW BP and needs adjustment" info out of
4019 the target/kernel (and thus never reach here; see above). */
4020 if (software_breakpoint_inserted_here_p (aspace
, breakpoint_pc
)
4021 || (target_is_non_stop_p ()
4022 && moribund_breakpoint_here_p (aspace
, breakpoint_pc
)))
4024 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
4026 if (record_full_is_used ())
4027 record_full_gdb_operation_disable_set ();
4029 /* When using hardware single-step, a SIGTRAP is reported for both
4030 a completed single-step and a software breakpoint. Need to
4031 differentiate between the two, as the latter needs adjusting
4032 but the former does not.
4034 The SIGTRAP can be due to a completed hardware single-step only if
4035 - we didn't insert software single-step breakpoints
4036 - this thread is currently being stepped
4038 If any of these events did not occur, we must have stopped due
4039 to hitting a software breakpoint, and have to back up to the
4042 As a special case, we could have hardware single-stepped a
4043 software breakpoint. In this case (prev_pc == breakpoint_pc),
4044 we also need to back up to the breakpoint address. */
4046 if (thread_has_single_step_breakpoints_set (thread
)
4047 || !currently_stepping (thread
)
4048 || (thread
->stepped_breakpoint
4049 && thread
->prev_pc
== breakpoint_pc
))
4050 regcache_write_pc (regcache
, breakpoint_pc
);
4052 do_cleanups (old_cleanups
);
4057 stepped_in_from (struct frame_info
*frame
, struct frame_id step_frame_id
)
4059 for (frame
= get_prev_frame (frame
);
4061 frame
= get_prev_frame (frame
))
4063 if (frame_id_eq (get_frame_id (frame
), step_frame_id
))
4065 if (get_frame_type (frame
) != INLINE_FRAME
)
4072 /* Auxiliary function that handles syscall entry/return events.
4073 It returns 1 if the inferior should keep going (and GDB
4074 should ignore the event), or 0 if the event deserves to be
4078 handle_syscall_event (struct execution_control_state
*ecs
)
4080 struct regcache
*regcache
;
4083 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4084 context_switch (ecs
->ptid
);
4086 regcache
= get_thread_regcache (ecs
->ptid
);
4087 syscall_number
= ecs
->ws
.value
.syscall_number
;
4088 stop_pc
= regcache_read_pc (regcache
);
4090 if (catch_syscall_enabled () > 0
4091 && catching_syscall_number (syscall_number
) > 0)
4094 fprintf_unfiltered (gdb_stdlog
, "infrun: syscall number = '%d'\n",
4097 ecs
->event_thread
->control
.stop_bpstat
4098 = bpstat_stop_status (get_regcache_aspace (regcache
),
4099 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4101 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4103 /* Catchpoint hit. */
4108 /* If no catchpoint triggered for this, then keep going. */
4113 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4116 fill_in_stop_func (struct gdbarch
*gdbarch
,
4117 struct execution_control_state
*ecs
)
4119 if (!ecs
->stop_func_filled_in
)
4121 /* Don't care about return value; stop_func_start and stop_func_name
4122 will both be 0 if it doesn't work. */
4123 find_pc_partial_function (stop_pc
, &ecs
->stop_func_name
,
4124 &ecs
->stop_func_start
, &ecs
->stop_func_end
);
4125 ecs
->stop_func_start
4126 += gdbarch_deprecated_function_start_offset (gdbarch
);
4128 if (gdbarch_skip_entrypoint_p (gdbarch
))
4129 ecs
->stop_func_start
= gdbarch_skip_entrypoint (gdbarch
,
4130 ecs
->stop_func_start
);
4132 ecs
->stop_func_filled_in
= 1;
4137 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
4139 static enum stop_kind
4140 get_inferior_stop_soon (ptid_t ptid
)
4142 struct inferior
*inf
= find_inferior_ptid (ptid
);
4144 gdb_assert (inf
!= NULL
);
4145 return inf
->control
.stop_soon
;
4148 /* Wait for one event. Store the resulting waitstatus in WS, and
4149 return the event ptid. */
4152 wait_one (struct target_waitstatus
*ws
)
4155 ptid_t wait_ptid
= minus_one_ptid
;
4157 overlay_cache_invalid
= 1;
4159 /* Flush target cache before starting to handle each event.
4160 Target was running and cache could be stale. This is just a
4161 heuristic. Running threads may modify target memory, but we
4162 don't get any event. */
4163 target_dcache_invalidate ();
4165 if (deprecated_target_wait_hook
)
4166 event_ptid
= deprecated_target_wait_hook (wait_ptid
, ws
, 0);
4168 event_ptid
= target_wait (wait_ptid
, ws
, 0);
4171 print_target_wait_results (wait_ptid
, event_ptid
, ws
);
4176 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4177 instead of the current thread. */
4178 #define THREAD_STOPPED_BY(REASON) \
4180 thread_stopped_by_ ## REASON (ptid_t ptid) \
4182 struct cleanup *old_chain; \
4185 old_chain = save_inferior_ptid (); \
4186 inferior_ptid = ptid; \
4188 res = target_stopped_by_ ## REASON (); \
4190 do_cleanups (old_chain); \
4195 /* Generate thread_stopped_by_watchpoint. */
4196 THREAD_STOPPED_BY (watchpoint
)
4197 /* Generate thread_stopped_by_sw_breakpoint. */
4198 THREAD_STOPPED_BY (sw_breakpoint
)
4199 /* Generate thread_stopped_by_hw_breakpoint. */
4200 THREAD_STOPPED_BY (hw_breakpoint
)
4202 /* Cleanups that switches to the PTID pointed at by PTID_P. */
4205 switch_to_thread_cleanup (void *ptid_p
)
4207 ptid_t ptid
= *(ptid_t
*) ptid_p
;
4209 switch_to_thread (ptid
);
4212 /* Save the thread's event and stop reason to process it later. */
4215 save_waitstatus (struct thread_info
*tp
, struct target_waitstatus
*ws
)
4217 struct regcache
*regcache
;
4218 struct address_space
*aspace
;
4224 statstr
= target_waitstatus_to_string (ws
);
4225 fprintf_unfiltered (gdb_stdlog
,
4226 "infrun: saving status %s for %d.%ld.%ld\n",
4228 ptid_get_pid (tp
->ptid
),
4229 ptid_get_lwp (tp
->ptid
),
4230 ptid_get_tid (tp
->ptid
));
4234 /* Record for later. */
4235 tp
->suspend
.waitstatus
= *ws
;
4236 tp
->suspend
.waitstatus_pending_p
= 1;
4238 regcache
= get_thread_regcache (tp
->ptid
);
4239 aspace
= get_regcache_aspace (regcache
);
4241 if (ws
->kind
== TARGET_WAITKIND_STOPPED
4242 && ws
->value
.sig
== GDB_SIGNAL_TRAP
)
4244 CORE_ADDR pc
= regcache_read_pc (regcache
);
4246 adjust_pc_after_break (tp
, &tp
->suspend
.waitstatus
);
4248 if (thread_stopped_by_watchpoint (tp
->ptid
))
4250 tp
->suspend
.stop_reason
4251 = TARGET_STOPPED_BY_WATCHPOINT
;
4253 else if (target_supports_stopped_by_sw_breakpoint ()
4254 && thread_stopped_by_sw_breakpoint (tp
->ptid
))
4256 tp
->suspend
.stop_reason
4257 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4259 else if (target_supports_stopped_by_hw_breakpoint ()
4260 && thread_stopped_by_hw_breakpoint (tp
->ptid
))
4262 tp
->suspend
.stop_reason
4263 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4265 else if (!target_supports_stopped_by_hw_breakpoint ()
4266 && hardware_breakpoint_inserted_here_p (aspace
,
4269 tp
->suspend
.stop_reason
4270 = TARGET_STOPPED_BY_HW_BREAKPOINT
;
4272 else if (!target_supports_stopped_by_sw_breakpoint ()
4273 && software_breakpoint_inserted_here_p (aspace
,
4276 tp
->suspend
.stop_reason
4277 = TARGET_STOPPED_BY_SW_BREAKPOINT
;
4279 else if (!thread_has_single_step_breakpoints_set (tp
)
4280 && currently_stepping (tp
))
4282 tp
->suspend
.stop_reason
4283 = TARGET_STOPPED_BY_SINGLE_STEP
;
4288 /* Stop all threads. */
4291 stop_all_threads (void)
4293 /* We may need multiple passes to discover all threads. */
4297 struct cleanup
*old_chain
;
4299 gdb_assert (target_is_non_stop_p ());
4302 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads\n");
4304 entry_ptid
= inferior_ptid
;
4305 old_chain
= make_cleanup (switch_to_thread_cleanup
, &entry_ptid
);
4307 /* Request threads to stop, and then wait for the stops. Because
4308 threads we already know about can spawn more threads while we're
4309 trying to stop them, and we only learn about new threads when we
4310 update the thread list, do this in a loop, and keep iterating
4311 until two passes find no threads that need to be stopped. */
4312 for (pass
= 0; pass
< 2; pass
++, iterations
++)
4315 fprintf_unfiltered (gdb_stdlog
,
4316 "infrun: stop_all_threads, pass=%d, "
4317 "iterations=%d\n", pass
, iterations
);
4321 struct target_waitstatus ws
;
4323 struct thread_info
*t
;
4325 update_thread_list ();
4327 /* Go through all threads looking for threads that we need
4328 to tell the target to stop. */
4329 ALL_NON_EXITED_THREADS (t
)
4333 /* If already stopping, don't request a stop again.
4334 We just haven't seen the notification yet. */
4335 if (!t
->stop_requested
)
4338 fprintf_unfiltered (gdb_stdlog
,
4339 "infrun: %s executing, "
4341 target_pid_to_str (t
->ptid
));
4342 target_stop (t
->ptid
);
4343 t
->stop_requested
= 1;
4348 fprintf_unfiltered (gdb_stdlog
,
4349 "infrun: %s executing, "
4350 "already stopping\n",
4351 target_pid_to_str (t
->ptid
));
4354 if (t
->stop_requested
)
4360 fprintf_unfiltered (gdb_stdlog
,
4361 "infrun: %s not executing\n",
4362 target_pid_to_str (t
->ptid
));
4364 /* The thread may be not executing, but still be
4365 resumed with a pending status to process. */
4373 /* If we find new threads on the second iteration, restart
4374 over. We want to see two iterations in a row with all
4379 event_ptid
= wait_one (&ws
);
4380 if (ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4382 /* All resumed threads exited. */
4384 else if (ws
.kind
== TARGET_WAITKIND_EXITED
4385 || ws
.kind
== TARGET_WAITKIND_SIGNALLED
)
4389 ptid_t ptid
= pid_to_ptid (ws
.value
.integer
);
4391 fprintf_unfiltered (gdb_stdlog
,
4392 "infrun: %s exited while "
4393 "stopping threads\n",
4394 target_pid_to_str (ptid
));
4399 t
= find_thread_ptid (event_ptid
);
4401 t
= add_thread (event_ptid
);
4403 t
->stop_requested
= 0;
4406 t
->control
.may_range_step
= 0;
4408 if (ws
.kind
== TARGET_WAITKIND_STOPPED
4409 && ws
.value
.sig
== GDB_SIGNAL_0
)
4411 /* We caught the event that we intended to catch, so
4412 there's no event pending. */
4413 t
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
4414 t
->suspend
.waitstatus_pending_p
= 0;
4416 if (displaced_step_fixup (t
->ptid
, GDB_SIGNAL_0
) < 0)
4418 /* Add it back to the step-over queue. */
4421 fprintf_unfiltered (gdb_stdlog
,
4422 "infrun: displaced-step of %s "
4423 "canceled: adding back to the "
4424 "step-over queue\n",
4425 target_pid_to_str (t
->ptid
));
4427 t
->control
.trap_expected
= 0;
4428 thread_step_over_chain_enqueue (t
);
4433 enum gdb_signal sig
;
4434 struct regcache
*regcache
;
4435 struct address_space
*aspace
;
4441 statstr
= target_waitstatus_to_string (&ws
);
4442 fprintf_unfiltered (gdb_stdlog
,
4443 "infrun: target_wait %s, saving "
4444 "status for %d.%ld.%ld\n",
4446 ptid_get_pid (t
->ptid
),
4447 ptid_get_lwp (t
->ptid
),
4448 ptid_get_tid (t
->ptid
));
4452 /* Record for later. */
4453 save_waitstatus (t
, &ws
);
4455 sig
= (ws
.kind
== TARGET_WAITKIND_STOPPED
4456 ? ws
.value
.sig
: GDB_SIGNAL_0
);
4458 if (displaced_step_fixup (t
->ptid
, sig
) < 0)
4460 /* Add it back to the step-over queue. */
4461 t
->control
.trap_expected
= 0;
4462 thread_step_over_chain_enqueue (t
);
4465 regcache
= get_thread_regcache (t
->ptid
);
4466 t
->suspend
.stop_pc
= regcache_read_pc (regcache
);
4470 fprintf_unfiltered (gdb_stdlog
,
4471 "infrun: saved stop_pc=%s for %s "
4472 "(currently_stepping=%d)\n",
4473 paddress (target_gdbarch (),
4474 t
->suspend
.stop_pc
),
4475 target_pid_to_str (t
->ptid
),
4476 currently_stepping (t
));
4483 do_cleanups (old_chain
);
4486 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_all_threads done\n");
4489 /* Given an execution control state that has been freshly filled in by
4490 an event from the inferior, figure out what it means and take
4493 The alternatives are:
4495 1) stop_waiting and return; to really stop and return to the
4498 2) keep_going and return; to wait for the next event (set
4499 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4503 handle_inferior_event_1 (struct execution_control_state
*ecs
)
4505 enum stop_kind stop_soon
;
4507 if (ecs
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
4509 /* We had an event in the inferior, but we are not interested in
4510 handling it at this level. The lower layers have already
4511 done what needs to be done, if anything.
4513 One of the possible circumstances for this is when the
4514 inferior produces output for the console. The inferior has
4515 not stopped, and we are ignoring the event. Another possible
4516 circumstance is any event which the lower level knows will be
4517 reported multiple times without an intervening resume. */
4519 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_IGNORE\n");
4520 prepare_to_wait (ecs
);
4524 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
4525 && target_can_async_p () && !sync_execution
)
4527 /* There were no unwaited-for children left in the target, but,
4528 we're not synchronously waiting for events either. Just
4529 ignore. Otherwise, if we were running a synchronous
4530 execution command, we need to cancel it and give the user
4531 back the terminal. */
4533 fprintf_unfiltered (gdb_stdlog
,
4534 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
4535 prepare_to_wait (ecs
);
4539 /* Cache the last pid/waitstatus. */
4540 set_last_target_status (ecs
->ptid
, ecs
->ws
);
4542 /* Always clear state belonging to the previous time we stopped. */
4543 stop_stack_dummy
= STOP_NONE
;
4545 if (ecs
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
)
4547 /* No unwaited-for children left. IOW, all resumed children
4550 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4552 stop_print_frame
= 0;
4557 if (ecs
->ws
.kind
!= TARGET_WAITKIND_EXITED
4558 && ecs
->ws
.kind
!= TARGET_WAITKIND_SIGNALLED
)
4560 ecs
->event_thread
= find_thread_ptid (ecs
->ptid
);
4561 /* If it's a new thread, add it to the thread database. */
4562 if (ecs
->event_thread
== NULL
)
4563 ecs
->event_thread
= add_thread (ecs
->ptid
);
4565 /* Disable range stepping. If the next step request could use a
4566 range, this will be end up re-enabled then. */
4567 ecs
->event_thread
->control
.may_range_step
= 0;
4570 /* Dependent on valid ECS->EVENT_THREAD. */
4571 adjust_pc_after_break (ecs
->event_thread
, &ecs
->ws
);
4573 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4574 reinit_frame_cache ();
4576 breakpoint_retire_moribund ();
4578 /* First, distinguish signals caused by the debugger from signals
4579 that have to do with the program's own actions. Note that
4580 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4581 on the operating system version. Here we detect when a SIGILL or
4582 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4583 something similar for SIGSEGV, since a SIGSEGV will be generated
4584 when we're trying to execute a breakpoint instruction on a
4585 non-executable stack. This happens for call dummy breakpoints
4586 for architectures like SPARC that place call dummies on the
4588 if (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
4589 && (ecs
->ws
.value
.sig
== GDB_SIGNAL_ILL
4590 || ecs
->ws
.value
.sig
== GDB_SIGNAL_SEGV
4591 || ecs
->ws
.value
.sig
== GDB_SIGNAL_EMT
))
4593 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4595 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
),
4596 regcache_read_pc (regcache
)))
4599 fprintf_unfiltered (gdb_stdlog
,
4600 "infrun: Treating signal as SIGTRAP\n");
4601 ecs
->ws
.value
.sig
= GDB_SIGNAL_TRAP
;
4605 /* Mark the non-executing threads accordingly. In all-stop, all
4606 threads of all processes are stopped when we get any event
4607 reported. In non-stop mode, only the event thread stops. */
4611 if (!target_is_non_stop_p ())
4612 mark_ptid
= minus_one_ptid
;
4613 else if (ecs
->ws
.kind
== TARGET_WAITKIND_SIGNALLED
4614 || ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4616 /* If we're handling a process exit in non-stop mode, even
4617 though threads haven't been deleted yet, one would think
4618 that there is nothing to do, as threads of the dead process
4619 will be soon deleted, and threads of any other process were
4620 left running. However, on some targets, threads survive a
4621 process exit event. E.g., for the "checkpoint" command,
4622 when the current checkpoint/fork exits, linux-fork.c
4623 automatically switches to another fork from within
4624 target_mourn_inferior, by associating the same
4625 inferior/thread to another fork. We haven't mourned yet at
4626 this point, but we must mark any threads left in the
4627 process as not-executing so that finish_thread_state marks
4628 them stopped (in the user's perspective) if/when we present
4629 the stop to the user. */
4630 mark_ptid
= pid_to_ptid (ptid_get_pid (ecs
->ptid
));
4633 mark_ptid
= ecs
->ptid
;
4635 set_executing (mark_ptid
, 0);
4637 /* Likewise the resumed flag. */
4638 set_resumed (mark_ptid
, 0);
4641 switch (ecs
->ws
.kind
)
4643 case TARGET_WAITKIND_LOADED
:
4645 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_LOADED\n");
4646 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4647 context_switch (ecs
->ptid
);
4648 /* Ignore gracefully during startup of the inferior, as it might
4649 be the shell which has just loaded some objects, otherwise
4650 add the symbols for the newly loaded objects. Also ignore at
4651 the beginning of an attach or remote session; we will query
4652 the full list of libraries once the connection is
4655 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
4656 if (stop_soon
== NO_STOP_QUIETLY
)
4658 struct regcache
*regcache
;
4660 regcache
= get_thread_regcache (ecs
->ptid
);
4662 handle_solib_event ();
4664 ecs
->event_thread
->control
.stop_bpstat
4665 = bpstat_stop_status (get_regcache_aspace (regcache
),
4666 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4668 if (bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4670 /* A catchpoint triggered. */
4671 process_event_stop_test (ecs
);
4675 /* If requested, stop when the dynamic linker notifies
4676 gdb of events. This allows the user to get control
4677 and place breakpoints in initializer routines for
4678 dynamically loaded objects (among other things). */
4679 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4680 if (stop_on_solib_events
)
4682 /* Make sure we print "Stopped due to solib-event" in
4684 stop_print_frame
= 1;
4691 /* If we are skipping through a shell, or through shared library
4692 loading that we aren't interested in, resume the program. If
4693 we're running the program normally, also resume. */
4694 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== NO_STOP_QUIETLY
)
4696 /* Loading of shared libraries might have changed breakpoint
4697 addresses. Make sure new breakpoints are inserted. */
4698 if (stop_soon
== NO_STOP_QUIETLY
)
4699 insert_breakpoints ();
4700 resume (GDB_SIGNAL_0
);
4701 prepare_to_wait (ecs
);
4705 /* But stop if we're attaching or setting up a remote
4707 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
4708 || stop_soon
== STOP_QUIETLY_REMOTE
)
4711 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
4716 internal_error (__FILE__
, __LINE__
,
4717 _("unhandled stop_soon: %d"), (int) stop_soon
);
4719 case TARGET_WAITKIND_SPURIOUS
:
4721 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_SPURIOUS\n");
4722 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4723 context_switch (ecs
->ptid
);
4724 resume (GDB_SIGNAL_0
);
4725 prepare_to_wait (ecs
);
4728 case TARGET_WAITKIND_EXITED
:
4729 case TARGET_WAITKIND_SIGNALLED
:
4732 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4733 fprintf_unfiltered (gdb_stdlog
,
4734 "infrun: TARGET_WAITKIND_EXITED\n");
4736 fprintf_unfiltered (gdb_stdlog
,
4737 "infrun: TARGET_WAITKIND_SIGNALLED\n");
4740 inferior_ptid
= ecs
->ptid
;
4741 set_current_inferior (find_inferior_ptid (ecs
->ptid
));
4742 set_current_program_space (current_inferior ()->pspace
);
4743 handle_vfork_child_exec_or_exit (0);
4744 target_terminal_ours (); /* Must do this before mourn anyway. */
4746 /* Clearing any previous state of convenience variables. */
4747 clear_exit_convenience_vars ();
4749 if (ecs
->ws
.kind
== TARGET_WAITKIND_EXITED
)
4751 /* Record the exit code in the convenience variable $_exitcode, so
4752 that the user can inspect this again later. */
4753 set_internalvar_integer (lookup_internalvar ("_exitcode"),
4754 (LONGEST
) ecs
->ws
.value
.integer
);
4756 /* Also record this in the inferior itself. */
4757 current_inferior ()->has_exit_code
= 1;
4758 current_inferior ()->exit_code
= (LONGEST
) ecs
->ws
.value
.integer
;
4760 /* Support the --return-child-result option. */
4761 return_child_result_value
= ecs
->ws
.value
.integer
;
4763 observer_notify_exited (ecs
->ws
.value
.integer
);
4767 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4768 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4770 if (gdbarch_gdb_signal_to_target_p (gdbarch
))
4772 /* Set the value of the internal variable $_exitsignal,
4773 which holds the signal uncaught by the inferior. */
4774 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
4775 gdbarch_gdb_signal_to_target (gdbarch
,
4776 ecs
->ws
.value
.sig
));
4780 /* We don't have access to the target's method used for
4781 converting between signal numbers (GDB's internal
4782 representation <-> target's representation).
4783 Therefore, we cannot do a good job at displaying this
4784 information to the user. It's better to just warn
4785 her about it (if infrun debugging is enabled), and
4788 fprintf_filtered (gdb_stdlog
, _("\
4789 Cannot fill $_exitsignal with the correct signal number.\n"));
4792 observer_notify_signal_exited (ecs
->ws
.value
.sig
);
4795 gdb_flush (gdb_stdout
);
4796 target_mourn_inferior ();
4797 stop_print_frame
= 0;
4801 /* The following are the only cases in which we keep going;
4802 the above cases end in a continue or goto. */
4803 case TARGET_WAITKIND_FORKED
:
4804 case TARGET_WAITKIND_VFORKED
:
4807 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
4808 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_FORKED\n");
4810 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_VFORKED\n");
4813 /* Check whether the inferior is displaced stepping. */
4815 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
4816 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4817 struct displaced_step_inferior_state
*displaced
4818 = get_displaced_stepping_state (ptid_get_pid (ecs
->ptid
));
4820 /* If checking displaced stepping is supported, and thread
4821 ecs->ptid is displaced stepping. */
4822 if (displaced
&& ptid_equal (displaced
->step_ptid
, ecs
->ptid
))
4824 struct inferior
*parent_inf
4825 = find_inferior_ptid (ecs
->ptid
);
4826 struct regcache
*child_regcache
;
4827 CORE_ADDR parent_pc
;
4829 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
4830 indicating that the displaced stepping of syscall instruction
4831 has been done. Perform cleanup for parent process here. Note
4832 that this operation also cleans up the child process for vfork,
4833 because their pages are shared. */
4834 displaced_step_fixup (ecs
->ptid
, GDB_SIGNAL_TRAP
);
4835 /* Start a new step-over in another thread if there's one
4839 if (ecs
->ws
.kind
== TARGET_WAITKIND_FORKED
)
4841 /* Restore scratch pad for child process. */
4842 displaced_step_restore (displaced
, ecs
->ws
.value
.related_pid
);
4845 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
4846 the child's PC is also within the scratchpad. Set the child's PC
4847 to the parent's PC value, which has already been fixed up.
4848 FIXME: we use the parent's aspace here, although we're touching
4849 the child, because the child hasn't been added to the inferior
4850 list yet at this point. */
4853 = get_thread_arch_aspace_regcache (ecs
->ws
.value
.related_pid
,
4855 parent_inf
->aspace
);
4856 /* Read PC value of parent process. */
4857 parent_pc
= regcache_read_pc (regcache
);
4859 if (debug_displaced
)
4860 fprintf_unfiltered (gdb_stdlog
,
4861 "displaced: write child pc from %s to %s\n",
4863 regcache_read_pc (child_regcache
)),
4864 paddress (gdbarch
, parent_pc
));
4866 regcache_write_pc (child_regcache
, parent_pc
);
4870 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4871 context_switch (ecs
->ptid
);
4873 /* Immediately detach breakpoints from the child before there's
4874 any chance of letting the user delete breakpoints from the
4875 breakpoint lists. If we don't do this early, it's easy to
4876 leave left over traps in the child, vis: "break foo; catch
4877 fork; c; <fork>; del; c; <child calls foo>". We only follow
4878 the fork on the last `continue', and by that time the
4879 breakpoint at "foo" is long gone from the breakpoint table.
4880 If we vforked, then we don't need to unpatch here, since both
4881 parent and child are sharing the same memory pages; we'll
4882 need to unpatch at follow/detach time instead to be certain
4883 that new breakpoints added between catchpoint hit time and
4884 vfork follow are detached. */
4885 if (ecs
->ws
.kind
!= TARGET_WAITKIND_VFORKED
)
4887 /* This won't actually modify the breakpoint list, but will
4888 physically remove the breakpoints from the child. */
4889 detach_breakpoints (ecs
->ws
.value
.related_pid
);
4892 delete_just_stopped_threads_single_step_breakpoints ();
4894 /* In case the event is caught by a catchpoint, remember that
4895 the event is to be followed at the next resume of the thread,
4896 and not immediately. */
4897 ecs
->event_thread
->pending_follow
= ecs
->ws
;
4899 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4901 ecs
->event_thread
->control
.stop_bpstat
4902 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4903 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4905 /* If no catchpoint triggered for this, then keep going. Note
4906 that we're interested in knowing the bpstat actually causes a
4907 stop, not just if it may explain the signal. Software
4908 watchpoints, for example, always appear in the bpstat. */
4909 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
4915 = (follow_fork_mode_string
== follow_fork_mode_child
);
4917 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
4919 should_resume
= follow_fork ();
4922 child
= ecs
->ws
.value
.related_pid
;
4924 /* In non-stop mode, also resume the other branch. */
4925 if (!detach_fork
&& (non_stop
4926 || (sched_multi
&& target_is_non_stop_p ())))
4929 switch_to_thread (parent
);
4931 switch_to_thread (child
);
4933 ecs
->event_thread
= inferior_thread ();
4934 ecs
->ptid
= inferior_ptid
;
4939 switch_to_thread (child
);
4941 switch_to_thread (parent
);
4943 ecs
->event_thread
= inferior_thread ();
4944 ecs
->ptid
= inferior_ptid
;
4952 process_event_stop_test (ecs
);
4955 case TARGET_WAITKIND_VFORK_DONE
:
4956 /* Done with the shared memory region. Re-insert breakpoints in
4957 the parent, and keep going. */
4960 fprintf_unfiltered (gdb_stdlog
,
4961 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
4963 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4964 context_switch (ecs
->ptid
);
4966 current_inferior ()->waiting_for_vfork_done
= 0;
4967 current_inferior ()->pspace
->breakpoints_not_allowed
= 0;
4968 /* This also takes care of reinserting breakpoints in the
4969 previously locked inferior. */
4973 case TARGET_WAITKIND_EXECD
:
4975 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_EXECD\n");
4977 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
4978 context_switch (ecs
->ptid
);
4980 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
4982 /* Do whatever is necessary to the parent branch of the vfork. */
4983 handle_vfork_child_exec_or_exit (1);
4985 /* This causes the eventpoints and symbol table to be reset.
4986 Must do this now, before trying to determine whether to
4988 follow_exec (inferior_ptid
, ecs
->ws
.value
.execd_pathname
);
4990 /* In follow_exec we may have deleted the original thread and
4991 created a new one. Make sure that the event thread is the
4992 execd thread for that case (this is a nop otherwise). */
4993 ecs
->event_thread
= inferior_thread ();
4995 ecs
->event_thread
->control
.stop_bpstat
4996 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4997 stop_pc
, ecs
->ptid
, &ecs
->ws
);
4999 /* Note that this may be referenced from inside
5000 bpstat_stop_status above, through inferior_has_execd. */
5001 xfree (ecs
->ws
.value
.execd_pathname
);
5002 ecs
->ws
.value
.execd_pathname
= NULL
;
5004 /* If no catchpoint triggered for this, then keep going. */
5005 if (!bpstat_causes_stop (ecs
->event_thread
->control
.stop_bpstat
))
5007 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5011 process_event_stop_test (ecs
);
5014 /* Be careful not to try to gather much state about a thread
5015 that's in a syscall. It's frequently a losing proposition. */
5016 case TARGET_WAITKIND_SYSCALL_ENTRY
:
5018 fprintf_unfiltered (gdb_stdlog
,
5019 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
5020 /* Getting the current syscall number. */
5021 if (handle_syscall_event (ecs
) == 0)
5022 process_event_stop_test (ecs
);
5025 /* Before examining the threads further, step this thread to
5026 get it entirely out of the syscall. (We get notice of the
5027 event when the thread is just on the verge of exiting a
5028 syscall. Stepping one instruction seems to get it back
5030 case TARGET_WAITKIND_SYSCALL_RETURN
:
5032 fprintf_unfiltered (gdb_stdlog
,
5033 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5034 if (handle_syscall_event (ecs
) == 0)
5035 process_event_stop_test (ecs
);
5038 case TARGET_WAITKIND_STOPPED
:
5040 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_STOPPED\n");
5041 ecs
->event_thread
->suspend
.stop_signal
= ecs
->ws
.value
.sig
;
5042 handle_signal_stop (ecs
);
5045 case TARGET_WAITKIND_NO_HISTORY
:
5047 fprintf_unfiltered (gdb_stdlog
, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5048 /* Reverse execution: target ran out of history info. */
5050 delete_just_stopped_threads_single_step_breakpoints ();
5051 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5052 observer_notify_no_history ();
5058 /* A wrapper around handle_inferior_event_1, which also makes sure
5059 that all temporary struct value objects that were created during
5060 the handling of the event get deleted at the end. */
5063 handle_inferior_event (struct execution_control_state
*ecs
)
5065 struct value
*mark
= value_mark ();
5067 handle_inferior_event_1 (ecs
);
5068 /* Purge all temporary values created during the event handling,
5069 as it could be a long time before we return to the command level
5070 where such values would otherwise be purged. */
5071 value_free_to_mark (mark
);
5074 /* Restart threads back to what they were trying to do back when we
5075 paused them for an in-line step-over. The EVENT_THREAD thread is
5079 restart_threads (struct thread_info
*event_thread
)
5081 struct thread_info
*tp
;
5082 struct thread_info
*step_over
= NULL
;
5084 /* In case the instruction just stepped spawned a new thread. */
5085 update_thread_list ();
5087 ALL_NON_EXITED_THREADS (tp
)
5089 if (tp
== event_thread
)
5092 fprintf_unfiltered (gdb_stdlog
,
5093 "infrun: restart threads: "
5094 "[%s] is event thread\n",
5095 target_pid_to_str (tp
->ptid
));
5099 if (!(tp
->state
== THREAD_RUNNING
|| tp
->control
.in_infcall
))
5102 fprintf_unfiltered (gdb_stdlog
,
5103 "infrun: restart threads: "
5104 "[%s] not meant to be running\n",
5105 target_pid_to_str (tp
->ptid
));
5112 fprintf_unfiltered (gdb_stdlog
,
5113 "infrun: restart threads: [%s] resumed\n",
5114 target_pid_to_str (tp
->ptid
));
5115 gdb_assert (tp
->executing
|| tp
->suspend
.waitstatus_pending_p
);
5119 if (thread_is_in_step_over_chain (tp
))
5122 fprintf_unfiltered (gdb_stdlog
,
5123 "infrun: restart threads: "
5124 "[%s] needs step-over\n",
5125 target_pid_to_str (tp
->ptid
));
5126 gdb_assert (!tp
->resumed
);
5131 if (tp
->suspend
.waitstatus_pending_p
)
5134 fprintf_unfiltered (gdb_stdlog
,
5135 "infrun: restart threads: "
5136 "[%s] has pending status\n",
5137 target_pid_to_str (tp
->ptid
));
5142 /* If some thread needs to start a step-over at this point, it
5143 should still be in the step-over queue, and thus skipped
5145 if (thread_still_needs_step_over (tp
))
5147 internal_error (__FILE__
, __LINE__
,
5148 "thread [%s] needs a step-over, but not in "
5149 "step-over queue\n",
5150 target_pid_to_str (tp
->ptid
));
5153 if (currently_stepping (tp
))
5156 fprintf_unfiltered (gdb_stdlog
,
5157 "infrun: restart threads: [%s] was stepping\n",
5158 target_pid_to_str (tp
->ptid
));
5159 keep_going_stepped_thread (tp
);
5163 struct execution_control_state ecss
;
5164 struct execution_control_state
*ecs
= &ecss
;
5167 fprintf_unfiltered (gdb_stdlog
,
5168 "infrun: restart threads: [%s] continuing\n",
5169 target_pid_to_str (tp
->ptid
));
5170 reset_ecs (ecs
, tp
);
5171 switch_to_thread (tp
->ptid
);
5172 keep_going_pass_signal (ecs
);
5177 /* Callback for iterate_over_threads. Find a resumed thread that has
5178 a pending waitstatus. */
5181 resumed_thread_with_pending_status (struct thread_info
*tp
,
5185 && tp
->suspend
.waitstatus_pending_p
);
5188 /* Called when we get an event that may finish an in-line or
5189 out-of-line (displaced stepping) step-over started previously.
5190 Return true if the event is processed and we should go back to the
5191 event loop; false if the caller should continue processing the
5195 finish_step_over (struct execution_control_state
*ecs
)
5197 int had_step_over_info
;
5199 displaced_step_fixup (ecs
->ptid
,
5200 ecs
->event_thread
->suspend
.stop_signal
);
5202 had_step_over_info
= step_over_info_valid_p ();
5204 if (had_step_over_info
)
5206 /* If we're stepping over a breakpoint with all threads locked,
5207 then only the thread that was stepped should be reporting
5209 gdb_assert (ecs
->event_thread
->control
.trap_expected
);
5211 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5212 clear_step_over_info ();
5215 if (!target_is_non_stop_p ())
5218 /* Start a new step-over in another thread if there's one that
5222 /* If we were stepping over a breakpoint before, and haven't started
5223 a new in-line step-over sequence, then restart all other threads
5224 (except the event thread). We can't do this in all-stop, as then
5225 e.g., we wouldn't be able to issue any other remote packet until
5226 these other threads stop. */
5227 if (had_step_over_info
&& !step_over_info_valid_p ())
5229 struct thread_info
*pending
;
5231 /* If we only have threads with pending statuses, the restart
5232 below won't restart any thread and so nothing re-inserts the
5233 breakpoint we just stepped over. But we need it inserted
5234 when we later process the pending events, otherwise if
5235 another thread has a pending event for this breakpoint too,
5236 we'd discard its event (because the breakpoint that
5237 originally caused the event was no longer inserted). */
5238 context_switch (ecs
->ptid
);
5239 insert_breakpoints ();
5241 restart_threads (ecs
->event_thread
);
5243 /* If we have events pending, go through handle_inferior_event
5244 again, picking up a pending event at random. This avoids
5245 thread starvation. */
5247 /* But not if we just stepped over a watchpoint in order to let
5248 the instruction execute so we can evaluate its expression.
5249 The set of watchpoints that triggered is recorded in the
5250 breakpoint objects themselves (see bp->watchpoint_triggered).
5251 If we processed another event first, that other event could
5252 clobber this info. */
5253 if (ecs
->event_thread
->stepping_over_watchpoint
)
5256 pending
= iterate_over_threads (resumed_thread_with_pending_status
,
5258 if (pending
!= NULL
)
5260 struct thread_info
*tp
= ecs
->event_thread
;
5261 struct regcache
*regcache
;
5265 fprintf_unfiltered (gdb_stdlog
,
5266 "infrun: found resumed threads with "
5267 "pending events, saving status\n");
5270 gdb_assert (pending
!= tp
);
5272 /* Record the event thread's event for later. */
5273 save_waitstatus (tp
, &ecs
->ws
);
5274 /* This was cleared early, by handle_inferior_event. Set it
5275 so this pending event is considered by
5279 gdb_assert (!tp
->executing
);
5281 regcache
= get_thread_regcache (tp
->ptid
);
5282 tp
->suspend
.stop_pc
= regcache_read_pc (regcache
);
5286 fprintf_unfiltered (gdb_stdlog
,
5287 "infrun: saved stop_pc=%s for %s "
5288 "(currently_stepping=%d)\n",
5289 paddress (target_gdbarch (),
5290 tp
->suspend
.stop_pc
),
5291 target_pid_to_str (tp
->ptid
),
5292 currently_stepping (tp
));
5295 /* This in-line step-over finished; clear this so we won't
5296 start a new one. This is what handle_signal_stop would
5297 do, if we returned false. */
5298 tp
->stepping_over_breakpoint
= 0;
5300 /* Wake up the event loop again. */
5301 mark_async_event_handler (infrun_async_inferior_event_token
);
5303 prepare_to_wait (ecs
);
5311 /* Come here when the program has stopped with a signal. */
5314 handle_signal_stop (struct execution_control_state
*ecs
)
5316 struct frame_info
*frame
;
5317 struct gdbarch
*gdbarch
;
5318 int stopped_by_watchpoint
;
5319 enum stop_kind stop_soon
;
5322 gdb_assert (ecs
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
5324 /* Do we need to clean up the state of a thread that has
5325 completed a displaced single-step? (Doing so usually affects
5326 the PC, so do it here, before we set stop_pc.) */
5327 if (finish_step_over (ecs
))
5330 /* If we either finished a single-step or hit a breakpoint, but
5331 the user wanted this thread to be stopped, pretend we got a
5332 SIG0 (generic unsignaled stop). */
5333 if (ecs
->event_thread
->stop_requested
5334 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5335 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5337 stop_pc
= regcache_read_pc (get_thread_regcache (ecs
->ptid
));
5341 struct regcache
*regcache
= get_thread_regcache (ecs
->ptid
);
5342 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5343 struct cleanup
*old_chain
= save_inferior_ptid ();
5345 inferior_ptid
= ecs
->ptid
;
5347 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_pc = %s\n",
5348 paddress (gdbarch
, stop_pc
));
5349 if (target_stopped_by_watchpoint ())
5353 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped by watchpoint\n");
5355 if (target_stopped_data_address (¤t_target
, &addr
))
5356 fprintf_unfiltered (gdb_stdlog
,
5357 "infrun: stopped data address = %s\n",
5358 paddress (gdbarch
, addr
));
5360 fprintf_unfiltered (gdb_stdlog
,
5361 "infrun: (no data address available)\n");
5364 do_cleanups (old_chain
);
5367 /* This is originated from start_remote(), start_inferior() and
5368 shared libraries hook functions. */
5369 stop_soon
= get_inferior_stop_soon (ecs
->ptid
);
5370 if (stop_soon
== STOP_QUIETLY
|| stop_soon
== STOP_QUIETLY_REMOTE
)
5372 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5373 context_switch (ecs
->ptid
);
5375 fprintf_unfiltered (gdb_stdlog
, "infrun: quietly stopped\n");
5376 stop_print_frame
= 1;
5381 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5384 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5385 context_switch (ecs
->ptid
);
5387 fprintf_unfiltered (gdb_stdlog
, "infrun: stopped\n");
5388 stop_print_frame
= 0;
5393 /* This originates from attach_command(). We need to overwrite
5394 the stop_signal here, because some kernels don't ignore a
5395 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5396 See more comments in inferior.h. On the other hand, if we
5397 get a non-SIGSTOP, report it to the user - assume the backend
5398 will handle the SIGSTOP if it should show up later.
5400 Also consider that the attach is complete when we see a
5401 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5402 target extended-remote report it instead of a SIGSTOP
5403 (e.g. gdbserver). We already rely on SIGTRAP being our
5404 signal, so this is no exception.
5406 Also consider that the attach is complete when we see a
5407 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5408 the target to stop all threads of the inferior, in case the
5409 low level attach operation doesn't stop them implicitly. If
5410 they weren't stopped implicitly, then the stub will report a
5411 GDB_SIGNAL_0, meaning: stopped for no particular reason
5412 other than GDB's request. */
5413 if (stop_soon
== STOP_QUIETLY_NO_SIGSTOP
5414 && (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_STOP
5415 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5416 || ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_0
))
5418 stop_print_frame
= 1;
5420 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5424 /* See if something interesting happened to the non-current thread. If
5425 so, then switch to that thread. */
5426 if (!ptid_equal (ecs
->ptid
, inferior_ptid
))
5429 fprintf_unfiltered (gdb_stdlog
, "infrun: context switch\n");
5431 context_switch (ecs
->ptid
);
5433 if (deprecated_context_hook
)
5434 deprecated_context_hook (pid_to_thread_id (ecs
->ptid
));
5437 /* At this point, get hold of the now-current thread's frame. */
5438 frame
= get_current_frame ();
5439 gdbarch
= get_frame_arch (frame
);
5441 /* Pull the single step breakpoints out of the target. */
5442 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
5444 struct regcache
*regcache
;
5445 struct address_space
*aspace
;
5448 regcache
= get_thread_regcache (ecs
->ptid
);
5449 aspace
= get_regcache_aspace (regcache
);
5450 pc
= regcache_read_pc (regcache
);
5452 /* However, before doing so, if this single-step breakpoint was
5453 actually for another thread, set this thread up for moving
5455 if (!thread_has_single_step_breakpoint_here (ecs
->event_thread
,
5458 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
5462 fprintf_unfiltered (gdb_stdlog
,
5463 "infrun: [%s] hit another thread's "
5464 "single-step breakpoint\n",
5465 target_pid_to_str (ecs
->ptid
));
5467 ecs
->hit_singlestep_breakpoint
= 1;
5474 fprintf_unfiltered (gdb_stdlog
,
5475 "infrun: [%s] hit its "
5476 "single-step breakpoint\n",
5477 target_pid_to_str (ecs
->ptid
));
5481 delete_just_stopped_threads_single_step_breakpoints ();
5483 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5484 && ecs
->event_thread
->control
.trap_expected
5485 && ecs
->event_thread
->stepping_over_watchpoint
)
5486 stopped_by_watchpoint
= 0;
5488 stopped_by_watchpoint
= watchpoints_triggered (&ecs
->ws
);
5490 /* If necessary, step over this watchpoint. We'll be back to display
5492 if (stopped_by_watchpoint
5493 && (target_have_steppable_watchpoint
5494 || gdbarch_have_nonsteppable_watchpoint (gdbarch
)))
5496 /* At this point, we are stopped at an instruction which has
5497 attempted to write to a piece of memory under control of
5498 a watchpoint. The instruction hasn't actually executed
5499 yet. If we were to evaluate the watchpoint expression
5500 now, we would get the old value, and therefore no change
5501 would seem to have occurred.
5503 In order to make watchpoints work `right', we really need
5504 to complete the memory write, and then evaluate the
5505 watchpoint expression. We do this by single-stepping the
5508 It may not be necessary to disable the watchpoint to step over
5509 it. For example, the PA can (with some kernel cooperation)
5510 single step over a watchpoint without disabling the watchpoint.
5512 It is far more common to need to disable a watchpoint to step
5513 the inferior over it. If we have non-steppable watchpoints,
5514 we must disable the current watchpoint; it's simplest to
5515 disable all watchpoints.
5517 Any breakpoint at PC must also be stepped over -- if there's
5518 one, it will have already triggered before the watchpoint
5519 triggered, and we either already reported it to the user, or
5520 it didn't cause a stop and we called keep_going. In either
5521 case, if there was a breakpoint at PC, we must be trying to
5523 ecs
->event_thread
->stepping_over_watchpoint
= 1;
5528 ecs
->event_thread
->stepping_over_breakpoint
= 0;
5529 ecs
->event_thread
->stepping_over_watchpoint
= 0;
5530 bpstat_clear (&ecs
->event_thread
->control
.stop_bpstat
);
5531 ecs
->event_thread
->control
.stop_step
= 0;
5532 stop_print_frame
= 1;
5533 stopped_by_random_signal
= 0;
5535 /* Hide inlined functions starting here, unless we just performed stepi or
5536 nexti. After stepi and nexti, always show the innermost frame (not any
5537 inline function call sites). */
5538 if (ecs
->event_thread
->control
.step_range_end
!= 1)
5540 struct address_space
*aspace
=
5541 get_regcache_aspace (get_thread_regcache (ecs
->ptid
));
5543 /* skip_inline_frames is expensive, so we avoid it if we can
5544 determine that the address is one where functions cannot have
5545 been inlined. This improves performance with inferiors that
5546 load a lot of shared libraries, because the solib event
5547 breakpoint is defined as the address of a function (i.e. not
5548 inline). Note that we have to check the previous PC as well
5549 as the current one to catch cases when we have just
5550 single-stepped off a breakpoint prior to reinstating it.
5551 Note that we're assuming that the code we single-step to is
5552 not inline, but that's not definitive: there's nothing
5553 preventing the event breakpoint function from containing
5554 inlined code, and the single-step ending up there. If the
5555 user had set a breakpoint on that inlined code, the missing
5556 skip_inline_frames call would break things. Fortunately
5557 that's an extremely unlikely scenario. */
5558 if (!pc_at_non_inline_function (aspace
, stop_pc
, &ecs
->ws
)
5559 && !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5560 && ecs
->event_thread
->control
.trap_expected
5561 && pc_at_non_inline_function (aspace
,
5562 ecs
->event_thread
->prev_pc
,
5565 skip_inline_frames (ecs
->ptid
);
5567 /* Re-fetch current thread's frame in case that invalidated
5569 frame
= get_current_frame ();
5570 gdbarch
= get_frame_arch (frame
);
5574 if (ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5575 && ecs
->event_thread
->control
.trap_expected
5576 && gdbarch_single_step_through_delay_p (gdbarch
)
5577 && currently_stepping (ecs
->event_thread
))
5579 /* We're trying to step off a breakpoint. Turns out that we're
5580 also on an instruction that needs to be stepped multiple
5581 times before it's been fully executing. E.g., architectures
5582 with a delay slot. It needs to be stepped twice, once for
5583 the instruction and once for the delay slot. */
5584 int step_through_delay
5585 = gdbarch_single_step_through_delay (gdbarch
, frame
);
5587 if (debug_infrun
&& step_through_delay
)
5588 fprintf_unfiltered (gdb_stdlog
, "infrun: step through delay\n");
5589 if (ecs
->event_thread
->control
.step_range_end
== 0
5590 && step_through_delay
)
5592 /* The user issued a continue when stopped at a breakpoint.
5593 Set up for another trap and get out of here. */
5594 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5598 else if (step_through_delay
)
5600 /* The user issued a step when stopped at a breakpoint.
5601 Maybe we should stop, maybe we should not - the delay
5602 slot *might* correspond to a line of source. In any
5603 case, don't decide that here, just set
5604 ecs->stepping_over_breakpoint, making sure we
5605 single-step again before breakpoints are re-inserted. */
5606 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5610 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5611 handles this event. */
5612 ecs
->event_thread
->control
.stop_bpstat
5613 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5614 stop_pc
, ecs
->ptid
, &ecs
->ws
);
5616 /* Following in case break condition called a
5618 stop_print_frame
= 1;
5620 /* This is where we handle "moribund" watchpoints. Unlike
5621 software breakpoints traps, hardware watchpoint traps are
5622 always distinguishable from random traps. If no high-level
5623 watchpoint is associated with the reported stop data address
5624 anymore, then the bpstat does not explain the signal ---
5625 simply make sure to ignore it if `stopped_by_watchpoint' is
5629 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5630 && !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
5632 && stopped_by_watchpoint
)
5633 fprintf_unfiltered (gdb_stdlog
,
5634 "infrun: no user watchpoint explains "
5635 "watchpoint SIGTRAP, ignoring\n");
5637 /* NOTE: cagney/2003-03-29: These checks for a random signal
5638 at one stage in the past included checks for an inferior
5639 function call's call dummy's return breakpoint. The original
5640 comment, that went with the test, read:
5642 ``End of a stack dummy. Some systems (e.g. Sony news) give
5643 another signal besides SIGTRAP, so check here as well as
5646 If someone ever tries to get call dummys on a
5647 non-executable stack to work (where the target would stop
5648 with something like a SIGSEGV), then those tests might need
5649 to be re-instated. Given, however, that the tests were only
5650 enabled when momentary breakpoints were not being used, I
5651 suspect that it won't be the case.
5653 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5654 be necessary for call dummies on a non-executable stack on
5657 /* See if the breakpoints module can explain the signal. */
5659 = !bpstat_explains_signal (ecs
->event_thread
->control
.stop_bpstat
,
5660 ecs
->event_thread
->suspend
.stop_signal
);
5662 /* Maybe this was a trap for a software breakpoint that has since
5664 if (random_signal
&& target_stopped_by_sw_breakpoint ())
5666 if (program_breakpoint_here_p (gdbarch
, stop_pc
))
5668 struct regcache
*regcache
;
5671 /* Re-adjust PC to what the program would see if GDB was not
5673 regcache
= get_thread_regcache (ecs
->event_thread
->ptid
);
5674 decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
5677 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
5679 if (record_full_is_used ())
5680 record_full_gdb_operation_disable_set ();
5682 regcache_write_pc (regcache
, stop_pc
+ decr_pc
);
5684 do_cleanups (old_cleanups
);
5689 /* A delayed software breakpoint event. Ignore the trap. */
5691 fprintf_unfiltered (gdb_stdlog
,
5692 "infrun: delayed software breakpoint "
5693 "trap, ignoring\n");
5698 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
5699 has since been removed. */
5700 if (random_signal
&& target_stopped_by_hw_breakpoint ())
5702 /* A delayed hardware breakpoint event. Ignore the trap. */
5704 fprintf_unfiltered (gdb_stdlog
,
5705 "infrun: delayed hardware breakpoint/watchpoint "
5706 "trap, ignoring\n");
5710 /* If not, perhaps stepping/nexting can. */
5712 random_signal
= !(ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
5713 && currently_stepping (ecs
->event_thread
));
5715 /* Perhaps the thread hit a single-step breakpoint of _another_
5716 thread. Single-step breakpoints are transparent to the
5717 breakpoints module. */
5719 random_signal
= !ecs
->hit_singlestep_breakpoint
;
5721 /* No? Perhaps we got a moribund watchpoint. */
5723 random_signal
= !stopped_by_watchpoint
;
5725 /* For the program's own signals, act according to
5726 the signal handling tables. */
5730 /* Signal not for debugging purposes. */
5731 struct inferior
*inf
= find_inferior_ptid (ecs
->ptid
);
5732 enum gdb_signal stop_signal
= ecs
->event_thread
->suspend
.stop_signal
;
5735 fprintf_unfiltered (gdb_stdlog
, "infrun: random signal (%s)\n",
5736 gdb_signal_to_symbol_string (stop_signal
));
5738 stopped_by_random_signal
= 1;
5740 /* Always stop on signals if we're either just gaining control
5741 of the program, or the user explicitly requested this thread
5742 to remain stopped. */
5743 if (stop_soon
!= NO_STOP_QUIETLY
5744 || ecs
->event_thread
->stop_requested
5746 && signal_stop_state (ecs
->event_thread
->suspend
.stop_signal
)))
5752 /* Notify observers the signal has "handle print" set. Note we
5753 returned early above if stopping; normal_stop handles the
5754 printing in that case. */
5755 if (signal_print
[ecs
->event_thread
->suspend
.stop_signal
])
5757 /* The signal table tells us to print about this signal. */
5758 target_terminal_ours_for_output ();
5759 observer_notify_signal_received (ecs
->event_thread
->suspend
.stop_signal
);
5760 target_terminal_inferior ();
5763 /* Clear the signal if it should not be passed. */
5764 if (signal_program
[ecs
->event_thread
->suspend
.stop_signal
] == 0)
5765 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5767 if (ecs
->event_thread
->prev_pc
== stop_pc
5768 && ecs
->event_thread
->control
.trap_expected
5769 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
5773 /* We were just starting a new sequence, attempting to
5774 single-step off of a breakpoint and expecting a SIGTRAP.
5775 Instead this signal arrives. This signal will take us out
5776 of the stepping range so GDB needs to remember to, when
5777 the signal handler returns, resume stepping off that
5779 /* To simplify things, "continue" is forced to use the same
5780 code paths as single-step - set a breakpoint at the
5781 signal return address and then, once hit, step off that
5784 fprintf_unfiltered (gdb_stdlog
,
5785 "infrun: signal arrived while stepping over "
5788 was_in_line
= step_over_info_valid_p ();
5789 clear_step_over_info ();
5790 insert_hp_step_resume_breakpoint_at_frame (frame
);
5791 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
5792 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5793 ecs
->event_thread
->control
.trap_expected
= 0;
5795 if (target_is_non_stop_p ())
5797 /* Either "set non-stop" is "on", or the target is
5798 always in non-stop mode. In this case, we have a bit
5799 more work to do. Resume the current thread, and if
5800 we had paused all threads, restart them while the
5801 signal handler runs. */
5806 restart_threads (ecs
->event_thread
);
5808 else if (debug_infrun
)
5810 fprintf_unfiltered (gdb_stdlog
,
5811 "infrun: no need to restart threads\n");
5816 /* If we were nexting/stepping some other thread, switch to
5817 it, so that we don't continue it, losing control. */
5818 if (!switch_back_to_stepped_thread (ecs
))
5823 if (ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
5824 && (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
5825 || ecs
->event_thread
->control
.step_range_end
== 1)
5826 && frame_id_eq (get_stack_frame_id (frame
),
5827 ecs
->event_thread
->control
.step_stack_frame_id
)
5828 && ecs
->event_thread
->control
.step_resume_breakpoint
== NULL
)
5830 /* The inferior is about to take a signal that will take it
5831 out of the single step range. Set a breakpoint at the
5832 current PC (which is presumably where the signal handler
5833 will eventually return) and then allow the inferior to
5836 Note that this is only needed for a signal delivered
5837 while in the single-step range. Nested signals aren't a
5838 problem as they eventually all return. */
5840 fprintf_unfiltered (gdb_stdlog
,
5841 "infrun: signal may take us out of "
5842 "single-step range\n");
5844 clear_step_over_info ();
5845 insert_hp_step_resume_breakpoint_at_frame (frame
);
5846 ecs
->event_thread
->step_after_step_resume_breakpoint
= 1;
5847 /* Reset trap_expected to ensure breakpoints are re-inserted. */
5848 ecs
->event_thread
->control
.trap_expected
= 0;
5853 /* Note: step_resume_breakpoint may be non-NULL. This occures
5854 when either there's a nested signal, or when there's a
5855 pending signal enabled just as the signal handler returns
5856 (leaving the inferior at the step-resume-breakpoint without
5857 actually executing it). Either way continue until the
5858 breakpoint is really hit. */
5860 if (!switch_back_to_stepped_thread (ecs
))
5863 fprintf_unfiltered (gdb_stdlog
,
5864 "infrun: random signal, keep going\n");
5871 process_event_stop_test (ecs
);
5874 /* Come here when we've got some debug event / signal we can explain
5875 (IOW, not a random signal), and test whether it should cause a
5876 stop, or whether we should resume the inferior (transparently).
5877 E.g., could be a breakpoint whose condition evaluates false; we
5878 could be still stepping within the line; etc. */
5881 process_event_stop_test (struct execution_control_state
*ecs
)
5883 struct symtab_and_line stop_pc_sal
;
5884 struct frame_info
*frame
;
5885 struct gdbarch
*gdbarch
;
5886 CORE_ADDR jmp_buf_pc
;
5887 struct bpstat_what what
;
5889 /* Handle cases caused by hitting a breakpoint. */
5891 frame
= get_current_frame ();
5892 gdbarch
= get_frame_arch (frame
);
5894 what
= bpstat_what (ecs
->event_thread
->control
.stop_bpstat
);
5896 if (what
.call_dummy
)
5898 stop_stack_dummy
= what
.call_dummy
;
5901 /* If we hit an internal event that triggers symbol changes, the
5902 current frame will be invalidated within bpstat_what (e.g., if we
5903 hit an internal solib event). Re-fetch it. */
5904 frame
= get_current_frame ();
5905 gdbarch
= get_frame_arch (frame
);
5907 switch (what
.main_action
)
5909 case BPSTAT_WHAT_SET_LONGJMP_RESUME
:
5910 /* If we hit the breakpoint at longjmp while stepping, we
5911 install a momentary breakpoint at the target of the
5915 fprintf_unfiltered (gdb_stdlog
,
5916 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
5918 ecs
->event_thread
->stepping_over_breakpoint
= 1;
5920 if (what
.is_longjmp
)
5922 struct value
*arg_value
;
5924 /* If we set the longjmp breakpoint via a SystemTap probe,
5925 then use it to extract the arguments. The destination PC
5926 is the third argument to the probe. */
5927 arg_value
= probe_safe_evaluate_at_pc (frame
, 2);
5930 jmp_buf_pc
= value_as_address (arg_value
);
5931 jmp_buf_pc
= gdbarch_addr_bits_remove (gdbarch
, jmp_buf_pc
);
5933 else if (!gdbarch_get_longjmp_target_p (gdbarch
)
5934 || !gdbarch_get_longjmp_target (gdbarch
,
5935 frame
, &jmp_buf_pc
))
5938 fprintf_unfiltered (gdb_stdlog
,
5939 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
5940 "(!gdbarch_get_longjmp_target)\n");
5945 /* Insert a breakpoint at resume address. */
5946 insert_longjmp_resume_breakpoint (gdbarch
, jmp_buf_pc
);
5949 check_exception_resume (ecs
, frame
);
5953 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
:
5955 struct frame_info
*init_frame
;
5957 /* There are several cases to consider.
5959 1. The initiating frame no longer exists. In this case we
5960 must stop, because the exception or longjmp has gone too
5963 2. The initiating frame exists, and is the same as the
5964 current frame. We stop, because the exception or longjmp
5967 3. The initiating frame exists and is different from the
5968 current frame. This means the exception or longjmp has
5969 been caught beneath the initiating frame, so keep going.
5971 4. longjmp breakpoint has been placed just to protect
5972 against stale dummy frames and user is not interested in
5973 stopping around longjmps. */
5976 fprintf_unfiltered (gdb_stdlog
,
5977 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
5979 gdb_assert (ecs
->event_thread
->control
.exception_resume_breakpoint
5981 delete_exception_resume_breakpoint (ecs
->event_thread
);
5983 if (what
.is_longjmp
)
5985 check_longjmp_breakpoint_for_call_dummy (ecs
->event_thread
);
5987 if (!frame_id_p (ecs
->event_thread
->initiating_frame
))
5995 init_frame
= frame_find_by_id (ecs
->event_thread
->initiating_frame
);
5999 struct frame_id current_id
6000 = get_frame_id (get_current_frame ());
6001 if (frame_id_eq (current_id
,
6002 ecs
->event_thread
->initiating_frame
))
6004 /* Case 2. Fall through. */
6014 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6016 delete_step_resume_breakpoint (ecs
->event_thread
);
6018 end_stepping_range (ecs
);
6022 case BPSTAT_WHAT_SINGLE
:
6024 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_SINGLE\n");
6025 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6026 /* Still need to check other stuff, at least the case where we
6027 are stepping and step out of the right range. */
6030 case BPSTAT_WHAT_STEP_RESUME
:
6032 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6034 delete_step_resume_breakpoint (ecs
->event_thread
);
6035 if (ecs
->event_thread
->control
.proceed_to_finish
6036 && execution_direction
== EXEC_REVERSE
)
6038 struct thread_info
*tp
= ecs
->event_thread
;
6040 /* We are finishing a function in reverse, and just hit the
6041 step-resume breakpoint at the start address of the
6042 function, and we're almost there -- just need to back up
6043 by one more single-step, which should take us back to the
6045 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
6049 fill_in_stop_func (gdbarch
, ecs
);
6050 if (stop_pc
== ecs
->stop_func_start
6051 && execution_direction
== EXEC_REVERSE
)
6053 /* We are stepping over a function call in reverse, and just
6054 hit the step-resume breakpoint at the start address of
6055 the function. Go back to single-stepping, which should
6056 take us back to the function call. */
6057 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6063 case BPSTAT_WHAT_STOP_NOISY
:
6065 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6066 stop_print_frame
= 1;
6068 /* Assume the thread stopped for a breapoint. We'll still check
6069 whether a/the breakpoint is there when the thread is next
6071 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6076 case BPSTAT_WHAT_STOP_SILENT
:
6078 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6079 stop_print_frame
= 0;
6081 /* Assume the thread stopped for a breapoint. We'll still check
6082 whether a/the breakpoint is there when the thread is next
6084 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6088 case BPSTAT_WHAT_HP_STEP_RESUME
:
6090 fprintf_unfiltered (gdb_stdlog
, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6092 delete_step_resume_breakpoint (ecs
->event_thread
);
6093 if (ecs
->event_thread
->step_after_step_resume_breakpoint
)
6095 /* Back when the step-resume breakpoint was inserted, we
6096 were trying to single-step off a breakpoint. Go back to
6098 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6099 ecs
->event_thread
->stepping_over_breakpoint
= 1;
6105 case BPSTAT_WHAT_KEEP_CHECKING
:
6109 /* If we stepped a permanent breakpoint and we had a high priority
6110 step-resume breakpoint for the address we stepped, but we didn't
6111 hit it, then we must have stepped into the signal handler. The
6112 step-resume was only necessary to catch the case of _not_
6113 stepping into the handler, so delete it, and fall through to
6114 checking whether the step finished. */
6115 if (ecs
->event_thread
->stepped_breakpoint
)
6117 struct breakpoint
*sr_bp
6118 = ecs
->event_thread
->control
.step_resume_breakpoint
;
6121 && sr_bp
->loc
->permanent
6122 && sr_bp
->type
== bp_hp_step_resume
6123 && sr_bp
->loc
->address
== ecs
->event_thread
->prev_pc
)
6126 fprintf_unfiltered (gdb_stdlog
,
6127 "infrun: stepped permanent breakpoint, stopped in "
6129 delete_step_resume_breakpoint (ecs
->event_thread
);
6130 ecs
->event_thread
->step_after_step_resume_breakpoint
= 0;
6134 /* We come here if we hit a breakpoint but should not stop for it.
6135 Possibly we also were stepping and should stop for that. So fall
6136 through and test for stepping. But, if not stepping, do not
6139 /* In all-stop mode, if we're currently stepping but have stopped in
6140 some other thread, we need to switch back to the stepped thread. */
6141 if (switch_back_to_stepped_thread (ecs
))
6144 if (ecs
->event_thread
->control
.step_resume_breakpoint
)
6147 fprintf_unfiltered (gdb_stdlog
,
6148 "infrun: step-resume breakpoint is inserted\n");
6150 /* Having a step-resume breakpoint overrides anything
6151 else having to do with stepping commands until
6152 that breakpoint is reached. */
6157 if (ecs
->event_thread
->control
.step_range_end
== 0)
6160 fprintf_unfiltered (gdb_stdlog
, "infrun: no stepping, continue\n");
6161 /* Likewise if we aren't even stepping. */
6166 /* Re-fetch current thread's frame in case the code above caused
6167 the frame cache to be re-initialized, making our FRAME variable
6168 a dangling pointer. */
6169 frame
= get_current_frame ();
6170 gdbarch
= get_frame_arch (frame
);
6171 fill_in_stop_func (gdbarch
, ecs
);
6173 /* If stepping through a line, keep going if still within it.
6175 Note that step_range_end is the address of the first instruction
6176 beyond the step range, and NOT the address of the last instruction
6179 Note also that during reverse execution, we may be stepping
6180 through a function epilogue and therefore must detect when
6181 the current-frame changes in the middle of a line. */
6183 if (pc_in_thread_step_range (stop_pc
, ecs
->event_thread
)
6184 && (execution_direction
!= EXEC_REVERSE
6185 || frame_id_eq (get_frame_id (frame
),
6186 ecs
->event_thread
->control
.step_frame_id
)))
6190 (gdb_stdlog
, "infrun: stepping inside range [%s-%s]\n",
6191 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_start
),
6192 paddress (gdbarch
, ecs
->event_thread
->control
.step_range_end
));
6194 /* Tentatively re-enable range stepping; `resume' disables it if
6195 necessary (e.g., if we're stepping over a breakpoint or we
6196 have software watchpoints). */
6197 ecs
->event_thread
->control
.may_range_step
= 1;
6199 /* When stepping backward, stop at beginning of line range
6200 (unless it's the function entry point, in which case
6201 keep going back to the call point). */
6202 if (stop_pc
== ecs
->event_thread
->control
.step_range_start
6203 && stop_pc
!= ecs
->stop_func_start
6204 && execution_direction
== EXEC_REVERSE
)
6205 end_stepping_range (ecs
);
6212 /* We stepped out of the stepping range. */
6214 /* If we are stepping at the source level and entered the runtime
6215 loader dynamic symbol resolution code...
6217 EXEC_FORWARD: we keep on single stepping until we exit the run
6218 time loader code and reach the callee's address.
6220 EXEC_REVERSE: we've already executed the callee (backward), and
6221 the runtime loader code is handled just like any other
6222 undebuggable function call. Now we need only keep stepping
6223 backward through the trampoline code, and that's handled further
6224 down, so there is nothing for us to do here. */
6226 if (execution_direction
!= EXEC_REVERSE
6227 && ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6228 && in_solib_dynsym_resolve_code (stop_pc
))
6230 CORE_ADDR pc_after_resolver
=
6231 gdbarch_skip_solib_resolver (gdbarch
, stop_pc
);
6234 fprintf_unfiltered (gdb_stdlog
,
6235 "infrun: stepped into dynsym resolve code\n");
6237 if (pc_after_resolver
)
6239 /* Set up a step-resume breakpoint at the address
6240 indicated by SKIP_SOLIB_RESOLVER. */
6241 struct symtab_and_line sr_sal
;
6244 sr_sal
.pc
= pc_after_resolver
;
6245 sr_sal
.pspace
= get_frame_program_space (frame
);
6247 insert_step_resume_breakpoint_at_sal (gdbarch
,
6248 sr_sal
, null_frame_id
);
6255 if (ecs
->event_thread
->control
.step_range_end
!= 1
6256 && (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6257 || ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6258 && get_frame_type (frame
) == SIGTRAMP_FRAME
)
6261 fprintf_unfiltered (gdb_stdlog
,
6262 "infrun: stepped into signal trampoline\n");
6263 /* The inferior, while doing a "step" or "next", has ended up in
6264 a signal trampoline (either by a signal being delivered or by
6265 the signal handler returning). Just single-step until the
6266 inferior leaves the trampoline (either by calling the handler
6272 /* If we're in the return path from a shared library trampoline,
6273 we want to proceed through the trampoline when stepping. */
6274 /* macro/2012-04-25: This needs to come before the subroutine
6275 call check below as on some targets return trampolines look
6276 like subroutine calls (MIPS16 return thunks). */
6277 if (gdbarch_in_solib_return_trampoline (gdbarch
,
6278 stop_pc
, ecs
->stop_func_name
)
6279 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6281 /* Determine where this trampoline returns. */
6282 CORE_ADDR real_stop_pc
;
6284 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6287 fprintf_unfiltered (gdb_stdlog
,
6288 "infrun: stepped into solib return tramp\n");
6290 /* Only proceed through if we know where it's going. */
6293 /* And put the step-breakpoint there and go until there. */
6294 struct symtab_and_line sr_sal
;
6296 init_sal (&sr_sal
); /* initialize to zeroes */
6297 sr_sal
.pc
= real_stop_pc
;
6298 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
6299 sr_sal
.pspace
= get_frame_program_space (frame
);
6301 /* Do not specify what the fp should be when we stop since
6302 on some machines the prologue is where the new fp value
6304 insert_step_resume_breakpoint_at_sal (gdbarch
,
6305 sr_sal
, null_frame_id
);
6307 /* Restart without fiddling with the step ranges or
6314 /* Check for subroutine calls. The check for the current frame
6315 equalling the step ID is not necessary - the check of the
6316 previous frame's ID is sufficient - but it is a common case and
6317 cheaper than checking the previous frame's ID.
6319 NOTE: frame_id_eq will never report two invalid frame IDs as
6320 being equal, so to get into this block, both the current and
6321 previous frame must have valid frame IDs. */
6322 /* The outer_frame_id check is a heuristic to detect stepping
6323 through startup code. If we step over an instruction which
6324 sets the stack pointer from an invalid value to a valid value,
6325 we may detect that as a subroutine call from the mythical
6326 "outermost" function. This could be fixed by marking
6327 outermost frames as !stack_p,code_p,special_p. Then the
6328 initial outermost frame, before sp was valid, would
6329 have code_addr == &_start. See the comment in frame_id_eq
6331 if (!frame_id_eq (get_stack_frame_id (frame
),
6332 ecs
->event_thread
->control
.step_stack_frame_id
)
6333 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6334 ecs
->event_thread
->control
.step_stack_frame_id
)
6335 && (!frame_id_eq (ecs
->event_thread
->control
.step_stack_frame_id
,
6337 || (ecs
->event_thread
->control
.step_start_function
6338 != find_pc_function (stop_pc
)))))
6340 CORE_ADDR real_stop_pc
;
6343 fprintf_unfiltered (gdb_stdlog
, "infrun: stepped into subroutine\n");
6345 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_NONE
)
6347 /* I presume that step_over_calls is only 0 when we're
6348 supposed to be stepping at the assembly language level
6349 ("stepi"). Just stop. */
6350 /* And this works the same backward as frontward. MVS */
6351 end_stepping_range (ecs
);
6355 /* Reverse stepping through solib trampolines. */
6357 if (execution_direction
== EXEC_REVERSE
6358 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
6359 && (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6360 || (ecs
->stop_func_start
== 0
6361 && in_solib_dynsym_resolve_code (stop_pc
))))
6363 /* Any solib trampoline code can be handled in reverse
6364 by simply continuing to single-step. We have already
6365 executed the solib function (backwards), and a few
6366 steps will take us back through the trampoline to the
6372 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6374 /* We're doing a "next".
6376 Normal (forward) execution: set a breakpoint at the
6377 callee's return address (the address at which the caller
6380 Reverse (backward) execution. set the step-resume
6381 breakpoint at the start of the function that we just
6382 stepped into (backwards), and continue to there. When we
6383 get there, we'll need to single-step back to the caller. */
6385 if (execution_direction
== EXEC_REVERSE
)
6387 /* If we're already at the start of the function, we've either
6388 just stepped backward into a single instruction function,
6389 or stepped back out of a signal handler to the first instruction
6390 of the function. Just keep going, which will single-step back
6392 if (ecs
->stop_func_start
!= stop_pc
&& ecs
->stop_func_start
!= 0)
6394 struct symtab_and_line sr_sal
;
6396 /* Normal function call return (static or dynamic). */
6398 sr_sal
.pc
= ecs
->stop_func_start
;
6399 sr_sal
.pspace
= get_frame_program_space (frame
);
6400 insert_step_resume_breakpoint_at_sal (gdbarch
,
6401 sr_sal
, null_frame_id
);
6405 insert_step_resume_breakpoint_at_caller (frame
);
6411 /* If we are in a function call trampoline (a stub between the
6412 calling routine and the real function), locate the real
6413 function. That's what tells us (a) whether we want to step
6414 into it at all, and (b) what prologue we want to run to the
6415 end of, if we do step into it. */
6416 real_stop_pc
= skip_language_trampoline (frame
, stop_pc
);
6417 if (real_stop_pc
== 0)
6418 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
6419 if (real_stop_pc
!= 0)
6420 ecs
->stop_func_start
= real_stop_pc
;
6422 if (real_stop_pc
!= 0 && in_solib_dynsym_resolve_code (real_stop_pc
))
6424 struct symtab_and_line sr_sal
;
6427 sr_sal
.pc
= ecs
->stop_func_start
;
6428 sr_sal
.pspace
= get_frame_program_space (frame
);
6430 insert_step_resume_breakpoint_at_sal (gdbarch
,
6431 sr_sal
, null_frame_id
);
6436 /* If we have line number information for the function we are
6437 thinking of stepping into and the function isn't on the skip
6440 If there are several symtabs at that PC (e.g. with include
6441 files), just want to know whether *any* of them have line
6442 numbers. find_pc_line handles this. */
6444 struct symtab_and_line tmp_sal
;
6446 tmp_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6447 if (tmp_sal
.line
!= 0
6448 && !function_name_is_marked_for_skip (ecs
->stop_func_name
,
6451 if (execution_direction
== EXEC_REVERSE
)
6452 handle_step_into_function_backward (gdbarch
, ecs
);
6454 handle_step_into_function (gdbarch
, ecs
);
6459 /* If we have no line number and the step-stop-if-no-debug is
6460 set, we stop the step so that the user has a chance to switch
6461 in assembly mode. */
6462 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6463 && step_stop_if_no_debug
)
6465 end_stepping_range (ecs
);
6469 if (execution_direction
== EXEC_REVERSE
)
6471 /* If we're already at the start of the function, we've either just
6472 stepped backward into a single instruction function without line
6473 number info, or stepped back out of a signal handler to the first
6474 instruction of the function without line number info. Just keep
6475 going, which will single-step back to the caller. */
6476 if (ecs
->stop_func_start
!= stop_pc
)
6478 /* Set a breakpoint at callee's start address.
6479 From there we can step once and be back in the caller. */
6480 struct symtab_and_line sr_sal
;
6483 sr_sal
.pc
= ecs
->stop_func_start
;
6484 sr_sal
.pspace
= get_frame_program_space (frame
);
6485 insert_step_resume_breakpoint_at_sal (gdbarch
,
6486 sr_sal
, null_frame_id
);
6490 /* Set a breakpoint at callee's return address (the address
6491 at which the caller will resume). */
6492 insert_step_resume_breakpoint_at_caller (frame
);
6498 /* Reverse stepping through solib trampolines. */
6500 if (execution_direction
== EXEC_REVERSE
6501 && ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_NONE
)
6503 if (gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
)
6504 || (ecs
->stop_func_start
== 0
6505 && in_solib_dynsym_resolve_code (stop_pc
)))
6507 /* Any solib trampoline code can be handled in reverse
6508 by simply continuing to single-step. We have already
6509 executed the solib function (backwards), and a few
6510 steps will take us back through the trampoline to the
6515 else if (in_solib_dynsym_resolve_code (stop_pc
))
6517 /* Stepped backward into the solib dynsym resolver.
6518 Set a breakpoint at its start and continue, then
6519 one more step will take us out. */
6520 struct symtab_and_line sr_sal
;
6523 sr_sal
.pc
= ecs
->stop_func_start
;
6524 sr_sal
.pspace
= get_frame_program_space (frame
);
6525 insert_step_resume_breakpoint_at_sal (gdbarch
,
6526 sr_sal
, null_frame_id
);
6532 stop_pc_sal
= find_pc_line (stop_pc
, 0);
6534 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6535 the trampoline processing logic, however, there are some trampolines
6536 that have no names, so we should do trampoline handling first. */
6537 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_UNDEBUGGABLE
6538 && ecs
->stop_func_name
== NULL
6539 && stop_pc_sal
.line
== 0)
6542 fprintf_unfiltered (gdb_stdlog
,
6543 "infrun: stepped into undebuggable function\n");
6545 /* The inferior just stepped into, or returned to, an
6546 undebuggable function (where there is no debugging information
6547 and no line number corresponding to the address where the
6548 inferior stopped). Since we want to skip this kind of code,
6549 we keep going until the inferior returns from this
6550 function - unless the user has asked us not to (via
6551 set step-mode) or we no longer know how to get back
6552 to the call site. */
6553 if (step_stop_if_no_debug
6554 || !frame_id_p (frame_unwind_caller_id (frame
)))
6556 /* If we have no line number and the step-stop-if-no-debug
6557 is set, we stop the step so that the user has a chance to
6558 switch in assembly mode. */
6559 end_stepping_range (ecs
);
6564 /* Set a breakpoint at callee's return address (the address
6565 at which the caller will resume). */
6566 insert_step_resume_breakpoint_at_caller (frame
);
6572 if (ecs
->event_thread
->control
.step_range_end
== 1)
6574 /* It is stepi or nexti. We always want to stop stepping after
6577 fprintf_unfiltered (gdb_stdlog
, "infrun: stepi/nexti\n");
6578 end_stepping_range (ecs
);
6582 if (stop_pc_sal
.line
== 0)
6584 /* We have no line number information. That means to stop
6585 stepping (does this always happen right after one instruction,
6586 when we do "s" in a function with no line numbers,
6587 or can this happen as a result of a return or longjmp?). */
6589 fprintf_unfiltered (gdb_stdlog
, "infrun: no line number info\n");
6590 end_stepping_range (ecs
);
6594 /* Look for "calls" to inlined functions, part one. If the inline
6595 frame machinery detected some skipped call sites, we have entered
6596 a new inline function. */
6598 if (frame_id_eq (get_frame_id (get_current_frame ()),
6599 ecs
->event_thread
->control
.step_frame_id
)
6600 && inline_skipped_frames (ecs
->ptid
))
6602 struct symtab_and_line call_sal
;
6605 fprintf_unfiltered (gdb_stdlog
,
6606 "infrun: stepped into inlined function\n");
6608 find_frame_sal (get_current_frame (), &call_sal
);
6610 if (ecs
->event_thread
->control
.step_over_calls
!= STEP_OVER_ALL
)
6612 /* For "step", we're going to stop. But if the call site
6613 for this inlined function is on the same source line as
6614 we were previously stepping, go down into the function
6615 first. Otherwise stop at the call site. */
6617 if (call_sal
.line
== ecs
->event_thread
->current_line
6618 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
6619 step_into_inline_frame (ecs
->ptid
);
6621 end_stepping_range (ecs
);
6626 /* For "next", we should stop at the call site if it is on a
6627 different source line. Otherwise continue through the
6628 inlined function. */
6629 if (call_sal
.line
== ecs
->event_thread
->current_line
6630 && call_sal
.symtab
== ecs
->event_thread
->current_symtab
)
6633 end_stepping_range (ecs
);
6638 /* Look for "calls" to inlined functions, part two. If we are still
6639 in the same real function we were stepping through, but we have
6640 to go further up to find the exact frame ID, we are stepping
6641 through a more inlined call beyond its call site. */
6643 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6644 && !frame_id_eq (get_frame_id (get_current_frame ()),
6645 ecs
->event_thread
->control
.step_frame_id
)
6646 && stepped_in_from (get_current_frame (),
6647 ecs
->event_thread
->control
.step_frame_id
))
6650 fprintf_unfiltered (gdb_stdlog
,
6651 "infrun: stepping through inlined function\n");
6653 if (ecs
->event_thread
->control
.step_over_calls
== STEP_OVER_ALL
)
6656 end_stepping_range (ecs
);
6660 if ((stop_pc
== stop_pc_sal
.pc
)
6661 && (ecs
->event_thread
->current_line
!= stop_pc_sal
.line
6662 || ecs
->event_thread
->current_symtab
!= stop_pc_sal
.symtab
))
6664 /* We are at the start of a different line. So stop. Note that
6665 we don't stop if we step into the middle of a different line.
6666 That is said to make things like for (;;) statements work
6669 fprintf_unfiltered (gdb_stdlog
,
6670 "infrun: stepped to a different line\n");
6671 end_stepping_range (ecs
);
6675 /* We aren't done stepping.
6677 Optimize by setting the stepping range to the line.
6678 (We might not be in the original line, but if we entered a
6679 new line in mid-statement, we continue stepping. This makes
6680 things like for(;;) statements work better.) */
6682 ecs
->event_thread
->control
.step_range_start
= stop_pc_sal
.pc
;
6683 ecs
->event_thread
->control
.step_range_end
= stop_pc_sal
.end
;
6684 ecs
->event_thread
->control
.may_range_step
= 1;
6685 set_step_info (frame
, stop_pc_sal
);
6688 fprintf_unfiltered (gdb_stdlog
, "infrun: keep going\n");
6692 /* In all-stop mode, if we're currently stepping but have stopped in
6693 some other thread, we may need to switch back to the stepped
6694 thread. Returns true we set the inferior running, false if we left
6695 it stopped (and the event needs further processing). */
6698 switch_back_to_stepped_thread (struct execution_control_state
*ecs
)
6700 if (!target_is_non_stop_p ())
6702 struct thread_info
*tp
;
6703 struct thread_info
*stepping_thread
;
6705 /* If any thread is blocked on some internal breakpoint, and we
6706 simply need to step over that breakpoint to get it going
6707 again, do that first. */
6709 /* However, if we see an event for the stepping thread, then we
6710 know all other threads have been moved past their breakpoints
6711 already. Let the caller check whether the step is finished,
6712 etc., before deciding to move it past a breakpoint. */
6713 if (ecs
->event_thread
->control
.step_range_end
!= 0)
6716 /* Check if the current thread is blocked on an incomplete
6717 step-over, interrupted by a random signal. */
6718 if (ecs
->event_thread
->control
.trap_expected
6719 && ecs
->event_thread
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
6723 fprintf_unfiltered (gdb_stdlog
,
6724 "infrun: need to finish step-over of [%s]\n",
6725 target_pid_to_str (ecs
->event_thread
->ptid
));
6731 /* Check if the current thread is blocked by a single-step
6732 breakpoint of another thread. */
6733 if (ecs
->hit_singlestep_breakpoint
)
6737 fprintf_unfiltered (gdb_stdlog
,
6738 "infrun: need to step [%s] over single-step "
6740 target_pid_to_str (ecs
->ptid
));
6746 /* If this thread needs yet another step-over (e.g., stepping
6747 through a delay slot), do it first before moving on to
6749 if (thread_still_needs_step_over (ecs
->event_thread
))
6753 fprintf_unfiltered (gdb_stdlog
,
6754 "infrun: thread [%s] still needs step-over\n",
6755 target_pid_to_str (ecs
->event_thread
->ptid
));
6761 /* If scheduler locking applies even if not stepping, there's no
6762 need to walk over threads. Above we've checked whether the
6763 current thread is stepping. If some other thread not the
6764 event thread is stepping, then it must be that scheduler
6765 locking is not in effect. */
6766 if (schedlock_applies (ecs
->event_thread
))
6769 /* Otherwise, we no longer expect a trap in the current thread.
6770 Clear the trap_expected flag before switching back -- this is
6771 what keep_going does as well, if we call it. */
6772 ecs
->event_thread
->control
.trap_expected
= 0;
6774 /* Likewise, clear the signal if it should not be passed. */
6775 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
6776 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6778 /* Do all pending step-overs before actually proceeding with
6780 if (start_step_over ())
6782 prepare_to_wait (ecs
);
6786 /* Look for the stepping/nexting thread. */
6787 stepping_thread
= NULL
;
6789 ALL_NON_EXITED_THREADS (tp
)
6791 /* Ignore threads of processes the caller is not
6794 && ptid_get_pid (tp
->ptid
) != ptid_get_pid (ecs
->ptid
))
6797 /* When stepping over a breakpoint, we lock all threads
6798 except the one that needs to move past the breakpoint.
6799 If a non-event thread has this set, the "incomplete
6800 step-over" check above should have caught it earlier. */
6801 if (tp
->control
.trap_expected
)
6803 internal_error (__FILE__
, __LINE__
,
6804 "[%s] has inconsistent state: "
6805 "trap_expected=%d\n",
6806 target_pid_to_str (tp
->ptid
),
6807 tp
->control
.trap_expected
);
6810 /* Did we find the stepping thread? */
6811 if (tp
->control
.step_range_end
)
6813 /* Yep. There should only one though. */
6814 gdb_assert (stepping_thread
== NULL
);
6816 /* The event thread is handled at the top, before we
6818 gdb_assert (tp
!= ecs
->event_thread
);
6820 /* If some thread other than the event thread is
6821 stepping, then scheduler locking can't be in effect,
6822 otherwise we wouldn't have resumed the current event
6823 thread in the first place. */
6824 gdb_assert (!schedlock_applies (tp
));
6826 stepping_thread
= tp
;
6830 if (stepping_thread
!= NULL
)
6833 fprintf_unfiltered (gdb_stdlog
,
6834 "infrun: switching back to stepped thread\n");
6836 if (keep_going_stepped_thread (stepping_thread
))
6838 prepare_to_wait (ecs
);
6847 /* Set a previously stepped thread back to stepping. Returns true on
6848 success, false if the resume is not possible (e.g., the thread
6852 keep_going_stepped_thread (struct thread_info
*tp
)
6854 struct frame_info
*frame
;
6855 struct gdbarch
*gdbarch
;
6856 struct execution_control_state ecss
;
6857 struct execution_control_state
*ecs
= &ecss
;
6859 /* If the stepping thread exited, then don't try to switch back and
6860 resume it, which could fail in several different ways depending
6861 on the target. Instead, just keep going.
6863 We can find a stepping dead thread in the thread list in two
6866 - The target supports thread exit events, and when the target
6867 tries to delete the thread from the thread list, inferior_ptid
6868 pointed at the exiting thread. In such case, calling
6869 delete_thread does not really remove the thread from the list;
6870 instead, the thread is left listed, with 'exited' state.
6872 - The target's debug interface does not support thread exit
6873 events, and so we have no idea whatsoever if the previously
6874 stepping thread is still alive. For that reason, we need to
6875 synchronously query the target now. */
6877 if (is_exited (tp
->ptid
)
6878 || !target_thread_alive (tp
->ptid
))
6881 fprintf_unfiltered (gdb_stdlog
,
6882 "infrun: not resuming previously "
6883 "stepped thread, it has vanished\n");
6885 delete_thread (tp
->ptid
);
6890 fprintf_unfiltered (gdb_stdlog
,
6891 "infrun: resuming previously stepped thread\n");
6893 reset_ecs (ecs
, tp
);
6894 switch_to_thread (tp
->ptid
);
6896 stop_pc
= regcache_read_pc (get_thread_regcache (tp
->ptid
));
6897 frame
= get_current_frame ();
6898 gdbarch
= get_frame_arch (frame
);
6900 /* If the PC of the thread we were trying to single-step has
6901 changed, then that thread has trapped or been signaled, but the
6902 event has not been reported to GDB yet. Re-poll the target
6903 looking for this particular thread's event (i.e. temporarily
6904 enable schedlock) by:
6906 - setting a break at the current PC
6907 - resuming that particular thread, only (by setting trap
6910 This prevents us continuously moving the single-step breakpoint
6911 forward, one instruction at a time, overstepping. */
6913 if (stop_pc
!= tp
->prev_pc
)
6918 fprintf_unfiltered (gdb_stdlog
,
6919 "infrun: expected thread advanced also (%s -> %s)\n",
6920 paddress (target_gdbarch (), tp
->prev_pc
),
6921 paddress (target_gdbarch (), stop_pc
));
6923 /* Clear the info of the previous step-over, as it's no longer
6924 valid (if the thread was trying to step over a breakpoint, it
6925 has already succeeded). It's what keep_going would do too,
6926 if we called it. Do this before trying to insert the sss
6927 breakpoint, otherwise if we were previously trying to step
6928 over this exact address in another thread, the breakpoint is
6930 clear_step_over_info ();
6931 tp
->control
.trap_expected
= 0;
6933 insert_single_step_breakpoint (get_frame_arch (frame
),
6934 get_frame_address_space (frame
),
6938 resume_ptid
= internal_resume_ptid (tp
->control
.stepping_command
);
6939 do_target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
6944 fprintf_unfiltered (gdb_stdlog
,
6945 "infrun: expected thread still hasn't advanced\n");
6947 keep_going_pass_signal (ecs
);
6952 /* Is thread TP in the middle of (software or hardware)
6953 single-stepping? (Note the result of this function must never be
6954 passed directly as target_resume's STEP parameter.) */
6957 currently_stepping (struct thread_info
*tp
)
6959 return ((tp
->control
.step_range_end
6960 && tp
->control
.step_resume_breakpoint
== NULL
)
6961 || tp
->control
.trap_expected
6962 || tp
->stepped_breakpoint
6963 || bpstat_should_step ());
6966 /* Inferior has stepped into a subroutine call with source code that
6967 we should not step over. Do step to the first line of code in
6971 handle_step_into_function (struct gdbarch
*gdbarch
,
6972 struct execution_control_state
*ecs
)
6974 struct compunit_symtab
*cust
;
6975 struct symtab_and_line stop_func_sal
, sr_sal
;
6977 fill_in_stop_func (gdbarch
, ecs
);
6979 cust
= find_pc_compunit_symtab (stop_pc
);
6980 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
6981 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
6982 ecs
->stop_func_start
);
6984 stop_func_sal
= find_pc_line (ecs
->stop_func_start
, 0);
6985 /* Use the step_resume_break to step until the end of the prologue,
6986 even if that involves jumps (as it seems to on the vax under
6988 /* If the prologue ends in the middle of a source line, continue to
6989 the end of that source line (if it is still within the function).
6990 Otherwise, just go to end of prologue. */
6991 if (stop_func_sal
.end
6992 && stop_func_sal
.pc
!= ecs
->stop_func_start
6993 && stop_func_sal
.end
< ecs
->stop_func_end
)
6994 ecs
->stop_func_start
= stop_func_sal
.end
;
6996 /* Architectures which require breakpoint adjustment might not be able
6997 to place a breakpoint at the computed address. If so, the test
6998 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
6999 ecs->stop_func_start to an address at which a breakpoint may be
7000 legitimately placed.
7002 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7003 made, GDB will enter an infinite loop when stepping through
7004 optimized code consisting of VLIW instructions which contain
7005 subinstructions corresponding to different source lines. On
7006 FR-V, it's not permitted to place a breakpoint on any but the
7007 first subinstruction of a VLIW instruction. When a breakpoint is
7008 set, GDB will adjust the breakpoint address to the beginning of
7009 the VLIW instruction. Thus, we need to make the corresponding
7010 adjustment here when computing the stop address. */
7012 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7014 ecs
->stop_func_start
7015 = gdbarch_adjust_breakpoint_address (gdbarch
,
7016 ecs
->stop_func_start
);
7019 if (ecs
->stop_func_start
== stop_pc
)
7021 /* We are already there: stop now. */
7022 end_stepping_range (ecs
);
7027 /* Put the step-breakpoint there and go until there. */
7028 init_sal (&sr_sal
); /* initialize to zeroes */
7029 sr_sal
.pc
= ecs
->stop_func_start
;
7030 sr_sal
.section
= find_pc_overlay (ecs
->stop_func_start
);
7031 sr_sal
.pspace
= get_frame_program_space (get_current_frame ());
7033 /* Do not specify what the fp should be when we stop since on
7034 some machines the prologue is where the new fp value is
7036 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
, null_frame_id
);
7038 /* And make sure stepping stops right away then. */
7039 ecs
->event_thread
->control
.step_range_end
7040 = ecs
->event_thread
->control
.step_range_start
;
7045 /* Inferior has stepped backward into a subroutine call with source
7046 code that we should not step over. Do step to the beginning of the
7047 last line of code in it. */
7050 handle_step_into_function_backward (struct gdbarch
*gdbarch
,
7051 struct execution_control_state
*ecs
)
7053 struct compunit_symtab
*cust
;
7054 struct symtab_and_line stop_func_sal
;
7056 fill_in_stop_func (gdbarch
, ecs
);
7058 cust
= find_pc_compunit_symtab (stop_pc
);
7059 if (cust
!= NULL
&& compunit_language (cust
) != language_asm
)
7060 ecs
->stop_func_start
= gdbarch_skip_prologue (gdbarch
,
7061 ecs
->stop_func_start
);
7063 stop_func_sal
= find_pc_line (stop_pc
, 0);
7065 /* OK, we're just going to keep stepping here. */
7066 if (stop_func_sal
.pc
== stop_pc
)
7068 /* We're there already. Just stop stepping now. */
7069 end_stepping_range (ecs
);
7073 /* Else just reset the step range and keep going.
7074 No step-resume breakpoint, they don't work for
7075 epilogues, which can have multiple entry paths. */
7076 ecs
->event_thread
->control
.step_range_start
= stop_func_sal
.pc
;
7077 ecs
->event_thread
->control
.step_range_end
= stop_func_sal
.end
;
7083 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7084 This is used to both functions and to skip over code. */
7087 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch
*gdbarch
,
7088 struct symtab_and_line sr_sal
,
7089 struct frame_id sr_id
,
7090 enum bptype sr_type
)
7092 /* There should never be more than one step-resume or longjmp-resume
7093 breakpoint per thread, so we should never be setting a new
7094 step_resume_breakpoint when one is already active. */
7095 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
== NULL
);
7096 gdb_assert (sr_type
== bp_step_resume
|| sr_type
== bp_hp_step_resume
);
7099 fprintf_unfiltered (gdb_stdlog
,
7100 "infrun: inserting step-resume breakpoint at %s\n",
7101 paddress (gdbarch
, sr_sal
.pc
));
7103 inferior_thread ()->control
.step_resume_breakpoint
7104 = set_momentary_breakpoint (gdbarch
, sr_sal
, sr_id
, sr_type
);
7108 insert_step_resume_breakpoint_at_sal (struct gdbarch
*gdbarch
,
7109 struct symtab_and_line sr_sal
,
7110 struct frame_id sr_id
)
7112 insert_step_resume_breakpoint_at_sal_1 (gdbarch
,
7117 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7118 This is used to skip a potential signal handler.
7120 This is called with the interrupted function's frame. The signal
7121 handler, when it returns, will resume the interrupted function at
7125 insert_hp_step_resume_breakpoint_at_frame (struct frame_info
*return_frame
)
7127 struct symtab_and_line sr_sal
;
7128 struct gdbarch
*gdbarch
;
7130 gdb_assert (return_frame
!= NULL
);
7131 init_sal (&sr_sal
); /* initialize to zeros */
7133 gdbarch
= get_frame_arch (return_frame
);
7134 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
, get_frame_pc (return_frame
));
7135 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7136 sr_sal
.pspace
= get_frame_program_space (return_frame
);
7138 insert_step_resume_breakpoint_at_sal_1 (gdbarch
, sr_sal
,
7139 get_stack_frame_id (return_frame
),
7143 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7144 is used to skip a function after stepping into it (for "next" or if
7145 the called function has no debugging information).
7147 The current function has almost always been reached by single
7148 stepping a call or return instruction. NEXT_FRAME belongs to the
7149 current function, and the breakpoint will be set at the caller's
7152 This is a separate function rather than reusing
7153 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7154 get_prev_frame, which may stop prematurely (see the implementation
7155 of frame_unwind_caller_id for an example). */
7158 insert_step_resume_breakpoint_at_caller (struct frame_info
*next_frame
)
7160 struct symtab_and_line sr_sal
;
7161 struct gdbarch
*gdbarch
;
7163 /* We shouldn't have gotten here if we don't know where the call site
7165 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame
)));
7167 init_sal (&sr_sal
); /* initialize to zeros */
7169 gdbarch
= frame_unwind_caller_arch (next_frame
);
7170 sr_sal
.pc
= gdbarch_addr_bits_remove (gdbarch
,
7171 frame_unwind_caller_pc (next_frame
));
7172 sr_sal
.section
= find_pc_overlay (sr_sal
.pc
);
7173 sr_sal
.pspace
= frame_unwind_program_space (next_frame
);
7175 insert_step_resume_breakpoint_at_sal (gdbarch
, sr_sal
,
7176 frame_unwind_caller_id (next_frame
));
7179 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7180 new breakpoint at the target of a jmp_buf. The handling of
7181 longjmp-resume uses the same mechanisms used for handling
7182 "step-resume" breakpoints. */
7185 insert_longjmp_resume_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
7187 /* There should never be more than one longjmp-resume breakpoint per
7188 thread, so we should never be setting a new
7189 longjmp_resume_breakpoint when one is already active. */
7190 gdb_assert (inferior_thread ()->control
.exception_resume_breakpoint
== NULL
);
7193 fprintf_unfiltered (gdb_stdlog
,
7194 "infrun: inserting longjmp-resume breakpoint at %s\n",
7195 paddress (gdbarch
, pc
));
7197 inferior_thread ()->control
.exception_resume_breakpoint
=
7198 set_momentary_breakpoint_at_pc (gdbarch
, pc
, bp_longjmp_resume
);
7201 /* Insert an exception resume breakpoint. TP is the thread throwing
7202 the exception. The block B is the block of the unwinder debug hook
7203 function. FRAME is the frame corresponding to the call to this
7204 function. SYM is the symbol of the function argument holding the
7205 target PC of the exception. */
7208 insert_exception_resume_breakpoint (struct thread_info
*tp
,
7209 const struct block
*b
,
7210 struct frame_info
*frame
,
7215 struct block_symbol vsym
;
7216 struct value
*value
;
7218 struct breakpoint
*bp
;
7220 vsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
), b
, VAR_DOMAIN
, NULL
);
7221 value
= read_var_value (vsym
.symbol
, vsym
.block
, frame
);
7222 /* If the value was optimized out, revert to the old behavior. */
7223 if (! value_optimized_out (value
))
7225 handler
= value_as_address (value
);
7228 fprintf_unfiltered (gdb_stdlog
,
7229 "infrun: exception resume at %lx\n",
7230 (unsigned long) handler
);
7232 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7233 handler
, bp_exception_resume
);
7235 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7238 bp
->thread
= tp
->num
;
7239 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7242 CATCH (e
, RETURN_MASK_ERROR
)
7244 /* We want to ignore errors here. */
7249 /* A helper for check_exception_resume that sets an
7250 exception-breakpoint based on a SystemTap probe. */
7253 insert_exception_resume_from_probe (struct thread_info
*tp
,
7254 const struct bound_probe
*probe
,
7255 struct frame_info
*frame
)
7257 struct value
*arg_value
;
7259 struct breakpoint
*bp
;
7261 arg_value
= probe_safe_evaluate_at_pc (frame
, 1);
7265 handler
= value_as_address (arg_value
);
7268 fprintf_unfiltered (gdb_stdlog
,
7269 "infrun: exception resume at %s\n",
7270 paddress (get_objfile_arch (probe
->objfile
),
7273 bp
= set_momentary_breakpoint_at_pc (get_frame_arch (frame
),
7274 handler
, bp_exception_resume
);
7275 bp
->thread
= tp
->num
;
7276 inferior_thread ()->control
.exception_resume_breakpoint
= bp
;
7279 /* This is called when an exception has been intercepted. Check to
7280 see whether the exception's destination is of interest, and if so,
7281 set an exception resume breakpoint there. */
7284 check_exception_resume (struct execution_control_state
*ecs
,
7285 struct frame_info
*frame
)
7287 struct bound_probe probe
;
7288 struct symbol
*func
;
7290 /* First see if this exception unwinding breakpoint was set via a
7291 SystemTap probe point. If so, the probe has two arguments: the
7292 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7293 set a breakpoint there. */
7294 probe
= find_probe_by_pc (get_frame_pc (frame
));
7297 insert_exception_resume_from_probe (ecs
->event_thread
, &probe
, frame
);
7301 func
= get_frame_function (frame
);
7307 const struct block
*b
;
7308 struct block_iterator iter
;
7312 /* The exception breakpoint is a thread-specific breakpoint on
7313 the unwinder's debug hook, declared as:
7315 void _Unwind_DebugHook (void *cfa, void *handler);
7317 The CFA argument indicates the frame to which control is
7318 about to be transferred. HANDLER is the destination PC.
7320 We ignore the CFA and set a temporary breakpoint at HANDLER.
7321 This is not extremely efficient but it avoids issues in gdb
7322 with computing the DWARF CFA, and it also works even in weird
7323 cases such as throwing an exception from inside a signal
7326 b
= SYMBOL_BLOCK_VALUE (func
);
7327 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
7329 if (!SYMBOL_IS_ARGUMENT (sym
))
7336 insert_exception_resume_breakpoint (ecs
->event_thread
,
7342 CATCH (e
, RETURN_MASK_ERROR
)
7349 stop_waiting (struct execution_control_state
*ecs
)
7352 fprintf_unfiltered (gdb_stdlog
, "infrun: stop_waiting\n");
7354 clear_step_over_info ();
7356 /* Let callers know we don't want to wait for the inferior anymore. */
7357 ecs
->wait_some_more
= 0;
7359 /* If all-stop, but the target is always in non-stop mode, stop all
7360 threads now that we're presenting the stop to the user. */
7361 if (!non_stop
&& target_is_non_stop_p ())
7362 stop_all_threads ();
7365 /* Like keep_going, but passes the signal to the inferior, even if the
7366 signal is set to nopass. */
7369 keep_going_pass_signal (struct execution_control_state
*ecs
)
7371 /* Make sure normal_stop is called if we get a QUIT handled before
7373 struct cleanup
*old_cleanups
= make_cleanup (resume_cleanups
, 0);
7375 gdb_assert (ptid_equal (ecs
->event_thread
->ptid
, inferior_ptid
));
7376 gdb_assert (!ecs
->event_thread
->resumed
);
7378 /* Save the pc before execution, to compare with pc after stop. */
7379 ecs
->event_thread
->prev_pc
7380 = regcache_read_pc (get_thread_regcache (ecs
->ptid
));
7382 if (ecs
->event_thread
->control
.trap_expected
)
7384 struct thread_info
*tp
= ecs
->event_thread
;
7387 fprintf_unfiltered (gdb_stdlog
,
7388 "infrun: %s has trap_expected set, "
7389 "resuming to collect trap\n",
7390 target_pid_to_str (tp
->ptid
));
7392 /* We haven't yet gotten our trap, and either: intercepted a
7393 non-signal event (e.g., a fork); or took a signal which we
7394 are supposed to pass through to the inferior. Simply
7396 discard_cleanups (old_cleanups
);
7397 resume (ecs
->event_thread
->suspend
.stop_signal
);
7399 else if (step_over_info_valid_p ())
7401 /* Another thread is stepping over a breakpoint in-line. If
7402 this thread needs a step-over too, queue the request. In
7403 either case, this resume must be deferred for later. */
7404 struct thread_info
*tp
= ecs
->event_thread
;
7406 if (ecs
->hit_singlestep_breakpoint
7407 || thread_still_needs_step_over (tp
))
7410 fprintf_unfiltered (gdb_stdlog
,
7411 "infrun: step-over already in progress: "
7412 "step-over for %s deferred\n",
7413 target_pid_to_str (tp
->ptid
));
7414 thread_step_over_chain_enqueue (tp
);
7419 fprintf_unfiltered (gdb_stdlog
,
7420 "infrun: step-over in progress: "
7421 "resume of %s deferred\n",
7422 target_pid_to_str (tp
->ptid
));
7425 discard_cleanups (old_cleanups
);
7429 struct regcache
*regcache
= get_current_regcache ();
7432 enum step_over_what step_what
;
7434 /* Either the trap was not expected, but we are continuing
7435 anyway (if we got a signal, the user asked it be passed to
7438 We got our expected trap, but decided we should resume from
7441 We're going to run this baby now!
7443 Note that insert_breakpoints won't try to re-insert
7444 already inserted breakpoints. Therefore, we don't
7445 care if breakpoints were already inserted, or not. */
7447 /* If we need to step over a breakpoint, and we're not using
7448 displaced stepping to do so, insert all breakpoints
7449 (watchpoints, etc.) but the one we're stepping over, step one
7450 instruction, and then re-insert the breakpoint when that step
7453 step_what
= thread_still_needs_step_over (ecs
->event_thread
);
7455 remove_bp
= (ecs
->hit_singlestep_breakpoint
7456 || (step_what
& STEP_OVER_BREAKPOINT
));
7457 remove_wps
= (step_what
& STEP_OVER_WATCHPOINT
);
7459 /* We can't use displaced stepping if we need to step past a
7460 watchpoint. The instruction copied to the scratch pad would
7461 still trigger the watchpoint. */
7463 && (remove_wps
|| !use_displaced_stepping (ecs
->event_thread
)))
7465 set_step_over_info (get_regcache_aspace (regcache
),
7466 regcache_read_pc (regcache
), remove_wps
);
7468 else if (remove_wps
)
7469 set_step_over_info (NULL
, 0, remove_wps
);
7471 /* If we now need to do an in-line step-over, we need to stop
7472 all other threads. Note this must be done before
7473 insert_breakpoints below, because that removes the breakpoint
7474 we're about to step over, otherwise other threads could miss
7476 if (step_over_info_valid_p () && target_is_non_stop_p ())
7477 stop_all_threads ();
7479 /* Stop stepping if inserting breakpoints fails. */
7482 insert_breakpoints ();
7484 CATCH (e
, RETURN_MASK_ERROR
)
7486 exception_print (gdb_stderr
, e
);
7488 discard_cleanups (old_cleanups
);
7493 ecs
->event_thread
->control
.trap_expected
= (remove_bp
|| remove_wps
);
7495 discard_cleanups (old_cleanups
);
7496 resume (ecs
->event_thread
->suspend
.stop_signal
);
7499 prepare_to_wait (ecs
);
7502 /* Called when we should continue running the inferior, because the
7503 current event doesn't cause a user visible stop. This does the
7504 resuming part; waiting for the next event is done elsewhere. */
7507 keep_going (struct execution_control_state
*ecs
)
7509 if (ecs
->event_thread
->control
.trap_expected
7510 && ecs
->event_thread
->suspend
.stop_signal
== GDB_SIGNAL_TRAP
)
7511 ecs
->event_thread
->control
.trap_expected
= 0;
7513 if (!signal_program
[ecs
->event_thread
->suspend
.stop_signal
])
7514 ecs
->event_thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
7515 keep_going_pass_signal (ecs
);
7518 /* This function normally comes after a resume, before
7519 handle_inferior_event exits. It takes care of any last bits of
7520 housekeeping, and sets the all-important wait_some_more flag. */
7523 prepare_to_wait (struct execution_control_state
*ecs
)
7526 fprintf_unfiltered (gdb_stdlog
, "infrun: prepare_to_wait\n");
7528 ecs
->wait_some_more
= 1;
7530 if (!target_is_async_p ())
7531 mark_infrun_async_event_handler ();
7534 /* We are done with the step range of a step/next/si/ni command.
7535 Called once for each n of a "step n" operation. */
7538 end_stepping_range (struct execution_control_state
*ecs
)
7540 ecs
->event_thread
->control
.stop_step
= 1;
7544 /* Several print_*_reason functions to print why the inferior has stopped.
7545 We always print something when the inferior exits, or receives a signal.
7546 The rest of the cases are dealt with later on in normal_stop and
7547 print_it_typical. Ideally there should be a call to one of these
7548 print_*_reason functions functions from handle_inferior_event each time
7549 stop_waiting is called.
7551 Note that we don't call these directly, instead we delegate that to
7552 the interpreters, through observers. Interpreters then call these
7553 with whatever uiout is right. */
7556 print_end_stepping_range_reason (struct ui_out
*uiout
)
7558 /* For CLI-like interpreters, print nothing. */
7560 if (ui_out_is_mi_like_p (uiout
))
7562 ui_out_field_string (uiout
, "reason",
7563 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE
));
7568 print_signal_exited_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7570 annotate_signalled ();
7571 if (ui_out_is_mi_like_p (uiout
))
7573 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED
));
7574 ui_out_text (uiout
, "\nProgram terminated with signal ");
7575 annotate_signal_name ();
7576 ui_out_field_string (uiout
, "signal-name",
7577 gdb_signal_to_name (siggnal
));
7578 annotate_signal_name_end ();
7579 ui_out_text (uiout
, ", ");
7580 annotate_signal_string ();
7581 ui_out_field_string (uiout
, "signal-meaning",
7582 gdb_signal_to_string (siggnal
));
7583 annotate_signal_string_end ();
7584 ui_out_text (uiout
, ".\n");
7585 ui_out_text (uiout
, "The program no longer exists.\n");
7589 print_exited_reason (struct ui_out
*uiout
, int exitstatus
)
7591 struct inferior
*inf
= current_inferior ();
7592 const char *pidstr
= target_pid_to_str (pid_to_ptid (inf
->pid
));
7594 annotate_exited (exitstatus
);
7597 if (ui_out_is_mi_like_p (uiout
))
7598 ui_out_field_string (uiout
, "reason",
7599 async_reason_lookup (EXEC_ASYNC_EXITED
));
7600 ui_out_text (uiout
, "[Inferior ");
7601 ui_out_text (uiout
, plongest (inf
->num
));
7602 ui_out_text (uiout
, " (");
7603 ui_out_text (uiout
, pidstr
);
7604 ui_out_text (uiout
, ") exited with code ");
7605 ui_out_field_fmt (uiout
, "exit-code", "0%o", (unsigned int) exitstatus
);
7606 ui_out_text (uiout
, "]\n");
7610 if (ui_out_is_mi_like_p (uiout
))
7612 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY
));
7613 ui_out_text (uiout
, "[Inferior ");
7614 ui_out_text (uiout
, plongest (inf
->num
));
7615 ui_out_text (uiout
, " (");
7616 ui_out_text (uiout
, pidstr
);
7617 ui_out_text (uiout
, ") exited normally]\n");
7622 print_signal_received_reason (struct ui_out
*uiout
, enum gdb_signal siggnal
)
7626 if (siggnal
== GDB_SIGNAL_0
&& !ui_out_is_mi_like_p (uiout
))
7628 struct thread_info
*t
= inferior_thread ();
7630 ui_out_text (uiout
, "\n[");
7631 ui_out_field_string (uiout
, "thread-name",
7632 target_pid_to_str (t
->ptid
));
7633 ui_out_field_fmt (uiout
, "thread-id", "] #%d", t
->num
);
7634 ui_out_text (uiout
, " stopped");
7638 ui_out_text (uiout
, "\nProgram received signal ");
7639 annotate_signal_name ();
7640 if (ui_out_is_mi_like_p (uiout
))
7642 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED
));
7643 ui_out_field_string (uiout
, "signal-name",
7644 gdb_signal_to_name (siggnal
));
7645 annotate_signal_name_end ();
7646 ui_out_text (uiout
, ", ");
7647 annotate_signal_string ();
7648 ui_out_field_string (uiout
, "signal-meaning",
7649 gdb_signal_to_string (siggnal
));
7650 annotate_signal_string_end ();
7652 ui_out_text (uiout
, ".\n");
7656 print_no_history_reason (struct ui_out
*uiout
)
7658 ui_out_text (uiout
, "\nNo more reverse-execution history.\n");
7661 /* Print current location without a level number, if we have changed
7662 functions or hit a breakpoint. Print source line if we have one.
7663 bpstat_print contains the logic deciding in detail what to print,
7664 based on the event(s) that just occurred. */
7667 print_stop_event (struct target_waitstatus
*ws
)
7670 enum print_what source_flag
;
7671 int do_frame_printing
= 1;
7672 struct thread_info
*tp
= inferior_thread ();
7674 bpstat_ret
= bpstat_print (tp
->control
.stop_bpstat
, ws
->kind
);
7678 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
7679 should) carry around the function and does (or should) use
7680 that when doing a frame comparison. */
7681 if (tp
->control
.stop_step
7682 && frame_id_eq (tp
->control
.step_frame_id
,
7683 get_frame_id (get_current_frame ()))
7684 && tp
->control
.step_start_function
== find_pc_function (stop_pc
))
7686 /* Finished step, just print source line. */
7687 source_flag
= SRC_LINE
;
7691 /* Print location and source line. */
7692 source_flag
= SRC_AND_LOC
;
7695 case PRINT_SRC_AND_LOC
:
7696 /* Print location and source line. */
7697 source_flag
= SRC_AND_LOC
;
7699 case PRINT_SRC_ONLY
:
7700 source_flag
= SRC_LINE
;
7703 /* Something bogus. */
7704 source_flag
= SRC_LINE
;
7705 do_frame_printing
= 0;
7708 internal_error (__FILE__
, __LINE__
, _("Unknown value."));
7711 /* The behavior of this routine with respect to the source
7713 SRC_LINE: Print only source line
7714 LOCATION: Print only location
7715 SRC_AND_LOC: Print location and source line. */
7716 if (do_frame_printing
)
7717 print_stack_frame (get_selected_frame (NULL
), 0, source_flag
, 1);
7719 /* Display the auto-display expressions. */
7723 /* Here to return control to GDB when the inferior stops for real.
7724 Print appropriate messages, remove breakpoints, give terminal our modes.
7726 STOP_PRINT_FRAME nonzero means print the executing frame
7727 (pc, function, args, file, line number and line text).
7728 BREAKPOINTS_FAILED nonzero means stop was due to error
7729 attempting to insert breakpoints. */
7734 struct target_waitstatus last
;
7736 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
7739 get_last_target_status (&last_ptid
, &last
);
7741 /* If an exception is thrown from this point on, make sure to
7742 propagate GDB's knowledge of the executing state to the
7743 frontend/user running state. A QUIT is an easy exception to see
7744 here, so do this before any filtered output. */
7746 make_cleanup (finish_thread_state_cleanup
, &minus_one_ptid
);
7747 else if (last
.kind
== TARGET_WAITKIND_SIGNALLED
7748 || last
.kind
== TARGET_WAITKIND_EXITED
)
7750 /* On some targets, we may still have live threads in the
7751 inferior when we get a process exit event. E.g., for
7752 "checkpoint", when the current checkpoint/fork exits,
7753 linux-fork.c automatically switches to another fork from
7754 within target_mourn_inferior. */
7755 if (!ptid_equal (inferior_ptid
, null_ptid
))
7757 pid_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
7758 make_cleanup (finish_thread_state_cleanup
, &pid_ptid
);
7761 else if (last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
7762 make_cleanup (finish_thread_state_cleanup
, &inferior_ptid
);
7764 /* As we're presenting a stop, and potentially removing breakpoints,
7765 update the thread list so we can tell whether there are threads
7766 running on the target. With target remote, for example, we can
7767 only learn about new threads when we explicitly update the thread
7768 list. Do this before notifying the interpreters about signal
7769 stops, end of stepping ranges, etc., so that the "new thread"
7770 output is emitted before e.g., "Program received signal FOO",
7771 instead of after. */
7772 update_thread_list ();
7774 if (last
.kind
== TARGET_WAITKIND_STOPPED
&& stopped_by_random_signal
)
7775 observer_notify_signal_received (inferior_thread ()->suspend
.stop_signal
);
7777 /* As with the notification of thread events, we want to delay
7778 notifying the user that we've switched thread context until
7779 the inferior actually stops.
7781 There's no point in saying anything if the inferior has exited.
7782 Note that SIGNALLED here means "exited with a signal", not
7783 "received a signal".
7785 Also skip saying anything in non-stop mode. In that mode, as we
7786 don't want GDB to switch threads behind the user's back, to avoid
7787 races where the user is typing a command to apply to thread x,
7788 but GDB switches to thread y before the user finishes entering
7789 the command, fetch_inferior_event installs a cleanup to restore
7790 the current thread back to the thread the user had selected right
7791 after this event is handled, so we're not really switching, only
7792 informing of a stop. */
7794 && !ptid_equal (previous_inferior_ptid
, inferior_ptid
)
7795 && target_has_execution
7796 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
7797 && last
.kind
!= TARGET_WAITKIND_EXITED
7798 && last
.kind
!= TARGET_WAITKIND_NO_RESUMED
)
7800 target_terminal_ours_for_output ();
7801 printf_filtered (_("[Switching to %s]\n"),
7802 target_pid_to_str (inferior_ptid
));
7803 annotate_thread_changed ();
7804 previous_inferior_ptid
= inferior_ptid
;
7807 if (last
.kind
== TARGET_WAITKIND_NO_RESUMED
)
7809 gdb_assert (sync_execution
|| !target_can_async_p ());
7811 target_terminal_ours_for_output ();
7812 printf_filtered (_("No unwaited-for children left.\n"));
7815 /* Note: this depends on the update_thread_list call above. */
7816 if (!breakpoints_should_be_inserted_now () && target_has_execution
)
7818 if (remove_breakpoints ())
7820 target_terminal_ours_for_output ();
7821 printf_filtered (_("Cannot remove breakpoints because "
7822 "program is no longer writable.\nFurther "
7823 "execution is probably impossible.\n"));
7827 /* If an auto-display called a function and that got a signal,
7828 delete that auto-display to avoid an infinite recursion. */
7830 if (stopped_by_random_signal
)
7831 disable_current_display ();
7833 /* Notify observers if we finished a "step"-like command, etc. */
7834 if (target_has_execution
7835 && last
.kind
!= TARGET_WAITKIND_SIGNALLED
7836 && last
.kind
!= TARGET_WAITKIND_EXITED
7837 && inferior_thread ()->control
.stop_step
)
7839 /* But not if in the middle of doing a "step n" operation for
7841 if (inferior_thread ()->step_multi
)
7844 observer_notify_end_stepping_range ();
7847 target_terminal_ours ();
7848 async_enable_stdin ();
7850 /* Set the current source location. This will also happen if we
7851 display the frame below, but the current SAL will be incorrect
7852 during a user hook-stop function. */
7853 if (has_stack_frames () && !stop_stack_dummy
)
7854 set_current_sal_from_frame (get_current_frame ());
7856 /* Let the user/frontend see the threads as stopped, but defer to
7857 call_function_by_hand if the thread finished an infcall
7858 successfully. We may be e.g., evaluating a breakpoint condition.
7859 In that case, the thread had state THREAD_RUNNING before the
7860 infcall, and shall remain marked running, all without informing
7861 the user/frontend about state transition changes. */
7862 if (target_has_execution
7863 && inferior_thread ()->control
.in_infcall
7864 && stop_stack_dummy
== STOP_STACK_DUMMY
)
7865 discard_cleanups (old_chain
);
7867 do_cleanups (old_chain
);
7869 /* Look up the hook_stop and run it (CLI internally handles problem
7870 of stop_command's pre-hook not existing). */
7872 catch_errors (hook_stop_stub
, stop_command
,
7873 "Error while running hook_stop:\n", RETURN_MASK_ALL
);
7875 if (!has_stack_frames ())
7878 if (last
.kind
== TARGET_WAITKIND_SIGNALLED
7879 || last
.kind
== TARGET_WAITKIND_EXITED
)
7882 /* Select innermost stack frame - i.e., current frame is frame 0,
7883 and current location is based on that.
7884 Don't do this on return from a stack dummy routine,
7885 or if the program has exited. */
7887 if (!stop_stack_dummy
)
7889 select_frame (get_current_frame ());
7891 /* If --batch-silent is enabled then there's no need to print the current
7892 source location, and to try risks causing an error message about
7893 missing source files. */
7894 if (stop_print_frame
&& !batch_silent
)
7895 print_stop_event (&last
);
7898 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
7900 /* Pop the empty frame that contains the stack dummy.
7901 This also restores inferior state prior to the call
7902 (struct infcall_suspend_state). */
7903 struct frame_info
*frame
= get_current_frame ();
7905 gdb_assert (get_frame_type (frame
) == DUMMY_FRAME
);
7907 /* frame_pop() calls reinit_frame_cache as the last thing it
7908 does which means there's currently no selected frame. We
7909 don't need to re-establish a selected frame if the dummy call
7910 returns normally, that will be done by
7911 restore_infcall_control_state. However, we do have to handle
7912 the case where the dummy call is returning after being
7913 stopped (e.g. the dummy call previously hit a breakpoint).
7914 We can't know which case we have so just always re-establish
7915 a selected frame here. */
7916 select_frame (get_current_frame ());
7920 annotate_stopped ();
7922 /* Suppress the stop observer if we're in the middle of:
7924 - a step n (n > 1), as there still more steps to be done.
7926 - a "finish" command, as the observer will be called in
7927 finish_command_continuation, so it can include the inferior
7928 function's return value.
7930 - calling an inferior function, as we pretend we inferior didn't
7931 run at all. The return value of the call is handled by the
7932 expression evaluator, through call_function_by_hand. */
7934 if (!target_has_execution
7935 || last
.kind
== TARGET_WAITKIND_SIGNALLED
7936 || last
.kind
== TARGET_WAITKIND_EXITED
7937 || last
.kind
== TARGET_WAITKIND_NO_RESUMED
7938 || (!(inferior_thread ()->step_multi
7939 && inferior_thread ()->control
.stop_step
)
7940 && !(inferior_thread ()->control
.stop_bpstat
7941 && inferior_thread ()->control
.proceed_to_finish
)
7942 && !inferior_thread ()->control
.in_infcall
))
7944 if (!ptid_equal (inferior_ptid
, null_ptid
))
7945 observer_notify_normal_stop (inferior_thread ()->control
.stop_bpstat
,
7948 observer_notify_normal_stop (NULL
, stop_print_frame
);
7951 if (target_has_execution
)
7953 if (last
.kind
!= TARGET_WAITKIND_SIGNALLED
7954 && last
.kind
!= TARGET_WAITKIND_EXITED
)
7955 /* Delete the breakpoint we stopped at, if it wants to be deleted.
7956 Delete any breakpoint that is to be deleted at the next stop. */
7957 breakpoint_auto_delete (inferior_thread ()->control
.stop_bpstat
);
7960 /* Try to get rid of automatically added inferiors that are no
7961 longer needed. Keeping those around slows down things linearly.
7962 Note that this never removes the current inferior. */
7967 hook_stop_stub (void *cmd
)
7969 execute_cmd_pre_hook ((struct cmd_list_element
*) cmd
);
7974 signal_stop_state (int signo
)
7976 return signal_stop
[signo
];
7980 signal_print_state (int signo
)
7982 return signal_print
[signo
];
7986 signal_pass_state (int signo
)
7988 return signal_program
[signo
];
7992 signal_cache_update (int signo
)
7996 for (signo
= 0; signo
< (int) GDB_SIGNAL_LAST
; signo
++)
7997 signal_cache_update (signo
);
8002 signal_pass
[signo
] = (signal_stop
[signo
] == 0
8003 && signal_print
[signo
] == 0
8004 && signal_program
[signo
] == 1
8005 && signal_catch
[signo
] == 0);
8009 signal_stop_update (int signo
, int state
)
8011 int ret
= signal_stop
[signo
];
8013 signal_stop
[signo
] = state
;
8014 signal_cache_update (signo
);
8019 signal_print_update (int signo
, int state
)
8021 int ret
= signal_print
[signo
];
8023 signal_print
[signo
] = state
;
8024 signal_cache_update (signo
);
8029 signal_pass_update (int signo
, int state
)
8031 int ret
= signal_program
[signo
];
8033 signal_program
[signo
] = state
;
8034 signal_cache_update (signo
);
8038 /* Update the global 'signal_catch' from INFO and notify the
8042 signal_catch_update (const unsigned int *info
)
8046 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
8047 signal_catch
[i
] = info
[i
] > 0;
8048 signal_cache_update (-1);
8049 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
8053 sig_print_header (void)
8055 printf_filtered (_("Signal Stop\tPrint\tPass "
8056 "to program\tDescription\n"));
8060 sig_print_info (enum gdb_signal oursig
)
8062 const char *name
= gdb_signal_to_name (oursig
);
8063 int name_padding
= 13 - strlen (name
);
8065 if (name_padding
<= 0)
8068 printf_filtered ("%s", name
);
8069 printf_filtered ("%*.*s ", name_padding
, name_padding
, " ");
8070 printf_filtered ("%s\t", signal_stop
[oursig
] ? "Yes" : "No");
8071 printf_filtered ("%s\t", signal_print
[oursig
] ? "Yes" : "No");
8072 printf_filtered ("%s\t\t", signal_program
[oursig
] ? "Yes" : "No");
8073 printf_filtered ("%s\n", gdb_signal_to_string (oursig
));
8076 /* Specify how various signals in the inferior should be handled. */
8079 handle_command (char *args
, int from_tty
)
8082 int digits
, wordlen
;
8083 int sigfirst
, signum
, siglast
;
8084 enum gdb_signal oursig
;
8087 unsigned char *sigs
;
8088 struct cleanup
*old_chain
;
8092 error_no_arg (_("signal to handle"));
8095 /* Allocate and zero an array of flags for which signals to handle. */
8097 nsigs
= (int) GDB_SIGNAL_LAST
;
8098 sigs
= (unsigned char *) alloca (nsigs
);
8099 memset (sigs
, 0, nsigs
);
8101 /* Break the command line up into args. */
8103 argv
= gdb_buildargv (args
);
8104 old_chain
= make_cleanup_freeargv (argv
);
8106 /* Walk through the args, looking for signal oursigs, signal names, and
8107 actions. Signal numbers and signal names may be interspersed with
8108 actions, with the actions being performed for all signals cumulatively
8109 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8111 while (*argv
!= NULL
)
8113 wordlen
= strlen (*argv
);
8114 for (digits
= 0; isdigit ((*argv
)[digits
]); digits
++)
8118 sigfirst
= siglast
= -1;
8120 if (wordlen
>= 1 && !strncmp (*argv
, "all", wordlen
))
8122 /* Apply action to all signals except those used by the
8123 debugger. Silently skip those. */
8126 siglast
= nsigs
- 1;
8128 else if (wordlen
>= 1 && !strncmp (*argv
, "stop", wordlen
))
8130 SET_SIGS (nsigs
, sigs
, signal_stop
);
8131 SET_SIGS (nsigs
, sigs
, signal_print
);
8133 else if (wordlen
>= 1 && !strncmp (*argv
, "ignore", wordlen
))
8135 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8137 else if (wordlen
>= 2 && !strncmp (*argv
, "print", wordlen
))
8139 SET_SIGS (nsigs
, sigs
, signal_print
);
8141 else if (wordlen
>= 2 && !strncmp (*argv
, "pass", wordlen
))
8143 SET_SIGS (nsigs
, sigs
, signal_program
);
8145 else if (wordlen
>= 3 && !strncmp (*argv
, "nostop", wordlen
))
8147 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8149 else if (wordlen
>= 3 && !strncmp (*argv
, "noignore", wordlen
))
8151 SET_SIGS (nsigs
, sigs
, signal_program
);
8153 else if (wordlen
>= 4 && !strncmp (*argv
, "noprint", wordlen
))
8155 UNSET_SIGS (nsigs
, sigs
, signal_print
);
8156 UNSET_SIGS (nsigs
, sigs
, signal_stop
);
8158 else if (wordlen
>= 4 && !strncmp (*argv
, "nopass", wordlen
))
8160 UNSET_SIGS (nsigs
, sigs
, signal_program
);
8162 else if (digits
> 0)
8164 /* It is numeric. The numeric signal refers to our own
8165 internal signal numbering from target.h, not to host/target
8166 signal number. This is a feature; users really should be
8167 using symbolic names anyway, and the common ones like
8168 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8170 sigfirst
= siglast
= (int)
8171 gdb_signal_from_command (atoi (*argv
));
8172 if ((*argv
)[digits
] == '-')
8175 gdb_signal_from_command (atoi ((*argv
) + digits
+ 1));
8177 if (sigfirst
> siglast
)
8179 /* Bet he didn't figure we'd think of this case... */
8187 oursig
= gdb_signal_from_name (*argv
);
8188 if (oursig
!= GDB_SIGNAL_UNKNOWN
)
8190 sigfirst
= siglast
= (int) oursig
;
8194 /* Not a number and not a recognized flag word => complain. */
8195 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv
);
8199 /* If any signal numbers or symbol names were found, set flags for
8200 which signals to apply actions to. */
8202 for (signum
= sigfirst
; signum
>= 0 && signum
<= siglast
; signum
++)
8204 switch ((enum gdb_signal
) signum
)
8206 case GDB_SIGNAL_TRAP
:
8207 case GDB_SIGNAL_INT
:
8208 if (!allsigs
&& !sigs
[signum
])
8210 if (query (_("%s is used by the debugger.\n\
8211 Are you sure you want to change it? "),
8212 gdb_signal_to_name ((enum gdb_signal
) signum
)))
8218 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8219 gdb_flush (gdb_stdout
);
8224 case GDB_SIGNAL_DEFAULT
:
8225 case GDB_SIGNAL_UNKNOWN
:
8226 /* Make sure that "all" doesn't print these. */
8237 for (signum
= 0; signum
< nsigs
; signum
++)
8240 signal_cache_update (-1);
8241 target_pass_signals ((int) GDB_SIGNAL_LAST
, signal_pass
);
8242 target_program_signals ((int) GDB_SIGNAL_LAST
, signal_program
);
8246 /* Show the results. */
8247 sig_print_header ();
8248 for (; signum
< nsigs
; signum
++)
8250 sig_print_info ((enum gdb_signal
) signum
);
8256 do_cleanups (old_chain
);
8259 /* Complete the "handle" command. */
8261 static VEC (char_ptr
) *
8262 handle_completer (struct cmd_list_element
*ignore
,
8263 const char *text
, const char *word
)
8265 VEC (char_ptr
) *vec_signals
, *vec_keywords
, *return_val
;
8266 static const char * const keywords
[] =
8280 vec_signals
= signal_completer (ignore
, text
, word
);
8281 vec_keywords
= complete_on_enum (keywords
, word
, word
);
8283 return_val
= VEC_merge (char_ptr
, vec_signals
, vec_keywords
);
8284 VEC_free (char_ptr
, vec_signals
);
8285 VEC_free (char_ptr
, vec_keywords
);
8290 gdb_signal_from_command (int num
)
8292 if (num
>= 1 && num
<= 15)
8293 return (enum gdb_signal
) num
;
8294 error (_("Only signals 1-15 are valid as numeric signals.\n\
8295 Use \"info signals\" for a list of symbolic signals."));
8298 /* Print current contents of the tables set by the handle command.
8299 It is possible we should just be printing signals actually used
8300 by the current target (but for things to work right when switching
8301 targets, all signals should be in the signal tables). */
8304 signals_info (char *signum_exp
, int from_tty
)
8306 enum gdb_signal oursig
;
8308 sig_print_header ();
8312 /* First see if this is a symbol name. */
8313 oursig
= gdb_signal_from_name (signum_exp
);
8314 if (oursig
== GDB_SIGNAL_UNKNOWN
)
8316 /* No, try numeric. */
8318 gdb_signal_from_command (parse_and_eval_long (signum_exp
));
8320 sig_print_info (oursig
);
8324 printf_filtered ("\n");
8325 /* These ugly casts brought to you by the native VAX compiler. */
8326 for (oursig
= GDB_SIGNAL_FIRST
;
8327 (int) oursig
< (int) GDB_SIGNAL_LAST
;
8328 oursig
= (enum gdb_signal
) ((int) oursig
+ 1))
8332 if (oursig
!= GDB_SIGNAL_UNKNOWN
8333 && oursig
!= GDB_SIGNAL_DEFAULT
&& oursig
!= GDB_SIGNAL_0
)
8334 sig_print_info (oursig
);
8337 printf_filtered (_("\nUse the \"handle\" command "
8338 "to change these tables.\n"));
8341 /* Check if it makes sense to read $_siginfo from the current thread
8342 at this point. If not, throw an error. */
8345 validate_siginfo_access (void)
8347 /* No current inferior, no siginfo. */
8348 if (ptid_equal (inferior_ptid
, null_ptid
))
8349 error (_("No thread selected."));
8351 /* Don't try to read from a dead thread. */
8352 if (is_exited (inferior_ptid
))
8353 error (_("The current thread has terminated"));
8355 /* ... or from a spinning thread. */
8356 if (is_running (inferior_ptid
))
8357 error (_("Selected thread is running."));
8360 /* The $_siginfo convenience variable is a bit special. We don't know
8361 for sure the type of the value until we actually have a chance to
8362 fetch the data. The type can change depending on gdbarch, so it is
8363 also dependent on which thread you have selected.
8365 1. making $_siginfo be an internalvar that creates a new value on
8368 2. making the value of $_siginfo be an lval_computed value. */
8370 /* This function implements the lval_computed support for reading a
8374 siginfo_value_read (struct value
*v
)
8376 LONGEST transferred
;
8378 validate_siginfo_access ();
8381 target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
,
8383 value_contents_all_raw (v
),
8385 TYPE_LENGTH (value_type (v
)));
8387 if (transferred
!= TYPE_LENGTH (value_type (v
)))
8388 error (_("Unable to read siginfo"));
8391 /* This function implements the lval_computed support for writing a
8395 siginfo_value_write (struct value
*v
, struct value
*fromval
)
8397 LONGEST transferred
;
8399 validate_siginfo_access ();
8401 transferred
= target_write (¤t_target
,
8402 TARGET_OBJECT_SIGNAL_INFO
,
8404 value_contents_all_raw (fromval
),
8406 TYPE_LENGTH (value_type (fromval
)));
8408 if (transferred
!= TYPE_LENGTH (value_type (fromval
)))
8409 error (_("Unable to write siginfo"));
8412 static const struct lval_funcs siginfo_value_funcs
=
8418 /* Return a new value with the correct type for the siginfo object of
8419 the current thread using architecture GDBARCH. Return a void value
8420 if there's no object available. */
8422 static struct value
*
8423 siginfo_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
8426 if (target_has_stack
8427 && !ptid_equal (inferior_ptid
, null_ptid
)
8428 && gdbarch_get_siginfo_type_p (gdbarch
))
8430 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8432 return allocate_computed_value (type
, &siginfo_value_funcs
, NULL
);
8435 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
8439 /* infcall_suspend_state contains state about the program itself like its
8440 registers and any signal it received when it last stopped.
8441 This state must be restored regardless of how the inferior function call
8442 ends (either successfully, or after it hits a breakpoint or signal)
8443 if the program is to properly continue where it left off. */
8445 struct infcall_suspend_state
8447 struct thread_suspend_state thread_suspend
;
8451 struct regcache
*registers
;
8453 /* Format of SIGINFO_DATA or NULL if it is not present. */
8454 struct gdbarch
*siginfo_gdbarch
;
8456 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8457 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8458 content would be invalid. */
8459 gdb_byte
*siginfo_data
;
8462 struct infcall_suspend_state
*
8463 save_infcall_suspend_state (void)
8465 struct infcall_suspend_state
*inf_state
;
8466 struct thread_info
*tp
= inferior_thread ();
8467 struct regcache
*regcache
= get_current_regcache ();
8468 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
8469 gdb_byte
*siginfo_data
= NULL
;
8471 if (gdbarch_get_siginfo_type_p (gdbarch
))
8473 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8474 size_t len
= TYPE_LENGTH (type
);
8475 struct cleanup
*back_to
;
8477 siginfo_data
= xmalloc (len
);
8478 back_to
= make_cleanup (xfree
, siginfo_data
);
8480 if (target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8481 siginfo_data
, 0, len
) == len
)
8482 discard_cleanups (back_to
);
8485 /* Errors ignored. */
8486 do_cleanups (back_to
);
8487 siginfo_data
= NULL
;
8491 inf_state
= XCNEW (struct infcall_suspend_state
);
8495 inf_state
->siginfo_gdbarch
= gdbarch
;
8496 inf_state
->siginfo_data
= siginfo_data
;
8499 inf_state
->thread_suspend
= tp
->suspend
;
8501 /* run_inferior_call will not use the signal due to its `proceed' call with
8502 GDB_SIGNAL_0 anyway. */
8503 tp
->suspend
.stop_signal
= GDB_SIGNAL_0
;
8505 inf_state
->stop_pc
= stop_pc
;
8507 inf_state
->registers
= regcache_dup (regcache
);
8512 /* Restore inferior session state to INF_STATE. */
8515 restore_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8517 struct thread_info
*tp
= inferior_thread ();
8518 struct regcache
*regcache
= get_current_regcache ();
8519 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
8521 tp
->suspend
= inf_state
->thread_suspend
;
8523 stop_pc
= inf_state
->stop_pc
;
8525 if (inf_state
->siginfo_gdbarch
== gdbarch
)
8527 struct type
*type
= gdbarch_get_siginfo_type (gdbarch
);
8529 /* Errors ignored. */
8530 target_write (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
8531 inf_state
->siginfo_data
, 0, TYPE_LENGTH (type
));
8534 /* The inferior can be gone if the user types "print exit(0)"
8535 (and perhaps other times). */
8536 if (target_has_execution
)
8537 /* NB: The register write goes through to the target. */
8538 regcache_cpy (regcache
, inf_state
->registers
);
8540 discard_infcall_suspend_state (inf_state
);
8544 do_restore_infcall_suspend_state_cleanup (void *state
)
8546 restore_infcall_suspend_state (state
);
8550 make_cleanup_restore_infcall_suspend_state
8551 (struct infcall_suspend_state
*inf_state
)
8553 return make_cleanup (do_restore_infcall_suspend_state_cleanup
, inf_state
);
8557 discard_infcall_suspend_state (struct infcall_suspend_state
*inf_state
)
8559 regcache_xfree (inf_state
->registers
);
8560 xfree (inf_state
->siginfo_data
);
8565 get_infcall_suspend_state_regcache (struct infcall_suspend_state
*inf_state
)
8567 return inf_state
->registers
;
8570 /* infcall_control_state contains state regarding gdb's control of the
8571 inferior itself like stepping control. It also contains session state like
8572 the user's currently selected frame. */
8574 struct infcall_control_state
8576 struct thread_control_state thread_control
;
8577 struct inferior_control_state inferior_control
;
8580 enum stop_stack_kind stop_stack_dummy
;
8581 int stopped_by_random_signal
;
8582 int stop_after_trap
;
8584 /* ID if the selected frame when the inferior function call was made. */
8585 struct frame_id selected_frame_id
;
8588 /* Save all of the information associated with the inferior<==>gdb
8591 struct infcall_control_state
*
8592 save_infcall_control_state (void)
8594 struct infcall_control_state
*inf_status
=
8595 XNEW (struct infcall_control_state
);
8596 struct thread_info
*tp
= inferior_thread ();
8597 struct inferior
*inf
= current_inferior ();
8599 inf_status
->thread_control
= tp
->control
;
8600 inf_status
->inferior_control
= inf
->control
;
8602 tp
->control
.step_resume_breakpoint
= NULL
;
8603 tp
->control
.exception_resume_breakpoint
= NULL
;
8605 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8606 chain. If caller's caller is walking the chain, they'll be happier if we
8607 hand them back the original chain when restore_infcall_control_state is
8609 tp
->control
.stop_bpstat
= bpstat_copy (tp
->control
.stop_bpstat
);
8612 inf_status
->stop_stack_dummy
= stop_stack_dummy
;
8613 inf_status
->stopped_by_random_signal
= stopped_by_random_signal
;
8614 inf_status
->stop_after_trap
= stop_after_trap
;
8616 inf_status
->selected_frame_id
= get_frame_id (get_selected_frame (NULL
));
8622 restore_selected_frame (void *args
)
8624 struct frame_id
*fid
= (struct frame_id
*) args
;
8625 struct frame_info
*frame
;
8627 frame
= frame_find_by_id (*fid
);
8629 /* If inf_status->selected_frame_id is NULL, there was no previously
8633 warning (_("Unable to restore previously selected frame."));
8637 select_frame (frame
);
8642 /* Restore inferior session state to INF_STATUS. */
8645 restore_infcall_control_state (struct infcall_control_state
*inf_status
)
8647 struct thread_info
*tp
= inferior_thread ();
8648 struct inferior
*inf
= current_inferior ();
8650 if (tp
->control
.step_resume_breakpoint
)
8651 tp
->control
.step_resume_breakpoint
->disposition
= disp_del_at_next_stop
;
8653 if (tp
->control
.exception_resume_breakpoint
)
8654 tp
->control
.exception_resume_breakpoint
->disposition
8655 = disp_del_at_next_stop
;
8657 /* Handle the bpstat_copy of the chain. */
8658 bpstat_clear (&tp
->control
.stop_bpstat
);
8660 tp
->control
= inf_status
->thread_control
;
8661 inf
->control
= inf_status
->inferior_control
;
8664 stop_stack_dummy
= inf_status
->stop_stack_dummy
;
8665 stopped_by_random_signal
= inf_status
->stopped_by_random_signal
;
8666 stop_after_trap
= inf_status
->stop_after_trap
;
8668 if (target_has_stack
)
8670 /* The point of catch_errors is that if the stack is clobbered,
8671 walking the stack might encounter a garbage pointer and
8672 error() trying to dereference it. */
8674 (restore_selected_frame
, &inf_status
->selected_frame_id
,
8675 "Unable to restore previously selected frame:\n",
8676 RETURN_MASK_ERROR
) == 0)
8677 /* Error in restoring the selected frame. Select the innermost
8679 select_frame (get_current_frame ());
8686 do_restore_infcall_control_state_cleanup (void *sts
)
8688 restore_infcall_control_state (sts
);
8692 make_cleanup_restore_infcall_control_state
8693 (struct infcall_control_state
*inf_status
)
8695 return make_cleanup (do_restore_infcall_control_state_cleanup
, inf_status
);
8699 discard_infcall_control_state (struct infcall_control_state
*inf_status
)
8701 if (inf_status
->thread_control
.step_resume_breakpoint
)
8702 inf_status
->thread_control
.step_resume_breakpoint
->disposition
8703 = disp_del_at_next_stop
;
8705 if (inf_status
->thread_control
.exception_resume_breakpoint
)
8706 inf_status
->thread_control
.exception_resume_breakpoint
->disposition
8707 = disp_del_at_next_stop
;
8709 /* See save_infcall_control_state for info on stop_bpstat. */
8710 bpstat_clear (&inf_status
->thread_control
.stop_bpstat
);
8715 /* restore_inferior_ptid() will be used by the cleanup machinery
8716 to restore the inferior_ptid value saved in a call to
8717 save_inferior_ptid(). */
8720 restore_inferior_ptid (void *arg
)
8722 ptid_t
*saved_ptid_ptr
= arg
;
8724 inferior_ptid
= *saved_ptid_ptr
;
8728 /* Save the value of inferior_ptid so that it may be restored by a
8729 later call to do_cleanups(). Returns the struct cleanup pointer
8730 needed for later doing the cleanup. */
8733 save_inferior_ptid (void)
8735 ptid_t
*saved_ptid_ptr
= XNEW (ptid_t
);
8737 *saved_ptid_ptr
= inferior_ptid
;
8738 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
8744 clear_exit_convenience_vars (void)
8746 clear_internalvar (lookup_internalvar ("_exitsignal"));
8747 clear_internalvar (lookup_internalvar ("_exitcode"));
8751 /* User interface for reverse debugging:
8752 Set exec-direction / show exec-direction commands
8753 (returns error unless target implements to_set_exec_direction method). */
8755 int execution_direction
= EXEC_FORWARD
;
8756 static const char exec_forward
[] = "forward";
8757 static const char exec_reverse
[] = "reverse";
8758 static const char *exec_direction
= exec_forward
;
8759 static const char *const exec_direction_names
[] = {
8766 set_exec_direction_func (char *args
, int from_tty
,
8767 struct cmd_list_element
*cmd
)
8769 if (target_can_execute_reverse
)
8771 if (!strcmp (exec_direction
, exec_forward
))
8772 execution_direction
= EXEC_FORWARD
;
8773 else if (!strcmp (exec_direction
, exec_reverse
))
8774 execution_direction
= EXEC_REVERSE
;
8778 exec_direction
= exec_forward
;
8779 error (_("Target does not support this operation."));
8784 show_exec_direction_func (struct ui_file
*out
, int from_tty
,
8785 struct cmd_list_element
*cmd
, const char *value
)
8787 switch (execution_direction
) {
8789 fprintf_filtered (out
, _("Forward.\n"));
8792 fprintf_filtered (out
, _("Reverse.\n"));
8795 internal_error (__FILE__
, __LINE__
,
8796 _("bogus execution_direction value: %d"),
8797 (int) execution_direction
);
8802 show_schedule_multiple (struct ui_file
*file
, int from_tty
,
8803 struct cmd_list_element
*c
, const char *value
)
8805 fprintf_filtered (file
, _("Resuming the execution of threads "
8806 "of all processes is %s.\n"), value
);
8809 /* Implementation of `siginfo' variable. */
8811 static const struct internalvar_funcs siginfo_funcs
=
8818 /* Callback for infrun's target events source. This is marked when a
8819 thread has a pending status to process. */
8822 infrun_async_inferior_event_handler (gdb_client_data data
)
8824 inferior_event_handler (INF_REG_EVENT
, NULL
);
8828 _initialize_infrun (void)
8832 struct cmd_list_element
*c
;
8834 /* Register extra event sources in the event loop. */
8835 infrun_async_inferior_event_token
8836 = create_async_event_handler (infrun_async_inferior_event_handler
, NULL
);
8838 add_info ("signals", signals_info
, _("\
8839 What debugger does when program gets various signals.\n\
8840 Specify a signal as argument to print info on that signal only."));
8841 add_info_alias ("handle", "signals", 0);
8843 c
= add_com ("handle", class_run
, handle_command
, _("\
8844 Specify how to handle signals.\n\
8845 Usage: handle SIGNAL [ACTIONS]\n\
8846 Args are signals and actions to apply to those signals.\n\
8847 If no actions are specified, the current settings for the specified signals\n\
8848 will be displayed instead.\n\
8850 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
8851 from 1-15 are allowed for compatibility with old versions of GDB.\n\
8852 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
8853 The special arg \"all\" is recognized to mean all signals except those\n\
8854 used by the debugger, typically SIGTRAP and SIGINT.\n\
8856 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
8857 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
8858 Stop means reenter debugger if this signal happens (implies print).\n\
8859 Print means print a message if this signal happens.\n\
8860 Pass means let program see this signal; otherwise program doesn't know.\n\
8861 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
8862 Pass and Stop may be combined.\n\
8864 Multiple signals may be specified. Signal numbers and signal names\n\
8865 may be interspersed with actions, with the actions being performed for\n\
8866 all signals cumulatively specified."));
8867 set_cmd_completer (c
, handle_completer
);
8870 stop_command
= add_cmd ("stop", class_obscure
,
8871 not_just_help_class_command
, _("\
8872 There is no `stop' command, but you can set a hook on `stop'.\n\
8873 This allows you to set a list of commands to be run each time execution\n\
8874 of the program stops."), &cmdlist
);
8876 add_setshow_zuinteger_cmd ("infrun", class_maintenance
, &debug_infrun
, _("\
8877 Set inferior debugging."), _("\
8878 Show inferior debugging."), _("\
8879 When non-zero, inferior specific debugging is enabled."),
8882 &setdebuglist
, &showdebuglist
);
8884 add_setshow_boolean_cmd ("displaced", class_maintenance
,
8885 &debug_displaced
, _("\
8886 Set displaced stepping debugging."), _("\
8887 Show displaced stepping debugging."), _("\
8888 When non-zero, displaced stepping specific debugging is enabled."),
8890 show_debug_displaced
,
8891 &setdebuglist
, &showdebuglist
);
8893 add_setshow_boolean_cmd ("non-stop", no_class
,
8895 Set whether gdb controls the inferior in non-stop mode."), _("\
8896 Show whether gdb controls the inferior in non-stop mode."), _("\
8897 When debugging a multi-threaded program and this setting is\n\
8898 off (the default, also called all-stop mode), when one thread stops\n\
8899 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
8900 all other threads in the program while you interact with the thread of\n\
8901 interest. When you continue or step a thread, you can allow the other\n\
8902 threads to run, or have them remain stopped, but while you inspect any\n\
8903 thread's state, all threads stop.\n\
8905 In non-stop mode, when one thread stops, other threads can continue\n\
8906 to run freely. You'll be able to step each thread independently,\n\
8907 leave it stopped or free to run as needed."),
8913 numsigs
= (int) GDB_SIGNAL_LAST
;
8914 signal_stop
= XNEWVEC (unsigned char, numsigs
);
8915 signal_print
= XNEWVEC (unsigned char, numsigs
);
8916 signal_program
= XNEWVEC (unsigned char, numsigs
);
8917 signal_catch
= XNEWVEC (unsigned char, numsigs
);
8918 signal_pass
= XNEWVEC (unsigned char, numsigs
);
8919 for (i
= 0; i
< numsigs
; i
++)
8922 signal_print
[i
] = 1;
8923 signal_program
[i
] = 1;
8924 signal_catch
[i
] = 0;
8927 /* Signals caused by debugger's own actions should not be given to
8928 the program afterwards.
8930 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
8931 explicitly specifies that it should be delivered to the target
8932 program. Typically, that would occur when a user is debugging a
8933 target monitor on a simulator: the target monitor sets a
8934 breakpoint; the simulator encounters this breakpoint and halts
8935 the simulation handing control to GDB; GDB, noting that the stop
8936 address doesn't map to any known breakpoint, returns control back
8937 to the simulator; the simulator then delivers the hardware
8938 equivalent of a GDB_SIGNAL_TRAP to the program being
8940 signal_program
[GDB_SIGNAL_TRAP
] = 0;
8941 signal_program
[GDB_SIGNAL_INT
] = 0;
8943 /* Signals that are not errors should not normally enter the debugger. */
8944 signal_stop
[GDB_SIGNAL_ALRM
] = 0;
8945 signal_print
[GDB_SIGNAL_ALRM
] = 0;
8946 signal_stop
[GDB_SIGNAL_VTALRM
] = 0;
8947 signal_print
[GDB_SIGNAL_VTALRM
] = 0;
8948 signal_stop
[GDB_SIGNAL_PROF
] = 0;
8949 signal_print
[GDB_SIGNAL_PROF
] = 0;
8950 signal_stop
[GDB_SIGNAL_CHLD
] = 0;
8951 signal_print
[GDB_SIGNAL_CHLD
] = 0;
8952 signal_stop
[GDB_SIGNAL_IO
] = 0;
8953 signal_print
[GDB_SIGNAL_IO
] = 0;
8954 signal_stop
[GDB_SIGNAL_POLL
] = 0;
8955 signal_print
[GDB_SIGNAL_POLL
] = 0;
8956 signal_stop
[GDB_SIGNAL_URG
] = 0;
8957 signal_print
[GDB_SIGNAL_URG
] = 0;
8958 signal_stop
[GDB_SIGNAL_WINCH
] = 0;
8959 signal_print
[GDB_SIGNAL_WINCH
] = 0;
8960 signal_stop
[GDB_SIGNAL_PRIO
] = 0;
8961 signal_print
[GDB_SIGNAL_PRIO
] = 0;
8963 /* These signals are used internally by user-level thread
8964 implementations. (See signal(5) on Solaris.) Like the above
8965 signals, a healthy program receives and handles them as part of
8966 its normal operation. */
8967 signal_stop
[GDB_SIGNAL_LWP
] = 0;
8968 signal_print
[GDB_SIGNAL_LWP
] = 0;
8969 signal_stop
[GDB_SIGNAL_WAITING
] = 0;
8970 signal_print
[GDB_SIGNAL_WAITING
] = 0;
8971 signal_stop
[GDB_SIGNAL_CANCEL
] = 0;
8972 signal_print
[GDB_SIGNAL_CANCEL
] = 0;
8974 /* Update cached state. */
8975 signal_cache_update (-1);
8977 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support
,
8978 &stop_on_solib_events
, _("\
8979 Set stopping for shared library events."), _("\
8980 Show stopping for shared library events."), _("\
8981 If nonzero, gdb will give control to the user when the dynamic linker\n\
8982 notifies gdb of shared library events. The most common event of interest\n\
8983 to the user would be loading/unloading of a new library."),
8984 set_stop_on_solib_events
,
8985 show_stop_on_solib_events
,
8986 &setlist
, &showlist
);
8988 add_setshow_enum_cmd ("follow-fork-mode", class_run
,
8989 follow_fork_mode_kind_names
,
8990 &follow_fork_mode_string
, _("\
8991 Set debugger response to a program call of fork or vfork."), _("\
8992 Show debugger response to a program call of fork or vfork."), _("\
8993 A fork or vfork creates a new process. follow-fork-mode can be:\n\
8994 parent - the original process is debugged after a fork\n\
8995 child - the new process is debugged after a fork\n\
8996 The unfollowed process will continue to run.\n\
8997 By default, the debugger will follow the parent process."),
8999 show_follow_fork_mode_string
,
9000 &setlist
, &showlist
);
9002 add_setshow_enum_cmd ("follow-exec-mode", class_run
,
9003 follow_exec_mode_names
,
9004 &follow_exec_mode_string
, _("\
9005 Set debugger response to a program call of exec."), _("\
9006 Show debugger response to a program call of exec."), _("\
9007 An exec call replaces the program image of a process.\n\
9009 follow-exec-mode can be:\n\
9011 new - the debugger creates a new inferior and rebinds the process\n\
9012 to this new inferior. The program the process was running before\n\
9013 the exec call can be restarted afterwards by restarting the original\n\
9016 same - the debugger keeps the process bound to the same inferior.\n\
9017 The new executable image replaces the previous executable loaded in\n\
9018 the inferior. Restarting the inferior after the exec call restarts\n\
9019 the executable the process was running after the exec call.\n\
9021 By default, the debugger will use the same inferior."),
9023 show_follow_exec_mode_string
,
9024 &setlist
, &showlist
);
9026 add_setshow_enum_cmd ("scheduler-locking", class_run
,
9027 scheduler_enums
, &scheduler_mode
, _("\
9028 Set mode for locking scheduler during execution."), _("\
9029 Show mode for locking scheduler during execution."), _("\
9030 off == no locking (threads may preempt at any time)\n\
9031 on == full locking (no thread except the current thread may run)\n\
9032 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9033 In this mode, other threads may run during other commands."),
9034 set_schedlock_func
, /* traps on target vector */
9035 show_scheduler_mode
,
9036 &setlist
, &showlist
);
9038 add_setshow_boolean_cmd ("schedule-multiple", class_run
, &sched_multi
, _("\
9039 Set mode for resuming threads of all processes."), _("\
9040 Show mode for resuming threads of all processes."), _("\
9041 When on, execution commands (such as 'continue' or 'next') resume all\n\
9042 threads of all processes. When off (which is the default), execution\n\
9043 commands only resume the threads of the current process. The set of\n\
9044 threads that are resumed is further refined by the scheduler-locking\n\
9045 mode (see help set scheduler-locking)."),
9047 show_schedule_multiple
,
9048 &setlist
, &showlist
);
9050 add_setshow_boolean_cmd ("step-mode", class_run
, &step_stop_if_no_debug
, _("\
9051 Set mode of the step operation."), _("\
9052 Show mode of the step operation."), _("\
9053 When set, doing a step over a function without debug line information\n\
9054 will stop at the first instruction of that function. Otherwise, the\n\
9055 function is skipped and the step command stops at a different source line."),
9057 show_step_stop_if_no_debug
,
9058 &setlist
, &showlist
);
9060 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run
,
9061 &can_use_displaced_stepping
, _("\
9062 Set debugger's willingness to use displaced stepping."), _("\
9063 Show debugger's willingness to use displaced stepping."), _("\
9064 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9065 supported by the target architecture. If off, gdb will not use displaced\n\
9066 stepping to step over breakpoints, even if such is supported by the target\n\
9067 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9068 if the target architecture supports it and non-stop mode is active, but will not\n\
9069 use it in all-stop mode (see help set non-stop)."),
9071 show_can_use_displaced_stepping
,
9072 &setlist
, &showlist
);
9074 add_setshow_enum_cmd ("exec-direction", class_run
, exec_direction_names
,
9075 &exec_direction
, _("Set direction of execution.\n\
9076 Options are 'forward' or 'reverse'."),
9077 _("Show direction of execution (forward/reverse)."),
9078 _("Tells gdb whether to execute forward or backward."),
9079 set_exec_direction_func
, show_exec_direction_func
,
9080 &setlist
, &showlist
);
9082 /* Set/show detach-on-fork: user-settable mode. */
9084 add_setshow_boolean_cmd ("detach-on-fork", class_run
, &detach_fork
, _("\
9085 Set whether gdb will detach the child of a fork."), _("\
9086 Show whether gdb will detach the child of a fork."), _("\
9087 Tells gdb whether to detach the child of a fork."),
9088 NULL
, NULL
, &setlist
, &showlist
);
9090 /* Set/show disable address space randomization mode. */
9092 add_setshow_boolean_cmd ("disable-randomization", class_support
,
9093 &disable_randomization
, _("\
9094 Set disabling of debuggee's virtual address space randomization."), _("\
9095 Show disabling of debuggee's virtual address space randomization."), _("\
9096 When this mode is on (which is the default), randomization of the virtual\n\
9097 address space is disabled. Standalone programs run with the randomization\n\
9098 enabled by default on some platforms."),
9099 &set_disable_randomization
,
9100 &show_disable_randomization
,
9101 &setlist
, &showlist
);
9103 /* ptid initializations */
9104 inferior_ptid
= null_ptid
;
9105 target_last_wait_ptid
= minus_one_ptid
;
9107 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed
);
9108 observer_attach_thread_stop_requested (infrun_thread_stop_requested
);
9109 observer_attach_thread_exit (infrun_thread_thread_exit
);
9110 observer_attach_inferior_exit (infrun_inferior_exit
);
9112 /* Explicitly create without lookup, since that tries to create a
9113 value with a void typed value, and when we get here, gdbarch
9114 isn't initialized yet. At this point, we're quite sure there
9115 isn't another convenience variable of the same name. */
9116 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs
, NULL
);
9118 add_setshow_boolean_cmd ("observer", no_class
,
9119 &observer_mode_1
, _("\
9120 Set whether gdb controls the inferior in observer mode."), _("\
9121 Show whether gdb controls the inferior in observer mode."), _("\
9122 In observer mode, GDB can get data from the inferior, but not\n\
9123 affect its execution. Registers and memory may not be changed,\n\
9124 breakpoints may not be set, and the program cannot be interrupted\n\