Improve "'g' reply is is to long" error message
[deliverable/binutils-gdb.git] / gdb / infrun.c
CommitLineData
ca557f44
AC
1/* Target-struct-independent code to start (run) and stop an inferior
2 process.
8926118c 3
61baf725 4 Copyright (C) 1986-2017 Free Software Foundation, Inc.
c906108c 5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM
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
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
c5aa993b 11 (at your option) any later version.
c906108c 12
c5aa993b
JM
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.
c906108c 17
c5aa993b 18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
20
21#include "defs.h"
45741a9c 22#include "infrun.h"
c906108c
SS
23#include <ctype.h>
24#include "symtab.h"
25#include "frame.h"
26#include "inferior.h"
27#include "breakpoint.h"
03f2053f 28#include "gdb_wait.h"
c906108c
SS
29#include "gdbcore.h"
30#include "gdbcmd.h"
210661e7 31#include "cli/cli-script.h"
c906108c
SS
32#include "target.h"
33#include "gdbthread.h"
34#include "annotate.h"
1adeb98a 35#include "symfile.h"
7a292a7a 36#include "top.h"
c906108c 37#include <signal.h>
2acceee2 38#include "inf-loop.h"
4e052eda 39#include "regcache.h"
fd0407d6 40#include "value.h"
06600e06 41#include "observer.h"
f636b87d 42#include "language.h"
a77053c2 43#include "solib.h"
f17517ea 44#include "main.h"
186c406b
TT
45#include "dictionary.h"
46#include "block.h"
034dad6f 47#include "mi/mi-common.h"
4f8d22e3 48#include "event-top.h"
96429cc8 49#include "record.h"
d02ed0bb 50#include "record-full.h"
edb3359d 51#include "inline-frame.h"
4efc6507 52#include "jit.h"
06cd862c 53#include "tracepoint.h"
be34f849 54#include "continuations.h"
b4a14fd0 55#include "interps.h"
1bfeeb0f 56#include "skip.h"
28106bc2
SDJ
57#include "probe.h"
58#include "objfiles.h"
de0bea00 59#include "completer.h"
9107fc8d 60#include "target-descriptions.h"
f15cb84a 61#include "target-dcache.h"
d83ad864 62#include "terminal.h"
ff862be4 63#include "solist.h"
372316f1 64#include "event-loop.h"
243a9253 65#include "thread-fsm.h"
8d297bbf 66#include "common/enum-flags.h"
5ed8105e
PA
67#include "progspace-and-thread.h"
68#include "common/gdb_optional.h"
46a62268 69#include "arch-utils.h"
c906108c
SS
70
71/* Prototypes for local functions */
72
11db9430 73static void info_signals_command (char *, int);
c906108c 74
96baa820 75static void handle_command (char *, int);
c906108c 76
2ea28649 77static void sig_print_info (enum gdb_signal);
c906108c 78
96baa820 79static void sig_print_header (void);
c906108c 80
74b7792f 81static void resume_cleanups (void *);
c906108c 82
96baa820 83static int hook_stop_stub (void *);
c906108c 84
96baa820
JM
85static int restore_selected_frame (void *);
86
4ef3f3be 87static int follow_fork (void);
96baa820 88
d83ad864
DB
89static int follow_fork_inferior (int follow_child, int detach_fork);
90
91static void follow_inferior_reset_breakpoints (void);
92
96baa820 93static void set_schedlock_func (char *args, int from_tty,
488f131b 94 struct cmd_list_element *c);
96baa820 95
a289b8f6
JK
96static int currently_stepping (struct thread_info *tp);
97
96baa820 98void _initialize_infrun (void);
43ff13b4 99
e58b0e63
PA
100void nullify_last_target_wait_ptid (void);
101
2c03e5be 102static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
2484c66b
UW
103
104static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
105
2484c66b
UW
106static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
107
8550d3b3
YQ
108static int maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc);
109
372316f1
PA
110/* Asynchronous signal handler registered as event loop source for
111 when we have pending events ready to be passed to the core. */
112static struct async_event_handler *infrun_async_inferior_event_token;
113
114/* Stores whether infrun_async was previously enabled or disabled.
115 Starts off as -1, indicating "never enabled/disabled". */
116static int infrun_is_async = -1;
117
118/* See infrun.h. */
119
120void
121infrun_async (int enable)
122{
123 if (infrun_is_async != enable)
124 {
125 infrun_is_async = enable;
126
127 if (debug_infrun)
128 fprintf_unfiltered (gdb_stdlog,
129 "infrun: infrun_async(%d)\n",
130 enable);
131
132 if (enable)
133 mark_async_event_handler (infrun_async_inferior_event_token);
134 else
135 clear_async_event_handler (infrun_async_inferior_event_token);
136 }
137}
138
0b333c5e
PA
139/* See infrun.h. */
140
141void
142mark_infrun_async_event_handler (void)
143{
144 mark_async_event_handler (infrun_async_inferior_event_token);
145}
146
5fbbeb29
CF
147/* When set, stop the 'step' command if we enter a function which has
148 no line number information. The normal behavior is that we step
149 over such function. */
150int step_stop_if_no_debug = 0;
920d2a44
AC
151static void
152show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
153 struct cmd_list_element *c, const char *value)
154{
155 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
156}
5fbbeb29 157
b9f437de
PA
158/* proceed and normal_stop use this to notify the user when the
159 inferior stopped in a different thread than it had been running
160 in. */
96baa820 161
39f77062 162static ptid_t previous_inferior_ptid;
7a292a7a 163
07107ca6
LM
164/* If set (default for legacy reasons), when following a fork, GDB
165 will detach from one of the fork branches, child or parent.
166 Exactly which branch is detached depends on 'set follow-fork-mode'
167 setting. */
168
169static int detach_fork = 1;
6c95b8df 170
237fc4c9
PA
171int debug_displaced = 0;
172static void
173show_debug_displaced (struct ui_file *file, int from_tty,
174 struct cmd_list_element *c, const char *value)
175{
176 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
177}
178
ccce17b0 179unsigned int debug_infrun = 0;
920d2a44
AC
180static void
181show_debug_infrun (struct ui_file *file, int from_tty,
182 struct cmd_list_element *c, const char *value)
183{
184 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
185}
527159b7 186
03583c20
UW
187
188/* Support for disabling address space randomization. */
189
190int disable_randomization = 1;
191
192static void
193show_disable_randomization (struct ui_file *file, int from_tty,
194 struct cmd_list_element *c, const char *value)
195{
196 if (target_supports_disable_randomization ())
197 fprintf_filtered (file,
198 _("Disabling randomization of debuggee's "
199 "virtual address space is %s.\n"),
200 value);
201 else
202 fputs_filtered (_("Disabling randomization of debuggee's "
203 "virtual address space is unsupported on\n"
204 "this platform.\n"), file);
205}
206
207static void
208set_disable_randomization (char *args, int from_tty,
209 struct cmd_list_element *c)
210{
211 if (!target_supports_disable_randomization ())
212 error (_("Disabling randomization of debuggee's "
213 "virtual address space is unsupported on\n"
214 "this platform."));
215}
216
d32dc48e
PA
217/* User interface for non-stop mode. */
218
219int non_stop = 0;
220static int non_stop_1 = 0;
221
222static void
223set_non_stop (char *args, int from_tty,
224 struct cmd_list_element *c)
225{
226 if (target_has_execution)
227 {
228 non_stop_1 = non_stop;
229 error (_("Cannot change this setting while the inferior is running."));
230 }
231
232 non_stop = non_stop_1;
233}
234
235static void
236show_non_stop (struct ui_file *file, int from_tty,
237 struct cmd_list_element *c, const char *value)
238{
239 fprintf_filtered (file,
240 _("Controlling the inferior in non-stop mode is %s.\n"),
241 value);
242}
243
d914c394
SS
244/* "Observer mode" is somewhat like a more extreme version of
245 non-stop, in which all GDB operations that might affect the
246 target's execution have been disabled. */
247
d914c394
SS
248int observer_mode = 0;
249static int observer_mode_1 = 0;
250
251static void
252set_observer_mode (char *args, int from_tty,
253 struct cmd_list_element *c)
254{
d914c394
SS
255 if (target_has_execution)
256 {
257 observer_mode_1 = observer_mode;
258 error (_("Cannot change this setting while the inferior is running."));
259 }
260
261 observer_mode = observer_mode_1;
262
263 may_write_registers = !observer_mode;
264 may_write_memory = !observer_mode;
265 may_insert_breakpoints = !observer_mode;
266 may_insert_tracepoints = !observer_mode;
267 /* We can insert fast tracepoints in or out of observer mode,
268 but enable them if we're going into this mode. */
269 if (observer_mode)
270 may_insert_fast_tracepoints = 1;
271 may_stop = !observer_mode;
272 update_target_permissions ();
273
274 /* Going *into* observer mode we must force non-stop, then
275 going out we leave it that way. */
276 if (observer_mode)
277 {
d914c394
SS
278 pagination_enabled = 0;
279 non_stop = non_stop_1 = 1;
280 }
281
282 if (from_tty)
283 printf_filtered (_("Observer mode is now %s.\n"),
284 (observer_mode ? "on" : "off"));
285}
286
287static void
288show_observer_mode (struct ui_file *file, int from_tty,
289 struct cmd_list_element *c, const char *value)
290{
291 fprintf_filtered (file, _("Observer mode is %s.\n"), value);
292}
293
294/* This updates the value of observer mode based on changes in
295 permissions. Note that we are deliberately ignoring the values of
296 may-write-registers and may-write-memory, since the user may have
297 reason to enable these during a session, for instance to turn on a
298 debugging-related global. */
299
300void
301update_observer_mode (void)
302{
303 int newval;
304
305 newval = (!may_insert_breakpoints
306 && !may_insert_tracepoints
307 && may_insert_fast_tracepoints
308 && !may_stop
309 && non_stop);
310
311 /* Let the user know if things change. */
312 if (newval != observer_mode)
313 printf_filtered (_("Observer mode is now %s.\n"),
314 (newval ? "on" : "off"));
315
316 observer_mode = observer_mode_1 = newval;
317}
c2c6d25f 318
c906108c
SS
319/* Tables of how to react to signals; the user sets them. */
320
321static unsigned char *signal_stop;
322static unsigned char *signal_print;
323static unsigned char *signal_program;
324
ab04a2af
TT
325/* Table of signals that are registered with "catch signal". A
326 non-zero entry indicates that the signal is caught by some "catch
327 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
328 signals. */
329static unsigned char *signal_catch;
330
2455069d
UW
331/* Table of signals that the target may silently handle.
332 This is automatically determined from the flags above,
333 and simply cached here. */
334static unsigned char *signal_pass;
335
c906108c
SS
336#define SET_SIGS(nsigs,sigs,flags) \
337 do { \
338 int signum = (nsigs); \
339 while (signum-- > 0) \
340 if ((sigs)[signum]) \
341 (flags)[signum] = 1; \
342 } while (0)
343
344#define UNSET_SIGS(nsigs,sigs,flags) \
345 do { \
346 int signum = (nsigs); \
347 while (signum-- > 0) \
348 if ((sigs)[signum]) \
349 (flags)[signum] = 0; \
350 } while (0)
351
9b224c5e
PA
352/* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
353 this function is to avoid exporting `signal_program'. */
354
355void
356update_signals_program_target (void)
357{
a493e3e2 358 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
9b224c5e
PA
359}
360
1777feb0 361/* Value to pass to target_resume() to cause all threads to resume. */
39f77062 362
edb3359d 363#define RESUME_ALL minus_one_ptid
c906108c
SS
364
365/* Command list pointer for the "stop" placeholder. */
366
367static struct cmd_list_element *stop_command;
368
c906108c
SS
369/* Nonzero if we want to give control to the user when we're notified
370 of shared library events by the dynamic linker. */
628fe4e4 371int stop_on_solib_events;
f9e14852
GB
372
373/* Enable or disable optional shared library event breakpoints
374 as appropriate when the above flag is changed. */
375
376static void
377set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
378{
379 update_solib_breakpoints ();
380}
381
920d2a44
AC
382static void
383show_stop_on_solib_events (struct ui_file *file, int from_tty,
384 struct cmd_list_element *c, const char *value)
385{
386 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
387 value);
388}
c906108c 389
c906108c
SS
390/* Nonzero after stop if current stack frame should be printed. */
391
392static int stop_print_frame;
393
e02bc4cc 394/* This is a cached copy of the pid/waitstatus of the last event
9a4105ab
AC
395 returned by target_wait()/deprecated_target_wait_hook(). This
396 information is returned by get_last_target_status(). */
39f77062 397static ptid_t target_last_wait_ptid;
e02bc4cc
DS
398static struct target_waitstatus target_last_waitstatus;
399
0d1e5fa7
PA
400static void context_switch (ptid_t ptid);
401
4e1c45ea 402void init_thread_stepping_state (struct thread_info *tss);
0d1e5fa7 403
53904c9e
AC
404static const char follow_fork_mode_child[] = "child";
405static const char follow_fork_mode_parent[] = "parent";
406
40478521 407static const char *const follow_fork_mode_kind_names[] = {
53904c9e
AC
408 follow_fork_mode_child,
409 follow_fork_mode_parent,
410 NULL
ef346e04 411};
c906108c 412
53904c9e 413static const char *follow_fork_mode_string = follow_fork_mode_parent;
920d2a44
AC
414static void
415show_follow_fork_mode_string (struct ui_file *file, int from_tty,
416 struct cmd_list_element *c, const char *value)
417{
3e43a32a
MS
418 fprintf_filtered (file,
419 _("Debugger response to a program "
420 "call of fork or vfork is \"%s\".\n"),
920d2a44
AC
421 value);
422}
c906108c
SS
423\f
424
d83ad864
DB
425/* Handle changes to the inferior list based on the type of fork,
426 which process is being followed, and whether the other process
427 should be detached. On entry inferior_ptid must be the ptid of
428 the fork parent. At return inferior_ptid is the ptid of the
429 followed inferior. */
430
431static int
432follow_fork_inferior (int follow_child, int detach_fork)
433{
434 int has_vforked;
79639e11 435 ptid_t parent_ptid, child_ptid;
d83ad864
DB
436
437 has_vforked = (inferior_thread ()->pending_follow.kind
438 == TARGET_WAITKIND_VFORKED);
79639e11
PA
439 parent_ptid = inferior_ptid;
440 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
d83ad864
DB
441
442 if (has_vforked
443 && !non_stop /* Non-stop always resumes both branches. */
3b12939d 444 && current_ui->prompt_state == PROMPT_BLOCKED
d83ad864
DB
445 && !(follow_child || detach_fork || sched_multi))
446 {
447 /* The parent stays blocked inside the vfork syscall until the
448 child execs or exits. If we don't let the child run, then
449 the parent stays blocked. If we're telling the parent to run
450 in the foreground, the user will not be able to ctrl-c to get
451 back the terminal, effectively hanging the debug session. */
452 fprintf_filtered (gdb_stderr, _("\
453Can not resume the parent process over vfork in the foreground while\n\
454holding the child stopped. Try \"set detach-on-fork\" or \
455\"set schedule-multiple\".\n"));
456 /* FIXME output string > 80 columns. */
457 return 1;
458 }
459
460 if (!follow_child)
461 {
462 /* Detach new forked process? */
463 if (detach_fork)
464 {
d83ad864
DB
465 /* Before detaching from the child, remove all breakpoints
466 from it. If we forked, then this has already been taken
467 care of by infrun.c. If we vforked however, any
468 breakpoint inserted in the parent is visible in the
469 child, even those added while stopped in a vfork
470 catchpoint. This will remove the breakpoints from the
471 parent also, but they'll be reinserted below. */
472 if (has_vforked)
473 {
474 /* Keep breakpoints list in sync. */
475 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
476 }
477
478 if (info_verbose || debug_infrun)
479 {
8dd06f7a
DB
480 /* Ensure that we have a process ptid. */
481 ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
482
6f259a23 483 target_terminal_ours_for_output ();
d83ad864 484 fprintf_filtered (gdb_stdlog,
79639e11 485 _("Detaching after %s from child %s.\n"),
6f259a23 486 has_vforked ? "vfork" : "fork",
8dd06f7a 487 target_pid_to_str (process_ptid));
d83ad864
DB
488 }
489 }
490 else
491 {
492 struct inferior *parent_inf, *child_inf;
d83ad864
DB
493
494 /* Add process to GDB's tables. */
79639e11 495 child_inf = add_inferior (ptid_get_pid (child_ptid));
d83ad864
DB
496
497 parent_inf = current_inferior ();
498 child_inf->attach_flag = parent_inf->attach_flag;
499 copy_terminal_info (child_inf, parent_inf);
500 child_inf->gdbarch = parent_inf->gdbarch;
501 copy_inferior_target_desc_info (child_inf, parent_inf);
502
5ed8105e 503 scoped_restore_current_pspace_and_thread restore_pspace_thread;
d83ad864 504
79639e11 505 inferior_ptid = child_ptid;
d83ad864 506 add_thread (inferior_ptid);
2a00d7ce 507 set_current_inferior (child_inf);
d83ad864
DB
508 child_inf->symfile_flags = SYMFILE_NO_READ;
509
510 /* If this is a vfork child, then the address-space is
511 shared with the parent. */
512 if (has_vforked)
513 {
514 child_inf->pspace = parent_inf->pspace;
515 child_inf->aspace = parent_inf->aspace;
516
517 /* The parent will be frozen until the child is done
518 with the shared region. Keep track of the
519 parent. */
520 child_inf->vfork_parent = parent_inf;
521 child_inf->pending_detach = 0;
522 parent_inf->vfork_child = child_inf;
523 parent_inf->pending_detach = 0;
524 }
525 else
526 {
527 child_inf->aspace = new_address_space ();
528 child_inf->pspace = add_program_space (child_inf->aspace);
529 child_inf->removable = 1;
530 set_current_program_space (child_inf->pspace);
531 clone_program_space (child_inf->pspace, parent_inf->pspace);
532
533 /* Let the shared library layer (e.g., solib-svr4) learn
534 about this new process, relocate the cloned exec, pull
535 in shared libraries, and install the solib event
536 breakpoint. If a "cloned-VM" event was propagated
537 better throughout the core, this wouldn't be
538 required. */
539 solib_create_inferior_hook (0);
540 }
d83ad864
DB
541 }
542
543 if (has_vforked)
544 {
545 struct inferior *parent_inf;
546
547 parent_inf = current_inferior ();
548
549 /* If we detached from the child, then we have to be careful
550 to not insert breakpoints in the parent until the child
551 is done with the shared memory region. However, if we're
552 staying attached to the child, then we can and should
553 insert breakpoints, so that we can debug it. A
554 subsequent child exec or exit is enough to know when does
555 the child stops using the parent's address space. */
556 parent_inf->waiting_for_vfork_done = detach_fork;
557 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
558 }
559 }
560 else
561 {
562 /* Follow the child. */
563 struct inferior *parent_inf, *child_inf;
564 struct program_space *parent_pspace;
565
566 if (info_verbose || debug_infrun)
567 {
6f259a23
DB
568 target_terminal_ours_for_output ();
569 fprintf_filtered (gdb_stdlog,
79639e11
PA
570 _("Attaching after %s %s to child %s.\n"),
571 target_pid_to_str (parent_ptid),
6f259a23 572 has_vforked ? "vfork" : "fork",
79639e11 573 target_pid_to_str (child_ptid));
d83ad864
DB
574 }
575
576 /* Add the new inferior first, so that the target_detach below
577 doesn't unpush the target. */
578
79639e11 579 child_inf = add_inferior (ptid_get_pid (child_ptid));
d83ad864
DB
580
581 parent_inf = current_inferior ();
582 child_inf->attach_flag = parent_inf->attach_flag;
583 copy_terminal_info (child_inf, parent_inf);
584 child_inf->gdbarch = parent_inf->gdbarch;
585 copy_inferior_target_desc_info (child_inf, parent_inf);
586
587 parent_pspace = parent_inf->pspace;
588
589 /* If we're vforking, we want to hold on to the parent until the
590 child exits or execs. At child exec or exit time we can
591 remove the old breakpoints from the parent and detach or
592 resume debugging it. Otherwise, detach the parent now; we'll
593 want to reuse it's program/address spaces, but we can't set
594 them to the child before removing breakpoints from the
595 parent, otherwise, the breakpoints module could decide to
596 remove breakpoints from the wrong process (since they'd be
597 assigned to the same address space). */
598
599 if (has_vforked)
600 {
601 gdb_assert (child_inf->vfork_parent == NULL);
602 gdb_assert (parent_inf->vfork_child == NULL);
603 child_inf->vfork_parent = parent_inf;
604 child_inf->pending_detach = 0;
605 parent_inf->vfork_child = child_inf;
606 parent_inf->pending_detach = detach_fork;
607 parent_inf->waiting_for_vfork_done = 0;
608 }
609 else if (detach_fork)
6f259a23
DB
610 {
611 if (info_verbose || debug_infrun)
612 {
8dd06f7a
DB
613 /* Ensure that we have a process ptid. */
614 ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
615
6f259a23
DB
616 target_terminal_ours_for_output ();
617 fprintf_filtered (gdb_stdlog,
618 _("Detaching after fork from "
79639e11 619 "child %s.\n"),
8dd06f7a 620 target_pid_to_str (process_ptid));
6f259a23
DB
621 }
622
623 target_detach (NULL, 0);
624 }
d83ad864
DB
625
626 /* Note that the detach above makes PARENT_INF dangling. */
627
628 /* Add the child thread to the appropriate lists, and switch to
629 this new thread, before cloning the program space, and
630 informing the solib layer about this new process. */
631
79639e11 632 inferior_ptid = child_ptid;
d83ad864 633 add_thread (inferior_ptid);
2a00d7ce 634 set_current_inferior (child_inf);
d83ad864
DB
635
636 /* If this is a vfork child, then the address-space is shared
637 with the parent. If we detached from the parent, then we can
638 reuse the parent's program/address spaces. */
639 if (has_vforked || detach_fork)
640 {
641 child_inf->pspace = parent_pspace;
642 child_inf->aspace = child_inf->pspace->aspace;
643 }
644 else
645 {
646 child_inf->aspace = new_address_space ();
647 child_inf->pspace = add_program_space (child_inf->aspace);
648 child_inf->removable = 1;
649 child_inf->symfile_flags = SYMFILE_NO_READ;
650 set_current_program_space (child_inf->pspace);
651 clone_program_space (child_inf->pspace, parent_pspace);
652
653 /* Let the shared library layer (e.g., solib-svr4) learn
654 about this new process, relocate the cloned exec, pull in
655 shared libraries, and install the solib event breakpoint.
656 If a "cloned-VM" event was propagated better throughout
657 the core, this wouldn't be required. */
658 solib_create_inferior_hook (0);
659 }
660 }
661
662 return target_follow_fork (follow_child, detach_fork);
663}
664
e58b0e63
PA
665/* Tell the target to follow the fork we're stopped at. Returns true
666 if the inferior should be resumed; false, if the target for some
667 reason decided it's best not to resume. */
668
6604731b 669static int
4ef3f3be 670follow_fork (void)
c906108c 671{
ea1dd7bc 672 int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
e58b0e63
PA
673 int should_resume = 1;
674 struct thread_info *tp;
675
676 /* Copy user stepping state to the new inferior thread. FIXME: the
677 followed fork child thread should have a copy of most of the
4e3990f4
DE
678 parent thread structure's run control related fields, not just these.
679 Initialized to avoid "may be used uninitialized" warnings from gcc. */
680 struct breakpoint *step_resume_breakpoint = NULL;
186c406b 681 struct breakpoint *exception_resume_breakpoint = NULL;
4e3990f4
DE
682 CORE_ADDR step_range_start = 0;
683 CORE_ADDR step_range_end = 0;
684 struct frame_id step_frame_id = { 0 };
8980e177 685 struct thread_fsm *thread_fsm = NULL;
e58b0e63
PA
686
687 if (!non_stop)
688 {
689 ptid_t wait_ptid;
690 struct target_waitstatus wait_status;
691
692 /* Get the last target status returned by target_wait(). */
693 get_last_target_status (&wait_ptid, &wait_status);
694
695 /* If not stopped at a fork event, then there's nothing else to
696 do. */
697 if (wait_status.kind != TARGET_WAITKIND_FORKED
698 && wait_status.kind != TARGET_WAITKIND_VFORKED)
699 return 1;
700
701 /* Check if we switched over from WAIT_PTID, since the event was
702 reported. */
703 if (!ptid_equal (wait_ptid, minus_one_ptid)
704 && !ptid_equal (inferior_ptid, wait_ptid))
705 {
706 /* We did. Switch back to WAIT_PTID thread, to tell the
707 target to follow it (in either direction). We'll
708 afterwards refuse to resume, and inform the user what
709 happened. */
710 switch_to_thread (wait_ptid);
711 should_resume = 0;
712 }
713 }
714
715 tp = inferior_thread ();
716
717 /* If there were any forks/vforks that were caught and are now to be
718 followed, then do so now. */
719 switch (tp->pending_follow.kind)
720 {
721 case TARGET_WAITKIND_FORKED:
722 case TARGET_WAITKIND_VFORKED:
723 {
724 ptid_t parent, child;
725
726 /* If the user did a next/step, etc, over a fork call,
727 preserve the stepping state in the fork child. */
728 if (follow_child && should_resume)
729 {
8358c15c
JK
730 step_resume_breakpoint = clone_momentary_breakpoint
731 (tp->control.step_resume_breakpoint);
16c381f0
JK
732 step_range_start = tp->control.step_range_start;
733 step_range_end = tp->control.step_range_end;
734 step_frame_id = tp->control.step_frame_id;
186c406b
TT
735 exception_resume_breakpoint
736 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
8980e177 737 thread_fsm = tp->thread_fsm;
e58b0e63
PA
738
739 /* For now, delete the parent's sr breakpoint, otherwise,
740 parent/child sr breakpoints are considered duplicates,
741 and the child version will not be installed. Remove
742 this when the breakpoints module becomes aware of
743 inferiors and address spaces. */
744 delete_step_resume_breakpoint (tp);
16c381f0
JK
745 tp->control.step_range_start = 0;
746 tp->control.step_range_end = 0;
747 tp->control.step_frame_id = null_frame_id;
186c406b 748 delete_exception_resume_breakpoint (tp);
8980e177 749 tp->thread_fsm = NULL;
e58b0e63
PA
750 }
751
752 parent = inferior_ptid;
753 child = tp->pending_follow.value.related_pid;
754
d83ad864
DB
755 /* Set up inferior(s) as specified by the caller, and tell the
756 target to do whatever is necessary to follow either parent
757 or child. */
758 if (follow_fork_inferior (follow_child, detach_fork))
e58b0e63
PA
759 {
760 /* Target refused to follow, or there's some other reason
761 we shouldn't resume. */
762 should_resume = 0;
763 }
764 else
765 {
766 /* This pending follow fork event is now handled, one way
767 or another. The previous selected thread may be gone
768 from the lists by now, but if it is still around, need
769 to clear the pending follow request. */
e09875d4 770 tp = find_thread_ptid (parent);
e58b0e63
PA
771 if (tp)
772 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
773
774 /* This makes sure we don't try to apply the "Switched
775 over from WAIT_PID" logic above. */
776 nullify_last_target_wait_ptid ();
777
1777feb0 778 /* If we followed the child, switch to it... */
e58b0e63
PA
779 if (follow_child)
780 {
781 switch_to_thread (child);
782
783 /* ... and preserve the stepping state, in case the
784 user was stepping over the fork call. */
785 if (should_resume)
786 {
787 tp = inferior_thread ();
8358c15c
JK
788 tp->control.step_resume_breakpoint
789 = step_resume_breakpoint;
16c381f0
JK
790 tp->control.step_range_start = step_range_start;
791 tp->control.step_range_end = step_range_end;
792 tp->control.step_frame_id = step_frame_id;
186c406b
TT
793 tp->control.exception_resume_breakpoint
794 = exception_resume_breakpoint;
8980e177 795 tp->thread_fsm = thread_fsm;
e58b0e63
PA
796 }
797 else
798 {
799 /* If we get here, it was because we're trying to
800 resume from a fork catchpoint, but, the user
801 has switched threads away from the thread that
802 forked. In that case, the resume command
803 issued is most likely not applicable to the
804 child, so just warn, and refuse to resume. */
3e43a32a 805 warning (_("Not resuming: switched threads "
fd7dcb94 806 "before following fork child."));
e58b0e63
PA
807 }
808
809 /* Reset breakpoints in the child as appropriate. */
810 follow_inferior_reset_breakpoints ();
811 }
812 else
813 switch_to_thread (parent);
814 }
815 }
816 break;
817 case TARGET_WAITKIND_SPURIOUS:
818 /* Nothing to follow. */
819 break;
820 default:
821 internal_error (__FILE__, __LINE__,
822 "Unexpected pending_follow.kind %d\n",
823 tp->pending_follow.kind);
824 break;
825 }
c906108c 826
e58b0e63 827 return should_resume;
c906108c
SS
828}
829
d83ad864 830static void
6604731b 831follow_inferior_reset_breakpoints (void)
c906108c 832{
4e1c45ea
PA
833 struct thread_info *tp = inferior_thread ();
834
6604731b
DJ
835 /* Was there a step_resume breakpoint? (There was if the user
836 did a "next" at the fork() call.) If so, explicitly reset its
a1aa2221
LM
837 thread number. Cloned step_resume breakpoints are disabled on
838 creation, so enable it here now that it is associated with the
839 correct thread.
6604731b
DJ
840
841 step_resumes are a form of bp that are made to be per-thread.
842 Since we created the step_resume bp when the parent process
843 was being debugged, and now are switching to the child process,
844 from the breakpoint package's viewpoint, that's a switch of
845 "threads". We must update the bp's notion of which thread
846 it is for, or it'll be ignored when it triggers. */
847
8358c15c 848 if (tp->control.step_resume_breakpoint)
a1aa2221
LM
849 {
850 breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
851 tp->control.step_resume_breakpoint->loc->enabled = 1;
852 }
6604731b 853
a1aa2221 854 /* Treat exception_resume breakpoints like step_resume breakpoints. */
186c406b 855 if (tp->control.exception_resume_breakpoint)
a1aa2221
LM
856 {
857 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
858 tp->control.exception_resume_breakpoint->loc->enabled = 1;
859 }
186c406b 860
6604731b
DJ
861 /* Reinsert all breakpoints in the child. The user may have set
862 breakpoints after catching the fork, in which case those
863 were never set in the child, but only in the parent. This makes
864 sure the inserted breakpoints match the breakpoint list. */
865
866 breakpoint_re_set ();
867 insert_breakpoints ();
c906108c 868}
c906108c 869
6c95b8df
PA
870/* The child has exited or execed: resume threads of the parent the
871 user wanted to be executing. */
872
873static int
874proceed_after_vfork_done (struct thread_info *thread,
875 void *arg)
876{
877 int pid = * (int *) arg;
878
879 if (ptid_get_pid (thread->ptid) == pid
880 && is_running (thread->ptid)
881 && !is_executing (thread->ptid)
882 && !thread->stop_requested
a493e3e2 883 && thread->suspend.stop_signal == GDB_SIGNAL_0)
6c95b8df
PA
884 {
885 if (debug_infrun)
886 fprintf_unfiltered (gdb_stdlog,
887 "infrun: resuming vfork parent thread %s\n",
888 target_pid_to_str (thread->ptid));
889
890 switch_to_thread (thread->ptid);
70509625 891 clear_proceed_status (0);
64ce06e4 892 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
6c95b8df
PA
893 }
894
895 return 0;
896}
897
5ed8105e
PA
898/* Save/restore inferior_ptid, current program space and current
899 inferior. Only use this if the current context points at an exited
900 inferior (and therefore there's no current thread to save). */
901class scoped_restore_exited_inferior
902{
903public:
904 scoped_restore_exited_inferior ()
905 : m_saved_ptid (&inferior_ptid)
906 {}
907
908private:
909 scoped_restore_tmpl<ptid_t> m_saved_ptid;
910 scoped_restore_current_program_space m_pspace;
911 scoped_restore_current_inferior m_inferior;
912};
913
6c95b8df
PA
914/* Called whenever we notice an exec or exit event, to handle
915 detaching or resuming a vfork parent. */
916
917static void
918handle_vfork_child_exec_or_exit (int exec)
919{
920 struct inferior *inf = current_inferior ();
921
922 if (inf->vfork_parent)
923 {
924 int resume_parent = -1;
925
926 /* This exec or exit marks the end of the shared memory region
927 between the parent and the child. If the user wanted to
928 detach from the parent, now is the time. */
929
930 if (inf->vfork_parent->pending_detach)
931 {
932 struct thread_info *tp;
6c95b8df
PA
933 struct program_space *pspace;
934 struct address_space *aspace;
935
1777feb0 936 /* follow-fork child, detach-on-fork on. */
6c95b8df 937
68c9da30
PA
938 inf->vfork_parent->pending_detach = 0;
939
5ed8105e
PA
940 gdb::optional<scoped_restore_exited_inferior>
941 maybe_restore_inferior;
942 gdb::optional<scoped_restore_current_pspace_and_thread>
943 maybe_restore_thread;
944
945 /* If we're handling a child exit, then inferior_ptid points
946 at the inferior's pid, not to a thread. */
f50f4e56 947 if (!exec)
5ed8105e 948 maybe_restore_inferior.emplace ();
f50f4e56 949 else
5ed8105e 950 maybe_restore_thread.emplace ();
6c95b8df
PA
951
952 /* We're letting loose of the parent. */
953 tp = any_live_thread_of_process (inf->vfork_parent->pid);
954 switch_to_thread (tp->ptid);
955
956 /* We're about to detach from the parent, which implicitly
957 removes breakpoints from its address space. There's a
958 catch here: we want to reuse the spaces for the child,
959 but, parent/child are still sharing the pspace at this
960 point, although the exec in reality makes the kernel give
961 the child a fresh set of new pages. The problem here is
962 that the breakpoints module being unaware of this, would
963 likely chose the child process to write to the parent
964 address space. Swapping the child temporarily away from
965 the spaces has the desired effect. Yes, this is "sort
966 of" a hack. */
967
968 pspace = inf->pspace;
969 aspace = inf->aspace;
970 inf->aspace = NULL;
971 inf->pspace = NULL;
972
973 if (debug_infrun || info_verbose)
974 {
6f259a23 975 target_terminal_ours_for_output ();
6c95b8df
PA
976
977 if (exec)
6f259a23
DB
978 {
979 fprintf_filtered (gdb_stdlog,
980 _("Detaching vfork parent process "
981 "%d after child exec.\n"),
982 inf->vfork_parent->pid);
983 }
6c95b8df 984 else
6f259a23
DB
985 {
986 fprintf_filtered (gdb_stdlog,
987 _("Detaching vfork parent process "
988 "%d after child exit.\n"),
989 inf->vfork_parent->pid);
990 }
6c95b8df
PA
991 }
992
993 target_detach (NULL, 0);
994
995 /* Put it back. */
996 inf->pspace = pspace;
997 inf->aspace = aspace;
6c95b8df
PA
998 }
999 else if (exec)
1000 {
1001 /* We're staying attached to the parent, so, really give the
1002 child a new address space. */
1003 inf->pspace = add_program_space (maybe_new_address_space ());
1004 inf->aspace = inf->pspace->aspace;
1005 inf->removable = 1;
1006 set_current_program_space (inf->pspace);
1007
1008 resume_parent = inf->vfork_parent->pid;
1009
1010 /* Break the bonds. */
1011 inf->vfork_parent->vfork_child = NULL;
1012 }
1013 else
1014 {
6c95b8df
PA
1015 struct program_space *pspace;
1016
1017 /* If this is a vfork child exiting, then the pspace and
1018 aspaces were shared with the parent. Since we're
1019 reporting the process exit, we'll be mourning all that is
1020 found in the address space, and switching to null_ptid,
1021 preparing to start a new inferior. But, since we don't
1022 want to clobber the parent's address/program spaces, we
1023 go ahead and create a new one for this exiting
1024 inferior. */
1025
5ed8105e
PA
1026 /* Switch to null_ptid while running clone_program_space, so
1027 that clone_program_space doesn't want to read the
1028 selected frame of a dead process. */
1029 scoped_restore restore_ptid
1030 = make_scoped_restore (&inferior_ptid, null_ptid);
6c95b8df
PA
1031
1032 /* This inferior is dead, so avoid giving the breakpoints
1033 module the option to write through to it (cloning a
1034 program space resets breakpoints). */
1035 inf->aspace = NULL;
1036 inf->pspace = NULL;
1037 pspace = add_program_space (maybe_new_address_space ());
1038 set_current_program_space (pspace);
1039 inf->removable = 1;
7dcd53a0 1040 inf->symfile_flags = SYMFILE_NO_READ;
6c95b8df
PA
1041 clone_program_space (pspace, inf->vfork_parent->pspace);
1042 inf->pspace = pspace;
1043 inf->aspace = pspace->aspace;
1044
6c95b8df
PA
1045 resume_parent = inf->vfork_parent->pid;
1046 /* Break the bonds. */
1047 inf->vfork_parent->vfork_child = NULL;
1048 }
1049
1050 inf->vfork_parent = NULL;
1051
1052 gdb_assert (current_program_space == inf->pspace);
1053
1054 if (non_stop && resume_parent != -1)
1055 {
1056 /* If the user wanted the parent to be running, let it go
1057 free now. */
5ed8105e 1058 scoped_restore_current_thread restore_thread;
6c95b8df
PA
1059
1060 if (debug_infrun)
3e43a32a
MS
1061 fprintf_unfiltered (gdb_stdlog,
1062 "infrun: resuming vfork parent process %d\n",
6c95b8df
PA
1063 resume_parent);
1064
1065 iterate_over_threads (proceed_after_vfork_done, &resume_parent);
6c95b8df
PA
1066 }
1067 }
1068}
1069
eb6c553b 1070/* Enum strings for "set|show follow-exec-mode". */
6c95b8df
PA
1071
1072static const char follow_exec_mode_new[] = "new";
1073static const char follow_exec_mode_same[] = "same";
40478521 1074static const char *const follow_exec_mode_names[] =
6c95b8df
PA
1075{
1076 follow_exec_mode_new,
1077 follow_exec_mode_same,
1078 NULL,
1079};
1080
1081static const char *follow_exec_mode_string = follow_exec_mode_same;
1082static void
1083show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1084 struct cmd_list_element *c, const char *value)
1085{
1086 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
1087}
1088
ecf45d2c 1089/* EXEC_FILE_TARGET is assumed to be non-NULL. */
1adeb98a 1090
c906108c 1091static void
ecf45d2c 1092follow_exec (ptid_t ptid, char *exec_file_target)
c906108c 1093{
95e50b27 1094 struct thread_info *th, *tmp;
6c95b8df 1095 struct inferior *inf = current_inferior ();
95e50b27 1096 int pid = ptid_get_pid (ptid);
94585166 1097 ptid_t process_ptid;
ecf45d2c
SL
1098 char *exec_file_host;
1099 struct cleanup *old_chain;
7a292a7a 1100
c906108c
SS
1101 /* This is an exec event that we actually wish to pay attention to.
1102 Refresh our symbol table to the newly exec'd program, remove any
1103 momentary bp's, etc.
1104
1105 If there are breakpoints, they aren't really inserted now,
1106 since the exec() transformed our inferior into a fresh set
1107 of instructions.
1108
1109 We want to preserve symbolic breakpoints on the list, since
1110 we have hopes that they can be reset after the new a.out's
1111 symbol table is read.
1112
1113 However, any "raw" breakpoints must be removed from the list
1114 (e.g., the solib bp's), since their address is probably invalid
1115 now.
1116
1117 And, we DON'T want to call delete_breakpoints() here, since
1118 that may write the bp's "shadow contents" (the instruction
1119 value that was overwritten witha TRAP instruction). Since
1777feb0 1120 we now have a new a.out, those shadow contents aren't valid. */
6c95b8df
PA
1121
1122 mark_breakpoints_out ();
1123
95e50b27
PA
1124 /* The target reports the exec event to the main thread, even if
1125 some other thread does the exec, and even if the main thread was
1126 stopped or already gone. We may still have non-leader threads of
1127 the process on our list. E.g., on targets that don't have thread
1128 exit events (like remote); or on native Linux in non-stop mode if
1129 there were only two threads in the inferior and the non-leader
1130 one is the one that execs (and nothing forces an update of the
1131 thread list up to here). When debugging remotely, it's best to
1132 avoid extra traffic, when possible, so avoid syncing the thread
1133 list with the target, and instead go ahead and delete all threads
1134 of the process but one that reported the event. Note this must
1135 be done before calling update_breakpoints_after_exec, as
1136 otherwise clearing the threads' resources would reference stale
1137 thread breakpoints -- it may have been one of these threads that
1138 stepped across the exec. We could just clear their stepping
1139 states, but as long as we're iterating, might as well delete
1140 them. Deleting them now rather than at the next user-visible
1141 stop provides a nicer sequence of events for user and MI
1142 notifications. */
8a06aea7 1143 ALL_THREADS_SAFE (th, tmp)
95e50b27
PA
1144 if (ptid_get_pid (th->ptid) == pid && !ptid_equal (th->ptid, ptid))
1145 delete_thread (th->ptid);
1146
1147 /* We also need to clear any left over stale state for the
1148 leader/event thread. E.g., if there was any step-resume
1149 breakpoint or similar, it's gone now. We cannot truly
1150 step-to-next statement through an exec(). */
1151 th = inferior_thread ();
8358c15c 1152 th->control.step_resume_breakpoint = NULL;
186c406b 1153 th->control.exception_resume_breakpoint = NULL;
34b7e8a6 1154 th->control.single_step_breakpoints = NULL;
16c381f0
JK
1155 th->control.step_range_start = 0;
1156 th->control.step_range_end = 0;
c906108c 1157
95e50b27
PA
1158 /* The user may have had the main thread held stopped in the
1159 previous image (e.g., schedlock on, or non-stop). Release
1160 it now. */
a75724bc
PA
1161 th->stop_requested = 0;
1162
95e50b27
PA
1163 update_breakpoints_after_exec ();
1164
1777feb0 1165 /* What is this a.out's name? */
94585166 1166 process_ptid = pid_to_ptid (pid);
6c95b8df 1167 printf_unfiltered (_("%s is executing new program: %s\n"),
94585166 1168 target_pid_to_str (process_ptid),
ecf45d2c 1169 exec_file_target);
c906108c
SS
1170
1171 /* We've followed the inferior through an exec. Therefore, the
1777feb0 1172 inferior has essentially been killed & reborn. */
7a292a7a 1173
c906108c 1174 gdb_flush (gdb_stdout);
6ca15a4b
PA
1175
1176 breakpoint_init_inferior (inf_execd);
e85a822c 1177
ecf45d2c
SL
1178 exec_file_host = exec_file_find (exec_file_target, NULL);
1179 old_chain = make_cleanup (xfree, exec_file_host);
ff862be4 1180
ecf45d2c
SL
1181 /* If we were unable to map the executable target pathname onto a host
1182 pathname, tell the user that. Otherwise GDB's subsequent behavior
1183 is confusing. Maybe it would even be better to stop at this point
1184 so that the user can specify a file manually before continuing. */
1185 if (exec_file_host == NULL)
1186 warning (_("Could not load symbols for executable %s.\n"
1187 "Do you need \"set sysroot\"?"),
1188 exec_file_target);
c906108c 1189
cce9b6bf
PA
1190 /* Reset the shared library package. This ensures that we get a
1191 shlib event when the child reaches "_start", at which point the
1192 dld will have had a chance to initialize the child. */
1193 /* Also, loading a symbol file below may trigger symbol lookups, and
1194 we don't want those to be satisfied by the libraries of the
1195 previous incarnation of this process. */
1196 no_shared_libraries (NULL, 0);
1197
6c95b8df
PA
1198 if (follow_exec_mode_string == follow_exec_mode_new)
1199 {
6c95b8df
PA
1200 /* The user wants to keep the old inferior and program spaces
1201 around. Create a new fresh one, and switch to it. */
1202
17d8546e
DB
1203 /* Do exit processing for the original inferior before adding
1204 the new inferior so we don't have two active inferiors with
1205 the same ptid, which can confuse find_inferior_ptid. */
1206 exit_inferior_num_silent (current_inferior ()->num);
1207
94585166
DB
1208 inf = add_inferior_with_spaces ();
1209 inf->pid = pid;
ecf45d2c 1210 target_follow_exec (inf, exec_file_target);
6c95b8df
PA
1211
1212 set_current_inferior (inf);
94585166
DB
1213 set_current_program_space (inf->pspace);
1214 add_thread (ptid);
6c95b8df 1215 }
9107fc8d
PA
1216 else
1217 {
1218 /* The old description may no longer be fit for the new image.
1219 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1220 old description; we'll read a new one below. No need to do
1221 this on "follow-exec-mode new", as the old inferior stays
1222 around (its description is later cleared/refetched on
1223 restart). */
1224 target_clear_description ();
1225 }
6c95b8df
PA
1226
1227 gdb_assert (current_program_space == inf->pspace);
1228
ecf45d2c
SL
1229 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1230 because the proper displacement for a PIE (Position Independent
1231 Executable) main symbol file will only be computed by
1232 solib_create_inferior_hook below. breakpoint_re_set would fail
1233 to insert the breakpoints with the zero displacement. */
1234 try_open_exec_file (exec_file_host, inf, SYMFILE_DEFER_BP_RESET);
c1e56572 1235
ecf45d2c 1236 do_cleanups (old_chain);
c906108c 1237
9107fc8d
PA
1238 /* If the target can specify a description, read it. Must do this
1239 after flipping to the new executable (because the target supplied
1240 description must be compatible with the executable's
1241 architecture, and the old executable may e.g., be 32-bit, while
1242 the new one 64-bit), and before anything involving memory or
1243 registers. */
1244 target_find_description ();
1245
268a4a75 1246 solib_create_inferior_hook (0);
c906108c 1247
4efc6507
DE
1248 jit_inferior_created_hook ();
1249
c1e56572
JK
1250 breakpoint_re_set ();
1251
c906108c
SS
1252 /* Reinsert all breakpoints. (Those which were symbolic have
1253 been reset to the proper address in the new a.out, thanks
1777feb0 1254 to symbol_file_command...). */
c906108c
SS
1255 insert_breakpoints ();
1256
1257 /* The next resume of this inferior should bring it to the shlib
1258 startup breakpoints. (If the user had also set bp's on
1259 "main" from the old (parent) process, then they'll auto-
1777feb0 1260 matically get reset there in the new process.). */
c906108c
SS
1261}
1262
c2829269
PA
1263/* The queue of threads that need to do a step-over operation to get
1264 past e.g., a breakpoint. What technique is used to step over the
1265 breakpoint/watchpoint does not matter -- all threads end up in the
1266 same queue, to maintain rough temporal order of execution, in order
1267 to avoid starvation, otherwise, we could e.g., find ourselves
1268 constantly stepping the same couple threads past their breakpoints
1269 over and over, if the single-step finish fast enough. */
1270struct thread_info *step_over_queue_head;
1271
6c4cfb24
PA
1272/* Bit flags indicating what the thread needs to step over. */
1273
8d297bbf 1274enum step_over_what_flag
6c4cfb24
PA
1275 {
1276 /* Step over a breakpoint. */
1277 STEP_OVER_BREAKPOINT = 1,
1278
1279 /* Step past a non-continuable watchpoint, in order to let the
1280 instruction execute so we can evaluate the watchpoint
1281 expression. */
1282 STEP_OVER_WATCHPOINT = 2
1283 };
8d297bbf 1284DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag, step_over_what);
6c4cfb24 1285
963f9c80 1286/* Info about an instruction that is being stepped over. */
31e77af2
PA
1287
1288struct step_over_info
1289{
963f9c80
PA
1290 /* If we're stepping past a breakpoint, this is the address space
1291 and address of the instruction the breakpoint is set at. We'll
1292 skip inserting all breakpoints here. Valid iff ASPACE is
1293 non-NULL. */
31e77af2 1294 struct address_space *aspace;
31e77af2 1295 CORE_ADDR address;
963f9c80
PA
1296
1297 /* The instruction being stepped over triggers a nonsteppable
1298 watchpoint. If true, we'll skip inserting watchpoints. */
1299 int nonsteppable_watchpoint_p;
21edc42f
YQ
1300
1301 /* The thread's global number. */
1302 int thread;
31e77af2
PA
1303};
1304
1305/* The step-over info of the location that is being stepped over.
1306
1307 Note that with async/breakpoint always-inserted mode, a user might
1308 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1309 being stepped over. As setting a new breakpoint inserts all
1310 breakpoints, we need to make sure the breakpoint being stepped over
1311 isn't inserted then. We do that by only clearing the step-over
1312 info when the step-over is actually finished (or aborted).
1313
1314 Presently GDB can only step over one breakpoint at any given time.
1315 Given threads that can't run code in the same address space as the
1316 breakpoint's can't really miss the breakpoint, GDB could be taught
1317 to step-over at most one breakpoint per address space (so this info
1318 could move to the address space object if/when GDB is extended).
1319 The set of breakpoints being stepped over will normally be much
1320 smaller than the set of all breakpoints, so a flag in the
1321 breakpoint location structure would be wasteful. A separate list
1322 also saves complexity and run-time, as otherwise we'd have to go
1323 through all breakpoint locations clearing their flag whenever we
1324 start a new sequence. Similar considerations weigh against storing
1325 this info in the thread object. Plus, not all step overs actually
1326 have breakpoint locations -- e.g., stepping past a single-step
1327 breakpoint, or stepping to complete a non-continuable
1328 watchpoint. */
1329static struct step_over_info step_over_info;
1330
1331/* Record the address of the breakpoint/instruction we're currently
ce0db137
DE
1332 stepping over.
1333 N.B. We record the aspace and address now, instead of say just the thread,
1334 because when we need the info later the thread may be running. */
31e77af2
PA
1335
1336static void
963f9c80 1337set_step_over_info (struct address_space *aspace, CORE_ADDR address,
21edc42f
YQ
1338 int nonsteppable_watchpoint_p,
1339 int thread)
31e77af2
PA
1340{
1341 step_over_info.aspace = aspace;
1342 step_over_info.address = address;
963f9c80 1343 step_over_info.nonsteppable_watchpoint_p = nonsteppable_watchpoint_p;
21edc42f 1344 step_over_info.thread = thread;
31e77af2
PA
1345}
1346
1347/* Called when we're not longer stepping over a breakpoint / an
1348 instruction, so all breakpoints are free to be (re)inserted. */
1349
1350static void
1351clear_step_over_info (void)
1352{
372316f1
PA
1353 if (debug_infrun)
1354 fprintf_unfiltered (gdb_stdlog,
1355 "infrun: clear_step_over_info\n");
31e77af2
PA
1356 step_over_info.aspace = NULL;
1357 step_over_info.address = 0;
963f9c80 1358 step_over_info.nonsteppable_watchpoint_p = 0;
21edc42f 1359 step_over_info.thread = -1;
31e77af2
PA
1360}
1361
7f89fd65 1362/* See infrun.h. */
31e77af2
PA
1363
1364int
1365stepping_past_instruction_at (struct address_space *aspace,
1366 CORE_ADDR address)
1367{
1368 return (step_over_info.aspace != NULL
1369 && breakpoint_address_match (aspace, address,
1370 step_over_info.aspace,
1371 step_over_info.address));
1372}
1373
963f9c80
PA
1374/* See infrun.h. */
1375
21edc42f
YQ
1376int
1377thread_is_stepping_over_breakpoint (int thread)
1378{
1379 return (step_over_info.thread != -1
1380 && thread == step_over_info.thread);
1381}
1382
1383/* See infrun.h. */
1384
963f9c80
PA
1385int
1386stepping_past_nonsteppable_watchpoint (void)
1387{
1388 return step_over_info.nonsteppable_watchpoint_p;
1389}
1390
6cc83d2a
PA
1391/* Returns true if step-over info is valid. */
1392
1393static int
1394step_over_info_valid_p (void)
1395{
963f9c80
PA
1396 return (step_over_info.aspace != NULL
1397 || stepping_past_nonsteppable_watchpoint ());
6cc83d2a
PA
1398}
1399
c906108c 1400\f
237fc4c9
PA
1401/* Displaced stepping. */
1402
1403/* In non-stop debugging mode, we must take special care to manage
1404 breakpoints properly; in particular, the traditional strategy for
1405 stepping a thread past a breakpoint it has hit is unsuitable.
1406 'Displaced stepping' is a tactic for stepping one thread past a
1407 breakpoint it has hit while ensuring that other threads running
1408 concurrently will hit the breakpoint as they should.
1409
1410 The traditional way to step a thread T off a breakpoint in a
1411 multi-threaded program in all-stop mode is as follows:
1412
1413 a0) Initially, all threads are stopped, and breakpoints are not
1414 inserted.
1415 a1) We single-step T, leaving breakpoints uninserted.
1416 a2) We insert breakpoints, and resume all threads.
1417
1418 In non-stop debugging, however, this strategy is unsuitable: we
1419 don't want to have to stop all threads in the system in order to
1420 continue or step T past a breakpoint. Instead, we use displaced
1421 stepping:
1422
1423 n0) Initially, T is stopped, other threads are running, and
1424 breakpoints are inserted.
1425 n1) We copy the instruction "under" the breakpoint to a separate
1426 location, outside the main code stream, making any adjustments
1427 to the instruction, register, and memory state as directed by
1428 T's architecture.
1429 n2) We single-step T over the instruction at its new location.
1430 n3) We adjust the resulting register and memory state as directed
1431 by T's architecture. This includes resetting T's PC to point
1432 back into the main instruction stream.
1433 n4) We resume T.
1434
1435 This approach depends on the following gdbarch methods:
1436
1437 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1438 indicate where to copy the instruction, and how much space must
1439 be reserved there. We use these in step n1.
1440
1441 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1442 address, and makes any necessary adjustments to the instruction,
1443 register contents, and memory. We use this in step n1.
1444
1445 - gdbarch_displaced_step_fixup adjusts registers and memory after
1446 we have successfuly single-stepped the instruction, to yield the
1447 same effect the instruction would have had if we had executed it
1448 at its original address. We use this in step n3.
1449
1450 - gdbarch_displaced_step_free_closure provides cleanup.
1451
1452 The gdbarch_displaced_step_copy_insn and
1453 gdbarch_displaced_step_fixup functions must be written so that
1454 copying an instruction with gdbarch_displaced_step_copy_insn,
1455 single-stepping across the copied instruction, and then applying
1456 gdbarch_displaced_insn_fixup should have the same effects on the
1457 thread's memory and registers as stepping the instruction in place
1458 would have. Exactly which responsibilities fall to the copy and
1459 which fall to the fixup is up to the author of those functions.
1460
1461 See the comments in gdbarch.sh for details.
1462
1463 Note that displaced stepping and software single-step cannot
1464 currently be used in combination, although with some care I think
1465 they could be made to. Software single-step works by placing
1466 breakpoints on all possible subsequent instructions; if the
1467 displaced instruction is a PC-relative jump, those breakpoints
1468 could fall in very strange places --- on pages that aren't
1469 executable, or at addresses that are not proper instruction
1470 boundaries. (We do generally let other threads run while we wait
1471 to hit the software single-step breakpoint, and they might
1472 encounter such a corrupted instruction.) One way to work around
1473 this would be to have gdbarch_displaced_step_copy_insn fully
1474 simulate the effect of PC-relative instructions (and return NULL)
1475 on architectures that use software single-stepping.
1476
1477 In non-stop mode, we can have independent and simultaneous step
1478 requests, so more than one thread may need to simultaneously step
1479 over a breakpoint. The current implementation assumes there is
1480 only one scratch space per process. In this case, we have to
1481 serialize access to the scratch space. If thread A wants to step
1482 over a breakpoint, but we are currently waiting for some other
1483 thread to complete a displaced step, we leave thread A stopped and
1484 place it in the displaced_step_request_queue. Whenever a displaced
1485 step finishes, we pick the next thread in the queue and start a new
1486 displaced step operation on it. See displaced_step_prepare and
1487 displaced_step_fixup for details. */
1488
fc1cf338
PA
1489/* Per-inferior displaced stepping state. */
1490struct displaced_step_inferior_state
1491{
1492 /* Pointer to next in linked list. */
1493 struct displaced_step_inferior_state *next;
1494
1495 /* The process this displaced step state refers to. */
1496 int pid;
1497
3fc8eb30
PA
1498 /* True if preparing a displaced step ever failed. If so, we won't
1499 try displaced stepping for this inferior again. */
1500 int failed_before;
1501
fc1cf338
PA
1502 /* If this is not null_ptid, this is the thread carrying out a
1503 displaced single-step in process PID. This thread's state will
1504 require fixing up once it has completed its step. */
1505 ptid_t step_ptid;
1506
1507 /* The architecture the thread had when we stepped it. */
1508 struct gdbarch *step_gdbarch;
1509
1510 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1511 for post-step cleanup. */
1512 struct displaced_step_closure *step_closure;
1513
1514 /* The address of the original instruction, and the copy we
1515 made. */
1516 CORE_ADDR step_original, step_copy;
1517
1518 /* Saved contents of copy area. */
1519 gdb_byte *step_saved_copy;
1520};
1521
1522/* The list of states of processes involved in displaced stepping
1523 presently. */
1524static struct displaced_step_inferior_state *displaced_step_inferior_states;
1525
1526/* Get the displaced stepping state of process PID. */
1527
1528static struct displaced_step_inferior_state *
1529get_displaced_stepping_state (int pid)
1530{
1531 struct displaced_step_inferior_state *state;
1532
1533 for (state = displaced_step_inferior_states;
1534 state != NULL;
1535 state = state->next)
1536 if (state->pid == pid)
1537 return state;
1538
1539 return NULL;
1540}
1541
372316f1
PA
1542/* Returns true if any inferior has a thread doing a displaced
1543 step. */
1544
1545static int
1546displaced_step_in_progress_any_inferior (void)
1547{
1548 struct displaced_step_inferior_state *state;
1549
1550 for (state = displaced_step_inferior_states;
1551 state != NULL;
1552 state = state->next)
1553 if (!ptid_equal (state->step_ptid, null_ptid))
1554 return 1;
1555
1556 return 0;
1557}
1558
c0987663
YQ
1559/* Return true if thread represented by PTID is doing a displaced
1560 step. */
1561
1562static int
1563displaced_step_in_progress_thread (ptid_t ptid)
1564{
1565 struct displaced_step_inferior_state *displaced;
1566
1567 gdb_assert (!ptid_equal (ptid, null_ptid));
1568
1569 displaced = get_displaced_stepping_state (ptid_get_pid (ptid));
1570
1571 return (displaced != NULL && ptid_equal (displaced->step_ptid, ptid));
1572}
1573
8f572e5c
PA
1574/* Return true if process PID has a thread doing a displaced step. */
1575
1576static int
1577displaced_step_in_progress (int pid)
1578{
1579 struct displaced_step_inferior_state *displaced;
1580
1581 displaced = get_displaced_stepping_state (pid);
1582 if (displaced != NULL && !ptid_equal (displaced->step_ptid, null_ptid))
1583 return 1;
1584
1585 return 0;
1586}
1587
fc1cf338
PA
1588/* Add a new displaced stepping state for process PID to the displaced
1589 stepping state list, or return a pointer to an already existing
1590 entry, if it already exists. Never returns NULL. */
1591
1592static struct displaced_step_inferior_state *
1593add_displaced_stepping_state (int pid)
1594{
1595 struct displaced_step_inferior_state *state;
1596
1597 for (state = displaced_step_inferior_states;
1598 state != NULL;
1599 state = state->next)
1600 if (state->pid == pid)
1601 return state;
237fc4c9 1602
8d749320 1603 state = XCNEW (struct displaced_step_inferior_state);
fc1cf338
PA
1604 state->pid = pid;
1605 state->next = displaced_step_inferior_states;
1606 displaced_step_inferior_states = state;
237fc4c9 1607
fc1cf338
PA
1608 return state;
1609}
1610
a42244db
YQ
1611/* If inferior is in displaced stepping, and ADDR equals to starting address
1612 of copy area, return corresponding displaced_step_closure. Otherwise,
1613 return NULL. */
1614
1615struct displaced_step_closure*
1616get_displaced_step_closure_by_addr (CORE_ADDR addr)
1617{
1618 struct displaced_step_inferior_state *displaced
1619 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1620
1621 /* If checking the mode of displaced instruction in copy area. */
1622 if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1623 && (displaced->step_copy == addr))
1624 return displaced->step_closure;
1625
1626 return NULL;
1627}
1628
fc1cf338 1629/* Remove the displaced stepping state of process PID. */
237fc4c9 1630
fc1cf338
PA
1631static void
1632remove_displaced_stepping_state (int pid)
1633{
1634 struct displaced_step_inferior_state *it, **prev_next_p;
237fc4c9 1635
fc1cf338
PA
1636 gdb_assert (pid != 0);
1637
1638 it = displaced_step_inferior_states;
1639 prev_next_p = &displaced_step_inferior_states;
1640 while (it)
1641 {
1642 if (it->pid == pid)
1643 {
1644 *prev_next_p = it->next;
1645 xfree (it);
1646 return;
1647 }
1648
1649 prev_next_p = &it->next;
1650 it = *prev_next_p;
1651 }
1652}
1653
1654static void
1655infrun_inferior_exit (struct inferior *inf)
1656{
1657 remove_displaced_stepping_state (inf->pid);
1658}
237fc4c9 1659
fff08868
HZ
1660/* If ON, and the architecture supports it, GDB will use displaced
1661 stepping to step over breakpoints. If OFF, or if the architecture
1662 doesn't support it, GDB will instead use the traditional
1663 hold-and-step approach. If AUTO (which is the default), GDB will
1664 decide which technique to use to step over breakpoints depending on
1665 which of all-stop or non-stop mode is active --- displaced stepping
1666 in non-stop mode; hold-and-step in all-stop mode. */
1667
72d0e2c5 1668static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
fff08868 1669
237fc4c9
PA
1670static void
1671show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1672 struct cmd_list_element *c,
1673 const char *value)
1674{
72d0e2c5 1675 if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
3e43a32a
MS
1676 fprintf_filtered (file,
1677 _("Debugger's willingness to use displaced stepping "
1678 "to step over breakpoints is %s (currently %s).\n"),
fbea99ea 1679 value, target_is_non_stop_p () ? "on" : "off");
fff08868 1680 else
3e43a32a
MS
1681 fprintf_filtered (file,
1682 _("Debugger's willingness to use displaced stepping "
1683 "to step over breakpoints is %s.\n"), value);
237fc4c9
PA
1684}
1685
fff08868 1686/* Return non-zero if displaced stepping can/should be used to step
3fc8eb30 1687 over breakpoints of thread TP. */
fff08868 1688
237fc4c9 1689static int
3fc8eb30 1690use_displaced_stepping (struct thread_info *tp)
237fc4c9 1691{
3fc8eb30
PA
1692 struct regcache *regcache = get_thread_regcache (tp->ptid);
1693 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1694 struct displaced_step_inferior_state *displaced_state;
1695
1696 displaced_state = get_displaced_stepping_state (ptid_get_pid (tp->ptid));
1697
fbea99ea
PA
1698 return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
1699 && target_is_non_stop_p ())
72d0e2c5 1700 || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
96429cc8 1701 && gdbarch_displaced_step_copy_insn_p (gdbarch)
3fc8eb30
PA
1702 && find_record_target () == NULL
1703 && (displaced_state == NULL
1704 || !displaced_state->failed_before));
237fc4c9
PA
1705}
1706
1707/* Clean out any stray displaced stepping state. */
1708static void
fc1cf338 1709displaced_step_clear (struct displaced_step_inferior_state *displaced)
237fc4c9
PA
1710{
1711 /* Indicate that there is no cleanup pending. */
fc1cf338 1712 displaced->step_ptid = null_ptid;
237fc4c9 1713
6d45d4b4
SM
1714 xfree (displaced->step_closure);
1715 displaced->step_closure = NULL;
237fc4c9
PA
1716}
1717
1718static void
fc1cf338 1719displaced_step_clear_cleanup (void *arg)
237fc4c9 1720{
9a3c8263
SM
1721 struct displaced_step_inferior_state *state
1722 = (struct displaced_step_inferior_state *) arg;
fc1cf338
PA
1723
1724 displaced_step_clear (state);
237fc4c9
PA
1725}
1726
1727/* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1728void
1729displaced_step_dump_bytes (struct ui_file *file,
1730 const gdb_byte *buf,
1731 size_t len)
1732{
1733 int i;
1734
1735 for (i = 0; i < len; i++)
1736 fprintf_unfiltered (file, "%02x ", buf[i]);
1737 fputs_unfiltered ("\n", file);
1738}
1739
1740/* Prepare to single-step, using displaced stepping.
1741
1742 Note that we cannot use displaced stepping when we have a signal to
1743 deliver. If we have a signal to deliver and an instruction to step
1744 over, then after the step, there will be no indication from the
1745 target whether the thread entered a signal handler or ignored the
1746 signal and stepped over the instruction successfully --- both cases
1747 result in a simple SIGTRAP. In the first case we mustn't do a
1748 fixup, and in the second case we must --- but we can't tell which.
1749 Comments in the code for 'random signals' in handle_inferior_event
1750 explain how we handle this case instead.
1751
1752 Returns 1 if preparing was successful -- this thread is going to be
7f03bd92
PA
1753 stepped now; 0 if displaced stepping this thread got queued; or -1
1754 if this instruction can't be displaced stepped. */
1755
237fc4c9 1756static int
3fc8eb30 1757displaced_step_prepare_throw (ptid_t ptid)
237fc4c9 1758{
2989a365 1759 struct cleanup *ignore_cleanups;
c1e36e3e 1760 struct thread_info *tp = find_thread_ptid (ptid);
237fc4c9
PA
1761 struct regcache *regcache = get_thread_regcache (ptid);
1762 struct gdbarch *gdbarch = get_regcache_arch (regcache);
d35ae833 1763 struct address_space *aspace = get_regcache_aspace (regcache);
237fc4c9
PA
1764 CORE_ADDR original, copy;
1765 ULONGEST len;
1766 struct displaced_step_closure *closure;
fc1cf338 1767 struct displaced_step_inferior_state *displaced;
9e529e1d 1768 int status;
237fc4c9
PA
1769
1770 /* We should never reach this function if the architecture does not
1771 support displaced stepping. */
1772 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1773
c2829269
PA
1774 /* Nor if the thread isn't meant to step over a breakpoint. */
1775 gdb_assert (tp->control.trap_expected);
1776
c1e36e3e
PA
1777 /* Disable range stepping while executing in the scratch pad. We
1778 want a single-step even if executing the displaced instruction in
1779 the scratch buffer lands within the stepping range (e.g., a
1780 jump/branch). */
1781 tp->control.may_range_step = 0;
1782
fc1cf338
PA
1783 /* We have to displaced step one thread at a time, as we only have
1784 access to a single scratch space per inferior. */
237fc4c9 1785
fc1cf338
PA
1786 displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1787
1788 if (!ptid_equal (displaced->step_ptid, null_ptid))
237fc4c9
PA
1789 {
1790 /* Already waiting for a displaced step to finish. Defer this
1791 request and place in queue. */
237fc4c9
PA
1792
1793 if (debug_displaced)
1794 fprintf_unfiltered (gdb_stdlog,
c2829269 1795 "displaced: deferring step of %s\n",
237fc4c9
PA
1796 target_pid_to_str (ptid));
1797
c2829269 1798 thread_step_over_chain_enqueue (tp);
237fc4c9
PA
1799 return 0;
1800 }
1801 else
1802 {
1803 if (debug_displaced)
1804 fprintf_unfiltered (gdb_stdlog,
1805 "displaced: stepping %s now\n",
1806 target_pid_to_str (ptid));
1807 }
1808
fc1cf338 1809 displaced_step_clear (displaced);
237fc4c9 1810
2989a365 1811 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
ad53cd71
PA
1812 inferior_ptid = ptid;
1813
515630c5 1814 original = regcache_read_pc (regcache);
237fc4c9
PA
1815
1816 copy = gdbarch_displaced_step_location (gdbarch);
1817 len = gdbarch_max_insn_length (gdbarch);
1818
d35ae833
PA
1819 if (breakpoint_in_range_p (aspace, copy, len))
1820 {
1821 /* There's a breakpoint set in the scratch pad location range
1822 (which is usually around the entry point). We'd either
1823 install it before resuming, which would overwrite/corrupt the
1824 scratch pad, or if it was already inserted, this displaced
1825 step would overwrite it. The latter is OK in the sense that
1826 we already assume that no thread is going to execute the code
1827 in the scratch pad range (after initial startup) anyway, but
1828 the former is unacceptable. Simply punt and fallback to
1829 stepping over this breakpoint in-line. */
1830 if (debug_displaced)
1831 {
1832 fprintf_unfiltered (gdb_stdlog,
1833 "displaced: breakpoint set in scratch pad. "
1834 "Stepping over breakpoint in-line instead.\n");
1835 }
1836
d35ae833
PA
1837 return -1;
1838 }
1839
237fc4c9 1840 /* Save the original contents of the copy area. */
224c3ddb 1841 displaced->step_saved_copy = (gdb_byte *) xmalloc (len);
ad53cd71 1842 ignore_cleanups = make_cleanup (free_current_contents,
fc1cf338 1843 &displaced->step_saved_copy);
9e529e1d
JK
1844 status = target_read_memory (copy, displaced->step_saved_copy, len);
1845 if (status != 0)
1846 throw_error (MEMORY_ERROR,
1847 _("Error accessing memory address %s (%s) for "
1848 "displaced-stepping scratch space."),
1849 paddress (gdbarch, copy), safe_strerror (status));
237fc4c9
PA
1850 if (debug_displaced)
1851 {
5af949e3
UW
1852 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1853 paddress (gdbarch, copy));
fc1cf338
PA
1854 displaced_step_dump_bytes (gdb_stdlog,
1855 displaced->step_saved_copy,
1856 len);
237fc4c9
PA
1857 };
1858
1859 closure = gdbarch_displaced_step_copy_insn (gdbarch,
ad53cd71 1860 original, copy, regcache);
7f03bd92
PA
1861 if (closure == NULL)
1862 {
1863 /* The architecture doesn't know how or want to displaced step
1864 this instruction or instruction sequence. Fallback to
1865 stepping over the breakpoint in-line. */
2989a365 1866 do_cleanups (ignore_cleanups);
7f03bd92
PA
1867 return -1;
1868 }
237fc4c9 1869
9f5a595d
UW
1870 /* Save the information we need to fix things up if the step
1871 succeeds. */
fc1cf338
PA
1872 displaced->step_ptid = ptid;
1873 displaced->step_gdbarch = gdbarch;
1874 displaced->step_closure = closure;
1875 displaced->step_original = original;
1876 displaced->step_copy = copy;
9f5a595d 1877
fc1cf338 1878 make_cleanup (displaced_step_clear_cleanup, displaced);
237fc4c9
PA
1879
1880 /* Resume execution at the copy. */
515630c5 1881 regcache_write_pc (regcache, copy);
237fc4c9 1882
ad53cd71
PA
1883 discard_cleanups (ignore_cleanups);
1884
237fc4c9 1885 if (debug_displaced)
5af949e3
UW
1886 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1887 paddress (gdbarch, copy));
237fc4c9 1888
237fc4c9
PA
1889 return 1;
1890}
1891
3fc8eb30
PA
1892/* Wrapper for displaced_step_prepare_throw that disabled further
1893 attempts at displaced stepping if we get a memory error. */
1894
1895static int
1896displaced_step_prepare (ptid_t ptid)
1897{
1898 int prepared = -1;
1899
1900 TRY
1901 {
1902 prepared = displaced_step_prepare_throw (ptid);
1903 }
1904 CATCH (ex, RETURN_MASK_ERROR)
1905 {
1906 struct displaced_step_inferior_state *displaced_state;
1907
16b41842
PA
1908 if (ex.error != MEMORY_ERROR
1909 && ex.error != NOT_SUPPORTED_ERROR)
3fc8eb30
PA
1910 throw_exception (ex);
1911
1912 if (debug_infrun)
1913 {
1914 fprintf_unfiltered (gdb_stdlog,
1915 "infrun: disabling displaced stepping: %s\n",
1916 ex.message);
1917 }
1918
1919 /* Be verbose if "set displaced-stepping" is "on", silent if
1920 "auto". */
1921 if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1922 {
fd7dcb94 1923 warning (_("disabling displaced stepping: %s"),
3fc8eb30
PA
1924 ex.message);
1925 }
1926
1927 /* Disable further displaced stepping attempts. */
1928 displaced_state
1929 = get_displaced_stepping_state (ptid_get_pid (ptid));
1930 displaced_state->failed_before = 1;
1931 }
1932 END_CATCH
1933
1934 return prepared;
1935}
1936
237fc4c9 1937static void
3e43a32a
MS
1938write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1939 const gdb_byte *myaddr, int len)
237fc4c9 1940{
2989a365 1941 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
abbb1732 1942
237fc4c9
PA
1943 inferior_ptid = ptid;
1944 write_memory (memaddr, myaddr, len);
237fc4c9
PA
1945}
1946
e2d96639
YQ
1947/* Restore the contents of the copy area for thread PTID. */
1948
1949static void
1950displaced_step_restore (struct displaced_step_inferior_state *displaced,
1951 ptid_t ptid)
1952{
1953 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1954
1955 write_memory_ptid (ptid, displaced->step_copy,
1956 displaced->step_saved_copy, len);
1957 if (debug_displaced)
1958 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1959 target_pid_to_str (ptid),
1960 paddress (displaced->step_gdbarch,
1961 displaced->step_copy));
1962}
1963
372316f1
PA
1964/* If we displaced stepped an instruction successfully, adjust
1965 registers and memory to yield the same effect the instruction would
1966 have had if we had executed it at its original address, and return
1967 1. If the instruction didn't complete, relocate the PC and return
1968 -1. If the thread wasn't displaced stepping, return 0. */
1969
1970static int
2ea28649 1971displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
237fc4c9
PA
1972{
1973 struct cleanup *old_cleanups;
fc1cf338
PA
1974 struct displaced_step_inferior_state *displaced
1975 = get_displaced_stepping_state (ptid_get_pid (event_ptid));
372316f1 1976 int ret;
fc1cf338
PA
1977
1978 /* Was any thread of this process doing a displaced step? */
1979 if (displaced == NULL)
372316f1 1980 return 0;
237fc4c9
PA
1981
1982 /* Was this event for the pid we displaced? */
fc1cf338
PA
1983 if (ptid_equal (displaced->step_ptid, null_ptid)
1984 || ! ptid_equal (displaced->step_ptid, event_ptid))
372316f1 1985 return 0;
237fc4c9 1986
fc1cf338 1987 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
237fc4c9 1988
e2d96639 1989 displaced_step_restore (displaced, displaced->step_ptid);
237fc4c9 1990
cb71640d
PA
1991 /* Fixup may need to read memory/registers. Switch to the thread
1992 that we're fixing up. Also, target_stopped_by_watchpoint checks
1993 the current thread. */
1994 switch_to_thread (event_ptid);
1995
237fc4c9 1996 /* Did the instruction complete successfully? */
cb71640d
PA
1997 if (signal == GDB_SIGNAL_TRAP
1998 && !(target_stopped_by_watchpoint ()
1999 && (gdbarch_have_nonsteppable_watchpoint (displaced->step_gdbarch)
2000 || target_have_steppable_watchpoint)))
237fc4c9
PA
2001 {
2002 /* Fix up the resulting state. */
fc1cf338
PA
2003 gdbarch_displaced_step_fixup (displaced->step_gdbarch,
2004 displaced->step_closure,
2005 displaced->step_original,
2006 displaced->step_copy,
2007 get_thread_regcache (displaced->step_ptid));
372316f1 2008 ret = 1;
237fc4c9
PA
2009 }
2010 else
2011 {
2012 /* Since the instruction didn't complete, all we can do is
2013 relocate the PC. */
515630c5
UW
2014 struct regcache *regcache = get_thread_regcache (event_ptid);
2015 CORE_ADDR pc = regcache_read_pc (regcache);
abbb1732 2016
fc1cf338 2017 pc = displaced->step_original + (pc - displaced->step_copy);
515630c5 2018 regcache_write_pc (regcache, pc);
372316f1 2019 ret = -1;
237fc4c9
PA
2020 }
2021
2022 do_cleanups (old_cleanups);
2023
fc1cf338 2024 displaced->step_ptid = null_ptid;
372316f1
PA
2025
2026 return ret;
c2829269 2027}
1c5cfe86 2028
4d9d9d04
PA
2029/* Data to be passed around while handling an event. This data is
2030 discarded between events. */
2031struct execution_control_state
2032{
2033 ptid_t ptid;
2034 /* The thread that got the event, if this was a thread event; NULL
2035 otherwise. */
2036 struct thread_info *event_thread;
2037
2038 struct target_waitstatus ws;
2039 int stop_func_filled_in;
2040 CORE_ADDR stop_func_start;
2041 CORE_ADDR stop_func_end;
2042 const char *stop_func_name;
2043 int wait_some_more;
2044
2045 /* True if the event thread hit the single-step breakpoint of
2046 another thread. Thus the event doesn't cause a stop, the thread
2047 needs to be single-stepped past the single-step breakpoint before
2048 we can switch back to the original stepping thread. */
2049 int hit_singlestep_breakpoint;
2050};
2051
2052/* Clear ECS and set it to point at TP. */
c2829269
PA
2053
2054static void
4d9d9d04
PA
2055reset_ecs (struct execution_control_state *ecs, struct thread_info *tp)
2056{
2057 memset (ecs, 0, sizeof (*ecs));
2058 ecs->event_thread = tp;
2059 ecs->ptid = tp->ptid;
2060}
2061
2062static void keep_going_pass_signal (struct execution_control_state *ecs);
2063static void prepare_to_wait (struct execution_control_state *ecs);
2ac7589c 2064static int keep_going_stepped_thread (struct thread_info *tp);
8d297bbf 2065static step_over_what thread_still_needs_step_over (struct thread_info *tp);
4d9d9d04
PA
2066
2067/* Are there any pending step-over requests? If so, run all we can
2068 now and return true. Otherwise, return false. */
2069
2070static int
c2829269
PA
2071start_step_over (void)
2072{
2073 struct thread_info *tp, *next;
2074
372316f1
PA
2075 /* Don't start a new step-over if we already have an in-line
2076 step-over operation ongoing. */
2077 if (step_over_info_valid_p ())
2078 return 0;
2079
c2829269 2080 for (tp = step_over_queue_head; tp != NULL; tp = next)
237fc4c9 2081 {
4d9d9d04
PA
2082 struct execution_control_state ecss;
2083 struct execution_control_state *ecs = &ecss;
8d297bbf 2084 step_over_what step_what;
372316f1 2085 int must_be_in_line;
c2829269 2086
c65d6b55
PA
2087 gdb_assert (!tp->stop_requested);
2088
c2829269 2089 next = thread_step_over_chain_next (tp);
237fc4c9 2090
c2829269
PA
2091 /* If this inferior already has a displaced step in process,
2092 don't start a new one. */
4d9d9d04 2093 if (displaced_step_in_progress (ptid_get_pid (tp->ptid)))
c2829269
PA
2094 continue;
2095
372316f1
PA
2096 step_what = thread_still_needs_step_over (tp);
2097 must_be_in_line = ((step_what & STEP_OVER_WATCHPOINT)
2098 || ((step_what & STEP_OVER_BREAKPOINT)
3fc8eb30 2099 && !use_displaced_stepping (tp)));
372316f1
PA
2100
2101 /* We currently stop all threads of all processes to step-over
2102 in-line. If we need to start a new in-line step-over, let
2103 any pending displaced steps finish first. */
2104 if (must_be_in_line && displaced_step_in_progress_any_inferior ())
2105 return 0;
2106
c2829269
PA
2107 thread_step_over_chain_remove (tp);
2108
2109 if (step_over_queue_head == NULL)
2110 {
2111 if (debug_infrun)
2112 fprintf_unfiltered (gdb_stdlog,
2113 "infrun: step-over queue now empty\n");
2114 }
2115
372316f1
PA
2116 if (tp->control.trap_expected
2117 || tp->resumed
2118 || tp->executing)
ad53cd71 2119 {
4d9d9d04
PA
2120 internal_error (__FILE__, __LINE__,
2121 "[%s] has inconsistent state: "
372316f1 2122 "trap_expected=%d, resumed=%d, executing=%d\n",
4d9d9d04
PA
2123 target_pid_to_str (tp->ptid),
2124 tp->control.trap_expected,
372316f1 2125 tp->resumed,
4d9d9d04 2126 tp->executing);
ad53cd71 2127 }
1c5cfe86 2128
4d9d9d04
PA
2129 if (debug_infrun)
2130 fprintf_unfiltered (gdb_stdlog,
2131 "infrun: resuming [%s] for step-over\n",
2132 target_pid_to_str (tp->ptid));
2133
2134 /* keep_going_pass_signal skips the step-over if the breakpoint
2135 is no longer inserted. In all-stop, we want to keep looking
2136 for a thread that needs a step-over instead of resuming TP,
2137 because we wouldn't be able to resume anything else until the
2138 target stops again. In non-stop, the resume always resumes
2139 only TP, so it's OK to let the thread resume freely. */
fbea99ea 2140 if (!target_is_non_stop_p () && !step_what)
4d9d9d04 2141 continue;
8550d3b3 2142
4d9d9d04
PA
2143 switch_to_thread (tp->ptid);
2144 reset_ecs (ecs, tp);
2145 keep_going_pass_signal (ecs);
1c5cfe86 2146
4d9d9d04
PA
2147 if (!ecs->wait_some_more)
2148 error (_("Command aborted."));
1c5cfe86 2149
372316f1
PA
2150 gdb_assert (tp->resumed);
2151
2152 /* If we started a new in-line step-over, we're done. */
2153 if (step_over_info_valid_p ())
2154 {
2155 gdb_assert (tp->control.trap_expected);
2156 return 1;
2157 }
2158
fbea99ea 2159 if (!target_is_non_stop_p ())
4d9d9d04
PA
2160 {
2161 /* On all-stop, shouldn't have resumed unless we needed a
2162 step over. */
2163 gdb_assert (tp->control.trap_expected
2164 || tp->step_after_step_resume_breakpoint);
2165
2166 /* With remote targets (at least), in all-stop, we can't
2167 issue any further remote commands until the program stops
2168 again. */
2169 return 1;
1c5cfe86 2170 }
c2829269 2171
4d9d9d04
PA
2172 /* Either the thread no longer needed a step-over, or a new
2173 displaced stepping sequence started. Even in the latter
2174 case, continue looking. Maybe we can also start another
2175 displaced step on a thread of other process. */
237fc4c9 2176 }
4d9d9d04
PA
2177
2178 return 0;
237fc4c9
PA
2179}
2180
5231c1fd
PA
2181/* Update global variables holding ptids to hold NEW_PTID if they were
2182 holding OLD_PTID. */
2183static void
2184infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
2185{
fc1cf338 2186 struct displaced_step_inferior_state *displaced;
5231c1fd
PA
2187
2188 if (ptid_equal (inferior_ptid, old_ptid))
2189 inferior_ptid = new_ptid;
2190
fc1cf338
PA
2191 for (displaced = displaced_step_inferior_states;
2192 displaced;
2193 displaced = displaced->next)
2194 {
2195 if (ptid_equal (displaced->step_ptid, old_ptid))
2196 displaced->step_ptid = new_ptid;
fc1cf338 2197 }
5231c1fd
PA
2198}
2199
237fc4c9
PA
2200\f
2201/* Resuming. */
c906108c
SS
2202
2203/* Things to clean up if we QUIT out of resume (). */
c906108c 2204static void
74b7792f 2205resume_cleanups (void *ignore)
c906108c 2206{
34b7e8a6
PA
2207 if (!ptid_equal (inferior_ptid, null_ptid))
2208 delete_single_step_breakpoints (inferior_thread ());
7c16b83e 2209
c906108c
SS
2210 normal_stop ();
2211}
2212
53904c9e
AC
2213static const char schedlock_off[] = "off";
2214static const char schedlock_on[] = "on";
2215static const char schedlock_step[] = "step";
f2665db5 2216static const char schedlock_replay[] = "replay";
40478521 2217static const char *const scheduler_enums[] = {
ef346e04
AC
2218 schedlock_off,
2219 schedlock_on,
2220 schedlock_step,
f2665db5 2221 schedlock_replay,
ef346e04
AC
2222 NULL
2223};
f2665db5 2224static const char *scheduler_mode = schedlock_replay;
920d2a44
AC
2225static void
2226show_scheduler_mode (struct ui_file *file, int from_tty,
2227 struct cmd_list_element *c, const char *value)
2228{
3e43a32a
MS
2229 fprintf_filtered (file,
2230 _("Mode for locking scheduler "
2231 "during execution is \"%s\".\n"),
920d2a44
AC
2232 value);
2233}
c906108c
SS
2234
2235static void
96baa820 2236set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
c906108c 2237{
eefe576e
AC
2238 if (!target_can_lock_scheduler)
2239 {
2240 scheduler_mode = schedlock_off;
2241 error (_("Target '%s' cannot support this command."), target_shortname);
2242 }
c906108c
SS
2243}
2244
d4db2f36
PA
2245/* True if execution commands resume all threads of all processes by
2246 default; otherwise, resume only threads of the current inferior
2247 process. */
2248int sched_multi = 0;
2249
2facfe5c
DD
2250/* Try to setup for software single stepping over the specified location.
2251 Return 1 if target_resume() should use hardware single step.
2252
2253 GDBARCH the current gdbarch.
2254 PC the location to step over. */
2255
2256static int
2257maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
2258{
2259 int hw_step = 1;
2260
f02253f1 2261 if (execution_direction == EXEC_FORWARD
93f9a11f
YQ
2262 && gdbarch_software_single_step_p (gdbarch))
2263 hw_step = !insert_single_step_breakpoints (gdbarch);
2264
2facfe5c
DD
2265 return hw_step;
2266}
c906108c 2267
f3263aa4
PA
2268/* See infrun.h. */
2269
09cee04b
PA
2270ptid_t
2271user_visible_resume_ptid (int step)
2272{
f3263aa4 2273 ptid_t resume_ptid;
09cee04b 2274
09cee04b
PA
2275 if (non_stop)
2276 {
2277 /* With non-stop mode on, threads are always handled
2278 individually. */
2279 resume_ptid = inferior_ptid;
2280 }
2281 else if ((scheduler_mode == schedlock_on)
03d46957 2282 || (scheduler_mode == schedlock_step && step))
09cee04b 2283 {
f3263aa4
PA
2284 /* User-settable 'scheduler' mode requires solo thread
2285 resume. */
09cee04b
PA
2286 resume_ptid = inferior_ptid;
2287 }
f2665db5
MM
2288 else if ((scheduler_mode == schedlock_replay)
2289 && target_record_will_replay (minus_one_ptid, execution_direction))
2290 {
2291 /* User-settable 'scheduler' mode requires solo thread resume in replay
2292 mode. */
2293 resume_ptid = inferior_ptid;
2294 }
f3263aa4
PA
2295 else if (!sched_multi && target_supports_multi_process ())
2296 {
2297 /* Resume all threads of the current process (and none of other
2298 processes). */
2299 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
2300 }
2301 else
2302 {
2303 /* Resume all threads of all processes. */
2304 resume_ptid = RESUME_ALL;
2305 }
09cee04b
PA
2306
2307 return resume_ptid;
2308}
2309
fbea99ea
PA
2310/* Return a ptid representing the set of threads that we will resume,
2311 in the perspective of the target, assuming run control handling
2312 does not require leaving some threads stopped (e.g., stepping past
2313 breakpoint). USER_STEP indicates whether we're about to start the
2314 target for a stepping command. */
2315
2316static ptid_t
2317internal_resume_ptid (int user_step)
2318{
2319 /* In non-stop, we always control threads individually. Note that
2320 the target may always work in non-stop mode even with "set
2321 non-stop off", in which case user_visible_resume_ptid could
2322 return a wildcard ptid. */
2323 if (target_is_non_stop_p ())
2324 return inferior_ptid;
2325 else
2326 return user_visible_resume_ptid (user_step);
2327}
2328
64ce06e4
PA
2329/* Wrapper for target_resume, that handles infrun-specific
2330 bookkeeping. */
2331
2332static void
2333do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig)
2334{
2335 struct thread_info *tp = inferior_thread ();
2336
c65d6b55
PA
2337 gdb_assert (!tp->stop_requested);
2338
64ce06e4
PA
2339 /* Install inferior's terminal modes. */
2340 target_terminal_inferior ();
2341
2342 /* Avoid confusing the next resume, if the next stop/resume
2343 happens to apply to another thread. */
2344 tp->suspend.stop_signal = GDB_SIGNAL_0;
2345
8f572e5c
PA
2346 /* Advise target which signals may be handled silently.
2347
2348 If we have removed breakpoints because we are stepping over one
2349 in-line (in any thread), we need to receive all signals to avoid
2350 accidentally skipping a breakpoint during execution of a signal
2351 handler.
2352
2353 Likewise if we're displaced stepping, otherwise a trap for a
2354 breakpoint in a signal handler might be confused with the
2355 displaced step finishing. We don't make the displaced_step_fixup
2356 step distinguish the cases instead, because:
2357
2358 - a backtrace while stopped in the signal handler would show the
2359 scratch pad as frame older than the signal handler, instead of
2360 the real mainline code.
2361
2362 - when the thread is later resumed, the signal handler would
2363 return to the scratch pad area, which would no longer be
2364 valid. */
2365 if (step_over_info_valid_p ()
2366 || displaced_step_in_progress (ptid_get_pid (tp->ptid)))
64ce06e4
PA
2367 target_pass_signals (0, NULL);
2368 else
2369 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2370
2371 target_resume (resume_ptid, step, sig);
85ad3aaf
PA
2372
2373 target_commit_resume ();
64ce06e4
PA
2374}
2375
c906108c
SS
2376/* Resume the inferior, but allow a QUIT. This is useful if the user
2377 wants to interrupt some lengthy single-stepping operation
2378 (for child processes, the SIGINT goes to the inferior, and so
2379 we get a SIGINT random_signal, but for remote debugging and perhaps
2380 other targets, that's not true).
2381
c906108c
SS
2382 SIG is the signal to give the inferior (zero for none). */
2383void
64ce06e4 2384resume (enum gdb_signal sig)
c906108c 2385{
74b7792f 2386 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
515630c5
UW
2387 struct regcache *regcache = get_current_regcache ();
2388 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4e1c45ea 2389 struct thread_info *tp = inferior_thread ();
515630c5 2390 CORE_ADDR pc = regcache_read_pc (regcache);
6c95b8df 2391 struct address_space *aspace = get_regcache_aspace (regcache);
b0f16a3e 2392 ptid_t resume_ptid;
856e7dd6
PA
2393 /* This represents the user's step vs continue request. When
2394 deciding whether "set scheduler-locking step" applies, it's the
2395 user's intention that counts. */
2396 const int user_step = tp->control.stepping_command;
64ce06e4
PA
2397 /* This represents what we'll actually request the target to do.
2398 This can decay from a step to a continue, if e.g., we need to
2399 implement single-stepping with breakpoints (software
2400 single-step). */
6b403daa 2401 int step;
c7e8a53c 2402
c65d6b55 2403 gdb_assert (!tp->stop_requested);
c2829269
PA
2404 gdb_assert (!thread_is_in_step_over_chain (tp));
2405
c906108c
SS
2406 QUIT;
2407
372316f1
PA
2408 if (tp->suspend.waitstatus_pending_p)
2409 {
2410 if (debug_infrun)
2411 {
23fdd69e
SM
2412 std::string statstr
2413 = target_waitstatus_to_string (&tp->suspend.waitstatus);
372316f1 2414
372316f1 2415 fprintf_unfiltered (gdb_stdlog,
23fdd69e
SM
2416 "infrun: resume: thread %s has pending wait "
2417 "status %s (currently_stepping=%d).\n",
2418 target_pid_to_str (tp->ptid), statstr.c_str (),
372316f1 2419 currently_stepping (tp));
372316f1
PA
2420 }
2421
2422 tp->resumed = 1;
2423
2424 /* FIXME: What should we do if we are supposed to resume this
2425 thread with a signal? Maybe we should maintain a queue of
2426 pending signals to deliver. */
2427 if (sig != GDB_SIGNAL_0)
2428 {
fd7dcb94 2429 warning (_("Couldn't deliver signal %s to %s."),
372316f1
PA
2430 gdb_signal_to_name (sig), target_pid_to_str (tp->ptid));
2431 }
2432
2433 tp->suspend.stop_signal = GDB_SIGNAL_0;
2434 discard_cleanups (old_cleanups);
2435
2436 if (target_can_async_p ())
2437 target_async (1);
2438 return;
2439 }
2440
2441 tp->stepped_breakpoint = 0;
2442
6b403daa
PA
2443 /* Depends on stepped_breakpoint. */
2444 step = currently_stepping (tp);
2445
74609e71
YQ
2446 if (current_inferior ()->waiting_for_vfork_done)
2447 {
48f9886d
PA
2448 /* Don't try to single-step a vfork parent that is waiting for
2449 the child to get out of the shared memory region (by exec'ing
2450 or exiting). This is particularly important on software
2451 single-step archs, as the child process would trip on the
2452 software single step breakpoint inserted for the parent
2453 process. Since the parent will not actually execute any
2454 instruction until the child is out of the shared region (such
2455 are vfork's semantics), it is safe to simply continue it.
2456 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2457 the parent, and tell it to `keep_going', which automatically
2458 re-sets it stepping. */
74609e71
YQ
2459 if (debug_infrun)
2460 fprintf_unfiltered (gdb_stdlog,
2461 "infrun: resume : clear step\n");
a09dd441 2462 step = 0;
74609e71
YQ
2463 }
2464
527159b7 2465 if (debug_infrun)
237fc4c9 2466 fprintf_unfiltered (gdb_stdlog,
c9737c08 2467 "infrun: resume (step=%d, signal=%s), "
0d9a9a5f 2468 "trap_expected=%d, current thread [%s] at %s\n",
c9737c08
PA
2469 step, gdb_signal_to_symbol_string (sig),
2470 tp->control.trap_expected,
0d9a9a5f
PA
2471 target_pid_to_str (inferior_ptid),
2472 paddress (gdbarch, pc));
c906108c 2473
c2c6d25f
JM
2474 /* Normally, by the time we reach `resume', the breakpoints are either
2475 removed or inserted, as appropriate. The exception is if we're sitting
2476 at a permanent breakpoint; we need to step over it, but permanent
2477 breakpoints can't be removed. So we have to test for it here. */
6c95b8df 2478 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
6d350bb5 2479 {
af48d08f
PA
2480 if (sig != GDB_SIGNAL_0)
2481 {
2482 /* We have a signal to pass to the inferior. The resume
2483 may, or may not take us to the signal handler. If this
2484 is a step, we'll need to stop in the signal handler, if
2485 there's one, (if the target supports stepping into
2486 handlers), or in the next mainline instruction, if
2487 there's no handler. If this is a continue, we need to be
2488 sure to run the handler with all breakpoints inserted.
2489 In all cases, set a breakpoint at the current address
2490 (where the handler returns to), and once that breakpoint
2491 is hit, resume skipping the permanent breakpoint. If
2492 that breakpoint isn't hit, then we've stepped into the
2493 signal handler (or hit some other event). We'll delete
2494 the step-resume breakpoint then. */
2495
2496 if (debug_infrun)
2497 fprintf_unfiltered (gdb_stdlog,
2498 "infrun: resume: skipping permanent breakpoint, "
2499 "deliver signal first\n");
2500
2501 clear_step_over_info ();
2502 tp->control.trap_expected = 0;
2503
2504 if (tp->control.step_resume_breakpoint == NULL)
2505 {
2506 /* Set a "high-priority" step-resume, as we don't want
2507 user breakpoints at PC to trigger (again) when this
2508 hits. */
2509 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2510 gdb_assert (tp->control.step_resume_breakpoint->loc->permanent);
2511
2512 tp->step_after_step_resume_breakpoint = step;
2513 }
2514
2515 insert_breakpoints ();
2516 }
2517 else
2518 {
2519 /* There's no signal to pass, we can go ahead and skip the
2520 permanent breakpoint manually. */
2521 if (debug_infrun)
2522 fprintf_unfiltered (gdb_stdlog,
2523 "infrun: resume: skipping permanent breakpoint\n");
2524 gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2525 /* Update pc to reflect the new address from which we will
2526 execute instructions. */
2527 pc = regcache_read_pc (regcache);
2528
2529 if (step)
2530 {
2531 /* We've already advanced the PC, so the stepping part
2532 is done. Now we need to arrange for a trap to be
2533 reported to handle_inferior_event. Set a breakpoint
2534 at the current PC, and run to it. Don't update
2535 prev_pc, because if we end in
44a1ee51
PA
2536 switch_back_to_stepped_thread, we want the "expected
2537 thread advanced also" branch to be taken. IOW, we
2538 don't want this thread to step further from PC
af48d08f 2539 (overstep). */
1ac806b8 2540 gdb_assert (!step_over_info_valid_p ());
af48d08f
PA
2541 insert_single_step_breakpoint (gdbarch, aspace, pc);
2542 insert_breakpoints ();
2543
fbea99ea 2544 resume_ptid = internal_resume_ptid (user_step);
1ac806b8 2545 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
af48d08f 2546 discard_cleanups (old_cleanups);
372316f1 2547 tp->resumed = 1;
af48d08f
PA
2548 return;
2549 }
2550 }
6d350bb5 2551 }
c2c6d25f 2552
c1e36e3e
PA
2553 /* If we have a breakpoint to step over, make sure to do a single
2554 step only. Same if we have software watchpoints. */
2555 if (tp->control.trap_expected || bpstat_should_step ())
2556 tp->control.may_range_step = 0;
2557
237fc4c9
PA
2558 /* If enabled, step over breakpoints by executing a copy of the
2559 instruction at a different address.
2560
2561 We can't use displaced stepping when we have a signal to deliver;
2562 the comments for displaced_step_prepare explain why. The
2563 comments in the handle_inferior event for dealing with 'random
74609e71
YQ
2564 signals' explain what we do instead.
2565
2566 We can't use displaced stepping when we are waiting for vfork_done
2567 event, displaced stepping breaks the vfork child similarly as single
2568 step software breakpoint. */
3fc8eb30
PA
2569 if (tp->control.trap_expected
2570 && use_displaced_stepping (tp)
cb71640d 2571 && !step_over_info_valid_p ()
a493e3e2 2572 && sig == GDB_SIGNAL_0
74609e71 2573 && !current_inferior ()->waiting_for_vfork_done)
237fc4c9 2574 {
3fc8eb30 2575 int prepared = displaced_step_prepare (inferior_ptid);
fc1cf338 2576
3fc8eb30 2577 if (prepared == 0)
d56b7306 2578 {
4d9d9d04
PA
2579 if (debug_infrun)
2580 fprintf_unfiltered (gdb_stdlog,
2581 "Got placed in step-over queue\n");
2582
2583 tp->control.trap_expected = 0;
d56b7306
VP
2584 discard_cleanups (old_cleanups);
2585 return;
2586 }
3fc8eb30
PA
2587 else if (prepared < 0)
2588 {
2589 /* Fallback to stepping over the breakpoint in-line. */
2590
2591 if (target_is_non_stop_p ())
2592 stop_all_threads ();
2593
2594 set_step_over_info (get_regcache_aspace (regcache),
21edc42f 2595 regcache_read_pc (regcache), 0, tp->global_num);
3fc8eb30
PA
2596
2597 step = maybe_software_singlestep (gdbarch, pc);
2598
2599 insert_breakpoints ();
2600 }
2601 else if (prepared > 0)
2602 {
2603 struct displaced_step_inferior_state *displaced;
99e40580 2604
3fc8eb30
PA
2605 /* Update pc to reflect the new address from which we will
2606 execute instructions due to displaced stepping. */
2607 pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
ca7781d2 2608
3fc8eb30
PA
2609 displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
2610 step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2611 displaced->step_closure);
2612 }
237fc4c9
PA
2613 }
2614
2facfe5c 2615 /* Do we need to do it the hard way, w/temp breakpoints? */
99e40580 2616 else if (step)
2facfe5c 2617 step = maybe_software_singlestep (gdbarch, pc);
c906108c 2618
30852783
UW
2619 /* Currently, our software single-step implementation leads to different
2620 results than hardware single-stepping in one situation: when stepping
2621 into delivering a signal which has an associated signal handler,
2622 hardware single-step will stop at the first instruction of the handler,
2623 while software single-step will simply skip execution of the handler.
2624
2625 For now, this difference in behavior is accepted since there is no
2626 easy way to actually implement single-stepping into a signal handler
2627 without kernel support.
2628
2629 However, there is one scenario where this difference leads to follow-on
2630 problems: if we're stepping off a breakpoint by removing all breakpoints
2631 and then single-stepping. In this case, the software single-step
2632 behavior means that even if there is a *breakpoint* in the signal
2633 handler, GDB still would not stop.
2634
2635 Fortunately, we can at least fix this particular issue. We detect
2636 here the case where we are about to deliver a signal while software
2637 single-stepping with breakpoints removed. In this situation, we
2638 revert the decisions to remove all breakpoints and insert single-
2639 step breakpoints, and instead we install a step-resume breakpoint
2640 at the current address, deliver the signal without stepping, and
2641 once we arrive back at the step-resume breakpoint, actually step
2642 over the breakpoint we originally wanted to step over. */
34b7e8a6 2643 if (thread_has_single_step_breakpoints_set (tp)
6cc83d2a
PA
2644 && sig != GDB_SIGNAL_0
2645 && step_over_info_valid_p ())
30852783
UW
2646 {
2647 /* If we have nested signals or a pending signal is delivered
2648 immediately after a handler returns, might might already have
2649 a step-resume breakpoint set on the earlier handler. We cannot
2650 set another step-resume breakpoint; just continue on until the
2651 original breakpoint is hit. */
2652 if (tp->control.step_resume_breakpoint == NULL)
2653 {
2c03e5be 2654 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
30852783
UW
2655 tp->step_after_step_resume_breakpoint = 1;
2656 }
2657
34b7e8a6 2658 delete_single_step_breakpoints (tp);
30852783 2659
31e77af2 2660 clear_step_over_info ();
30852783 2661 tp->control.trap_expected = 0;
31e77af2
PA
2662
2663 insert_breakpoints ();
30852783
UW
2664 }
2665
b0f16a3e
SM
2666 /* If STEP is set, it's a request to use hardware stepping
2667 facilities. But in that case, we should never
2668 use singlestep breakpoint. */
34b7e8a6 2669 gdb_assert (!(thread_has_single_step_breakpoints_set (tp) && step));
dfcd3bfb 2670
fbea99ea 2671 /* Decide the set of threads to ask the target to resume. */
1946c4cc 2672 if (tp->control.trap_expected)
b0f16a3e
SM
2673 {
2674 /* We're allowing a thread to run past a breakpoint it has
1946c4cc
YQ
2675 hit, either by single-stepping the thread with the breakpoint
2676 removed, or by displaced stepping, with the breakpoint inserted.
2677 In the former case, we need to single-step only this thread,
2678 and keep others stopped, as they can miss this breakpoint if
2679 allowed to run. That's not really a problem for displaced
2680 stepping, but, we still keep other threads stopped, in case
2681 another thread is also stopped for a breakpoint waiting for
2682 its turn in the displaced stepping queue. */
b0f16a3e
SM
2683 resume_ptid = inferior_ptid;
2684 }
fbea99ea
PA
2685 else
2686 resume_ptid = internal_resume_ptid (user_step);
d4db2f36 2687
7f5ef605
PA
2688 if (execution_direction != EXEC_REVERSE
2689 && step && breakpoint_inserted_here_p (aspace, pc))
b0f16a3e 2690 {
372316f1
PA
2691 /* There are two cases where we currently need to step a
2692 breakpoint instruction when we have a signal to deliver:
2693
2694 - See handle_signal_stop where we handle random signals that
2695 could take out us out of the stepping range. Normally, in
2696 that case we end up continuing (instead of stepping) over the
7f5ef605
PA
2697 signal handler with a breakpoint at PC, but there are cases
2698 where we should _always_ single-step, even if we have a
2699 step-resume breakpoint, like when a software watchpoint is
2700 set. Assuming single-stepping and delivering a signal at the
2701 same time would takes us to the signal handler, then we could
2702 have removed the breakpoint at PC to step over it. However,
2703 some hardware step targets (like e.g., Mac OS) can't step
2704 into signal handlers, and for those, we need to leave the
2705 breakpoint at PC inserted, as otherwise if the handler
2706 recurses and executes PC again, it'll miss the breakpoint.
2707 So we leave the breakpoint inserted anyway, but we need to
2708 record that we tried to step a breakpoint instruction, so
372316f1
PA
2709 that adjust_pc_after_break doesn't end up confused.
2710
2711 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2712 in one thread after another thread that was stepping had been
2713 momentarily paused for a step-over. When we re-resume the
2714 stepping thread, it may be resumed from that address with a
2715 breakpoint that hasn't trapped yet. Seen with
2716 gdb.threads/non-stop-fair-events.exp, on targets that don't
2717 do displaced stepping. */
2718
2719 if (debug_infrun)
2720 fprintf_unfiltered (gdb_stdlog,
2721 "infrun: resume: [%s] stepped breakpoint\n",
2722 target_pid_to_str (tp->ptid));
7f5ef605
PA
2723
2724 tp->stepped_breakpoint = 1;
2725
b0f16a3e
SM
2726 /* Most targets can step a breakpoint instruction, thus
2727 executing it normally. But if this one cannot, just
2728 continue and we will hit it anyway. */
7f5ef605 2729 if (gdbarch_cannot_step_breakpoint (gdbarch))
b0f16a3e
SM
2730 step = 0;
2731 }
ef5cf84e 2732
b0f16a3e 2733 if (debug_displaced
cb71640d 2734 && tp->control.trap_expected
3fc8eb30 2735 && use_displaced_stepping (tp)
cb71640d 2736 && !step_over_info_valid_p ())
b0f16a3e 2737 {
d9b67d9f 2738 struct regcache *resume_regcache = get_thread_regcache (tp->ptid);
b0f16a3e
SM
2739 struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
2740 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2741 gdb_byte buf[4];
2742
2743 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2744 paddress (resume_gdbarch, actual_pc));
2745 read_memory (actual_pc, buf, sizeof (buf));
2746 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2747 }
237fc4c9 2748
b0f16a3e
SM
2749 if (tp->control.may_range_step)
2750 {
2751 /* If we're resuming a thread with the PC out of the step
2752 range, then we're doing some nested/finer run control
2753 operation, like stepping the thread out of the dynamic
2754 linker or the displaced stepping scratch pad. We
2755 shouldn't have allowed a range step then. */
2756 gdb_assert (pc_in_thread_step_range (pc, tp));
2757 }
c1e36e3e 2758
64ce06e4 2759 do_target_resume (resume_ptid, step, sig);
372316f1 2760 tp->resumed = 1;
c906108c
SS
2761 discard_cleanups (old_cleanups);
2762}
2763\f
237fc4c9 2764/* Proceeding. */
c906108c 2765
4c2f2a79
PA
2766/* See infrun.h. */
2767
2768/* Counter that tracks number of user visible stops. This can be used
2769 to tell whether a command has proceeded the inferior past the
2770 current location. This allows e.g., inferior function calls in
2771 breakpoint commands to not interrupt the command list. When the
2772 call finishes successfully, the inferior is standing at the same
2773 breakpoint as if nothing happened (and so we don't call
2774 normal_stop). */
2775static ULONGEST current_stop_id;
2776
2777/* See infrun.h. */
2778
2779ULONGEST
2780get_stop_id (void)
2781{
2782 return current_stop_id;
2783}
2784
2785/* Called when we report a user visible stop. */
2786
2787static void
2788new_stop_id (void)
2789{
2790 current_stop_id++;
2791}
2792
c906108c
SS
2793/* Clear out all variables saying what to do when inferior is continued.
2794 First do this, then set the ones you want, then call `proceed'. */
2795
a7212384
UW
2796static void
2797clear_proceed_status_thread (struct thread_info *tp)
c906108c 2798{
a7212384
UW
2799 if (debug_infrun)
2800 fprintf_unfiltered (gdb_stdlog,
2801 "infrun: clear_proceed_status_thread (%s)\n",
2802 target_pid_to_str (tp->ptid));
d6b48e9c 2803
372316f1
PA
2804 /* If we're starting a new sequence, then the previous finished
2805 single-step is no longer relevant. */
2806 if (tp->suspend.waitstatus_pending_p)
2807 {
2808 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
2809 {
2810 if (debug_infrun)
2811 fprintf_unfiltered (gdb_stdlog,
2812 "infrun: clear_proceed_status: pending "
2813 "event of %s was a finished step. "
2814 "Discarding.\n",
2815 target_pid_to_str (tp->ptid));
2816
2817 tp->suspend.waitstatus_pending_p = 0;
2818 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
2819 }
2820 else if (debug_infrun)
2821 {
23fdd69e
SM
2822 std::string statstr
2823 = target_waitstatus_to_string (&tp->suspend.waitstatus);
372316f1 2824
372316f1
PA
2825 fprintf_unfiltered (gdb_stdlog,
2826 "infrun: clear_proceed_status_thread: thread %s "
2827 "has pending wait status %s "
2828 "(currently_stepping=%d).\n",
23fdd69e 2829 target_pid_to_str (tp->ptid), statstr.c_str (),
372316f1 2830 currently_stepping (tp));
372316f1
PA
2831 }
2832 }
2833
70509625
PA
2834 /* If this signal should not be seen by program, give it zero.
2835 Used for debugging signals. */
2836 if (!signal_pass_state (tp->suspend.stop_signal))
2837 tp->suspend.stop_signal = GDB_SIGNAL_0;
2838
243a9253
PA
2839 thread_fsm_delete (tp->thread_fsm);
2840 tp->thread_fsm = NULL;
2841
16c381f0
JK
2842 tp->control.trap_expected = 0;
2843 tp->control.step_range_start = 0;
2844 tp->control.step_range_end = 0;
c1e36e3e 2845 tp->control.may_range_step = 0;
16c381f0
JK
2846 tp->control.step_frame_id = null_frame_id;
2847 tp->control.step_stack_frame_id = null_frame_id;
2848 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
885eeb5b 2849 tp->control.step_start_function = NULL;
a7212384 2850 tp->stop_requested = 0;
4e1c45ea 2851
16c381f0 2852 tp->control.stop_step = 0;
32400beb 2853
16c381f0 2854 tp->control.proceed_to_finish = 0;
414c69f7 2855
856e7dd6 2856 tp->control.stepping_command = 0;
17b2616c 2857
a7212384 2858 /* Discard any remaining commands or status from previous stop. */
16c381f0 2859 bpstat_clear (&tp->control.stop_bpstat);
a7212384 2860}
32400beb 2861
a7212384 2862void
70509625 2863clear_proceed_status (int step)
a7212384 2864{
f2665db5
MM
2865 /* With scheduler-locking replay, stop replaying other threads if we're
2866 not replaying the user-visible resume ptid.
2867
2868 This is a convenience feature to not require the user to explicitly
2869 stop replaying the other threads. We're assuming that the user's
2870 intent is to resume tracing the recorded process. */
2871 if (!non_stop && scheduler_mode == schedlock_replay
2872 && target_record_is_replaying (minus_one_ptid)
2873 && !target_record_will_replay (user_visible_resume_ptid (step),
2874 execution_direction))
2875 target_record_stop_replaying ();
2876
6c95b8df
PA
2877 if (!non_stop)
2878 {
70509625
PA
2879 struct thread_info *tp;
2880 ptid_t resume_ptid;
2881
2882 resume_ptid = user_visible_resume_ptid (step);
2883
2884 /* In all-stop mode, delete the per-thread status of all threads
2885 we're about to resume, implicitly and explicitly. */
2886 ALL_NON_EXITED_THREADS (tp)
2887 {
2888 if (!ptid_match (tp->ptid, resume_ptid))
2889 continue;
2890 clear_proceed_status_thread (tp);
2891 }
6c95b8df
PA
2892 }
2893
a7212384
UW
2894 if (!ptid_equal (inferior_ptid, null_ptid))
2895 {
2896 struct inferior *inferior;
2897
2898 if (non_stop)
2899 {
6c95b8df
PA
2900 /* If in non-stop mode, only delete the per-thread status of
2901 the current thread. */
a7212384
UW
2902 clear_proceed_status_thread (inferior_thread ());
2903 }
6c95b8df 2904
d6b48e9c 2905 inferior = current_inferior ();
16c381f0 2906 inferior->control.stop_soon = NO_STOP_QUIETLY;
4e1c45ea
PA
2907 }
2908
f3b1572e 2909 observer_notify_about_to_proceed ();
c906108c
SS
2910}
2911
99619bea
PA
2912/* Returns true if TP is still stopped at a breakpoint that needs
2913 stepping-over in order to make progress. If the breakpoint is gone
2914 meanwhile, we can skip the whole step-over dance. */
ea67f13b
DJ
2915
2916static int
6c4cfb24 2917thread_still_needs_step_over_bp (struct thread_info *tp)
99619bea
PA
2918{
2919 if (tp->stepping_over_breakpoint)
2920 {
2921 struct regcache *regcache = get_thread_regcache (tp->ptid);
2922
2923 if (breakpoint_here_p (get_regcache_aspace (regcache),
af48d08f
PA
2924 regcache_read_pc (regcache))
2925 == ordinary_breakpoint_here)
99619bea
PA
2926 return 1;
2927
2928 tp->stepping_over_breakpoint = 0;
2929 }
2930
2931 return 0;
2932}
2933
6c4cfb24
PA
2934/* Check whether thread TP still needs to start a step-over in order
2935 to make progress when resumed. Returns an bitwise or of enum
2936 step_over_what bits, indicating what needs to be stepped over. */
2937
8d297bbf 2938static step_over_what
6c4cfb24
PA
2939thread_still_needs_step_over (struct thread_info *tp)
2940{
8d297bbf 2941 step_over_what what = 0;
6c4cfb24
PA
2942
2943 if (thread_still_needs_step_over_bp (tp))
2944 what |= STEP_OVER_BREAKPOINT;
2945
2946 if (tp->stepping_over_watchpoint
2947 && !target_have_steppable_watchpoint)
2948 what |= STEP_OVER_WATCHPOINT;
2949
2950 return what;
2951}
2952
483805cf
PA
2953/* Returns true if scheduler locking applies. STEP indicates whether
2954 we're about to do a step/next-like command to a thread. */
2955
2956static int
856e7dd6 2957schedlock_applies (struct thread_info *tp)
483805cf
PA
2958{
2959 return (scheduler_mode == schedlock_on
2960 || (scheduler_mode == schedlock_step
f2665db5
MM
2961 && tp->control.stepping_command)
2962 || (scheduler_mode == schedlock_replay
2963 && target_record_will_replay (minus_one_ptid,
2964 execution_direction)));
483805cf
PA
2965}
2966
c906108c
SS
2967/* Basic routine for continuing the program in various fashions.
2968
2969 ADDR is the address to resume at, or -1 for resume where stopped.
2970 SIGGNAL is the signal to give it, or 0 for none,
c5aa993b 2971 or -1 for act according to how it stopped.
c906108c 2972 STEP is nonzero if should trap after one instruction.
c5aa993b
JM
2973 -1 means return after that and print nothing.
2974 You should probably set various step_... variables
2975 before calling here, if you are stepping.
c906108c
SS
2976
2977 You should call clear_proceed_status before calling proceed. */
2978
2979void
64ce06e4 2980proceed (CORE_ADDR addr, enum gdb_signal siggnal)
c906108c 2981{
e58b0e63
PA
2982 struct regcache *regcache;
2983 struct gdbarch *gdbarch;
4e1c45ea 2984 struct thread_info *tp;
e58b0e63 2985 CORE_ADDR pc;
6c95b8df 2986 struct address_space *aspace;
4d9d9d04
PA
2987 ptid_t resume_ptid;
2988 struct execution_control_state ecss;
2989 struct execution_control_state *ecs = &ecss;
2990 struct cleanup *old_chain;
85ad3aaf 2991 struct cleanup *defer_resume_cleanup;
4d9d9d04 2992 int started;
c906108c 2993
e58b0e63
PA
2994 /* If we're stopped at a fork/vfork, follow the branch set by the
2995 "set follow-fork-mode" command; otherwise, we'll just proceed
2996 resuming the current thread. */
2997 if (!follow_fork ())
2998 {
2999 /* The target for some reason decided not to resume. */
3000 normal_stop ();
f148b27e
PA
3001 if (target_can_async_p ())
3002 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
e58b0e63
PA
3003 return;
3004 }
3005
842951eb
PA
3006 /* We'll update this if & when we switch to a new thread. */
3007 previous_inferior_ptid = inferior_ptid;
3008
e58b0e63
PA
3009 regcache = get_current_regcache ();
3010 gdbarch = get_regcache_arch (regcache);
6c95b8df 3011 aspace = get_regcache_aspace (regcache);
e58b0e63 3012 pc = regcache_read_pc (regcache);
2adfaa28 3013 tp = inferior_thread ();
e58b0e63 3014
99619bea
PA
3015 /* Fill in with reasonable starting values. */
3016 init_thread_stepping_state (tp);
3017
c2829269
PA
3018 gdb_assert (!thread_is_in_step_over_chain (tp));
3019
2acceee2 3020 if (addr == (CORE_ADDR) -1)
c906108c 3021 {
af48d08f
PA
3022 if (pc == stop_pc
3023 && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
b2175913 3024 && execution_direction != EXEC_REVERSE)
3352ef37
AC
3025 /* There is a breakpoint at the address we will resume at,
3026 step one instruction before inserting breakpoints so that
3027 we do not stop right away (and report a second hit at this
b2175913
MS
3028 breakpoint).
3029
3030 Note, we don't do this in reverse, because we won't
3031 actually be executing the breakpoint insn anyway.
3032 We'll be (un-)executing the previous instruction. */
99619bea 3033 tp->stepping_over_breakpoint = 1;
515630c5
UW
3034 else if (gdbarch_single_step_through_delay_p (gdbarch)
3035 && gdbarch_single_step_through_delay (gdbarch,
3036 get_current_frame ()))
3352ef37
AC
3037 /* We stepped onto an instruction that needs to be stepped
3038 again before re-inserting the breakpoint, do so. */
99619bea 3039 tp->stepping_over_breakpoint = 1;
c906108c
SS
3040 }
3041 else
3042 {
515630c5 3043 regcache_write_pc (regcache, addr);
c906108c
SS
3044 }
3045
70509625
PA
3046 if (siggnal != GDB_SIGNAL_DEFAULT)
3047 tp->suspend.stop_signal = siggnal;
3048
4d9d9d04
PA
3049 resume_ptid = user_visible_resume_ptid (tp->control.stepping_command);
3050
3051 /* If an exception is thrown from this point on, make sure to
3052 propagate GDB's knowledge of the executing state to the
3053 frontend/user running state. */
3054 old_chain = make_cleanup (finish_thread_state_cleanup, &resume_ptid);
3055
3056 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3057 threads (e.g., we might need to set threads stepping over
3058 breakpoints first), from the user/frontend's point of view, all
3059 threads in RESUME_PTID are now running. Unless we're calling an
3060 inferior function, as in that case we pretend the inferior
3061 doesn't run at all. */
3062 if (!tp->control.in_infcall)
3063 set_running (resume_ptid, 1);
17b2616c 3064
527159b7 3065 if (debug_infrun)
8a9de0e4 3066 fprintf_unfiltered (gdb_stdlog,
64ce06e4 3067 "infrun: proceed (addr=%s, signal=%s)\n",
c9737c08 3068 paddress (gdbarch, addr),
64ce06e4 3069 gdb_signal_to_symbol_string (siggnal));
527159b7 3070
4d9d9d04
PA
3071 annotate_starting ();
3072
3073 /* Make sure that output from GDB appears before output from the
3074 inferior. */
3075 gdb_flush (gdb_stdout);
3076
3077 /* In a multi-threaded task we may select another thread and
3078 then continue or step.
3079
3080 But if a thread that we're resuming had stopped at a breakpoint,
3081 it will immediately cause another breakpoint stop without any
3082 execution (i.e. it will report a breakpoint hit incorrectly). So
3083 we must step over it first.
3084
3085 Look for threads other than the current (TP) that reported a
3086 breakpoint hit and haven't been resumed yet since. */
3087
3088 /* If scheduler locking applies, we can avoid iterating over all
3089 threads. */
3090 if (!non_stop && !schedlock_applies (tp))
94cc34af 3091 {
4d9d9d04
PA
3092 struct thread_info *current = tp;
3093
3094 ALL_NON_EXITED_THREADS (tp)
3095 {
3096 /* Ignore the current thread here. It's handled
3097 afterwards. */
3098 if (tp == current)
3099 continue;
99619bea 3100
4d9d9d04
PA
3101 /* Ignore threads of processes we're not resuming. */
3102 if (!ptid_match (tp->ptid, resume_ptid))
3103 continue;
c906108c 3104
4d9d9d04
PA
3105 if (!thread_still_needs_step_over (tp))
3106 continue;
3107
3108 gdb_assert (!thread_is_in_step_over_chain (tp));
c906108c 3109
99619bea
PA
3110 if (debug_infrun)
3111 fprintf_unfiltered (gdb_stdlog,
3112 "infrun: need to step-over [%s] first\n",
4d9d9d04 3113 target_pid_to_str (tp->ptid));
99619bea 3114
4d9d9d04 3115 thread_step_over_chain_enqueue (tp);
2adfaa28 3116 }
31e77af2 3117
4d9d9d04 3118 tp = current;
30852783
UW
3119 }
3120
4d9d9d04
PA
3121 /* Enqueue the current thread last, so that we move all other
3122 threads over their breakpoints first. */
3123 if (tp->stepping_over_breakpoint)
3124 thread_step_over_chain_enqueue (tp);
30852783 3125
4d9d9d04
PA
3126 /* If the thread isn't started, we'll still need to set its prev_pc,
3127 so that switch_back_to_stepped_thread knows the thread hasn't
3128 advanced. Must do this before resuming any thread, as in
3129 all-stop/remote, once we resume we can't send any other packet
3130 until the target stops again. */
3131 tp->prev_pc = regcache_read_pc (regcache);
99619bea 3132
85ad3aaf
PA
3133 defer_resume_cleanup = make_cleanup_defer_target_commit_resume ();
3134
4d9d9d04 3135 started = start_step_over ();
c906108c 3136
4d9d9d04
PA
3137 if (step_over_info_valid_p ())
3138 {
3139 /* Either this thread started a new in-line step over, or some
3140 other thread was already doing one. In either case, don't
3141 resume anything else until the step-over is finished. */
3142 }
fbea99ea 3143 else if (started && !target_is_non_stop_p ())
4d9d9d04
PA
3144 {
3145 /* A new displaced stepping sequence was started. In all-stop,
3146 we can't talk to the target anymore until it next stops. */
3147 }
fbea99ea
PA
3148 else if (!non_stop && target_is_non_stop_p ())
3149 {
3150 /* In all-stop, but the target is always in non-stop mode.
3151 Start all other threads that are implicitly resumed too. */
3152 ALL_NON_EXITED_THREADS (tp)
3153 {
3154 /* Ignore threads of processes we're not resuming. */
3155 if (!ptid_match (tp->ptid, resume_ptid))
3156 continue;
3157
3158 if (tp->resumed)
3159 {
3160 if (debug_infrun)
3161 fprintf_unfiltered (gdb_stdlog,
3162 "infrun: proceed: [%s] resumed\n",
3163 target_pid_to_str (tp->ptid));
3164 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
3165 continue;
3166 }
3167
3168 if (thread_is_in_step_over_chain (tp))
3169 {
3170 if (debug_infrun)
3171 fprintf_unfiltered (gdb_stdlog,
3172 "infrun: proceed: [%s] needs step-over\n",
3173 target_pid_to_str (tp->ptid));
3174 continue;
3175 }
3176
3177 if (debug_infrun)
3178 fprintf_unfiltered (gdb_stdlog,
3179 "infrun: proceed: resuming %s\n",
3180 target_pid_to_str (tp->ptid));
3181
3182 reset_ecs (ecs, tp);
3183 switch_to_thread (tp->ptid);
3184 keep_going_pass_signal (ecs);
3185 if (!ecs->wait_some_more)
fd7dcb94 3186 error (_("Command aborted."));
fbea99ea
PA
3187 }
3188 }
372316f1 3189 else if (!tp->resumed && !thread_is_in_step_over_chain (tp))
4d9d9d04
PA
3190 {
3191 /* The thread wasn't started, and isn't queued, run it now. */
3192 reset_ecs (ecs, tp);
3193 switch_to_thread (tp->ptid);
3194 keep_going_pass_signal (ecs);
3195 if (!ecs->wait_some_more)
fd7dcb94 3196 error (_("Command aborted."));
4d9d9d04 3197 }
c906108c 3198
85ad3aaf
PA
3199 do_cleanups (defer_resume_cleanup);
3200 target_commit_resume ();
3201
4d9d9d04 3202 discard_cleanups (old_chain);
c906108c 3203
0b333c5e
PA
3204 /* Tell the event loop to wait for it to stop. If the target
3205 supports asynchronous execution, it'll do this from within
3206 target_resume. */
362646f5 3207 if (!target_can_async_p ())
0b333c5e 3208 mark_async_event_handler (infrun_async_inferior_event_token);
c906108c 3209}
c906108c
SS
3210\f
3211
3212/* Start remote-debugging of a machine over a serial link. */
96baa820 3213
c906108c 3214void
8621d6a9 3215start_remote (int from_tty)
c906108c 3216{
d6b48e9c 3217 struct inferior *inferior;
d6b48e9c
PA
3218
3219 inferior = current_inferior ();
16c381f0 3220 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
43ff13b4 3221
1777feb0 3222 /* Always go on waiting for the target, regardless of the mode. */
6426a772 3223 /* FIXME: cagney/1999-09-23: At present it isn't possible to
7e73cedf 3224 indicate to wait_for_inferior that a target should timeout if
6426a772
JM
3225 nothing is returned (instead of just blocking). Because of this,
3226 targets expecting an immediate response need to, internally, set
3227 things up so that the target_wait() is forced to eventually
1777feb0 3228 timeout. */
6426a772
JM
3229 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3230 differentiate to its caller what the state of the target is after
3231 the initial open has been performed. Here we're assuming that
3232 the target has stopped. It should be possible to eventually have
3233 target_open() return to the caller an indication that the target
3234 is currently running and GDB state should be set to the same as
1777feb0 3235 for an async run. */
e4c8541f 3236 wait_for_inferior ();
8621d6a9
DJ
3237
3238 /* Now that the inferior has stopped, do any bookkeeping like
3239 loading shared libraries. We want to do this before normal_stop,
3240 so that the displayed frame is up to date. */
3241 post_create_inferior (&current_target, from_tty);
3242
6426a772 3243 normal_stop ();
c906108c
SS
3244}
3245
3246/* Initialize static vars when a new inferior begins. */
3247
3248void
96baa820 3249init_wait_for_inferior (void)
c906108c
SS
3250{
3251 /* These are meaningless until the first time through wait_for_inferior. */
c906108c 3252
c906108c
SS
3253 breakpoint_init_inferior (inf_starting);
3254
70509625 3255 clear_proceed_status (0);
9f976b41 3256
ca005067 3257 target_last_wait_ptid = minus_one_ptid;
237fc4c9 3258
842951eb 3259 previous_inferior_ptid = inferior_ptid;
0d1e5fa7 3260
edb3359d
DJ
3261 /* Discard any skipped inlined frames. */
3262 clear_inline_frame_state (minus_one_ptid);
c906108c 3263}
237fc4c9 3264
c906108c 3265\f
488f131b 3266
ec9499be 3267static void handle_inferior_event (struct execution_control_state *ecs);
cd0fc7c3 3268
568d6575
UW
3269static void handle_step_into_function (struct gdbarch *gdbarch,
3270 struct execution_control_state *ecs);
3271static void handle_step_into_function_backward (struct gdbarch *gdbarch,
3272 struct execution_control_state *ecs);
4f5d7f63 3273static void handle_signal_stop (struct execution_control_state *ecs);
186c406b 3274static void check_exception_resume (struct execution_control_state *,
28106bc2 3275 struct frame_info *);
611c83ae 3276
bdc36728 3277static void end_stepping_range (struct execution_control_state *ecs);
22bcd14b 3278static void stop_waiting (struct execution_control_state *ecs);
d4f3574e 3279static void keep_going (struct execution_control_state *ecs);
94c57d6a 3280static void process_event_stop_test (struct execution_control_state *ecs);
c447ac0b 3281static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
104c1213 3282
252fbfc8
PA
3283/* This function is attached as a "thread_stop_requested" observer.
3284 Cleanup local state that assumed the PTID was to be resumed, and
3285 report the stop to the frontend. */
3286
2c0b251b 3287static void
252fbfc8
PA
3288infrun_thread_stop_requested (ptid_t ptid)
3289{
c2829269 3290 struct thread_info *tp;
252fbfc8 3291
c65d6b55
PA
3292 /* PTID was requested to stop. If the thread was already stopped,
3293 but the user/frontend doesn't know about that yet (e.g., the
3294 thread had been temporarily paused for some step-over), set up
3295 for reporting the stop now. */
c2829269
PA
3296 ALL_NON_EXITED_THREADS (tp)
3297 if (ptid_match (tp->ptid, ptid))
3298 {
c65d6b55
PA
3299 if (tp->state != THREAD_RUNNING)
3300 continue;
3301 if (tp->executing)
3302 continue;
3303
3304 /* Remove matching threads from the step-over queue, so
3305 start_step_over doesn't try to resume them
3306 automatically. */
c2829269
PA
3307 if (thread_is_in_step_over_chain (tp))
3308 thread_step_over_chain_remove (tp);
252fbfc8 3309
c65d6b55
PA
3310 /* If the thread is stopped, but the user/frontend doesn't
3311 know about that yet, queue a pending event, as if the
3312 thread had just stopped now. Unless the thread already had
3313 a pending event. */
3314 if (!tp->suspend.waitstatus_pending_p)
3315 {
3316 tp->suspend.waitstatus_pending_p = 1;
3317 tp->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
3318 tp->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
3319 }
3320
3321 /* Clear the inline-frame state, since we're re-processing the
3322 stop. */
3323 clear_inline_frame_state (tp->ptid);
3324
3325 /* If this thread was paused because some other thread was
3326 doing an inline-step over, let that finish first. Once
3327 that happens, we'll restart all threads and consume pending
3328 stop events then. */
3329 if (step_over_info_valid_p ())
3330 continue;
3331
3332 /* Otherwise we can process the (new) pending event now. Set
3333 it so this pending event is considered by
3334 do_target_wait. */
3335 tp->resumed = 1;
3336 }
252fbfc8
PA
3337}
3338
a07daef3
PA
3339static void
3340infrun_thread_thread_exit (struct thread_info *tp, int silent)
3341{
3342 if (ptid_equal (target_last_wait_ptid, tp->ptid))
3343 nullify_last_target_wait_ptid ();
3344}
3345
0cbcdb96
PA
3346/* Delete the step resume, single-step and longjmp/exception resume
3347 breakpoints of TP. */
4e1c45ea 3348
0cbcdb96
PA
3349static void
3350delete_thread_infrun_breakpoints (struct thread_info *tp)
4e1c45ea 3351{
0cbcdb96
PA
3352 delete_step_resume_breakpoint (tp);
3353 delete_exception_resume_breakpoint (tp);
34b7e8a6 3354 delete_single_step_breakpoints (tp);
4e1c45ea
PA
3355}
3356
0cbcdb96
PA
3357/* If the target still has execution, call FUNC for each thread that
3358 just stopped. In all-stop, that's all the non-exited threads; in
3359 non-stop, that's the current thread, only. */
3360
3361typedef void (*for_each_just_stopped_thread_callback_func)
3362 (struct thread_info *tp);
4e1c45ea
PA
3363
3364static void
0cbcdb96 3365for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
4e1c45ea 3366{
0cbcdb96 3367 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
4e1c45ea
PA
3368 return;
3369
fbea99ea 3370 if (target_is_non_stop_p ())
4e1c45ea 3371 {
0cbcdb96
PA
3372 /* If in non-stop mode, only the current thread stopped. */
3373 func (inferior_thread ());
4e1c45ea
PA
3374 }
3375 else
0cbcdb96
PA
3376 {
3377 struct thread_info *tp;
3378
3379 /* In all-stop mode, all threads have stopped. */
3380 ALL_NON_EXITED_THREADS (tp)
3381 {
3382 func (tp);
3383 }
3384 }
3385}
3386
3387/* Delete the step resume and longjmp/exception resume breakpoints of
3388 the threads that just stopped. */
3389
3390static void
3391delete_just_stopped_threads_infrun_breakpoints (void)
3392{
3393 for_each_just_stopped_thread (delete_thread_infrun_breakpoints);
34b7e8a6
PA
3394}
3395
3396/* Delete the single-step breakpoints of the threads that just
3397 stopped. */
7c16b83e 3398
34b7e8a6
PA
3399static void
3400delete_just_stopped_threads_single_step_breakpoints (void)
3401{
3402 for_each_just_stopped_thread (delete_single_step_breakpoints);
4e1c45ea
PA
3403}
3404
1777feb0 3405/* A cleanup wrapper. */
4e1c45ea
PA
3406
3407static void
0cbcdb96 3408delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg)
4e1c45ea 3409{
0cbcdb96 3410 delete_just_stopped_threads_infrun_breakpoints ();
4e1c45ea
PA
3411}
3412
221e1a37 3413/* See infrun.h. */
223698f8 3414
221e1a37 3415void
223698f8
DE
3416print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
3417 const struct target_waitstatus *ws)
3418{
23fdd69e 3419 std::string status_string = target_waitstatus_to_string (ws);
d7e74731 3420 string_file stb;
223698f8
DE
3421
3422 /* The text is split over several lines because it was getting too long.
3423 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3424 output as a unit; we want only one timestamp printed if debug_timestamp
3425 is set. */
3426
d7e74731
PA
3427 stb.printf ("infrun: target_wait (%d.%ld.%ld",
3428 ptid_get_pid (waiton_ptid),
3429 ptid_get_lwp (waiton_ptid),
3430 ptid_get_tid (waiton_ptid));
dfd4cc63 3431 if (ptid_get_pid (waiton_ptid) != -1)
d7e74731
PA
3432 stb.printf (" [%s]", target_pid_to_str (waiton_ptid));
3433 stb.printf (", status) =\n");
3434 stb.printf ("infrun: %d.%ld.%ld [%s],\n",
3435 ptid_get_pid (result_ptid),
3436 ptid_get_lwp (result_ptid),
3437 ptid_get_tid (result_ptid),
3438 target_pid_to_str (result_ptid));
23fdd69e 3439 stb.printf ("infrun: %s\n", status_string.c_str ());
223698f8
DE
3440
3441 /* This uses %s in part to handle %'s in the text, but also to avoid
3442 a gcc error: the format attribute requires a string literal. */
d7e74731 3443 fprintf_unfiltered (gdb_stdlog, "%s", stb.c_str ());
223698f8
DE
3444}
3445
372316f1
PA
3446/* Select a thread at random, out of those which are resumed and have
3447 had events. */
3448
3449static struct thread_info *
3450random_pending_event_thread (ptid_t waiton_ptid)
3451{
3452 struct thread_info *event_tp;
3453 int num_events = 0;
3454 int random_selector;
3455
3456 /* First see how many events we have. Count only resumed threads
3457 that have an event pending. */
3458 ALL_NON_EXITED_THREADS (event_tp)
3459 if (ptid_match (event_tp->ptid, waiton_ptid)
3460 && event_tp->resumed
3461 && event_tp->suspend.waitstatus_pending_p)
3462 num_events++;
3463
3464 if (num_events == 0)
3465 return NULL;
3466
3467 /* Now randomly pick a thread out of those that have had events. */
3468 random_selector = (int)
3469 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
3470
3471 if (debug_infrun && num_events > 1)
3472 fprintf_unfiltered (gdb_stdlog,
3473 "infrun: Found %d events, selecting #%d\n",
3474 num_events, random_selector);
3475
3476 /* Select the Nth thread that has had an event. */
3477 ALL_NON_EXITED_THREADS (event_tp)
3478 if (ptid_match (event_tp->ptid, waiton_ptid)
3479 && event_tp->resumed
3480 && event_tp->suspend.waitstatus_pending_p)
3481 if (random_selector-- == 0)
3482 break;
3483
3484 return event_tp;
3485}
3486
3487/* Wrapper for target_wait that first checks whether threads have
3488 pending statuses to report before actually asking the target for
3489 more events. */
3490
3491static ptid_t
3492do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
3493{
3494 ptid_t event_ptid;
3495 struct thread_info *tp;
3496
3497 /* First check if there is a resumed thread with a wait status
3498 pending. */
3499 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3500 {
3501 tp = random_pending_event_thread (ptid);
3502 }
3503 else
3504 {
3505 if (debug_infrun)
3506 fprintf_unfiltered (gdb_stdlog,
3507 "infrun: Waiting for specific thread %s.\n",
3508 target_pid_to_str (ptid));
3509
3510 /* We have a specific thread to check. */
3511 tp = find_thread_ptid (ptid);
3512 gdb_assert (tp != NULL);
3513 if (!tp->suspend.waitstatus_pending_p)
3514 tp = NULL;
3515 }
3516
3517 if (tp != NULL
3518 && (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3519 || tp->suspend.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
3520 {
3521 struct regcache *regcache = get_thread_regcache (tp->ptid);
3522 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3523 CORE_ADDR pc;
3524 int discard = 0;
3525
3526 pc = regcache_read_pc (regcache);
3527
3528 if (pc != tp->suspend.stop_pc)
3529 {
3530 if (debug_infrun)
3531 fprintf_unfiltered (gdb_stdlog,
3532 "infrun: PC of %s changed. was=%s, now=%s\n",
3533 target_pid_to_str (tp->ptid),
3534 paddress (gdbarch, tp->prev_pc),
3535 paddress (gdbarch, pc));
3536 discard = 1;
3537 }
3538 else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3539 {
3540 if (debug_infrun)
3541 fprintf_unfiltered (gdb_stdlog,
3542 "infrun: previous breakpoint of %s, at %s gone\n",
3543 target_pid_to_str (tp->ptid),
3544 paddress (gdbarch, pc));
3545
3546 discard = 1;
3547 }
3548
3549 if (discard)
3550 {
3551 if (debug_infrun)
3552 fprintf_unfiltered (gdb_stdlog,
3553 "infrun: pending event of %s cancelled.\n",
3554 target_pid_to_str (tp->ptid));
3555
3556 tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
3557 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3558 }
3559 }
3560
3561 if (tp != NULL)
3562 {
3563 if (debug_infrun)
3564 {
23fdd69e
SM
3565 std::string statstr
3566 = target_waitstatus_to_string (&tp->suspend.waitstatus);
372316f1 3567
372316f1
PA
3568 fprintf_unfiltered (gdb_stdlog,
3569 "infrun: Using pending wait status %s for %s.\n",
23fdd69e 3570 statstr.c_str (),
372316f1 3571 target_pid_to_str (tp->ptid));
372316f1
PA
3572 }
3573
3574 /* Now that we've selected our final event LWP, un-adjust its PC
3575 if it was a software breakpoint (and the target doesn't
3576 always adjust the PC itself). */
3577 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3578 && !target_supports_stopped_by_sw_breakpoint ())
3579 {
3580 struct regcache *regcache;
3581 struct gdbarch *gdbarch;
3582 int decr_pc;
3583
3584 regcache = get_thread_regcache (tp->ptid);
3585 gdbarch = get_regcache_arch (regcache);
3586
3587 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3588 if (decr_pc != 0)
3589 {
3590 CORE_ADDR pc;
3591
3592 pc = regcache_read_pc (regcache);
3593 regcache_write_pc (regcache, pc + decr_pc);
3594 }
3595 }
3596
3597 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3598 *status = tp->suspend.waitstatus;
3599 tp->suspend.waitstatus_pending_p = 0;
3600
3601 /* Wake up the event loop again, until all pending events are
3602 processed. */
3603 if (target_is_async_p ())
3604 mark_async_event_handler (infrun_async_inferior_event_token);
3605 return tp->ptid;
3606 }
3607
3608 /* But if we don't find one, we'll have to wait. */
3609
3610 if (deprecated_target_wait_hook)
3611 event_ptid = deprecated_target_wait_hook (ptid, status, options);
3612 else
3613 event_ptid = target_wait (ptid, status, options);
3614
3615 return event_ptid;
3616}
3617
24291992
PA
3618/* Prepare and stabilize the inferior for detaching it. E.g.,
3619 detaching while a thread is displaced stepping is a recipe for
3620 crashing it, as nothing would readjust the PC out of the scratch
3621 pad. */
3622
3623void
3624prepare_for_detach (void)
3625{
3626 struct inferior *inf = current_inferior ();
3627 ptid_t pid_ptid = pid_to_ptid (inf->pid);
24291992
PA
3628 struct displaced_step_inferior_state *displaced;
3629
3630 displaced = get_displaced_stepping_state (inf->pid);
3631
3632 /* Is any thread of this process displaced stepping? If not,
3633 there's nothing else to do. */
3634 if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
3635 return;
3636
3637 if (debug_infrun)
3638 fprintf_unfiltered (gdb_stdlog,
3639 "displaced-stepping in-process while detaching");
3640
9bcb1f16 3641 scoped_restore restore_detaching = make_scoped_restore (&inf->detaching, true);
24291992
PA
3642
3643 while (!ptid_equal (displaced->step_ptid, null_ptid))
3644 {
3645 struct cleanup *old_chain_2;
3646 struct execution_control_state ecss;
3647 struct execution_control_state *ecs;
3648
3649 ecs = &ecss;
3650 memset (ecs, 0, sizeof (*ecs));
3651
3652 overlay_cache_invalid = 1;
f15cb84a
YQ
3653 /* Flush target cache before starting to handle each event.
3654 Target was running and cache could be stale. This is just a
3655 heuristic. Running threads may modify target memory, but we
3656 don't get any event. */
3657 target_dcache_invalidate ();
24291992 3658
372316f1 3659 ecs->ptid = do_target_wait (pid_ptid, &ecs->ws, 0);
24291992
PA
3660
3661 if (debug_infrun)
3662 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
3663
3664 /* If an error happens while handling the event, propagate GDB's
3665 knowledge of the executing state to the frontend/user running
3666 state. */
3e43a32a
MS
3667 old_chain_2 = make_cleanup (finish_thread_state_cleanup,
3668 &minus_one_ptid);
24291992
PA
3669
3670 /* Now figure out what to do with the result of the result. */
3671 handle_inferior_event (ecs);
3672
3673 /* No error, don't finish the state yet. */
3674 discard_cleanups (old_chain_2);
3675
3676 /* Breakpoints and watchpoints are not installed on the target
3677 at this point, and signals are passed directly to the
3678 inferior, so this must mean the process is gone. */
3679 if (!ecs->wait_some_more)
3680 {
9bcb1f16 3681 restore_detaching.release ();
24291992
PA
3682 error (_("Program exited while detaching"));
3683 }
3684 }
3685
9bcb1f16 3686 restore_detaching.release ();
24291992
PA
3687}
3688
cd0fc7c3 3689/* Wait for control to return from inferior to debugger.
ae123ec6 3690
cd0fc7c3
SS
3691 If inferior gets a signal, we may decide to start it up again
3692 instead of returning. That is why there is a loop in this function.
3693 When this function actually returns it means the inferior
3694 should be left stopped and GDB should read more commands. */
3695
3696void
e4c8541f 3697wait_for_inferior (void)
cd0fc7c3
SS
3698{
3699 struct cleanup *old_cleanups;
e6f5c25b 3700 struct cleanup *thread_state_chain;
c906108c 3701
527159b7 3702 if (debug_infrun)
ae123ec6 3703 fprintf_unfiltered
e4c8541f 3704 (gdb_stdlog, "infrun: wait_for_inferior ()\n");
527159b7 3705
0cbcdb96
PA
3706 old_cleanups
3707 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup,
3708 NULL);
cd0fc7c3 3709
e6f5c25b
PA
3710 /* If an error happens while handling the event, propagate GDB's
3711 knowledge of the executing state to the frontend/user running
3712 state. */
3713 thread_state_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3714
c906108c
SS
3715 while (1)
3716 {
ae25568b
PA
3717 struct execution_control_state ecss;
3718 struct execution_control_state *ecs = &ecss;
963f9c80 3719 ptid_t waiton_ptid = minus_one_ptid;
29f49a6a 3720
ae25568b
PA
3721 memset (ecs, 0, sizeof (*ecs));
3722
ec9499be 3723 overlay_cache_invalid = 1;
ec9499be 3724
f15cb84a
YQ
3725 /* Flush target cache before starting to handle each event.
3726 Target was running and cache could be stale. This is just a
3727 heuristic. Running threads may modify target memory, but we
3728 don't get any event. */
3729 target_dcache_invalidate ();
3730
372316f1 3731 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws, 0);
c906108c 3732
f00150c9 3733 if (debug_infrun)
223698f8 3734 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
f00150c9 3735
cd0fc7c3
SS
3736 /* Now figure out what to do with the result of the result. */
3737 handle_inferior_event (ecs);
c906108c 3738
cd0fc7c3
SS
3739 if (!ecs->wait_some_more)
3740 break;
3741 }
4e1c45ea 3742
e6f5c25b
PA
3743 /* No error, don't finish the state yet. */
3744 discard_cleanups (thread_state_chain);
3745
cd0fc7c3
SS
3746 do_cleanups (old_cleanups);
3747}
c906108c 3748
d3d4baed
PA
3749/* Cleanup that reinstalls the readline callback handler, if the
3750 target is running in the background. If while handling the target
3751 event something triggered a secondary prompt, like e.g., a
3752 pagination prompt, we'll have removed the callback handler (see
3753 gdb_readline_wrapper_line). Need to do this as we go back to the
3754 event loop, ready to process further input. Note this has no
3755 effect if the handler hasn't actually been removed, because calling
3756 rl_callback_handler_install resets the line buffer, thus losing
3757 input. */
3758
3759static void
3760reinstall_readline_callback_handler_cleanup (void *arg)
3761{
3b12939d
PA
3762 struct ui *ui = current_ui;
3763
3764 if (!ui->async)
6c400b59
PA
3765 {
3766 /* We're not going back to the top level event loop yet. Don't
3767 install the readline callback, as it'd prep the terminal,
3768 readline-style (raw, noecho) (e.g., --batch). We'll install
3769 it the next time the prompt is displayed, when we're ready
3770 for input. */
3771 return;
3772 }
3773
3b12939d 3774 if (ui->command_editing && ui->prompt_state != PROMPT_BLOCKED)
d3d4baed
PA
3775 gdb_rl_callback_handler_reinstall ();
3776}
3777
243a9253
PA
3778/* Clean up the FSMs of threads that are now stopped. In non-stop,
3779 that's just the event thread. In all-stop, that's all threads. */
3780
3781static void
3782clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
3783{
3784 struct thread_info *thr = ecs->event_thread;
3785
3786 if (thr != NULL && thr->thread_fsm != NULL)
8980e177 3787 thread_fsm_clean_up (thr->thread_fsm, thr);
243a9253
PA
3788
3789 if (!non_stop)
3790 {
3791 ALL_NON_EXITED_THREADS (thr)
3792 {
3793 if (thr->thread_fsm == NULL)
3794 continue;
3795 if (thr == ecs->event_thread)
3796 continue;
3797
3798 switch_to_thread (thr->ptid);
8980e177 3799 thread_fsm_clean_up (thr->thread_fsm, thr);
243a9253
PA
3800 }
3801
3802 if (ecs->event_thread != NULL)
3803 switch_to_thread (ecs->event_thread->ptid);
3804 }
3805}
3806
3b12939d
PA
3807/* Helper for all_uis_check_sync_execution_done that works on the
3808 current UI. */
3809
3810static void
3811check_curr_ui_sync_execution_done (void)
3812{
3813 struct ui *ui = current_ui;
3814
3815 if (ui->prompt_state == PROMPT_NEEDED
3816 && ui->async
3817 && !gdb_in_secondary_prompt_p (ui))
3818 {
3819 target_terminal_ours ();
3820 observer_notify_sync_execution_done ();
3eb7562a 3821 ui_register_input_event_handler (ui);
3b12939d
PA
3822 }
3823}
3824
3825/* See infrun.h. */
3826
3827void
3828all_uis_check_sync_execution_done (void)
3829{
0e454242 3830 SWITCH_THRU_ALL_UIS ()
3b12939d
PA
3831 {
3832 check_curr_ui_sync_execution_done ();
3833 }
3834}
3835
a8836c93
PA
3836/* See infrun.h. */
3837
3838void
3839all_uis_on_sync_execution_starting (void)
3840{
0e454242 3841 SWITCH_THRU_ALL_UIS ()
a8836c93
PA
3842 {
3843 if (current_ui->prompt_state == PROMPT_NEEDED)
3844 async_disable_stdin ();
3845 }
3846}
3847
1777feb0 3848/* Asynchronous version of wait_for_inferior. It is called by the
43ff13b4 3849 event loop whenever a change of state is detected on the file
1777feb0
MS
3850 descriptor corresponding to the target. It can be called more than
3851 once to complete a single execution command. In such cases we need
3852 to keep the state in a global variable ECSS. If it is the last time
a474d7c2
PA
3853 that this function is called for a single execution command, then
3854 report to the user that the inferior has stopped, and do the
1777feb0 3855 necessary cleanups. */
43ff13b4
JM
3856
3857void
fba45db2 3858fetch_inferior_event (void *client_data)
43ff13b4 3859{
0d1e5fa7 3860 struct execution_control_state ecss;
a474d7c2 3861 struct execution_control_state *ecs = &ecss;
4f8d22e3 3862 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
29f49a6a 3863 struct cleanup *ts_old_chain;
0f641c01 3864 int cmd_done = 0;
963f9c80 3865 ptid_t waiton_ptid = minus_one_ptid;
43ff13b4 3866
0d1e5fa7
PA
3867 memset (ecs, 0, sizeof (*ecs));
3868
c61db772
PA
3869 /* Events are always processed with the main UI as current UI. This
3870 way, warnings, debug output, etc. are always consistently sent to
3871 the main console. */
4b6749b9 3872 scoped_restore save_ui = make_scoped_restore (&current_ui, main_ui);
c61db772 3873
d3d4baed
PA
3874 /* End up with readline processing input, if necessary. */
3875 make_cleanup (reinstall_readline_callback_handler_cleanup, NULL);
3876
c5187ac6
PA
3877 /* We're handling a live event, so make sure we're doing live
3878 debugging. If we're looking at traceframes while the target is
3879 running, we're going to need to get back to that mode after
3880 handling the event. */
3881 if (non_stop)
3882 {
3883 make_cleanup_restore_current_traceframe ();
e6e4e701 3884 set_current_traceframe (-1);
c5187ac6
PA
3885 }
3886
5ed8105e
PA
3887 gdb::optional<scoped_restore_current_thread> maybe_restore_thread;
3888
4f8d22e3
PA
3889 if (non_stop)
3890 /* In non-stop mode, the user/frontend should not notice a thread
3891 switch due to internal events. Make sure we reverse to the
3892 user selected thread and frame after handling the event and
3893 running any breakpoint commands. */
5ed8105e 3894 maybe_restore_thread.emplace ();
4f8d22e3 3895
ec9499be 3896 overlay_cache_invalid = 1;
f15cb84a
YQ
3897 /* Flush target cache before starting to handle each event. Target
3898 was running and cache could be stale. This is just a heuristic.
3899 Running threads may modify target memory, but we don't get any
3900 event. */
3901 target_dcache_invalidate ();
3dd5b83d 3902
b7b633e9
TT
3903 scoped_restore save_exec_dir
3904 = make_scoped_restore (&execution_direction, target_execution_direction ());
32231432 3905
0b333c5e
PA
3906 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
3907 target_can_async_p () ? TARGET_WNOHANG : 0);
43ff13b4 3908
f00150c9 3909 if (debug_infrun)
223698f8 3910 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
f00150c9 3911
29f49a6a
PA
3912 /* If an error happens while handling the event, propagate GDB's
3913 knowledge of the executing state to the frontend/user running
3914 state. */
fbea99ea 3915 if (!target_is_non_stop_p ())
29f49a6a
PA
3916 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3917 else
3918 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
3919
353d1d73
JK
3920 /* Get executed before make_cleanup_restore_current_thread above to apply
3921 still for the thread which has thrown the exception. */
3922 make_bpstat_clear_actions_cleanup ();
3923
7c16b83e
PA
3924 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
3925
43ff13b4 3926 /* Now figure out what to do with the result of the result. */
a474d7c2 3927 handle_inferior_event (ecs);
43ff13b4 3928
a474d7c2 3929 if (!ecs->wait_some_more)
43ff13b4 3930 {
c9657e70 3931 struct inferior *inf = find_inferior_ptid (ecs->ptid);
243a9253
PA
3932 int should_stop = 1;
3933 struct thread_info *thr = ecs->event_thread;
388a7084 3934 int should_notify_stop = 1;
d6b48e9c 3935
0cbcdb96 3936 delete_just_stopped_threads_infrun_breakpoints ();
f107f563 3937
243a9253
PA
3938 if (thr != NULL)
3939 {
3940 struct thread_fsm *thread_fsm = thr->thread_fsm;
3941
3942 if (thread_fsm != NULL)
8980e177 3943 should_stop = thread_fsm_should_stop (thread_fsm, thr);
243a9253
PA
3944 }
3945
3946 if (!should_stop)
3947 {
3948 keep_going (ecs);
3949 }
c2d11a7d 3950 else
0f641c01 3951 {
243a9253
PA
3952 clean_up_just_stopped_threads_fsms (ecs);
3953
388a7084
PA
3954 if (thr != NULL && thr->thread_fsm != NULL)
3955 {
3956 should_notify_stop
3957 = thread_fsm_should_notify_stop (thr->thread_fsm);
3958 }
3959
3960 if (should_notify_stop)
3961 {
4c2f2a79
PA
3962 int proceeded = 0;
3963
388a7084
PA
3964 /* We may not find an inferior if this was a process exit. */
3965 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
4c2f2a79 3966 proceeded = normal_stop ();
243a9253 3967
4c2f2a79
PA
3968 if (!proceeded)
3969 {
3970 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3971 cmd_done = 1;
3972 }
388a7084 3973 }
0f641c01 3974 }
43ff13b4 3975 }
4f8d22e3 3976
29f49a6a
PA
3977 /* No error, don't finish the thread states yet. */
3978 discard_cleanups (ts_old_chain);
3979
4f8d22e3
PA
3980 /* Revert thread and frame. */
3981 do_cleanups (old_chain);
3982
3b12939d
PA
3983 /* If a UI was in sync execution mode, and now isn't, restore its
3984 prompt (a synchronous execution command has finished, and we're
3985 ready for input). */
3986 all_uis_check_sync_execution_done ();
0f641c01
PA
3987
3988 if (cmd_done
0f641c01
PA
3989 && exec_done_display_p
3990 && (ptid_equal (inferior_ptid, null_ptid)
3991 || !is_running (inferior_ptid)))
3992 printf_unfiltered (_("completed.\n"));
43ff13b4
JM
3993}
3994
edb3359d
DJ
3995/* Record the frame and location we're currently stepping through. */
3996void
3997set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3998{
3999 struct thread_info *tp = inferior_thread ();
4000
16c381f0
JK
4001 tp->control.step_frame_id = get_frame_id (frame);
4002 tp->control.step_stack_frame_id = get_stack_frame_id (frame);
edb3359d
DJ
4003
4004 tp->current_symtab = sal.symtab;
4005 tp->current_line = sal.line;
4006}
4007
0d1e5fa7
PA
4008/* Clear context switchable stepping state. */
4009
4010void
4e1c45ea 4011init_thread_stepping_state (struct thread_info *tss)
0d1e5fa7 4012{
7f5ef605 4013 tss->stepped_breakpoint = 0;
0d1e5fa7 4014 tss->stepping_over_breakpoint = 0;
963f9c80 4015 tss->stepping_over_watchpoint = 0;
0d1e5fa7 4016 tss->step_after_step_resume_breakpoint = 0;
cd0fc7c3
SS
4017}
4018
c32c64b7
DE
4019/* Set the cached copy of the last ptid/waitstatus. */
4020
6efcd9a8 4021void
c32c64b7
DE
4022set_last_target_status (ptid_t ptid, struct target_waitstatus status)
4023{
4024 target_last_wait_ptid = ptid;
4025 target_last_waitstatus = status;
4026}
4027
e02bc4cc 4028/* Return the cached copy of the last pid/waitstatus returned by
9a4105ab
AC
4029 target_wait()/deprecated_target_wait_hook(). The data is actually
4030 cached by handle_inferior_event(), which gets called immediately
4031 after target_wait()/deprecated_target_wait_hook(). */
e02bc4cc
DS
4032
4033void
488f131b 4034get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
e02bc4cc 4035{
39f77062 4036 *ptidp = target_last_wait_ptid;
e02bc4cc
DS
4037 *status = target_last_waitstatus;
4038}
4039
ac264b3b
MS
4040void
4041nullify_last_target_wait_ptid (void)
4042{
4043 target_last_wait_ptid = minus_one_ptid;
4044}
4045
dcf4fbde 4046/* Switch thread contexts. */
dd80620e
MS
4047
4048static void
0d1e5fa7 4049context_switch (ptid_t ptid)
dd80620e 4050{
4b51d87b 4051 if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
fd48f117
DJ
4052 {
4053 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
4054 target_pid_to_str (inferior_ptid));
4055 fprintf_unfiltered (gdb_stdlog, "to %s\n",
0d1e5fa7 4056 target_pid_to_str (ptid));
fd48f117
DJ
4057 }
4058
0d1e5fa7 4059 switch_to_thread (ptid);
dd80620e
MS
4060}
4061
d8dd4d5f
PA
4062/* If the target can't tell whether we've hit breakpoints
4063 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4064 check whether that could have been caused by a breakpoint. If so,
4065 adjust the PC, per gdbarch_decr_pc_after_break. */
4066
4fa8626c 4067static void
d8dd4d5f
PA
4068adjust_pc_after_break (struct thread_info *thread,
4069 struct target_waitstatus *ws)
4fa8626c 4070{
24a73cce
UW
4071 struct regcache *regcache;
4072 struct gdbarch *gdbarch;
6c95b8df 4073 struct address_space *aspace;
118e6252 4074 CORE_ADDR breakpoint_pc, decr_pc;
4fa8626c 4075
4fa8626c
DJ
4076 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4077 we aren't, just return.
9709f61c
DJ
4078
4079 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
b798847d
UW
4080 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4081 implemented by software breakpoints should be handled through the normal
4082 breakpoint layer.
8fb3e588 4083
4fa8626c
DJ
4084 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4085 different signals (SIGILL or SIGEMT for instance), but it is less
4086 clear where the PC is pointing afterwards. It may not match
b798847d
UW
4087 gdbarch_decr_pc_after_break. I don't know any specific target that
4088 generates these signals at breakpoints (the code has been in GDB since at
4089 least 1992) so I can not guess how to handle them here.
8fb3e588 4090
e6cf7916
UW
4091 In earlier versions of GDB, a target with
4092 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
b798847d
UW
4093 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4094 target with both of these set in GDB history, and it seems unlikely to be
4095 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4fa8626c 4096
d8dd4d5f 4097 if (ws->kind != TARGET_WAITKIND_STOPPED)
4fa8626c
DJ
4098 return;
4099
d8dd4d5f 4100 if (ws->value.sig != GDB_SIGNAL_TRAP)
4fa8626c
DJ
4101 return;
4102
4058b839
PA
4103 /* In reverse execution, when a breakpoint is hit, the instruction
4104 under it has already been de-executed. The reported PC always
4105 points at the breakpoint address, so adjusting it further would
4106 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4107 architecture:
4108
4109 B1 0x08000000 : INSN1
4110 B2 0x08000001 : INSN2
4111 0x08000002 : INSN3
4112 PC -> 0x08000003 : INSN4
4113
4114 Say you're stopped at 0x08000003 as above. Reverse continuing
4115 from that point should hit B2 as below. Reading the PC when the
4116 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4117 been de-executed already.
4118
4119 B1 0x08000000 : INSN1
4120 B2 PC -> 0x08000001 : INSN2
4121 0x08000002 : INSN3
4122 0x08000003 : INSN4
4123
4124 We can't apply the same logic as for forward execution, because
4125 we would wrongly adjust the PC to 0x08000000, since there's a
4126 breakpoint at PC - 1. We'd then report a hit on B1, although
4127 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4128 behaviour. */
4129 if (execution_direction == EXEC_REVERSE)
4130 return;
4131
1cf4d951
PA
4132 /* If the target can tell whether the thread hit a SW breakpoint,
4133 trust it. Targets that can tell also adjust the PC
4134 themselves. */
4135 if (target_supports_stopped_by_sw_breakpoint ())
4136 return;
4137
4138 /* Note that relying on whether a breakpoint is planted in memory to
4139 determine this can fail. E.g,. the breakpoint could have been
4140 removed since. Or the thread could have been told to step an
4141 instruction the size of a breakpoint instruction, and only
4142 _after_ was a breakpoint inserted at its address. */
4143
24a73cce
UW
4144 /* If this target does not decrement the PC after breakpoints, then
4145 we have nothing to do. */
d8dd4d5f 4146 regcache = get_thread_regcache (thread->ptid);
24a73cce 4147 gdbarch = get_regcache_arch (regcache);
118e6252 4148
527a273a 4149 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
118e6252 4150 if (decr_pc == 0)
24a73cce
UW
4151 return;
4152
6c95b8df
PA
4153 aspace = get_regcache_aspace (regcache);
4154
8aad930b
AC
4155 /* Find the location where (if we've hit a breakpoint) the
4156 breakpoint would be. */
118e6252 4157 breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
8aad930b 4158
1cf4d951
PA
4159 /* If the target can't tell whether a software breakpoint triggered,
4160 fallback to figuring it out based on breakpoints we think were
4161 inserted in the target, and on whether the thread was stepped or
4162 continued. */
4163
1c5cfe86
PA
4164 /* Check whether there actually is a software breakpoint inserted at
4165 that location.
4166
4167 If in non-stop mode, a race condition is possible where we've
4168 removed a breakpoint, but stop events for that breakpoint were
4169 already queued and arrive later. To suppress those spurious
4170 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
1cf4d951
PA
4171 and retire them after a number of stop events are reported. Note
4172 this is an heuristic and can thus get confused. The real fix is
4173 to get the "stopped by SW BP and needs adjustment" info out of
4174 the target/kernel (and thus never reach here; see above). */
6c95b8df 4175 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
fbea99ea
PA
4176 || (target_is_non_stop_p ()
4177 && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
8aad930b 4178 {
77f9e713 4179 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
abbb1732 4180
8213266a 4181 if (record_full_is_used ())
77f9e713 4182 record_full_gdb_operation_disable_set ();
96429cc8 4183
1c0fdd0e
UW
4184 /* When using hardware single-step, a SIGTRAP is reported for both
4185 a completed single-step and a software breakpoint. Need to
4186 differentiate between the two, as the latter needs adjusting
4187 but the former does not.
4188
4189 The SIGTRAP can be due to a completed hardware single-step only if
4190 - we didn't insert software single-step breakpoints
1c0fdd0e
UW
4191 - this thread is currently being stepped
4192
4193 If any of these events did not occur, we must have stopped due
4194 to hitting a software breakpoint, and have to back up to the
4195 breakpoint address.
4196
4197 As a special case, we could have hardware single-stepped a
4198 software breakpoint. In this case (prev_pc == breakpoint_pc),
4199 we also need to back up to the breakpoint address. */
4200
d8dd4d5f
PA
4201 if (thread_has_single_step_breakpoints_set (thread)
4202 || !currently_stepping (thread)
4203 || (thread->stepped_breakpoint
4204 && thread->prev_pc == breakpoint_pc))
515630c5 4205 regcache_write_pc (regcache, breakpoint_pc);
96429cc8 4206
77f9e713 4207 do_cleanups (old_cleanups);
8aad930b 4208 }
4fa8626c
DJ
4209}
4210
edb3359d
DJ
4211static int
4212stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
4213{
4214 for (frame = get_prev_frame (frame);
4215 frame != NULL;
4216 frame = get_prev_frame (frame))
4217 {
4218 if (frame_id_eq (get_frame_id (frame), step_frame_id))
4219 return 1;
4220 if (get_frame_type (frame) != INLINE_FRAME)
4221 break;
4222 }
4223
4224 return 0;
4225}
4226
c65d6b55
PA
4227/* If the event thread has the stop requested flag set, pretend it
4228 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4229 target_stop). */
4230
4231static bool
4232handle_stop_requested (struct execution_control_state *ecs)
4233{
4234 if (ecs->event_thread->stop_requested)
4235 {
4236 ecs->ws.kind = TARGET_WAITKIND_STOPPED;
4237 ecs->ws.value.sig = GDB_SIGNAL_0;
4238 handle_signal_stop (ecs);
4239 return true;
4240 }
4241 return false;
4242}
4243
a96d9b2e
SDJ
4244/* Auxiliary function that handles syscall entry/return events.
4245 It returns 1 if the inferior should keep going (and GDB
4246 should ignore the event), or 0 if the event deserves to be
4247 processed. */
ca2163eb 4248
a96d9b2e 4249static int
ca2163eb 4250handle_syscall_event (struct execution_control_state *ecs)
a96d9b2e 4251{
ca2163eb 4252 struct regcache *regcache;
ca2163eb
PA
4253 int syscall_number;
4254
4255 if (!ptid_equal (ecs->ptid, inferior_ptid))
4256 context_switch (ecs->ptid);
4257
4258 regcache = get_thread_regcache (ecs->ptid);
f90263c1 4259 syscall_number = ecs->ws.value.syscall_number;
ca2163eb
PA
4260 stop_pc = regcache_read_pc (regcache);
4261
a96d9b2e
SDJ
4262 if (catch_syscall_enabled () > 0
4263 && catching_syscall_number (syscall_number) > 0)
4264 {
4265 if (debug_infrun)
4266 fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
4267 syscall_number);
a96d9b2e 4268
16c381f0 4269 ecs->event_thread->control.stop_bpstat
6c95b8df 4270 = bpstat_stop_status (get_regcache_aspace (regcache),
09ac7c10 4271 stop_pc, ecs->ptid, &ecs->ws);
ab04a2af 4272
c65d6b55
PA
4273 if (handle_stop_requested (ecs))
4274 return 0;
4275
ce12b012 4276 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
ca2163eb
PA
4277 {
4278 /* Catchpoint hit. */
ca2163eb
PA
4279 return 0;
4280 }
a96d9b2e 4281 }
ca2163eb 4282
c65d6b55
PA
4283 if (handle_stop_requested (ecs))
4284 return 0;
4285
ca2163eb 4286 /* If no catchpoint triggered for this, then keep going. */
ca2163eb
PA
4287 keep_going (ecs);
4288 return 1;
a96d9b2e
SDJ
4289}
4290
7e324e48
GB
4291/* Lazily fill in the execution_control_state's stop_func_* fields. */
4292
4293static void
4294fill_in_stop_func (struct gdbarch *gdbarch,
4295 struct execution_control_state *ecs)
4296{
4297 if (!ecs->stop_func_filled_in)
4298 {
4299 /* Don't care about return value; stop_func_start and stop_func_name
4300 will both be 0 if it doesn't work. */
4301 find_pc_partial_function (stop_pc, &ecs->stop_func_name,
4302 &ecs->stop_func_start, &ecs->stop_func_end);
4303 ecs->stop_func_start
4304 += gdbarch_deprecated_function_start_offset (gdbarch);
4305
591a12a1
UW
4306 if (gdbarch_skip_entrypoint_p (gdbarch))
4307 ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
4308 ecs->stop_func_start);
4309
7e324e48
GB
4310 ecs->stop_func_filled_in = 1;
4311 }
4312}
4313
4f5d7f63
PA
4314
4315/* Return the STOP_SOON field of the inferior pointed at by PTID. */
4316
4317static enum stop_kind
4318get_inferior_stop_soon (ptid_t ptid)
4319{
c9657e70 4320 struct inferior *inf = find_inferior_ptid (ptid);
4f5d7f63
PA
4321
4322 gdb_assert (inf != NULL);
4323 return inf->control.stop_soon;
4324}
4325
372316f1
PA
4326/* Wait for one event. Store the resulting waitstatus in WS, and
4327 return the event ptid. */
4328
4329static ptid_t
4330wait_one (struct target_waitstatus *ws)
4331{
4332 ptid_t event_ptid;
4333 ptid_t wait_ptid = minus_one_ptid;
4334
4335 overlay_cache_invalid = 1;
4336
4337 /* Flush target cache before starting to handle each event.
4338 Target was running and cache could be stale. This is just a
4339 heuristic. Running threads may modify target memory, but we
4340 don't get any event. */
4341 target_dcache_invalidate ();
4342
4343 if (deprecated_target_wait_hook)
4344 event_ptid = deprecated_target_wait_hook (wait_ptid, ws, 0);
4345 else
4346 event_ptid = target_wait (wait_ptid, ws, 0);
4347
4348 if (debug_infrun)
4349 print_target_wait_results (wait_ptid, event_ptid, ws);
4350
4351 return event_ptid;
4352}
4353
4354/* Generate a wrapper for target_stopped_by_REASON that works on PTID
4355 instead of the current thread. */
4356#define THREAD_STOPPED_BY(REASON) \
4357static int \
4358thread_stopped_by_ ## REASON (ptid_t ptid) \
4359{ \
2989a365 4360 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); \
372316f1
PA
4361 inferior_ptid = ptid; \
4362 \
2989a365 4363 return target_stopped_by_ ## REASON (); \
372316f1
PA
4364}
4365
4366/* Generate thread_stopped_by_watchpoint. */
4367THREAD_STOPPED_BY (watchpoint)
4368/* Generate thread_stopped_by_sw_breakpoint. */
4369THREAD_STOPPED_BY (sw_breakpoint)
4370/* Generate thread_stopped_by_hw_breakpoint. */
4371THREAD_STOPPED_BY (hw_breakpoint)
4372
4373/* Cleanups that switches to the PTID pointed at by PTID_P. */
4374
4375static void
4376switch_to_thread_cleanup (void *ptid_p)
4377{
4378 ptid_t ptid = *(ptid_t *) ptid_p;
4379
4380 switch_to_thread (ptid);
4381}
4382
4383/* Save the thread's event and stop reason to process it later. */
4384
4385static void
4386save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws)
4387{
4388 struct regcache *regcache;
4389 struct address_space *aspace;
4390
4391 if (debug_infrun)
4392 {
23fdd69e 4393 std::string statstr = target_waitstatus_to_string (ws);
372316f1 4394
372316f1
PA
4395 fprintf_unfiltered (gdb_stdlog,
4396 "infrun: saving status %s for %d.%ld.%ld\n",
23fdd69e 4397 statstr.c_str (),
372316f1
PA
4398 ptid_get_pid (tp->ptid),
4399 ptid_get_lwp (tp->ptid),
4400 ptid_get_tid (tp->ptid));
372316f1
PA
4401 }
4402
4403 /* Record for later. */
4404 tp->suspend.waitstatus = *ws;
4405 tp->suspend.waitstatus_pending_p = 1;
4406
4407 regcache = get_thread_regcache (tp->ptid);
4408 aspace = get_regcache_aspace (regcache);
4409
4410 if (ws->kind == TARGET_WAITKIND_STOPPED
4411 && ws->value.sig == GDB_SIGNAL_TRAP)
4412 {
4413 CORE_ADDR pc = regcache_read_pc (regcache);
4414
4415 adjust_pc_after_break (tp, &tp->suspend.waitstatus);
4416
4417 if (thread_stopped_by_watchpoint (tp->ptid))
4418 {
4419 tp->suspend.stop_reason
4420 = TARGET_STOPPED_BY_WATCHPOINT;
4421 }
4422 else if (target_supports_stopped_by_sw_breakpoint ()
4423 && thread_stopped_by_sw_breakpoint (tp->ptid))
4424 {
4425 tp->suspend.stop_reason
4426 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4427 }
4428 else if (target_supports_stopped_by_hw_breakpoint ()
4429 && thread_stopped_by_hw_breakpoint (tp->ptid))
4430 {
4431 tp->suspend.stop_reason
4432 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4433 }
4434 else if (!target_supports_stopped_by_hw_breakpoint ()
4435 && hardware_breakpoint_inserted_here_p (aspace,
4436 pc))
4437 {
4438 tp->suspend.stop_reason
4439 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4440 }
4441 else if (!target_supports_stopped_by_sw_breakpoint ()
4442 && software_breakpoint_inserted_here_p (aspace,
4443 pc))
4444 {
4445 tp->suspend.stop_reason
4446 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4447 }
4448 else if (!thread_has_single_step_breakpoints_set (tp)
4449 && currently_stepping (tp))
4450 {
4451 tp->suspend.stop_reason
4452 = TARGET_STOPPED_BY_SINGLE_STEP;
4453 }
4454 }
4455}
4456
65706a29
PA
4457/* A cleanup that disables thread create/exit events. */
4458
4459static void
4460disable_thread_events (void *arg)
4461{
4462 target_thread_events (0);
4463}
4464
6efcd9a8 4465/* See infrun.h. */
372316f1 4466
6efcd9a8 4467void
372316f1
PA
4468stop_all_threads (void)
4469{
4470 /* We may need multiple passes to discover all threads. */
4471 int pass;
4472 int iterations = 0;
4473 ptid_t entry_ptid;
4474 struct cleanup *old_chain;
4475
fbea99ea 4476 gdb_assert (target_is_non_stop_p ());
372316f1
PA
4477
4478 if (debug_infrun)
4479 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
4480
4481 entry_ptid = inferior_ptid;
4482 old_chain = make_cleanup (switch_to_thread_cleanup, &entry_ptid);
4483
65706a29
PA
4484 target_thread_events (1);
4485 make_cleanup (disable_thread_events, NULL);
4486
372316f1
PA
4487 /* Request threads to stop, and then wait for the stops. Because
4488 threads we already know about can spawn more threads while we're
4489 trying to stop them, and we only learn about new threads when we
4490 update the thread list, do this in a loop, and keep iterating
4491 until two passes find no threads that need to be stopped. */
4492 for (pass = 0; pass < 2; pass++, iterations++)
4493 {
4494 if (debug_infrun)
4495 fprintf_unfiltered (gdb_stdlog,
4496 "infrun: stop_all_threads, pass=%d, "
4497 "iterations=%d\n", pass, iterations);
4498 while (1)
4499 {
4500 ptid_t event_ptid;
4501 struct target_waitstatus ws;
4502 int need_wait = 0;
4503 struct thread_info *t;
4504
4505 update_thread_list ();
4506
4507 /* Go through all threads looking for threads that we need
4508 to tell the target to stop. */
4509 ALL_NON_EXITED_THREADS (t)
4510 {
4511 if (t->executing)
4512 {
4513 /* If already stopping, don't request a stop again.
4514 We just haven't seen the notification yet. */
4515 if (!t->stop_requested)
4516 {
4517 if (debug_infrun)
4518 fprintf_unfiltered (gdb_stdlog,
4519 "infrun: %s executing, "
4520 "need stop\n",
4521 target_pid_to_str (t->ptid));
4522 target_stop (t->ptid);
4523 t->stop_requested = 1;
4524 }
4525 else
4526 {
4527 if (debug_infrun)
4528 fprintf_unfiltered (gdb_stdlog,
4529 "infrun: %s executing, "
4530 "already stopping\n",
4531 target_pid_to_str (t->ptid));
4532 }
4533
4534 if (t->stop_requested)
4535 need_wait = 1;
4536 }
4537 else
4538 {
4539 if (debug_infrun)
4540 fprintf_unfiltered (gdb_stdlog,
4541 "infrun: %s not executing\n",
4542 target_pid_to_str (t->ptid));
4543
4544 /* The thread may be not executing, but still be
4545 resumed with a pending status to process. */
4546 t->resumed = 0;
4547 }
4548 }
4549
4550 if (!need_wait)
4551 break;
4552
4553 /* If we find new threads on the second iteration, restart
4554 over. We want to see two iterations in a row with all
4555 threads stopped. */
4556 if (pass > 0)
4557 pass = -1;
4558
4559 event_ptid = wait_one (&ws);
4560 if (ws.kind == TARGET_WAITKIND_NO_RESUMED)
4561 {
4562 /* All resumed threads exited. */
4563 }
65706a29
PA
4564 else if (ws.kind == TARGET_WAITKIND_THREAD_EXITED
4565 || ws.kind == TARGET_WAITKIND_EXITED
372316f1
PA
4566 || ws.kind == TARGET_WAITKIND_SIGNALLED)
4567 {
4568 if (debug_infrun)
4569 {
4570 ptid_t ptid = pid_to_ptid (ws.value.integer);
4571
4572 fprintf_unfiltered (gdb_stdlog,
4573 "infrun: %s exited while "
4574 "stopping threads\n",
4575 target_pid_to_str (ptid));
4576 }
4577 }
4578 else
4579 {
6efcd9a8
PA
4580 struct inferior *inf;
4581
372316f1
PA
4582 t = find_thread_ptid (event_ptid);
4583 if (t == NULL)
4584 t = add_thread (event_ptid);
4585
4586 t->stop_requested = 0;
4587 t->executing = 0;
4588 t->resumed = 0;
4589 t->control.may_range_step = 0;
4590
6efcd9a8
PA
4591 /* This may be the first time we see the inferior report
4592 a stop. */
4593 inf = find_inferior_ptid (event_ptid);
4594 if (inf->needs_setup)
4595 {
4596 switch_to_thread_no_regs (t);
4597 setup_inferior (0);
4598 }
4599
372316f1
PA
4600 if (ws.kind == TARGET_WAITKIND_STOPPED
4601 && ws.value.sig == GDB_SIGNAL_0)
4602 {
4603 /* We caught the event that we intended to catch, so
4604 there's no event pending. */
4605 t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
4606 t->suspend.waitstatus_pending_p = 0;
4607
4608 if (displaced_step_fixup (t->ptid, GDB_SIGNAL_0) < 0)
4609 {
4610 /* Add it back to the step-over queue. */
4611 if (debug_infrun)
4612 {
4613 fprintf_unfiltered (gdb_stdlog,
4614 "infrun: displaced-step of %s "
4615 "canceled: adding back to the "
4616 "step-over queue\n",
4617 target_pid_to_str (t->ptid));
4618 }
4619 t->control.trap_expected = 0;
4620 thread_step_over_chain_enqueue (t);
4621 }
4622 }
4623 else
4624 {
4625 enum gdb_signal sig;
4626 struct regcache *regcache;
372316f1
PA
4627
4628 if (debug_infrun)
4629 {
23fdd69e 4630 std::string statstr = target_waitstatus_to_string (&ws);
372316f1 4631
372316f1
PA
4632 fprintf_unfiltered (gdb_stdlog,
4633 "infrun: target_wait %s, saving "
4634 "status for %d.%ld.%ld\n",
23fdd69e 4635 statstr.c_str (),
372316f1
PA
4636 ptid_get_pid (t->ptid),
4637 ptid_get_lwp (t->ptid),
4638 ptid_get_tid (t->ptid));
372316f1
PA
4639 }
4640
4641 /* Record for later. */
4642 save_waitstatus (t, &ws);
4643
4644 sig = (ws.kind == TARGET_WAITKIND_STOPPED
4645 ? ws.value.sig : GDB_SIGNAL_0);
4646
4647 if (displaced_step_fixup (t->ptid, sig) < 0)
4648 {
4649 /* Add it back to the step-over queue. */
4650 t->control.trap_expected = 0;
4651 thread_step_over_chain_enqueue (t);
4652 }
4653
4654 regcache = get_thread_regcache (t->ptid);
4655 t->suspend.stop_pc = regcache_read_pc (regcache);
4656
4657 if (debug_infrun)
4658 {
4659 fprintf_unfiltered (gdb_stdlog,
4660 "infrun: saved stop_pc=%s for %s "
4661 "(currently_stepping=%d)\n",
4662 paddress (target_gdbarch (),
4663 t->suspend.stop_pc),
4664 target_pid_to_str (t->ptid),
4665 currently_stepping (t));
4666 }
4667 }
4668 }
4669 }
4670 }
4671
4672 do_cleanups (old_chain);
4673
4674 if (debug_infrun)
4675 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
4676}
4677
f4836ba9
PA
4678/* Handle a TARGET_WAITKIND_NO_RESUMED event. */
4679
4680static int
4681handle_no_resumed (struct execution_control_state *ecs)
4682{
4683 struct inferior *inf;
4684 struct thread_info *thread;
4685
3b12939d 4686 if (target_can_async_p ())
f4836ba9 4687 {
3b12939d
PA
4688 struct ui *ui;
4689 int any_sync = 0;
f4836ba9 4690
3b12939d
PA
4691 ALL_UIS (ui)
4692 {
4693 if (ui->prompt_state == PROMPT_BLOCKED)
4694 {
4695 any_sync = 1;
4696 break;
4697 }
4698 }
4699 if (!any_sync)
4700 {
4701 /* There were no unwaited-for children left in the target, but,
4702 we're not synchronously waiting for events either. Just
4703 ignore. */
4704
4705 if (debug_infrun)
4706 fprintf_unfiltered (gdb_stdlog,
4707 "infrun: TARGET_WAITKIND_NO_RESUMED "
4708 "(ignoring: bg)\n");
4709 prepare_to_wait (ecs);
4710 return 1;
4711 }
f4836ba9
PA
4712 }
4713
4714 /* Otherwise, if we were running a synchronous execution command, we
4715 may need to cancel it and give the user back the terminal.
4716
4717 In non-stop mode, the target can't tell whether we've already
4718 consumed previous stop events, so it can end up sending us a
4719 no-resumed event like so:
4720
4721 #0 - thread 1 is left stopped
4722
4723 #1 - thread 2 is resumed and hits breakpoint
4724 -> TARGET_WAITKIND_STOPPED
4725
4726 #2 - thread 3 is resumed and exits
4727 this is the last resumed thread, so
4728 -> TARGET_WAITKIND_NO_RESUMED
4729
4730 #3 - gdb processes stop for thread 2 and decides to re-resume
4731 it.
4732
4733 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
4734 thread 2 is now resumed, so the event should be ignored.
4735
4736 IOW, if the stop for thread 2 doesn't end a foreground command,
4737 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
4738 event. But it could be that the event meant that thread 2 itself
4739 (or whatever other thread was the last resumed thread) exited.
4740
4741 To address this we refresh the thread list and check whether we
4742 have resumed threads _now_. In the example above, this removes
4743 thread 3 from the thread list. If thread 2 was re-resumed, we
4744 ignore this event. If we find no thread resumed, then we cancel
4745 the synchronous command show "no unwaited-for " to the user. */
4746 update_thread_list ();
4747
4748 ALL_NON_EXITED_THREADS (thread)
4749 {
4750 if (thread->executing
4751 || thread->suspend.waitstatus_pending_p)
4752 {
4753 /* There were no unwaited-for children left in the target at
4754 some point, but there are now. Just ignore. */
4755 if (debug_infrun)
4756 fprintf_unfiltered (gdb_stdlog,
4757 "infrun: TARGET_WAITKIND_NO_RESUMED "
4758 "(ignoring: found resumed)\n");
4759 prepare_to_wait (ecs);
4760 return 1;
4761 }
4762 }
4763
4764 /* Note however that we may find no resumed thread because the whole
4765 process exited meanwhile (thus updating the thread list results
4766 in an empty thread list). In this case we know we'll be getting
4767 a process exit event shortly. */
4768 ALL_INFERIORS (inf)
4769 {
4770 if (inf->pid == 0)
4771 continue;
4772
4773 thread = any_live_thread_of_process (inf->pid);
4774 if (thread == NULL)
4775 {
4776 if (debug_infrun)
4777 fprintf_unfiltered (gdb_stdlog,
4778 "infrun: TARGET_WAITKIND_NO_RESUMED "
4779 "(expect process exit)\n");
4780 prepare_to_wait (ecs);
4781 return 1;
4782 }
4783 }
4784
4785 /* Go ahead and report the event. */
4786 return 0;
4787}
4788
05ba8510
PA
4789/* Given an execution control state that has been freshly filled in by
4790 an event from the inferior, figure out what it means and take
4791 appropriate action.
4792
4793 The alternatives are:
4794
22bcd14b 4795 1) stop_waiting and return; to really stop and return to the
05ba8510
PA
4796 debugger.
4797
4798 2) keep_going and return; to wait for the next event (set
4799 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4800 once). */
c906108c 4801
ec9499be 4802static void
0b6e5e10 4803handle_inferior_event_1 (struct execution_control_state *ecs)
cd0fc7c3 4804{
d6b48e9c
PA
4805 enum stop_kind stop_soon;
4806
28736962
PA
4807 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
4808 {
4809 /* We had an event in the inferior, but we are not interested in
4810 handling it at this level. The lower layers have already
4811 done what needs to be done, if anything.
4812
4813 One of the possible circumstances for this is when the
4814 inferior produces output for the console. The inferior has
4815 not stopped, and we are ignoring the event. Another possible
4816 circumstance is any event which the lower level knows will be
4817 reported multiple times without an intervening resume. */
4818 if (debug_infrun)
4819 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
4820 prepare_to_wait (ecs);
4821 return;
4822 }
4823
65706a29
PA
4824 if (ecs->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
4825 {
4826 if (debug_infrun)
4827 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_EXITED\n");
4828 prepare_to_wait (ecs);
4829 return;
4830 }
4831
0e5bf2a8 4832 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
f4836ba9
PA
4833 && handle_no_resumed (ecs))
4834 return;
0e5bf2a8 4835
1777feb0 4836 /* Cache the last pid/waitstatus. */
c32c64b7 4837 set_last_target_status (ecs->ptid, ecs->ws);
e02bc4cc 4838
ca005067 4839 /* Always clear state belonging to the previous time we stopped. */
aa7d318d 4840 stop_stack_dummy = STOP_NONE;
ca005067 4841
0e5bf2a8
PA
4842 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
4843 {
4844 /* No unwaited-for children left. IOW, all resumed children
4845 have exited. */
4846 if (debug_infrun)
4847 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4848
4849 stop_print_frame = 0;
22bcd14b 4850 stop_waiting (ecs);
0e5bf2a8
PA
4851 return;
4852 }
4853
8c90c137 4854 if (ecs->ws.kind != TARGET_WAITKIND_EXITED
64776a0b 4855 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
359f5fe6
PA
4856 {
4857 ecs->event_thread = find_thread_ptid (ecs->ptid);
4858 /* If it's a new thread, add it to the thread database. */
4859 if (ecs->event_thread == NULL)
4860 ecs->event_thread = add_thread (ecs->ptid);
c1e36e3e
PA
4861
4862 /* Disable range stepping. If the next step request could use a
4863 range, this will be end up re-enabled then. */
4864 ecs->event_thread->control.may_range_step = 0;
359f5fe6 4865 }
88ed393a
JK
4866
4867 /* Dependent on valid ECS->EVENT_THREAD. */
d8dd4d5f 4868 adjust_pc_after_break (ecs->event_thread, &ecs->ws);
88ed393a
JK
4869
4870 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4871 reinit_frame_cache ();
4872
28736962
PA
4873 breakpoint_retire_moribund ();
4874
2b009048
DJ
4875 /* First, distinguish signals caused by the debugger from signals
4876 that have to do with the program's own actions. Note that
4877 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4878 on the operating system version. Here we detect when a SIGILL or
4879 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4880 something similar for SIGSEGV, since a SIGSEGV will be generated
4881 when we're trying to execute a breakpoint instruction on a
4882 non-executable stack. This happens for call dummy breakpoints
4883 for architectures like SPARC that place call dummies on the
4884 stack. */
2b009048 4885 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
a493e3e2
PA
4886 && (ecs->ws.value.sig == GDB_SIGNAL_ILL
4887 || ecs->ws.value.sig == GDB_SIGNAL_SEGV
4888 || ecs->ws.value.sig == GDB_SIGNAL_EMT))
2b009048 4889 {
de0a0249
UW
4890 struct regcache *regcache = get_thread_regcache (ecs->ptid);
4891
4892 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache),
4893 regcache_read_pc (regcache)))
4894 {
4895 if (debug_infrun)
4896 fprintf_unfiltered (gdb_stdlog,
4897 "infrun: Treating signal as SIGTRAP\n");
a493e3e2 4898 ecs->ws.value.sig = GDB_SIGNAL_TRAP;
de0a0249 4899 }
2b009048
DJ
4900 }
4901
28736962
PA
4902 /* Mark the non-executing threads accordingly. In all-stop, all
4903 threads of all processes are stopped when we get any event
e1316e60 4904 reported. In non-stop mode, only the event thread stops. */
372316f1
PA
4905 {
4906 ptid_t mark_ptid;
4907
fbea99ea 4908 if (!target_is_non_stop_p ())
372316f1
PA
4909 mark_ptid = minus_one_ptid;
4910 else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
4911 || ecs->ws.kind == TARGET_WAITKIND_EXITED)
4912 {
4913 /* If we're handling a process exit in non-stop mode, even
4914 though threads haven't been deleted yet, one would think
4915 that there is nothing to do, as threads of the dead process
4916 will be soon deleted, and threads of any other process were
4917 left running. However, on some targets, threads survive a
4918 process exit event. E.g., for the "checkpoint" command,
4919 when the current checkpoint/fork exits, linux-fork.c
4920 automatically switches to another fork from within
4921 target_mourn_inferior, by associating the same
4922 inferior/thread to another fork. We haven't mourned yet at
4923 this point, but we must mark any threads left in the
4924 process as not-executing so that finish_thread_state marks
4925 them stopped (in the user's perspective) if/when we present
4926 the stop to the user. */
4927 mark_ptid = pid_to_ptid (ptid_get_pid (ecs->ptid));
4928 }
4929 else
4930 mark_ptid = ecs->ptid;
4931
4932 set_executing (mark_ptid, 0);
4933
4934 /* Likewise the resumed flag. */
4935 set_resumed (mark_ptid, 0);
4936 }
8c90c137 4937
488f131b
JB
4938 switch (ecs->ws.kind)
4939 {
4940 case TARGET_WAITKIND_LOADED:
527159b7 4941 if (debug_infrun)
8a9de0e4 4942 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
5c09a2c5
PA
4943 if (!ptid_equal (ecs->ptid, inferior_ptid))
4944 context_switch (ecs->ptid);
b0f4b84b
DJ
4945 /* Ignore gracefully during startup of the inferior, as it might
4946 be the shell which has just loaded some objects, otherwise
4947 add the symbols for the newly loaded objects. Also ignore at
4948 the beginning of an attach or remote session; we will query
4949 the full list of libraries once the connection is
4950 established. */
4f5d7f63
PA
4951
4952 stop_soon = get_inferior_stop_soon (ecs->ptid);
c0236d92 4953 if (stop_soon == NO_STOP_QUIETLY)
488f131b 4954 {
edcc5120
TT
4955 struct regcache *regcache;
4956
edcc5120
TT
4957 regcache = get_thread_regcache (ecs->ptid);
4958
4959 handle_solib_event ();
4960
4961 ecs->event_thread->control.stop_bpstat
4962 = bpstat_stop_status (get_regcache_aspace (regcache),
4963 stop_pc, ecs->ptid, &ecs->ws);
ab04a2af 4964
c65d6b55
PA
4965 if (handle_stop_requested (ecs))
4966 return;
4967
ce12b012 4968 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
edcc5120
TT
4969 {
4970 /* A catchpoint triggered. */
94c57d6a
PA
4971 process_event_stop_test (ecs);
4972 return;
edcc5120 4973 }
488f131b 4974
b0f4b84b
DJ
4975 /* If requested, stop when the dynamic linker notifies
4976 gdb of events. This allows the user to get control
4977 and place breakpoints in initializer routines for
4978 dynamically loaded objects (among other things). */
a493e3e2 4979 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
b0f4b84b
DJ
4980 if (stop_on_solib_events)
4981 {
55409f9d
DJ
4982 /* Make sure we print "Stopped due to solib-event" in
4983 normal_stop. */
4984 stop_print_frame = 1;
4985
22bcd14b 4986 stop_waiting (ecs);
b0f4b84b
DJ
4987 return;
4988 }
488f131b 4989 }
b0f4b84b
DJ
4990
4991 /* If we are skipping through a shell, or through shared library
4992 loading that we aren't interested in, resume the program. If
5c09a2c5 4993 we're running the program normally, also resume. */
b0f4b84b
DJ
4994 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
4995 {
74960c60
VP
4996 /* Loading of shared libraries might have changed breakpoint
4997 addresses. Make sure new breakpoints are inserted. */
a25a5a45 4998 if (stop_soon == NO_STOP_QUIETLY)
74960c60 4999 insert_breakpoints ();
64ce06e4 5000 resume (GDB_SIGNAL_0);
b0f4b84b
DJ
5001 prepare_to_wait (ecs);
5002 return;
5003 }
5004
5c09a2c5
PA
5005 /* But stop if we're attaching or setting up a remote
5006 connection. */
5007 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5008 || stop_soon == STOP_QUIETLY_REMOTE)
5009 {
5010 if (debug_infrun)
5011 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
22bcd14b 5012 stop_waiting (ecs);
5c09a2c5
PA
5013 return;
5014 }
5015
5016 internal_error (__FILE__, __LINE__,
5017 _("unhandled stop_soon: %d"), (int) stop_soon);
c5aa993b 5018
488f131b 5019 case TARGET_WAITKIND_SPURIOUS:
527159b7 5020 if (debug_infrun)
8a9de0e4 5021 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
c65d6b55
PA
5022 if (handle_stop_requested (ecs))
5023 return;
64776a0b 5024 if (!ptid_equal (ecs->ptid, inferior_ptid))
8b3ee56d 5025 context_switch (ecs->ptid);
64ce06e4 5026 resume (GDB_SIGNAL_0);
488f131b
JB
5027 prepare_to_wait (ecs);
5028 return;
c5aa993b 5029
65706a29
PA
5030 case TARGET_WAITKIND_THREAD_CREATED:
5031 if (debug_infrun)
5032 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_CREATED\n");
c65d6b55
PA
5033 if (handle_stop_requested (ecs))
5034 return;
65706a29
PA
5035 if (!ptid_equal (ecs->ptid, inferior_ptid))
5036 context_switch (ecs->ptid);
5037 if (!switch_back_to_stepped_thread (ecs))
5038 keep_going (ecs);
5039 return;
5040
488f131b 5041 case TARGET_WAITKIND_EXITED:
940c3c06 5042 case TARGET_WAITKIND_SIGNALLED:
527159b7 5043 if (debug_infrun)
940c3c06
PA
5044 {
5045 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
5046 fprintf_unfiltered (gdb_stdlog,
5047 "infrun: TARGET_WAITKIND_EXITED\n");
5048 else
5049 fprintf_unfiltered (gdb_stdlog,
5050 "infrun: TARGET_WAITKIND_SIGNALLED\n");
5051 }
5052
fb66883a 5053 inferior_ptid = ecs->ptid;
c9657e70 5054 set_current_inferior (find_inferior_ptid (ecs->ptid));
6c95b8df
PA
5055 set_current_program_space (current_inferior ()->pspace);
5056 handle_vfork_child_exec_or_exit (0);
1777feb0 5057 target_terminal_ours (); /* Must do this before mourn anyway. */
488f131b 5058
0c557179
SDJ
5059 /* Clearing any previous state of convenience variables. */
5060 clear_exit_convenience_vars ();
5061
940c3c06
PA
5062 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
5063 {
5064 /* Record the exit code in the convenience variable $_exitcode, so
5065 that the user can inspect this again later. */
5066 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5067 (LONGEST) ecs->ws.value.integer);
5068
5069 /* Also record this in the inferior itself. */
5070 current_inferior ()->has_exit_code = 1;
5071 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
8cf64490 5072
98eb56a4
PA
5073 /* Support the --return-child-result option. */
5074 return_child_result_value = ecs->ws.value.integer;
5075
fd664c91 5076 observer_notify_exited (ecs->ws.value.integer);
940c3c06
PA
5077 }
5078 else
0c557179
SDJ
5079 {
5080 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5081 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5082
5083 if (gdbarch_gdb_signal_to_target_p (gdbarch))
5084 {
5085 /* Set the value of the internal variable $_exitsignal,
5086 which holds the signal uncaught by the inferior. */
5087 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5088 gdbarch_gdb_signal_to_target (gdbarch,
5089 ecs->ws.value.sig));
5090 }
5091 else
5092 {
5093 /* We don't have access to the target's method used for
5094 converting between signal numbers (GDB's internal
5095 representation <-> target's representation).
5096 Therefore, we cannot do a good job at displaying this
5097 information to the user. It's better to just warn
5098 her about it (if infrun debugging is enabled), and
5099 give up. */
5100 if (debug_infrun)
5101 fprintf_filtered (gdb_stdlog, _("\
5102Cannot fill $_exitsignal with the correct signal number.\n"));
5103 }
5104
fd664c91 5105 observer_notify_signal_exited (ecs->ws.value.sig);
0c557179 5106 }
8cf64490 5107
488f131b 5108 gdb_flush (gdb_stdout);
bc1e6c81 5109 target_mourn_inferior (inferior_ptid);
488f131b 5110 stop_print_frame = 0;
22bcd14b 5111 stop_waiting (ecs);
488f131b 5112 return;
c5aa993b 5113
488f131b 5114 /* The following are the only cases in which we keep going;
1777feb0 5115 the above cases end in a continue or goto. */
488f131b 5116 case TARGET_WAITKIND_FORKED:
deb3b17b 5117 case TARGET_WAITKIND_VFORKED:
527159b7 5118 if (debug_infrun)
fed708ed
PA
5119 {
5120 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
5121 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
5122 else
5123 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
5124 }
c906108c 5125
e2d96639
YQ
5126 /* Check whether the inferior is displaced stepping. */
5127 {
5128 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5129 struct gdbarch *gdbarch = get_regcache_arch (regcache);
e2d96639
YQ
5130
5131 /* If checking displaced stepping is supported, and thread
5132 ecs->ptid is displaced stepping. */
c0987663 5133 if (displaced_step_in_progress_thread (ecs->ptid))
e2d96639
YQ
5134 {
5135 struct inferior *parent_inf
c9657e70 5136 = find_inferior_ptid (ecs->ptid);
e2d96639
YQ
5137 struct regcache *child_regcache;
5138 CORE_ADDR parent_pc;
5139
5140 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5141 indicating that the displaced stepping of syscall instruction
5142 has been done. Perform cleanup for parent process here. Note
5143 that this operation also cleans up the child process for vfork,
5144 because their pages are shared. */
a493e3e2 5145 displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
c2829269
PA
5146 /* Start a new step-over in another thread if there's one
5147 that needs it. */
5148 start_step_over ();
e2d96639
YQ
5149
5150 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
5151 {
c0987663
YQ
5152 struct displaced_step_inferior_state *displaced
5153 = get_displaced_stepping_state (ptid_get_pid (ecs->ptid));
5154
e2d96639
YQ
5155 /* Restore scratch pad for child process. */
5156 displaced_step_restore (displaced, ecs->ws.value.related_pid);
5157 }
5158
5159 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5160 the child's PC is also within the scratchpad. Set the child's PC
5161 to the parent's PC value, which has already been fixed up.
5162 FIXME: we use the parent's aspace here, although we're touching
5163 the child, because the child hasn't been added to the inferior
5164 list yet at this point. */
5165
5166 child_regcache
5167 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
5168 gdbarch,
5169 parent_inf->aspace);
5170 /* Read PC value of parent process. */
5171 parent_pc = regcache_read_pc (regcache);
5172
5173 if (debug_displaced)
5174 fprintf_unfiltered (gdb_stdlog,
5175 "displaced: write child pc from %s to %s\n",
5176 paddress (gdbarch,
5177 regcache_read_pc (child_regcache)),
5178 paddress (gdbarch, parent_pc));
5179
5180 regcache_write_pc (child_regcache, parent_pc);
5181 }
5182 }
5183
5a2901d9 5184 if (!ptid_equal (ecs->ptid, inferior_ptid))
c3a01a22 5185 context_switch (ecs->ptid);
5a2901d9 5186
b242c3c2
PA
5187 /* Immediately detach breakpoints from the child before there's
5188 any chance of letting the user delete breakpoints from the
5189 breakpoint lists. If we don't do this early, it's easy to
5190 leave left over traps in the child, vis: "break foo; catch
5191 fork; c; <fork>; del; c; <child calls foo>". We only follow
5192 the fork on the last `continue', and by that time the
5193 breakpoint at "foo" is long gone from the breakpoint table.
5194 If we vforked, then we don't need to unpatch here, since both
5195 parent and child are sharing the same memory pages; we'll
5196 need to unpatch at follow/detach time instead to be certain
5197 that new breakpoints added between catchpoint hit time and
5198 vfork follow are detached. */
5199 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
5200 {
b242c3c2
PA
5201 /* This won't actually modify the breakpoint list, but will
5202 physically remove the breakpoints from the child. */
d80ee84f 5203 detach_breakpoints (ecs->ws.value.related_pid);
b242c3c2
PA
5204 }
5205
34b7e8a6 5206 delete_just_stopped_threads_single_step_breakpoints ();
d03285ec 5207
e58b0e63
PA
5208 /* In case the event is caught by a catchpoint, remember that
5209 the event is to be followed at the next resume of the thread,
5210 and not immediately. */
5211 ecs->event_thread->pending_follow = ecs->ws;
5212
fb14de7b 5213 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
675bf4cb 5214
16c381f0 5215 ecs->event_thread->control.stop_bpstat
6c95b8df 5216 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
09ac7c10 5217 stop_pc, ecs->ptid, &ecs->ws);
675bf4cb 5218
c65d6b55
PA
5219 if (handle_stop_requested (ecs))
5220 return;
5221
ce12b012
PA
5222 /* If no catchpoint triggered for this, then keep going. Note
5223 that we're interested in knowing the bpstat actually causes a
5224 stop, not just if it may explain the signal. Software
5225 watchpoints, for example, always appear in the bpstat. */
5226 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
04e68871 5227 {
6c95b8df
PA
5228 ptid_t parent;
5229 ptid_t child;
e58b0e63 5230 int should_resume;
3e43a32a
MS
5231 int follow_child
5232 = (follow_fork_mode_string == follow_fork_mode_child);
e58b0e63 5233
a493e3e2 5234 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
e58b0e63
PA
5235
5236 should_resume = follow_fork ();
5237
6c95b8df
PA
5238 parent = ecs->ptid;
5239 child = ecs->ws.value.related_pid;
5240
a2077e25
PA
5241 /* At this point, the parent is marked running, and the
5242 child is marked stopped. */
5243
5244 /* If not resuming the parent, mark it stopped. */
5245 if (follow_child && !detach_fork && !non_stop && !sched_multi)
5246 set_running (parent, 0);
5247
5248 /* If resuming the child, mark it running. */
5249 if (follow_child || (!detach_fork && (non_stop || sched_multi)))
5250 set_running (child, 1);
5251
6c95b8df 5252 /* In non-stop mode, also resume the other branch. */
fbea99ea
PA
5253 if (!detach_fork && (non_stop
5254 || (sched_multi && target_is_non_stop_p ())))
6c95b8df
PA
5255 {
5256 if (follow_child)
5257 switch_to_thread (parent);
5258 else
5259 switch_to_thread (child);
5260
5261 ecs->event_thread = inferior_thread ();
5262 ecs->ptid = inferior_ptid;
5263 keep_going (ecs);
5264 }
5265
5266 if (follow_child)
5267 switch_to_thread (child);
5268 else
5269 switch_to_thread (parent);
5270
e58b0e63
PA
5271 ecs->event_thread = inferior_thread ();
5272 ecs->ptid = inferior_ptid;
5273
5274 if (should_resume)
5275 keep_going (ecs);
5276 else
22bcd14b 5277 stop_waiting (ecs);
04e68871
DJ
5278 return;
5279 }
94c57d6a
PA
5280 process_event_stop_test (ecs);
5281 return;
488f131b 5282
6c95b8df
PA
5283 case TARGET_WAITKIND_VFORK_DONE:
5284 /* Done with the shared memory region. Re-insert breakpoints in
5285 the parent, and keep going. */
5286
5287 if (debug_infrun)
3e43a32a
MS
5288 fprintf_unfiltered (gdb_stdlog,
5289 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
6c95b8df
PA
5290
5291 if (!ptid_equal (ecs->ptid, inferior_ptid))
5292 context_switch (ecs->ptid);
5293
5294 current_inferior ()->waiting_for_vfork_done = 0;
56710373 5295 current_inferior ()->pspace->breakpoints_not_allowed = 0;
c65d6b55
PA
5296
5297 if (handle_stop_requested (ecs))
5298 return;
5299
6c95b8df
PA
5300 /* This also takes care of reinserting breakpoints in the
5301 previously locked inferior. */
5302 keep_going (ecs);
5303 return;
5304
488f131b 5305 case TARGET_WAITKIND_EXECD:
527159b7 5306 if (debug_infrun)
fc5261f2 5307 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
488f131b 5308
5a2901d9 5309 if (!ptid_equal (ecs->ptid, inferior_ptid))
c3a01a22 5310 context_switch (ecs->ptid);
5a2901d9 5311
fb14de7b 5312 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
795e548f 5313
6c95b8df
PA
5314 /* Do whatever is necessary to the parent branch of the vfork. */
5315 handle_vfork_child_exec_or_exit (1);
5316
795e548f
PA
5317 /* This causes the eventpoints and symbol table to be reset.
5318 Must do this now, before trying to determine whether to
5319 stop. */
71b43ef8 5320 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
795e548f 5321
17d8546e
DB
5322 /* In follow_exec we may have deleted the original thread and
5323 created a new one. Make sure that the event thread is the
5324 execd thread for that case (this is a nop otherwise). */
5325 ecs->event_thread = inferior_thread ();
5326
16c381f0 5327 ecs->event_thread->control.stop_bpstat
6c95b8df 5328 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
09ac7c10 5329 stop_pc, ecs->ptid, &ecs->ws);
795e548f 5330
71b43ef8
PA
5331 /* Note that this may be referenced from inside
5332 bpstat_stop_status above, through inferior_has_execd. */
5333 xfree (ecs->ws.value.execd_pathname);
5334 ecs->ws.value.execd_pathname = NULL;
5335
c65d6b55
PA
5336 if (handle_stop_requested (ecs))
5337 return;
5338
04e68871 5339 /* If no catchpoint triggered for this, then keep going. */
ce12b012 5340 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
04e68871 5341 {
a493e3e2 5342 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
04e68871
DJ
5343 keep_going (ecs);
5344 return;
5345 }
94c57d6a
PA
5346 process_event_stop_test (ecs);
5347 return;
488f131b 5348
b4dc5ffa
MK
5349 /* Be careful not to try to gather much state about a thread
5350 that's in a syscall. It's frequently a losing proposition. */
488f131b 5351 case TARGET_WAITKIND_SYSCALL_ENTRY:
527159b7 5352 if (debug_infrun)
3e43a32a
MS
5353 fprintf_unfiltered (gdb_stdlog,
5354 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
1777feb0 5355 /* Getting the current syscall number. */
94c57d6a
PA
5356 if (handle_syscall_event (ecs) == 0)
5357 process_event_stop_test (ecs);
5358 return;
c906108c 5359
488f131b
JB
5360 /* Before examining the threads further, step this thread to
5361 get it entirely out of the syscall. (We get notice of the
5362 event when the thread is just on the verge of exiting a
5363 syscall. Stepping one instruction seems to get it back
b4dc5ffa 5364 into user code.) */
488f131b 5365 case TARGET_WAITKIND_SYSCALL_RETURN:
527159b7 5366 if (debug_infrun)
3e43a32a
MS
5367 fprintf_unfiltered (gdb_stdlog,
5368 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
94c57d6a
PA
5369 if (handle_syscall_event (ecs) == 0)
5370 process_event_stop_test (ecs);
5371 return;
c906108c 5372
488f131b 5373 case TARGET_WAITKIND_STOPPED:
527159b7 5374 if (debug_infrun)
8a9de0e4 5375 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
4f5d7f63
PA
5376 handle_signal_stop (ecs);
5377 return;
c906108c 5378
b2175913 5379 case TARGET_WAITKIND_NO_HISTORY:
4b4e080e
PA
5380 if (debug_infrun)
5381 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
b2175913 5382 /* Reverse execution: target ran out of history info. */
eab402df 5383
d1988021
MM
5384 /* Switch to the stopped thread. */
5385 if (!ptid_equal (ecs->ptid, inferior_ptid))
5386 context_switch (ecs->ptid);
5387 if (debug_infrun)
5388 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
5389
34b7e8a6 5390 delete_just_stopped_threads_single_step_breakpoints ();
d1988021 5391 stop_pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
c65d6b55
PA
5392
5393 if (handle_stop_requested (ecs))
5394 return;
5395
fd664c91 5396 observer_notify_no_history ();
22bcd14b 5397 stop_waiting (ecs);
b2175913 5398 return;
488f131b 5399 }
4f5d7f63
PA
5400}
5401
0b6e5e10
JB
5402/* A wrapper around handle_inferior_event_1, which also makes sure
5403 that all temporary struct value objects that were created during
5404 the handling of the event get deleted at the end. */
5405
5406static void
5407handle_inferior_event (struct execution_control_state *ecs)
5408{
5409 struct value *mark = value_mark ();
5410
5411 handle_inferior_event_1 (ecs);
5412 /* Purge all temporary values created during the event handling,
5413 as it could be a long time before we return to the command level
5414 where such values would otherwise be purged. */
5415 value_free_to_mark (mark);
5416}
5417
372316f1
PA
5418/* Restart threads back to what they were trying to do back when we
5419 paused them for an in-line step-over. The EVENT_THREAD thread is
5420 ignored. */
4d9d9d04
PA
5421
5422static void
372316f1
PA
5423restart_threads (struct thread_info *event_thread)
5424{
5425 struct thread_info *tp;
372316f1
PA
5426
5427 /* In case the instruction just stepped spawned a new thread. */
5428 update_thread_list ();
5429
5430 ALL_NON_EXITED_THREADS (tp)
5431 {
5432 if (tp == event_thread)
5433 {
5434 if (debug_infrun)
5435 fprintf_unfiltered (gdb_stdlog,
5436 "infrun: restart threads: "
5437 "[%s] is event thread\n",
5438 target_pid_to_str (tp->ptid));
5439 continue;
5440 }
5441
5442 if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
5443 {
5444 if (debug_infrun)
5445 fprintf_unfiltered (gdb_stdlog,
5446 "infrun: restart threads: "
5447 "[%s] not meant to be running\n",
5448 target_pid_to_str (tp->ptid));
5449 continue;
5450 }
5451
5452 if (tp->resumed)
5453 {
5454 if (debug_infrun)
5455 fprintf_unfiltered (gdb_stdlog,
5456 "infrun: restart threads: [%s] resumed\n",
5457 target_pid_to_str (tp->ptid));
5458 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
5459 continue;
5460 }
5461
5462 if (thread_is_in_step_over_chain (tp))
5463 {
5464 if (debug_infrun)
5465 fprintf_unfiltered (gdb_stdlog,
5466 "infrun: restart threads: "
5467 "[%s] needs step-over\n",
5468 target_pid_to_str (tp->ptid));
5469 gdb_assert (!tp->resumed);
5470 continue;
5471 }
5472
5473
5474 if (tp->suspend.waitstatus_pending_p)
5475 {
5476 if (debug_infrun)
5477 fprintf_unfiltered (gdb_stdlog,
5478 "infrun: restart threads: "
5479 "[%s] has pending status\n",
5480 target_pid_to_str (tp->ptid));
5481 tp->resumed = 1;
5482 continue;
5483 }
5484
c65d6b55
PA
5485 gdb_assert (!tp->stop_requested);
5486
372316f1
PA
5487 /* If some thread needs to start a step-over at this point, it
5488 should still be in the step-over queue, and thus skipped
5489 above. */
5490 if (thread_still_needs_step_over (tp))
5491 {
5492 internal_error (__FILE__, __LINE__,
5493 "thread [%s] needs a step-over, but not in "
5494 "step-over queue\n",
5495 target_pid_to_str (tp->ptid));
5496 }
5497
5498 if (currently_stepping (tp))
5499 {
5500 if (debug_infrun)
5501 fprintf_unfiltered (gdb_stdlog,
5502 "infrun: restart threads: [%s] was stepping\n",
5503 target_pid_to_str (tp->ptid));
5504 keep_going_stepped_thread (tp);
5505 }
5506 else
5507 {
5508 struct execution_control_state ecss;
5509 struct execution_control_state *ecs = &ecss;
5510
5511 if (debug_infrun)
5512 fprintf_unfiltered (gdb_stdlog,
5513 "infrun: restart threads: [%s] continuing\n",
5514 target_pid_to_str (tp->ptid));
5515 reset_ecs (ecs, tp);
5516 switch_to_thread (tp->ptid);
5517 keep_going_pass_signal (ecs);
5518 }
5519 }
5520}
5521
5522/* Callback for iterate_over_threads. Find a resumed thread that has
5523 a pending waitstatus. */
5524
5525static int
5526resumed_thread_with_pending_status (struct thread_info *tp,
5527 void *arg)
5528{
5529 return (tp->resumed
5530 && tp->suspend.waitstatus_pending_p);
5531}
5532
5533/* Called when we get an event that may finish an in-line or
5534 out-of-line (displaced stepping) step-over started previously.
5535 Return true if the event is processed and we should go back to the
5536 event loop; false if the caller should continue processing the
5537 event. */
5538
5539static int
4d9d9d04
PA
5540finish_step_over (struct execution_control_state *ecs)
5541{
372316f1
PA
5542 int had_step_over_info;
5543
4d9d9d04
PA
5544 displaced_step_fixup (ecs->ptid,
5545 ecs->event_thread->suspend.stop_signal);
5546
372316f1
PA
5547 had_step_over_info = step_over_info_valid_p ();
5548
5549 if (had_step_over_info)
4d9d9d04
PA
5550 {
5551 /* If we're stepping over a breakpoint with all threads locked,
5552 then only the thread that was stepped should be reporting
5553 back an event. */
5554 gdb_assert (ecs->event_thread->control.trap_expected);
5555
c65d6b55 5556 clear_step_over_info ();
4d9d9d04
PA
5557 }
5558
fbea99ea 5559 if (!target_is_non_stop_p ())
372316f1 5560 return 0;
4d9d9d04
PA
5561
5562 /* Start a new step-over in another thread if there's one that
5563 needs it. */
5564 start_step_over ();
372316f1
PA
5565
5566 /* If we were stepping over a breakpoint before, and haven't started
5567 a new in-line step-over sequence, then restart all other threads
5568 (except the event thread). We can't do this in all-stop, as then
5569 e.g., we wouldn't be able to issue any other remote packet until
5570 these other threads stop. */
5571 if (had_step_over_info && !step_over_info_valid_p ())
5572 {
5573 struct thread_info *pending;
5574
5575 /* If we only have threads with pending statuses, the restart
5576 below won't restart any thread and so nothing re-inserts the
5577 breakpoint we just stepped over. But we need it inserted
5578 when we later process the pending events, otherwise if
5579 another thread has a pending event for this breakpoint too,
5580 we'd discard its event (because the breakpoint that
5581 originally caused the event was no longer inserted). */
5582 context_switch (ecs->ptid);
5583 insert_breakpoints ();
5584
5585 restart_threads (ecs->event_thread);
5586
5587 /* If we have events pending, go through handle_inferior_event
5588 again, picking up a pending event at random. This avoids
5589 thread starvation. */
5590
5591 /* But not if we just stepped over a watchpoint in order to let
5592 the instruction execute so we can evaluate its expression.
5593 The set of watchpoints that triggered is recorded in the
5594 breakpoint objects themselves (see bp->watchpoint_triggered).
5595 If we processed another event first, that other event could
5596 clobber this info. */
5597 if (ecs->event_thread->stepping_over_watchpoint)
5598 return 0;
5599
5600 pending = iterate_over_threads (resumed_thread_with_pending_status,
5601 NULL);
5602 if (pending != NULL)
5603 {
5604 struct thread_info *tp = ecs->event_thread;
5605 struct regcache *regcache;
5606
5607 if (debug_infrun)
5608 {
5609 fprintf_unfiltered (gdb_stdlog,
5610 "infrun: found resumed threads with "
5611 "pending events, saving status\n");
5612 }
5613
5614 gdb_assert (pending != tp);
5615
5616 /* Record the event thread's event for later. */
5617 save_waitstatus (tp, &ecs->ws);
5618 /* This was cleared early, by handle_inferior_event. Set it
5619 so this pending event is considered by
5620 do_target_wait. */
5621 tp->resumed = 1;
5622
5623 gdb_assert (!tp->executing);
5624
5625 regcache = get_thread_regcache (tp->ptid);
5626 tp->suspend.stop_pc = regcache_read_pc (regcache);
5627
5628 if (debug_infrun)
5629 {
5630 fprintf_unfiltered (gdb_stdlog,
5631 "infrun: saved stop_pc=%s for %s "
5632 "(currently_stepping=%d)\n",
5633 paddress (target_gdbarch (),
5634 tp->suspend.stop_pc),
5635 target_pid_to_str (tp->ptid),
5636 currently_stepping (tp));
5637 }
5638
5639 /* This in-line step-over finished; clear this so we won't
5640 start a new one. This is what handle_signal_stop would
5641 do, if we returned false. */
5642 tp->stepping_over_breakpoint = 0;
5643
5644 /* Wake up the event loop again. */
5645 mark_async_event_handler (infrun_async_inferior_event_token);
5646
5647 prepare_to_wait (ecs);
5648 return 1;
5649 }
5650 }
5651
5652 return 0;
4d9d9d04
PA
5653}
5654
4f5d7f63
PA
5655/* Come here when the program has stopped with a signal. */
5656
5657static void
5658handle_signal_stop (struct execution_control_state *ecs)
5659{
5660 struct frame_info *frame;
5661 struct gdbarch *gdbarch;
5662 int stopped_by_watchpoint;
5663 enum stop_kind stop_soon;
5664 int random_signal;
c906108c 5665
f0407826
DE
5666 gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
5667
c65d6b55
PA
5668 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
5669
f0407826
DE
5670 /* Do we need to clean up the state of a thread that has
5671 completed a displaced single-step? (Doing so usually affects
5672 the PC, so do it here, before we set stop_pc.) */
372316f1
PA
5673 if (finish_step_over (ecs))
5674 return;
f0407826
DE
5675
5676 /* If we either finished a single-step or hit a breakpoint, but
5677 the user wanted this thread to be stopped, pretend we got a
5678 SIG0 (generic unsignaled stop). */
5679 if (ecs->event_thread->stop_requested
5680 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5681 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
237fc4c9 5682
515630c5 5683 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
488f131b 5684
527159b7 5685 if (debug_infrun)
237fc4c9 5686 {
5af949e3
UW
5687 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5688 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2989a365 5689 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
7f82dfc7
JK
5690
5691 inferior_ptid = ecs->ptid;
5af949e3
UW
5692
5693 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
5694 paddress (gdbarch, stop_pc));
d92524f1 5695 if (target_stopped_by_watchpoint ())
237fc4c9
PA
5696 {
5697 CORE_ADDR addr;
abbb1732 5698
237fc4c9
PA
5699 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
5700
5701 if (target_stopped_data_address (&current_target, &addr))
5702 fprintf_unfiltered (gdb_stdlog,
5af949e3
UW
5703 "infrun: stopped data address = %s\n",
5704 paddress (gdbarch, addr));
237fc4c9
PA
5705 else
5706 fprintf_unfiltered (gdb_stdlog,
5707 "infrun: (no data address available)\n");
5708 }
5709 }
527159b7 5710
36fa8042
PA
5711 /* This is originated from start_remote(), start_inferior() and
5712 shared libraries hook functions. */
5713 stop_soon = get_inferior_stop_soon (ecs->ptid);
5714 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
5715 {
5716 if (!ptid_equal (ecs->ptid, inferior_ptid))
5717 context_switch (ecs->ptid);
5718 if (debug_infrun)
5719 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
5720 stop_print_frame = 1;
22bcd14b 5721 stop_waiting (ecs);
36fa8042
PA
5722 return;
5723 }
5724
36fa8042
PA
5725 /* This originates from attach_command(). We need to overwrite
5726 the stop_signal here, because some kernels don't ignore a
5727 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5728 See more comments in inferior.h. On the other hand, if we
5729 get a non-SIGSTOP, report it to the user - assume the backend
5730 will handle the SIGSTOP if it should show up later.
5731
5732 Also consider that the attach is complete when we see a
5733 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5734 target extended-remote report it instead of a SIGSTOP
5735 (e.g. gdbserver). We already rely on SIGTRAP being our
5736 signal, so this is no exception.
5737
5738 Also consider that the attach is complete when we see a
5739 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5740 the target to stop all threads of the inferior, in case the
5741 low level attach operation doesn't stop them implicitly. If
5742 they weren't stopped implicitly, then the stub will report a
5743 GDB_SIGNAL_0, meaning: stopped for no particular reason
5744 other than GDB's request. */
5745 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5746 && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
5747 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5748 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
5749 {
5750 stop_print_frame = 1;
22bcd14b 5751 stop_waiting (ecs);
36fa8042
PA
5752 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5753 return;
5754 }
5755
488f131b 5756 /* See if something interesting happened to the non-current thread. If
b40c7d58
DJ
5757 so, then switch to that thread. */
5758 if (!ptid_equal (ecs->ptid, inferior_ptid))
488f131b 5759 {
527159b7 5760 if (debug_infrun)
8a9de0e4 5761 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
527159b7 5762
0d1e5fa7 5763 context_switch (ecs->ptid);
c5aa993b 5764
9a4105ab 5765 if (deprecated_context_hook)
5d5658a1 5766 deprecated_context_hook (ptid_to_global_thread_id (ecs->ptid));
488f131b 5767 }
c906108c 5768
568d6575
UW
5769 /* At this point, get hold of the now-current thread's frame. */
5770 frame = get_current_frame ();
5771 gdbarch = get_frame_arch (frame);
5772
2adfaa28 5773 /* Pull the single step breakpoints out of the target. */
af48d08f 5774 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
488f131b 5775 {
af48d08f
PA
5776 struct regcache *regcache;
5777 struct address_space *aspace;
5778 CORE_ADDR pc;
2adfaa28 5779
af48d08f
PA
5780 regcache = get_thread_regcache (ecs->ptid);
5781 aspace = get_regcache_aspace (regcache);
5782 pc = regcache_read_pc (regcache);
34b7e8a6 5783
af48d08f
PA
5784 /* However, before doing so, if this single-step breakpoint was
5785 actually for another thread, set this thread up for moving
5786 past it. */
5787 if (!thread_has_single_step_breakpoint_here (ecs->event_thread,
5788 aspace, pc))
5789 {
5790 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2adfaa28
PA
5791 {
5792 if (debug_infrun)
5793 {
5794 fprintf_unfiltered (gdb_stdlog,
af48d08f 5795 "infrun: [%s] hit another thread's "
34b7e8a6
PA
5796 "single-step breakpoint\n",
5797 target_pid_to_str (ecs->ptid));
2adfaa28 5798 }
af48d08f
PA
5799 ecs->hit_singlestep_breakpoint = 1;
5800 }
5801 }
5802 else
5803 {
5804 if (debug_infrun)
5805 {
5806 fprintf_unfiltered (gdb_stdlog,
5807 "infrun: [%s] hit its "
5808 "single-step breakpoint\n",
5809 target_pid_to_str (ecs->ptid));
2adfaa28
PA
5810 }
5811 }
488f131b 5812 }
af48d08f 5813 delete_just_stopped_threads_single_step_breakpoints ();
c906108c 5814
963f9c80
PA
5815 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5816 && ecs->event_thread->control.trap_expected
5817 && ecs->event_thread->stepping_over_watchpoint)
d983da9c
DJ
5818 stopped_by_watchpoint = 0;
5819 else
5820 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
5821
5822 /* If necessary, step over this watchpoint. We'll be back to display
5823 it in a moment. */
5824 if (stopped_by_watchpoint
d92524f1 5825 && (target_have_steppable_watchpoint
568d6575 5826 || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
488f131b 5827 {
488f131b
JB
5828 /* At this point, we are stopped at an instruction which has
5829 attempted to write to a piece of memory under control of
5830 a watchpoint. The instruction hasn't actually executed
5831 yet. If we were to evaluate the watchpoint expression
5832 now, we would get the old value, and therefore no change
5833 would seem to have occurred.
5834
5835 In order to make watchpoints work `right', we really need
5836 to complete the memory write, and then evaluate the
d983da9c
DJ
5837 watchpoint expression. We do this by single-stepping the
5838 target.
5839
7f89fd65 5840 It may not be necessary to disable the watchpoint to step over
d983da9c
DJ
5841 it. For example, the PA can (with some kernel cooperation)
5842 single step over a watchpoint without disabling the watchpoint.
5843
5844 It is far more common to need to disable a watchpoint to step
5845 the inferior over it. If we have non-steppable watchpoints,
5846 we must disable the current watchpoint; it's simplest to
963f9c80
PA
5847 disable all watchpoints.
5848
5849 Any breakpoint at PC must also be stepped over -- if there's
5850 one, it will have already triggered before the watchpoint
5851 triggered, and we either already reported it to the user, or
5852 it didn't cause a stop and we called keep_going. In either
5853 case, if there was a breakpoint at PC, we must be trying to
5854 step past it. */
5855 ecs->event_thread->stepping_over_watchpoint = 1;
5856 keep_going (ecs);
488f131b
JB
5857 return;
5858 }
5859
4e1c45ea 5860 ecs->event_thread->stepping_over_breakpoint = 0;
963f9c80 5861 ecs->event_thread->stepping_over_watchpoint = 0;
16c381f0
JK
5862 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
5863 ecs->event_thread->control.stop_step = 0;
488f131b 5864 stop_print_frame = 1;
488f131b 5865 stopped_by_random_signal = 0;
488f131b 5866
edb3359d
DJ
5867 /* Hide inlined functions starting here, unless we just performed stepi or
5868 nexti. After stepi and nexti, always show the innermost frame (not any
5869 inline function call sites). */
16c381f0 5870 if (ecs->event_thread->control.step_range_end != 1)
0574c78f
GB
5871 {
5872 struct address_space *aspace =
5873 get_regcache_aspace (get_thread_regcache (ecs->ptid));
5874
5875 /* skip_inline_frames is expensive, so we avoid it if we can
5876 determine that the address is one where functions cannot have
5877 been inlined. This improves performance with inferiors that
5878 load a lot of shared libraries, because the solib event
5879 breakpoint is defined as the address of a function (i.e. not
5880 inline). Note that we have to check the previous PC as well
5881 as the current one to catch cases when we have just
5882 single-stepped off a breakpoint prior to reinstating it.
5883 Note that we're assuming that the code we single-step to is
5884 not inline, but that's not definitive: there's nothing
5885 preventing the event breakpoint function from containing
5886 inlined code, and the single-step ending up there. If the
5887 user had set a breakpoint on that inlined code, the missing
5888 skip_inline_frames call would break things. Fortunately
5889 that's an extremely unlikely scenario. */
09ac7c10 5890 if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
a210c238
MR
5891 && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5892 && ecs->event_thread->control.trap_expected
5893 && pc_at_non_inline_function (aspace,
5894 ecs->event_thread->prev_pc,
09ac7c10 5895 &ecs->ws)))
1c5a993e
MR
5896 {
5897 skip_inline_frames (ecs->ptid);
5898
5899 /* Re-fetch current thread's frame in case that invalidated
5900 the frame cache. */
5901 frame = get_current_frame ();
5902 gdbarch = get_frame_arch (frame);
5903 }
0574c78f 5904 }
edb3359d 5905
a493e3e2 5906 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
16c381f0 5907 && ecs->event_thread->control.trap_expected
568d6575 5908 && gdbarch_single_step_through_delay_p (gdbarch)
4e1c45ea 5909 && currently_stepping (ecs->event_thread))
3352ef37 5910 {
b50d7442 5911 /* We're trying to step off a breakpoint. Turns out that we're
3352ef37 5912 also on an instruction that needs to be stepped multiple
1777feb0 5913 times before it's been fully executing. E.g., architectures
3352ef37
AC
5914 with a delay slot. It needs to be stepped twice, once for
5915 the instruction and once for the delay slot. */
5916 int step_through_delay
568d6575 5917 = gdbarch_single_step_through_delay (gdbarch, frame);
abbb1732 5918
527159b7 5919 if (debug_infrun && step_through_delay)
8a9de0e4 5920 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
16c381f0
JK
5921 if (ecs->event_thread->control.step_range_end == 0
5922 && step_through_delay)
3352ef37
AC
5923 {
5924 /* The user issued a continue when stopped at a breakpoint.
5925 Set up for another trap and get out of here. */
4e1c45ea 5926 ecs->event_thread->stepping_over_breakpoint = 1;
3352ef37
AC
5927 keep_going (ecs);
5928 return;
5929 }
5930 else if (step_through_delay)
5931 {
5932 /* The user issued a step when stopped at a breakpoint.
5933 Maybe we should stop, maybe we should not - the delay
5934 slot *might* correspond to a line of source. In any
ca67fcb8
VP
5935 case, don't decide that here, just set
5936 ecs->stepping_over_breakpoint, making sure we
5937 single-step again before breakpoints are re-inserted. */
4e1c45ea 5938 ecs->event_thread->stepping_over_breakpoint = 1;
3352ef37
AC
5939 }
5940 }
5941
ab04a2af
TT
5942 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5943 handles this event. */
5944 ecs->event_thread->control.stop_bpstat
5945 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
5946 stop_pc, ecs->ptid, &ecs->ws);
db82e815 5947
ab04a2af
TT
5948 /* Following in case break condition called a
5949 function. */
5950 stop_print_frame = 1;
73dd234f 5951
ab04a2af
TT
5952 /* This is where we handle "moribund" watchpoints. Unlike
5953 software breakpoints traps, hardware watchpoint traps are
5954 always distinguishable from random traps. If no high-level
5955 watchpoint is associated with the reported stop data address
5956 anymore, then the bpstat does not explain the signal ---
5957 simply make sure to ignore it if `stopped_by_watchpoint' is
5958 set. */
5959
5960 if (debug_infrun
5961 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
47591c29 5962 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
427cd150 5963 GDB_SIGNAL_TRAP)
ab04a2af
TT
5964 && stopped_by_watchpoint)
5965 fprintf_unfiltered (gdb_stdlog,
5966 "infrun: no user watchpoint explains "
5967 "watchpoint SIGTRAP, ignoring\n");
73dd234f 5968
bac7d97b 5969 /* NOTE: cagney/2003-03-29: These checks for a random signal
ab04a2af
TT
5970 at one stage in the past included checks for an inferior
5971 function call's call dummy's return breakpoint. The original
5972 comment, that went with the test, read:
03cebad2 5973
ab04a2af
TT
5974 ``End of a stack dummy. Some systems (e.g. Sony news) give
5975 another signal besides SIGTRAP, so check here as well as
5976 above.''
73dd234f 5977
ab04a2af
TT
5978 If someone ever tries to get call dummys on a
5979 non-executable stack to work (where the target would stop
5980 with something like a SIGSEGV), then those tests might need
5981 to be re-instated. Given, however, that the tests were only
5982 enabled when momentary breakpoints were not being used, I
5983 suspect that it won't be the case.
488f131b 5984
ab04a2af
TT
5985 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5986 be necessary for call dummies on a non-executable stack on
5987 SPARC. */
488f131b 5988
bac7d97b 5989 /* See if the breakpoints module can explain the signal. */
47591c29
PA
5990 random_signal
5991 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5992 ecs->event_thread->suspend.stop_signal);
bac7d97b 5993
1cf4d951
PA
5994 /* Maybe this was a trap for a software breakpoint that has since
5995 been removed. */
5996 if (random_signal && target_stopped_by_sw_breakpoint ())
5997 {
5998 if (program_breakpoint_here_p (gdbarch, stop_pc))
5999 {
6000 struct regcache *regcache;
6001 int decr_pc;
6002
6003 /* Re-adjust PC to what the program would see if GDB was not
6004 debugging it. */
6005 regcache = get_thread_regcache (ecs->event_thread->ptid);
527a273a 6006 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
1cf4d951
PA
6007 if (decr_pc != 0)
6008 {
6009 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
6010
6011 if (record_full_is_used ())
6012 record_full_gdb_operation_disable_set ();
6013
6014 regcache_write_pc (regcache, stop_pc + decr_pc);
6015
6016 do_cleanups (old_cleanups);
6017 }
6018 }
6019 else
6020 {
6021 /* A delayed software breakpoint event. Ignore the trap. */
6022 if (debug_infrun)
6023 fprintf_unfiltered (gdb_stdlog,
6024 "infrun: delayed software breakpoint "
6025 "trap, ignoring\n");
6026 random_signal = 0;
6027 }
6028 }
6029
6030 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6031 has since been removed. */
6032 if (random_signal && target_stopped_by_hw_breakpoint ())
6033 {
6034 /* A delayed hardware breakpoint event. Ignore the trap. */
6035 if (debug_infrun)
6036 fprintf_unfiltered (gdb_stdlog,
6037 "infrun: delayed hardware breakpoint/watchpoint "
6038 "trap, ignoring\n");
6039 random_signal = 0;
6040 }
6041
bac7d97b
PA
6042 /* If not, perhaps stepping/nexting can. */
6043 if (random_signal)
6044 random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6045 && currently_stepping (ecs->event_thread));
ab04a2af 6046
2adfaa28
PA
6047 /* Perhaps the thread hit a single-step breakpoint of _another_
6048 thread. Single-step breakpoints are transparent to the
6049 breakpoints module. */
6050 if (random_signal)
6051 random_signal = !ecs->hit_singlestep_breakpoint;
6052
bac7d97b
PA
6053 /* No? Perhaps we got a moribund watchpoint. */
6054 if (random_signal)
6055 random_signal = !stopped_by_watchpoint;
ab04a2af 6056
c65d6b55
PA
6057 /* Always stop if the user explicitly requested this thread to
6058 remain stopped. */
6059 if (ecs->event_thread->stop_requested)
6060 {
6061 random_signal = 1;
6062 if (debug_infrun)
6063 fprintf_unfiltered (gdb_stdlog, "infrun: user-requested stop\n");
6064 }
6065
488f131b
JB
6066 /* For the program's own signals, act according to
6067 the signal handling tables. */
6068
ce12b012 6069 if (random_signal)
488f131b
JB
6070 {
6071 /* Signal not for debugging purposes. */
c9657e70 6072 struct inferior *inf = find_inferior_ptid (ecs->ptid);
c9737c08 6073 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
488f131b 6074
527159b7 6075 if (debug_infrun)
c9737c08
PA
6076 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
6077 gdb_signal_to_symbol_string (stop_signal));
527159b7 6078
488f131b
JB
6079 stopped_by_random_signal = 1;
6080
252fbfc8
PA
6081 /* Always stop on signals if we're either just gaining control
6082 of the program, or the user explicitly requested this thread
6083 to remain stopped. */
d6b48e9c 6084 if (stop_soon != NO_STOP_QUIETLY
252fbfc8 6085 || ecs->event_thread->stop_requested
24291992 6086 || (!inf->detaching
16c381f0 6087 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
488f131b 6088 {
22bcd14b 6089 stop_waiting (ecs);
488f131b
JB
6090 return;
6091 }
b57bacec
PA
6092
6093 /* Notify observers the signal has "handle print" set. Note we
6094 returned early above if stopping; normal_stop handles the
6095 printing in that case. */
6096 if (signal_print[ecs->event_thread->suspend.stop_signal])
6097 {
6098 /* The signal table tells us to print about this signal. */
6099 target_terminal_ours_for_output ();
6100 observer_notify_signal_received (ecs->event_thread->suspend.stop_signal);
6101 target_terminal_inferior ();
6102 }
488f131b
JB
6103
6104 /* Clear the signal if it should not be passed. */
16c381f0 6105 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
a493e3e2 6106 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
488f131b 6107
fb14de7b 6108 if (ecs->event_thread->prev_pc == stop_pc
16c381f0 6109 && ecs->event_thread->control.trap_expected
8358c15c 6110 && ecs->event_thread->control.step_resume_breakpoint == NULL)
68f53502
AC
6111 {
6112 /* We were just starting a new sequence, attempting to
6113 single-step off of a breakpoint and expecting a SIGTRAP.
237fc4c9 6114 Instead this signal arrives. This signal will take us out
68f53502
AC
6115 of the stepping range so GDB needs to remember to, when
6116 the signal handler returns, resume stepping off that
6117 breakpoint. */
6118 /* To simplify things, "continue" is forced to use the same
6119 code paths as single-step - set a breakpoint at the
6120 signal return address and then, once hit, step off that
6121 breakpoint. */
237fc4c9
PA
6122 if (debug_infrun)
6123 fprintf_unfiltered (gdb_stdlog,
6124 "infrun: signal arrived while stepping over "
6125 "breakpoint\n");
d3169d93 6126
2c03e5be 6127 insert_hp_step_resume_breakpoint_at_frame (frame);
4e1c45ea 6128 ecs->event_thread->step_after_step_resume_breakpoint = 1;
2455069d
UW
6129 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6130 ecs->event_thread->control.trap_expected = 0;
d137e6dc
PA
6131
6132 /* If we were nexting/stepping some other thread, switch to
6133 it, so that we don't continue it, losing control. */
6134 if (!switch_back_to_stepped_thread (ecs))
6135 keep_going (ecs);
9d799f85 6136 return;
68f53502 6137 }
9d799f85 6138
e5f8a7cc
PA
6139 if (ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
6140 && (pc_in_thread_step_range (stop_pc, ecs->event_thread)
6141 || ecs->event_thread->control.step_range_end == 1)
edb3359d 6142 && frame_id_eq (get_stack_frame_id (frame),
16c381f0 6143 ecs->event_thread->control.step_stack_frame_id)
8358c15c 6144 && ecs->event_thread->control.step_resume_breakpoint == NULL)
d303a6c7
AC
6145 {
6146 /* The inferior is about to take a signal that will take it
6147 out of the single step range. Set a breakpoint at the
6148 current PC (which is presumably where the signal handler
6149 will eventually return) and then allow the inferior to
6150 run free.
6151
6152 Note that this is only needed for a signal delivered
6153 while in the single-step range. Nested signals aren't a
6154 problem as they eventually all return. */
237fc4c9
PA
6155 if (debug_infrun)
6156 fprintf_unfiltered (gdb_stdlog,
6157 "infrun: signal may take us out of "
6158 "single-step range\n");
6159
372316f1 6160 clear_step_over_info ();
2c03e5be 6161 insert_hp_step_resume_breakpoint_at_frame (frame);
e5f8a7cc 6162 ecs->event_thread->step_after_step_resume_breakpoint = 1;
2455069d
UW
6163 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6164 ecs->event_thread->control.trap_expected = 0;
9d799f85
AC
6165 keep_going (ecs);
6166 return;
d303a6c7 6167 }
9d799f85
AC
6168
6169 /* Note: step_resume_breakpoint may be non-NULL. This occures
6170 when either there's a nested signal, or when there's a
6171 pending signal enabled just as the signal handler returns
6172 (leaving the inferior at the step-resume-breakpoint without
6173 actually executing it). Either way continue until the
6174 breakpoint is really hit. */
c447ac0b
PA
6175
6176 if (!switch_back_to_stepped_thread (ecs))
6177 {
6178 if (debug_infrun)
6179 fprintf_unfiltered (gdb_stdlog,
6180 "infrun: random signal, keep going\n");
6181
6182 keep_going (ecs);
6183 }
6184 return;
488f131b 6185 }
94c57d6a
PA
6186
6187 process_event_stop_test (ecs);
6188}
6189
6190/* Come here when we've got some debug event / signal we can explain
6191 (IOW, not a random signal), and test whether it should cause a
6192 stop, or whether we should resume the inferior (transparently).
6193 E.g., could be a breakpoint whose condition evaluates false; we
6194 could be still stepping within the line; etc. */
6195
6196static void
6197process_event_stop_test (struct execution_control_state *ecs)
6198{
6199 struct symtab_and_line stop_pc_sal;
6200 struct frame_info *frame;
6201 struct gdbarch *gdbarch;
cdaa5b73
PA
6202 CORE_ADDR jmp_buf_pc;
6203 struct bpstat_what what;
94c57d6a 6204
cdaa5b73 6205 /* Handle cases caused by hitting a breakpoint. */
611c83ae 6206
cdaa5b73
PA
6207 frame = get_current_frame ();
6208 gdbarch = get_frame_arch (frame);
fcf3daef 6209
cdaa5b73 6210 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
611c83ae 6211
cdaa5b73
PA
6212 if (what.call_dummy)
6213 {
6214 stop_stack_dummy = what.call_dummy;
6215 }
186c406b 6216
243a9253
PA
6217 /* A few breakpoint types have callbacks associated (e.g.,
6218 bp_jit_event). Run them now. */
6219 bpstat_run_callbacks (ecs->event_thread->control.stop_bpstat);
6220
cdaa5b73
PA
6221 /* If we hit an internal event that triggers symbol changes, the
6222 current frame will be invalidated within bpstat_what (e.g., if we
6223 hit an internal solib event). Re-fetch it. */
6224 frame = get_current_frame ();
6225 gdbarch = get_frame_arch (frame);
e2e4d78b 6226
cdaa5b73
PA
6227 switch (what.main_action)
6228 {
6229 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
6230 /* If we hit the breakpoint at longjmp while stepping, we
6231 install a momentary breakpoint at the target of the
6232 jmp_buf. */
186c406b 6233
cdaa5b73
PA
6234 if (debug_infrun)
6235 fprintf_unfiltered (gdb_stdlog,
6236 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
186c406b 6237
cdaa5b73 6238 ecs->event_thread->stepping_over_breakpoint = 1;
611c83ae 6239
cdaa5b73
PA
6240 if (what.is_longjmp)
6241 {
6242 struct value *arg_value;
6243
6244 /* If we set the longjmp breakpoint via a SystemTap probe,
6245 then use it to extract the arguments. The destination PC
6246 is the third argument to the probe. */
6247 arg_value = probe_safe_evaluate_at_pc (frame, 2);
6248 if (arg_value)
8fa0c4f8
AA
6249 {
6250 jmp_buf_pc = value_as_address (arg_value);
6251 jmp_buf_pc = gdbarch_addr_bits_remove (gdbarch, jmp_buf_pc);
6252 }
cdaa5b73
PA
6253 else if (!gdbarch_get_longjmp_target_p (gdbarch)
6254 || !gdbarch_get_longjmp_target (gdbarch,
6255 frame, &jmp_buf_pc))
e2e4d78b 6256 {
cdaa5b73
PA
6257 if (debug_infrun)
6258 fprintf_unfiltered (gdb_stdlog,
6259 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
6260 "(!gdbarch_get_longjmp_target)\n");
6261 keep_going (ecs);
6262 return;
e2e4d78b 6263 }
e2e4d78b 6264
cdaa5b73
PA
6265 /* Insert a breakpoint at resume address. */
6266 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
6267 }
6268 else
6269 check_exception_resume (ecs, frame);
6270 keep_going (ecs);
6271 return;
e81a37f7 6272
cdaa5b73
PA
6273 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
6274 {
6275 struct frame_info *init_frame;
e81a37f7 6276
cdaa5b73 6277 /* There are several cases to consider.
c906108c 6278
cdaa5b73
PA
6279 1. The initiating frame no longer exists. In this case we
6280 must stop, because the exception or longjmp has gone too
6281 far.
2c03e5be 6282
cdaa5b73
PA
6283 2. The initiating frame exists, and is the same as the
6284 current frame. We stop, because the exception or longjmp
6285 has been caught.
2c03e5be 6286
cdaa5b73
PA
6287 3. The initiating frame exists and is different from the
6288 current frame. This means the exception or longjmp has
6289 been caught beneath the initiating frame, so keep going.
c906108c 6290
cdaa5b73
PA
6291 4. longjmp breakpoint has been placed just to protect
6292 against stale dummy frames and user is not interested in
6293 stopping around longjmps. */
c5aa993b 6294
cdaa5b73
PA
6295 if (debug_infrun)
6296 fprintf_unfiltered (gdb_stdlog,
6297 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
c5aa993b 6298
cdaa5b73
PA
6299 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
6300 != NULL);
6301 delete_exception_resume_breakpoint (ecs->event_thread);
c5aa993b 6302
cdaa5b73
PA
6303 if (what.is_longjmp)
6304 {
b67a2c6f 6305 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
c5aa993b 6306
cdaa5b73 6307 if (!frame_id_p (ecs->event_thread->initiating_frame))
e5ef252a 6308 {
cdaa5b73
PA
6309 /* Case 4. */
6310 keep_going (ecs);
6311 return;
e5ef252a 6312 }
cdaa5b73 6313 }
c5aa993b 6314
cdaa5b73 6315 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
527159b7 6316
cdaa5b73
PA
6317 if (init_frame)
6318 {
6319 struct frame_id current_id
6320 = get_frame_id (get_current_frame ());
6321 if (frame_id_eq (current_id,
6322 ecs->event_thread->initiating_frame))
6323 {
6324 /* Case 2. Fall through. */
6325 }
6326 else
6327 {
6328 /* Case 3. */
6329 keep_going (ecs);
6330 return;
6331 }
68f53502 6332 }
488f131b 6333
cdaa5b73
PA
6334 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6335 exists. */
6336 delete_step_resume_breakpoint (ecs->event_thread);
e5ef252a 6337
bdc36728 6338 end_stepping_range (ecs);
cdaa5b73
PA
6339 }
6340 return;
e5ef252a 6341
cdaa5b73
PA
6342 case BPSTAT_WHAT_SINGLE:
6343 if (debug_infrun)
6344 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
6345 ecs->event_thread->stepping_over_breakpoint = 1;
6346 /* Still need to check other stuff, at least the case where we
6347 are stepping and step out of the right range. */
6348 break;
e5ef252a 6349
cdaa5b73
PA
6350 case BPSTAT_WHAT_STEP_RESUME:
6351 if (debug_infrun)
6352 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
e5ef252a 6353
cdaa5b73
PA
6354 delete_step_resume_breakpoint (ecs->event_thread);
6355 if (ecs->event_thread->control.proceed_to_finish
6356 && execution_direction == EXEC_REVERSE)
6357 {
6358 struct thread_info *tp = ecs->event_thread;
6359
6360 /* We are finishing a function in reverse, and just hit the
6361 step-resume breakpoint at the start address of the
6362 function, and we're almost there -- just need to back up
6363 by one more single-step, which should take us back to the
6364 function call. */
6365 tp->control.step_range_start = tp->control.step_range_end = 1;
6366 keep_going (ecs);
e5ef252a 6367 return;
cdaa5b73
PA
6368 }
6369 fill_in_stop_func (gdbarch, ecs);
6370 if (stop_pc == ecs->stop_func_start
6371 && execution_direction == EXEC_REVERSE)
6372 {
6373 /* We are stepping over a function call in reverse, and just
6374 hit the step-resume breakpoint at the start address of
6375 the function. Go back to single-stepping, which should
6376 take us back to the function call. */
6377 ecs->event_thread->stepping_over_breakpoint = 1;
6378 keep_going (ecs);
6379 return;
6380 }
6381 break;
e5ef252a 6382
cdaa5b73
PA
6383 case BPSTAT_WHAT_STOP_NOISY:
6384 if (debug_infrun)
6385 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6386 stop_print_frame = 1;
e5ef252a 6387
99619bea
PA
6388 /* Assume the thread stopped for a breapoint. We'll still check
6389 whether a/the breakpoint is there when the thread is next
6390 resumed. */
6391 ecs->event_thread->stepping_over_breakpoint = 1;
e5ef252a 6392
22bcd14b 6393 stop_waiting (ecs);
cdaa5b73 6394 return;
e5ef252a 6395
cdaa5b73
PA
6396 case BPSTAT_WHAT_STOP_SILENT:
6397 if (debug_infrun)
6398 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6399 stop_print_frame = 0;
e5ef252a 6400
99619bea
PA
6401 /* Assume the thread stopped for a breapoint. We'll still check
6402 whether a/the breakpoint is there when the thread is next
6403 resumed. */
6404 ecs->event_thread->stepping_over_breakpoint = 1;
22bcd14b 6405 stop_waiting (ecs);
cdaa5b73
PA
6406 return;
6407
6408 case BPSTAT_WHAT_HP_STEP_RESUME:
6409 if (debug_infrun)
6410 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6411
6412 delete_step_resume_breakpoint (ecs->event_thread);
6413 if (ecs->event_thread->step_after_step_resume_breakpoint)
6414 {
6415 /* Back when the step-resume breakpoint was inserted, we
6416 were trying to single-step off a breakpoint. Go back to
6417 doing that. */
6418 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6419 ecs->event_thread->stepping_over_breakpoint = 1;
6420 keep_going (ecs);
6421 return;
e5ef252a 6422 }
cdaa5b73
PA
6423 break;
6424
6425 case BPSTAT_WHAT_KEEP_CHECKING:
6426 break;
e5ef252a 6427 }
c906108c 6428
af48d08f
PA
6429 /* If we stepped a permanent breakpoint and we had a high priority
6430 step-resume breakpoint for the address we stepped, but we didn't
6431 hit it, then we must have stepped into the signal handler. The
6432 step-resume was only necessary to catch the case of _not_
6433 stepping into the handler, so delete it, and fall through to
6434 checking whether the step finished. */
6435 if (ecs->event_thread->stepped_breakpoint)
6436 {
6437 struct breakpoint *sr_bp
6438 = ecs->event_thread->control.step_resume_breakpoint;
6439
8d707a12
PA
6440 if (sr_bp != NULL
6441 && sr_bp->loc->permanent
af48d08f
PA
6442 && sr_bp->type == bp_hp_step_resume
6443 && sr_bp->loc->address == ecs->event_thread->prev_pc)
6444 {
6445 if (debug_infrun)
6446 fprintf_unfiltered (gdb_stdlog,
6447 "infrun: stepped permanent breakpoint, stopped in "
6448 "handler\n");
6449 delete_step_resume_breakpoint (ecs->event_thread);
6450 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6451 }
6452 }
6453
cdaa5b73
PA
6454 /* We come here if we hit a breakpoint but should not stop for it.
6455 Possibly we also were stepping and should stop for that. So fall
6456 through and test for stepping. But, if not stepping, do not
6457 stop. */
c906108c 6458
a7212384
UW
6459 /* In all-stop mode, if we're currently stepping but have stopped in
6460 some other thread, we need to switch back to the stepped thread. */
c447ac0b
PA
6461 if (switch_back_to_stepped_thread (ecs))
6462 return;
776f04fa 6463
8358c15c 6464 if (ecs->event_thread->control.step_resume_breakpoint)
488f131b 6465 {
527159b7 6466 if (debug_infrun)
d3169d93
DJ
6467 fprintf_unfiltered (gdb_stdlog,
6468 "infrun: step-resume breakpoint is inserted\n");
527159b7 6469
488f131b
JB
6470 /* Having a step-resume breakpoint overrides anything
6471 else having to do with stepping commands until
6472 that breakpoint is reached. */
488f131b
JB
6473 keep_going (ecs);
6474 return;
6475 }
c5aa993b 6476
16c381f0 6477 if (ecs->event_thread->control.step_range_end == 0)
488f131b 6478 {
527159b7 6479 if (debug_infrun)
8a9de0e4 6480 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
488f131b 6481 /* Likewise if we aren't even stepping. */
488f131b
JB
6482 keep_going (ecs);
6483 return;
6484 }
c5aa993b 6485
4b7703ad
JB
6486 /* Re-fetch current thread's frame in case the code above caused
6487 the frame cache to be re-initialized, making our FRAME variable
6488 a dangling pointer. */
6489 frame = get_current_frame ();
628fe4e4 6490 gdbarch = get_frame_arch (frame);
7e324e48 6491 fill_in_stop_func (gdbarch, ecs);
4b7703ad 6492
488f131b 6493 /* If stepping through a line, keep going if still within it.
c906108c 6494
488f131b
JB
6495 Note that step_range_end is the address of the first instruction
6496 beyond the step range, and NOT the address of the last instruction
31410e84
MS
6497 within it!
6498
6499 Note also that during reverse execution, we may be stepping
6500 through a function epilogue and therefore must detect when
6501 the current-frame changes in the middle of a line. */
6502
ce4c476a 6503 if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
31410e84 6504 && (execution_direction != EXEC_REVERSE
388a8562 6505 || frame_id_eq (get_frame_id (frame),
16c381f0 6506 ecs->event_thread->control.step_frame_id)))
488f131b 6507 {
527159b7 6508 if (debug_infrun)
5af949e3
UW
6509 fprintf_unfiltered
6510 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
16c381f0
JK
6511 paddress (gdbarch, ecs->event_thread->control.step_range_start),
6512 paddress (gdbarch, ecs->event_thread->control.step_range_end));
b2175913 6513
c1e36e3e
PA
6514 /* Tentatively re-enable range stepping; `resume' disables it if
6515 necessary (e.g., if we're stepping over a breakpoint or we
6516 have software watchpoints). */
6517 ecs->event_thread->control.may_range_step = 1;
6518
b2175913
MS
6519 /* When stepping backward, stop at beginning of line range
6520 (unless it's the function entry point, in which case
6521 keep going back to the call point). */
16c381f0 6522 if (stop_pc == ecs->event_thread->control.step_range_start
b2175913
MS
6523 && stop_pc != ecs->stop_func_start
6524 && execution_direction == EXEC_REVERSE)
bdc36728 6525 end_stepping_range (ecs);
b2175913
MS
6526 else
6527 keep_going (ecs);
6528
488f131b
JB
6529 return;
6530 }
c5aa993b 6531
488f131b 6532 /* We stepped out of the stepping range. */
c906108c 6533
488f131b 6534 /* If we are stepping at the source level and entered the runtime
388a8562
MS
6535 loader dynamic symbol resolution code...
6536
6537 EXEC_FORWARD: we keep on single stepping until we exit the run
6538 time loader code and reach the callee's address.
6539
6540 EXEC_REVERSE: we've already executed the callee (backward), and
6541 the runtime loader code is handled just like any other
6542 undebuggable function call. Now we need only keep stepping
6543 backward through the trampoline code, and that's handled further
6544 down, so there is nothing for us to do here. */
6545
6546 if (execution_direction != EXEC_REVERSE
16c381f0 6547 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
cfd8ab24 6548 && in_solib_dynsym_resolve_code (stop_pc))
488f131b 6549 {
4c8c40e6 6550 CORE_ADDR pc_after_resolver =
568d6575 6551 gdbarch_skip_solib_resolver (gdbarch, stop_pc);
c906108c 6552
527159b7 6553 if (debug_infrun)
3e43a32a
MS
6554 fprintf_unfiltered (gdb_stdlog,
6555 "infrun: stepped into dynsym resolve code\n");
527159b7 6556
488f131b
JB
6557 if (pc_after_resolver)
6558 {
6559 /* Set up a step-resume breakpoint at the address
6560 indicated by SKIP_SOLIB_RESOLVER. */
51abb421 6561 symtab_and_line sr_sal;
488f131b 6562 sr_sal.pc = pc_after_resolver;
6c95b8df 6563 sr_sal.pspace = get_frame_program_space (frame);
488f131b 6564
a6d9a66e
UW
6565 insert_step_resume_breakpoint_at_sal (gdbarch,
6566 sr_sal, null_frame_id);
c5aa993b 6567 }
c906108c 6568
488f131b
JB
6569 keep_going (ecs);
6570 return;
6571 }
c906108c 6572
16c381f0
JK
6573 if (ecs->event_thread->control.step_range_end != 1
6574 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6575 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
568d6575 6576 && get_frame_type (frame) == SIGTRAMP_FRAME)
488f131b 6577 {
527159b7 6578 if (debug_infrun)
3e43a32a
MS
6579 fprintf_unfiltered (gdb_stdlog,
6580 "infrun: stepped into signal trampoline\n");
42edda50 6581 /* The inferior, while doing a "step" or "next", has ended up in
8fb3e588
AC
6582 a signal trampoline (either by a signal being delivered or by
6583 the signal handler returning). Just single-step until the
6584 inferior leaves the trampoline (either by calling the handler
6585 or returning). */
488f131b
JB
6586 keep_going (ecs);
6587 return;
6588 }
c906108c 6589
14132e89
MR
6590 /* If we're in the return path from a shared library trampoline,
6591 we want to proceed through the trampoline when stepping. */
6592 /* macro/2012-04-25: This needs to come before the subroutine
6593 call check below as on some targets return trampolines look
6594 like subroutine calls (MIPS16 return thunks). */
6595 if (gdbarch_in_solib_return_trampoline (gdbarch,
6596 stop_pc, ecs->stop_func_name)
6597 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6598 {
6599 /* Determine where this trampoline returns. */
6600 CORE_ADDR real_stop_pc;
6601
6602 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6603
6604 if (debug_infrun)
6605 fprintf_unfiltered (gdb_stdlog,
6606 "infrun: stepped into solib return tramp\n");
6607
6608 /* Only proceed through if we know where it's going. */
6609 if (real_stop_pc)
6610 {
6611 /* And put the step-breakpoint there and go until there. */
51abb421 6612 symtab_and_line sr_sal;
14132e89
MR
6613 sr_sal.pc = real_stop_pc;
6614 sr_sal.section = find_pc_overlay (sr_sal.pc);
6615 sr_sal.pspace = get_frame_program_space (frame);
6616
6617 /* Do not specify what the fp should be when we stop since
6618 on some machines the prologue is where the new fp value
6619 is established. */
6620 insert_step_resume_breakpoint_at_sal (gdbarch,
6621 sr_sal, null_frame_id);
6622
6623 /* Restart without fiddling with the step ranges or
6624 other state. */
6625 keep_going (ecs);
6626 return;
6627 }
6628 }
6629
c17eaafe
DJ
6630 /* Check for subroutine calls. The check for the current frame
6631 equalling the step ID is not necessary - the check of the
6632 previous frame's ID is sufficient - but it is a common case and
6633 cheaper than checking the previous frame's ID.
14e60db5
DJ
6634
6635 NOTE: frame_id_eq will never report two invalid frame IDs as
6636 being equal, so to get into this block, both the current and
6637 previous frame must have valid frame IDs. */
005ca36a
JB
6638 /* The outer_frame_id check is a heuristic to detect stepping
6639 through startup code. If we step over an instruction which
6640 sets the stack pointer from an invalid value to a valid value,
6641 we may detect that as a subroutine call from the mythical
6642 "outermost" function. This could be fixed by marking
6643 outermost frames as !stack_p,code_p,special_p. Then the
6644 initial outermost frame, before sp was valid, would
ce6cca6d 6645 have code_addr == &_start. See the comment in frame_id_eq
005ca36a 6646 for more. */
edb3359d 6647 if (!frame_id_eq (get_stack_frame_id (frame),
16c381f0 6648 ecs->event_thread->control.step_stack_frame_id)
005ca36a 6649 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
16c381f0
JK
6650 ecs->event_thread->control.step_stack_frame_id)
6651 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
005ca36a 6652 outer_frame_id)
885eeb5b
PA
6653 || (ecs->event_thread->control.step_start_function
6654 != find_pc_function (stop_pc)))))
488f131b 6655 {
95918acb 6656 CORE_ADDR real_stop_pc;
8fb3e588 6657
527159b7 6658 if (debug_infrun)
8a9de0e4 6659 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
527159b7 6660
b7a084be 6661 if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
95918acb
AC
6662 {
6663 /* I presume that step_over_calls is only 0 when we're
6664 supposed to be stepping at the assembly language level
6665 ("stepi"). Just stop. */
388a8562 6666 /* And this works the same backward as frontward. MVS */
bdc36728 6667 end_stepping_range (ecs);
95918acb
AC
6668 return;
6669 }
8fb3e588 6670
388a8562
MS
6671 /* Reverse stepping through solib trampolines. */
6672
6673 if (execution_direction == EXEC_REVERSE
16c381f0 6674 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
388a8562
MS
6675 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6676 || (ecs->stop_func_start == 0
6677 && in_solib_dynsym_resolve_code (stop_pc))))
6678 {
6679 /* Any solib trampoline code can be handled in reverse
6680 by simply continuing to single-step. We have already
6681 executed the solib function (backwards), and a few
6682 steps will take us back through the trampoline to the
6683 caller. */
6684 keep_going (ecs);
6685 return;
6686 }
6687
16c381f0 6688 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
8567c30f 6689 {
b2175913
MS
6690 /* We're doing a "next".
6691
6692 Normal (forward) execution: set a breakpoint at the
6693 callee's return address (the address at which the caller
6694 will resume).
6695
6696 Reverse (backward) execution. set the step-resume
6697 breakpoint at the start of the function that we just
6698 stepped into (backwards), and continue to there. When we
6130d0b7 6699 get there, we'll need to single-step back to the caller. */
b2175913
MS
6700
6701 if (execution_direction == EXEC_REVERSE)
6702 {
acf9414f
JK
6703 /* If we're already at the start of the function, we've either
6704 just stepped backward into a single instruction function,
6705 or stepped back out of a signal handler to the first instruction
6706 of the function. Just keep going, which will single-step back
6707 to the caller. */
58c48e72 6708 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
acf9414f 6709 {
acf9414f 6710 /* Normal function call return (static or dynamic). */
51abb421 6711 symtab_and_line sr_sal;
acf9414f
JK
6712 sr_sal.pc = ecs->stop_func_start;
6713 sr_sal.pspace = get_frame_program_space (frame);
6714 insert_step_resume_breakpoint_at_sal (gdbarch,
6715 sr_sal, null_frame_id);
6716 }
b2175913
MS
6717 }
6718 else
568d6575 6719 insert_step_resume_breakpoint_at_caller (frame);
b2175913 6720
8567c30f
AC
6721 keep_going (ecs);
6722 return;
6723 }
a53c66de 6724
95918acb 6725 /* If we are in a function call trampoline (a stub between the
8fb3e588
AC
6726 calling routine and the real function), locate the real
6727 function. That's what tells us (a) whether we want to step
6728 into it at all, and (b) what prologue we want to run to the
6729 end of, if we do step into it. */
568d6575 6730 real_stop_pc = skip_language_trampoline (frame, stop_pc);
95918acb 6731 if (real_stop_pc == 0)
568d6575 6732 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
95918acb
AC
6733 if (real_stop_pc != 0)
6734 ecs->stop_func_start = real_stop_pc;
8fb3e588 6735
db5f024e 6736 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
1b2bfbb9 6737 {
51abb421 6738 symtab_and_line sr_sal;
1b2bfbb9 6739 sr_sal.pc = ecs->stop_func_start;
6c95b8df 6740 sr_sal.pspace = get_frame_program_space (frame);
1b2bfbb9 6741
a6d9a66e
UW
6742 insert_step_resume_breakpoint_at_sal (gdbarch,
6743 sr_sal, null_frame_id);
8fb3e588
AC
6744 keep_going (ecs);
6745 return;
1b2bfbb9
RC
6746 }
6747
95918acb 6748 /* If we have line number information for the function we are
1bfeeb0f
JL
6749 thinking of stepping into and the function isn't on the skip
6750 list, step into it.
95918acb 6751
8fb3e588
AC
6752 If there are several symtabs at that PC (e.g. with include
6753 files), just want to know whether *any* of them have line
6754 numbers. find_pc_line handles this. */
95918acb
AC
6755 {
6756 struct symtab_and_line tmp_sal;
8fb3e588 6757
95918acb 6758 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
2b914b52 6759 if (tmp_sal.line != 0
85817405 6760 && !function_name_is_marked_for_skip (ecs->stop_func_name,
de7985c3 6761 tmp_sal))
95918acb 6762 {
b2175913 6763 if (execution_direction == EXEC_REVERSE)
568d6575 6764 handle_step_into_function_backward (gdbarch, ecs);
b2175913 6765 else
568d6575 6766 handle_step_into_function (gdbarch, ecs);
95918acb
AC
6767 return;
6768 }
6769 }
6770
6771 /* If we have no line number and the step-stop-if-no-debug is
8fb3e588
AC
6772 set, we stop the step so that the user has a chance to switch
6773 in assembly mode. */
16c381f0 6774 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
078130d0 6775 && step_stop_if_no_debug)
95918acb 6776 {
bdc36728 6777 end_stepping_range (ecs);
95918acb
AC
6778 return;
6779 }
6780
b2175913
MS
6781 if (execution_direction == EXEC_REVERSE)
6782 {
acf9414f
JK
6783 /* If we're already at the start of the function, we've either just
6784 stepped backward into a single instruction function without line
6785 number info, or stepped back out of a signal handler to the first
6786 instruction of the function without line number info. Just keep
6787 going, which will single-step back to the caller. */
6788 if (ecs->stop_func_start != stop_pc)
6789 {
6790 /* Set a breakpoint at callee's start address.
6791 From there we can step once and be back in the caller. */
51abb421 6792 symtab_and_line sr_sal;
acf9414f
JK
6793 sr_sal.pc = ecs->stop_func_start;
6794 sr_sal.pspace = get_frame_program_space (frame);
6795 insert_step_resume_breakpoint_at_sal (gdbarch,
6796 sr_sal, null_frame_id);
6797 }
b2175913
MS
6798 }
6799 else
6800 /* Set a breakpoint at callee's return address (the address
6801 at which the caller will resume). */
568d6575 6802 insert_step_resume_breakpoint_at_caller (frame);
b2175913 6803
95918acb 6804 keep_going (ecs);
488f131b 6805 return;
488f131b 6806 }
c906108c 6807
fdd654f3
MS
6808 /* Reverse stepping through solib trampolines. */
6809
6810 if (execution_direction == EXEC_REVERSE
16c381f0 6811 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
fdd654f3
MS
6812 {
6813 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6814 || (ecs->stop_func_start == 0
6815 && in_solib_dynsym_resolve_code (stop_pc)))
6816 {
6817 /* Any solib trampoline code can be handled in reverse
6818 by simply continuing to single-step. We have already
6819 executed the solib function (backwards), and a few
6820 steps will take us back through the trampoline to the
6821 caller. */
6822 keep_going (ecs);
6823 return;
6824 }
6825 else if (in_solib_dynsym_resolve_code (stop_pc))
6826 {
6827 /* Stepped backward into the solib dynsym resolver.
6828 Set a breakpoint at its start and continue, then
6829 one more step will take us out. */
51abb421 6830 symtab_and_line sr_sal;
fdd654f3 6831 sr_sal.pc = ecs->stop_func_start;
9d1807c3 6832 sr_sal.pspace = get_frame_program_space (frame);
fdd654f3
MS
6833 insert_step_resume_breakpoint_at_sal (gdbarch,
6834 sr_sal, null_frame_id);
6835 keep_going (ecs);
6836 return;
6837 }
6838 }
6839
2afb61aa 6840 stop_pc_sal = find_pc_line (stop_pc, 0);
7ed0fe66 6841
1b2bfbb9
RC
6842 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6843 the trampoline processing logic, however, there are some trampolines
6844 that have no names, so we should do trampoline handling first. */
16c381f0 6845 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
7ed0fe66 6846 && ecs->stop_func_name == NULL
2afb61aa 6847 && stop_pc_sal.line == 0)
1b2bfbb9 6848 {
527159b7 6849 if (debug_infrun)
3e43a32a
MS
6850 fprintf_unfiltered (gdb_stdlog,
6851 "infrun: stepped into undebuggable function\n");
527159b7 6852
1b2bfbb9 6853 /* The inferior just stepped into, or returned to, an
7ed0fe66
DJ
6854 undebuggable function (where there is no debugging information
6855 and no line number corresponding to the address where the
1b2bfbb9
RC
6856 inferior stopped). Since we want to skip this kind of code,
6857 we keep going until the inferior returns from this
14e60db5
DJ
6858 function - unless the user has asked us not to (via
6859 set step-mode) or we no longer know how to get back
6860 to the call site. */
6861 if (step_stop_if_no_debug
c7ce8faa 6862 || !frame_id_p (frame_unwind_caller_id (frame)))
1b2bfbb9
RC
6863 {
6864 /* If we have no line number and the step-stop-if-no-debug
6865 is set, we stop the step so that the user has a chance to
6866 switch in assembly mode. */
bdc36728 6867 end_stepping_range (ecs);
1b2bfbb9
RC
6868 return;
6869 }
6870 else
6871 {
6872 /* Set a breakpoint at callee's return address (the address
6873 at which the caller will resume). */
568d6575 6874 insert_step_resume_breakpoint_at_caller (frame);
1b2bfbb9
RC
6875 keep_going (ecs);
6876 return;
6877 }
6878 }
6879
16c381f0 6880 if (ecs->event_thread->control.step_range_end == 1)
1b2bfbb9
RC
6881 {
6882 /* It is stepi or nexti. We always want to stop stepping after
6883 one instruction. */
527159b7 6884 if (debug_infrun)
8a9de0e4 6885 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
bdc36728 6886 end_stepping_range (ecs);
1b2bfbb9
RC
6887 return;
6888 }
6889
2afb61aa 6890 if (stop_pc_sal.line == 0)
488f131b
JB
6891 {
6892 /* We have no line number information. That means to stop
6893 stepping (does this always happen right after one instruction,
6894 when we do "s" in a function with no line numbers,
6895 or can this happen as a result of a return or longjmp?). */
527159b7 6896 if (debug_infrun)
8a9de0e4 6897 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
bdc36728 6898 end_stepping_range (ecs);
488f131b
JB
6899 return;
6900 }
c906108c 6901
edb3359d
DJ
6902 /* Look for "calls" to inlined functions, part one. If the inline
6903 frame machinery detected some skipped call sites, we have entered
6904 a new inline function. */
6905
6906 if (frame_id_eq (get_frame_id (get_current_frame ()),
16c381f0 6907 ecs->event_thread->control.step_frame_id)
edb3359d
DJ
6908 && inline_skipped_frames (ecs->ptid))
6909 {
edb3359d
DJ
6910 if (debug_infrun)
6911 fprintf_unfiltered (gdb_stdlog,
6912 "infrun: stepped into inlined function\n");
6913
51abb421 6914 symtab_and_line call_sal = find_frame_sal (get_current_frame ());
edb3359d 6915
16c381f0 6916 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
edb3359d
DJ
6917 {
6918 /* For "step", we're going to stop. But if the call site
6919 for this inlined function is on the same source line as
6920 we were previously stepping, go down into the function
6921 first. Otherwise stop at the call site. */
6922
6923 if (call_sal.line == ecs->event_thread->current_line
6924 && call_sal.symtab == ecs->event_thread->current_symtab)
6925 step_into_inline_frame (ecs->ptid);
6926
bdc36728 6927 end_stepping_range (ecs);
edb3359d
DJ
6928 return;
6929 }
6930 else
6931 {
6932 /* For "next", we should stop at the call site if it is on a
6933 different source line. Otherwise continue through the
6934 inlined function. */
6935 if (call_sal.line == ecs->event_thread->current_line
6936 && call_sal.symtab == ecs->event_thread->current_symtab)
6937 keep_going (ecs);
6938 else
bdc36728 6939 end_stepping_range (ecs);
edb3359d
DJ
6940 return;
6941 }
6942 }
6943
6944 /* Look for "calls" to inlined functions, part two. If we are still
6945 in the same real function we were stepping through, but we have
6946 to go further up to find the exact frame ID, we are stepping
6947 through a more inlined call beyond its call site. */
6948
6949 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6950 && !frame_id_eq (get_frame_id (get_current_frame ()),
16c381f0 6951 ecs->event_thread->control.step_frame_id)
edb3359d 6952 && stepped_in_from (get_current_frame (),
16c381f0 6953 ecs->event_thread->control.step_frame_id))
edb3359d
DJ
6954 {
6955 if (debug_infrun)
6956 fprintf_unfiltered (gdb_stdlog,
6957 "infrun: stepping through inlined function\n");
6958
16c381f0 6959 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
edb3359d
DJ
6960 keep_going (ecs);
6961 else
bdc36728 6962 end_stepping_range (ecs);
edb3359d
DJ
6963 return;
6964 }
6965
2afb61aa 6966 if ((stop_pc == stop_pc_sal.pc)
4e1c45ea
PA
6967 && (ecs->event_thread->current_line != stop_pc_sal.line
6968 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
488f131b
JB
6969 {
6970 /* We are at the start of a different line. So stop. Note that
6971 we don't stop if we step into the middle of a different line.
6972 That is said to make things like for (;;) statements work
6973 better. */
527159b7 6974 if (debug_infrun)
3e43a32a
MS
6975 fprintf_unfiltered (gdb_stdlog,
6976 "infrun: stepped to a different line\n");
bdc36728 6977 end_stepping_range (ecs);
488f131b
JB
6978 return;
6979 }
c906108c 6980
488f131b 6981 /* We aren't done stepping.
c906108c 6982
488f131b
JB
6983 Optimize by setting the stepping range to the line.
6984 (We might not be in the original line, but if we entered a
6985 new line in mid-statement, we continue stepping. This makes
6986 things like for(;;) statements work better.) */
c906108c 6987
16c381f0
JK
6988 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
6989 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
c1e36e3e 6990 ecs->event_thread->control.may_range_step = 1;
edb3359d 6991 set_step_info (frame, stop_pc_sal);
488f131b 6992
527159b7 6993 if (debug_infrun)
8a9de0e4 6994 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
488f131b 6995 keep_going (ecs);
104c1213
JM
6996}
6997
c447ac0b
PA
6998/* In all-stop mode, if we're currently stepping but have stopped in
6999 some other thread, we may need to switch back to the stepped
7000 thread. Returns true we set the inferior running, false if we left
7001 it stopped (and the event needs further processing). */
7002
7003static int
7004switch_back_to_stepped_thread (struct execution_control_state *ecs)
7005{
fbea99ea 7006 if (!target_is_non_stop_p ())
c447ac0b
PA
7007 {
7008 struct thread_info *tp;
99619bea
PA
7009 struct thread_info *stepping_thread;
7010
7011 /* If any thread is blocked on some internal breakpoint, and we
7012 simply need to step over that breakpoint to get it going
7013 again, do that first. */
7014
7015 /* However, if we see an event for the stepping thread, then we
7016 know all other threads have been moved past their breakpoints
7017 already. Let the caller check whether the step is finished,
7018 etc., before deciding to move it past a breakpoint. */
7019 if (ecs->event_thread->control.step_range_end != 0)
7020 return 0;
7021
7022 /* Check if the current thread is blocked on an incomplete
7023 step-over, interrupted by a random signal. */
7024 if (ecs->event_thread->control.trap_expected
7025 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
c447ac0b 7026 {
99619bea
PA
7027 if (debug_infrun)
7028 {
7029 fprintf_unfiltered (gdb_stdlog,
7030 "infrun: need to finish step-over of [%s]\n",
7031 target_pid_to_str (ecs->event_thread->ptid));
7032 }
7033 keep_going (ecs);
7034 return 1;
7035 }
2adfaa28 7036
99619bea
PA
7037 /* Check if the current thread is blocked by a single-step
7038 breakpoint of another thread. */
7039 if (ecs->hit_singlestep_breakpoint)
7040 {
7041 if (debug_infrun)
7042 {
7043 fprintf_unfiltered (gdb_stdlog,
7044 "infrun: need to step [%s] over single-step "
7045 "breakpoint\n",
7046 target_pid_to_str (ecs->ptid));
7047 }
7048 keep_going (ecs);
7049 return 1;
7050 }
7051
4d9d9d04
PA
7052 /* If this thread needs yet another step-over (e.g., stepping
7053 through a delay slot), do it first before moving on to
7054 another thread. */
7055 if (thread_still_needs_step_over (ecs->event_thread))
7056 {
7057 if (debug_infrun)
7058 {
7059 fprintf_unfiltered (gdb_stdlog,
7060 "infrun: thread [%s] still needs step-over\n",
7061 target_pid_to_str (ecs->event_thread->ptid));
7062 }
7063 keep_going (ecs);
7064 return 1;
7065 }
70509625 7066
483805cf
PA
7067 /* If scheduler locking applies even if not stepping, there's no
7068 need to walk over threads. Above we've checked whether the
7069 current thread is stepping. If some other thread not the
7070 event thread is stepping, then it must be that scheduler
7071 locking is not in effect. */
856e7dd6 7072 if (schedlock_applies (ecs->event_thread))
483805cf
PA
7073 return 0;
7074
4d9d9d04
PA
7075 /* Otherwise, we no longer expect a trap in the current thread.
7076 Clear the trap_expected flag before switching back -- this is
7077 what keep_going does as well, if we call it. */
7078 ecs->event_thread->control.trap_expected = 0;
7079
7080 /* Likewise, clear the signal if it should not be passed. */
7081 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7082 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7083
7084 /* Do all pending step-overs before actually proceeding with
483805cf 7085 step/next/etc. */
4d9d9d04
PA
7086 if (start_step_over ())
7087 {
7088 prepare_to_wait (ecs);
7089 return 1;
7090 }
7091
7092 /* Look for the stepping/nexting thread. */
483805cf 7093 stepping_thread = NULL;
4d9d9d04 7094
034f788c 7095 ALL_NON_EXITED_THREADS (tp)
483805cf 7096 {
fbea99ea
PA
7097 /* Ignore threads of processes the caller is not
7098 resuming. */
483805cf 7099 if (!sched_multi
1afd5965 7100 && ptid_get_pid (tp->ptid) != ptid_get_pid (ecs->ptid))
483805cf
PA
7101 continue;
7102
7103 /* When stepping over a breakpoint, we lock all threads
7104 except the one that needs to move past the breakpoint.
7105 If a non-event thread has this set, the "incomplete
7106 step-over" check above should have caught it earlier. */
372316f1
PA
7107 if (tp->control.trap_expected)
7108 {
7109 internal_error (__FILE__, __LINE__,
7110 "[%s] has inconsistent state: "
7111 "trap_expected=%d\n",
7112 target_pid_to_str (tp->ptid),
7113 tp->control.trap_expected);
7114 }
483805cf
PA
7115
7116 /* Did we find the stepping thread? */
7117 if (tp->control.step_range_end)
7118 {
7119 /* Yep. There should only one though. */
7120 gdb_assert (stepping_thread == NULL);
7121
7122 /* The event thread is handled at the top, before we
7123 enter this loop. */
7124 gdb_assert (tp != ecs->event_thread);
7125
7126 /* If some thread other than the event thread is
7127 stepping, then scheduler locking can't be in effect,
7128 otherwise we wouldn't have resumed the current event
7129 thread in the first place. */
856e7dd6 7130 gdb_assert (!schedlock_applies (tp));
483805cf
PA
7131
7132 stepping_thread = tp;
7133 }
99619bea
PA
7134 }
7135
483805cf 7136 if (stepping_thread != NULL)
99619bea 7137 {
c447ac0b
PA
7138 if (debug_infrun)
7139 fprintf_unfiltered (gdb_stdlog,
7140 "infrun: switching back to stepped thread\n");
7141
2ac7589c
PA
7142 if (keep_going_stepped_thread (stepping_thread))
7143 {
7144 prepare_to_wait (ecs);
7145 return 1;
7146 }
7147 }
7148 }
2adfaa28 7149
2ac7589c
PA
7150 return 0;
7151}
2adfaa28 7152
2ac7589c
PA
7153/* Set a previously stepped thread back to stepping. Returns true on
7154 success, false if the resume is not possible (e.g., the thread
7155 vanished). */
7156
7157static int
7158keep_going_stepped_thread (struct thread_info *tp)
7159{
7160 struct frame_info *frame;
2ac7589c
PA
7161 struct execution_control_state ecss;
7162 struct execution_control_state *ecs = &ecss;
2adfaa28 7163
2ac7589c
PA
7164 /* If the stepping thread exited, then don't try to switch back and
7165 resume it, which could fail in several different ways depending
7166 on the target. Instead, just keep going.
2adfaa28 7167
2ac7589c
PA
7168 We can find a stepping dead thread in the thread list in two
7169 cases:
2adfaa28 7170
2ac7589c
PA
7171 - The target supports thread exit events, and when the target
7172 tries to delete the thread from the thread list, inferior_ptid
7173 pointed at the exiting thread. In such case, calling
7174 delete_thread does not really remove the thread from the list;
7175 instead, the thread is left listed, with 'exited' state.
64ce06e4 7176
2ac7589c
PA
7177 - The target's debug interface does not support thread exit
7178 events, and so we have no idea whatsoever if the previously
7179 stepping thread is still alive. For that reason, we need to
7180 synchronously query the target now. */
2adfaa28 7181
2ac7589c
PA
7182 if (is_exited (tp->ptid)
7183 || !target_thread_alive (tp->ptid))
7184 {
7185 if (debug_infrun)
7186 fprintf_unfiltered (gdb_stdlog,
7187 "infrun: not resuming previously "
7188 "stepped thread, it has vanished\n");
7189
7190 delete_thread (tp->ptid);
7191 return 0;
c447ac0b 7192 }
2ac7589c
PA
7193
7194 if (debug_infrun)
7195 fprintf_unfiltered (gdb_stdlog,
7196 "infrun: resuming previously stepped thread\n");
7197
7198 reset_ecs (ecs, tp);
7199 switch_to_thread (tp->ptid);
7200
7201 stop_pc = regcache_read_pc (get_thread_regcache (tp->ptid));
7202 frame = get_current_frame ();
2ac7589c
PA
7203
7204 /* If the PC of the thread we were trying to single-step has
7205 changed, then that thread has trapped or been signaled, but the
7206 event has not been reported to GDB yet. Re-poll the target
7207 looking for this particular thread's event (i.e. temporarily
7208 enable schedlock) by:
7209
7210 - setting a break at the current PC
7211 - resuming that particular thread, only (by setting trap
7212 expected)
7213
7214 This prevents us continuously moving the single-step breakpoint
7215 forward, one instruction at a time, overstepping. */
7216
7217 if (stop_pc != tp->prev_pc)
7218 {
7219 ptid_t resume_ptid;
7220
7221 if (debug_infrun)
7222 fprintf_unfiltered (gdb_stdlog,
7223 "infrun: expected thread advanced also (%s -> %s)\n",
7224 paddress (target_gdbarch (), tp->prev_pc),
7225 paddress (target_gdbarch (), stop_pc));
7226
7227 /* Clear the info of the previous step-over, as it's no longer
7228 valid (if the thread was trying to step over a breakpoint, it
7229 has already succeeded). It's what keep_going would do too,
7230 if we called it. Do this before trying to insert the sss
7231 breakpoint, otherwise if we were previously trying to step
7232 over this exact address in another thread, the breakpoint is
7233 skipped. */
7234 clear_step_over_info ();
7235 tp->control.trap_expected = 0;
7236
7237 insert_single_step_breakpoint (get_frame_arch (frame),
7238 get_frame_address_space (frame),
7239 stop_pc);
7240
372316f1 7241 tp->resumed = 1;
fbea99ea 7242 resume_ptid = internal_resume_ptid (tp->control.stepping_command);
2ac7589c
PA
7243 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
7244 }
7245 else
7246 {
7247 if (debug_infrun)
7248 fprintf_unfiltered (gdb_stdlog,
7249 "infrun: expected thread still hasn't advanced\n");
7250
7251 keep_going_pass_signal (ecs);
7252 }
7253 return 1;
c447ac0b
PA
7254}
7255
8b061563
PA
7256/* Is thread TP in the middle of (software or hardware)
7257 single-stepping? (Note the result of this function must never be
7258 passed directly as target_resume's STEP parameter.) */
104c1213 7259
a289b8f6 7260static int
b3444185 7261currently_stepping (struct thread_info *tp)
a7212384 7262{
8358c15c
JK
7263 return ((tp->control.step_range_end
7264 && tp->control.step_resume_breakpoint == NULL)
7265 || tp->control.trap_expected
af48d08f 7266 || tp->stepped_breakpoint
8358c15c 7267 || bpstat_should_step ());
a7212384
UW
7268}
7269
b2175913
MS
7270/* Inferior has stepped into a subroutine call with source code that
7271 we should not step over. Do step to the first line of code in
7272 it. */
c2c6d25f
JM
7273
7274static void
568d6575
UW
7275handle_step_into_function (struct gdbarch *gdbarch,
7276 struct execution_control_state *ecs)
c2c6d25f 7277{
7e324e48
GB
7278 fill_in_stop_func (gdbarch, ecs);
7279
51abb421 7280 compunit_symtab *cust = find_pc_compunit_symtab (stop_pc);
43f3e411 7281 if (cust != NULL && compunit_language (cust) != language_asm)
46a62268
YQ
7282 ecs->stop_func_start
7283 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
c2c6d25f 7284
51abb421 7285 symtab_and_line stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
c2c6d25f
JM
7286 /* Use the step_resume_break to step until the end of the prologue,
7287 even if that involves jumps (as it seems to on the vax under
7288 4.2). */
7289 /* If the prologue ends in the middle of a source line, continue to
7290 the end of that source line (if it is still within the function).
7291 Otherwise, just go to end of prologue. */
2afb61aa
PA
7292 if (stop_func_sal.end
7293 && stop_func_sal.pc != ecs->stop_func_start
7294 && stop_func_sal.end < ecs->stop_func_end)
7295 ecs->stop_func_start = stop_func_sal.end;
c2c6d25f 7296
2dbd5e30
KB
7297 /* Architectures which require breakpoint adjustment might not be able
7298 to place a breakpoint at the computed address. If so, the test
7299 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7300 ecs->stop_func_start to an address at which a breakpoint may be
7301 legitimately placed.
8fb3e588 7302
2dbd5e30
KB
7303 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7304 made, GDB will enter an infinite loop when stepping through
7305 optimized code consisting of VLIW instructions which contain
7306 subinstructions corresponding to different source lines. On
7307 FR-V, it's not permitted to place a breakpoint on any but the
7308 first subinstruction of a VLIW instruction. When a breakpoint is
7309 set, GDB will adjust the breakpoint address to the beginning of
7310 the VLIW instruction. Thus, we need to make the corresponding
7311 adjustment here when computing the stop address. */
8fb3e588 7312
568d6575 7313 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
2dbd5e30
KB
7314 {
7315 ecs->stop_func_start
568d6575 7316 = gdbarch_adjust_breakpoint_address (gdbarch,
8fb3e588 7317 ecs->stop_func_start);
2dbd5e30
KB
7318 }
7319
c2c6d25f
JM
7320 if (ecs->stop_func_start == stop_pc)
7321 {
7322 /* We are already there: stop now. */
bdc36728 7323 end_stepping_range (ecs);
c2c6d25f
JM
7324 return;
7325 }
7326 else
7327 {
7328 /* Put the step-breakpoint there and go until there. */
51abb421 7329 symtab_and_line sr_sal;
c2c6d25f
JM
7330 sr_sal.pc = ecs->stop_func_start;
7331 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
6c95b8df 7332 sr_sal.pspace = get_frame_program_space (get_current_frame ());
44cbf7b5 7333
c2c6d25f 7334 /* Do not specify what the fp should be when we stop since on
488f131b
JB
7335 some machines the prologue is where the new fp value is
7336 established. */
a6d9a66e 7337 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
c2c6d25f
JM
7338
7339 /* And make sure stepping stops right away then. */
16c381f0
JK
7340 ecs->event_thread->control.step_range_end
7341 = ecs->event_thread->control.step_range_start;
c2c6d25f
JM
7342 }
7343 keep_going (ecs);
7344}
d4f3574e 7345
b2175913
MS
7346/* Inferior has stepped backward into a subroutine call with source
7347 code that we should not step over. Do step to the beginning of the
7348 last line of code in it. */
7349
7350static void
568d6575
UW
7351handle_step_into_function_backward (struct gdbarch *gdbarch,
7352 struct execution_control_state *ecs)
b2175913 7353{
43f3e411 7354 struct compunit_symtab *cust;
167e4384 7355 struct symtab_and_line stop_func_sal;
b2175913 7356
7e324e48
GB
7357 fill_in_stop_func (gdbarch, ecs);
7358
43f3e411
DE
7359 cust = find_pc_compunit_symtab (stop_pc);
7360 if (cust != NULL && compunit_language (cust) != language_asm)
46a62268
YQ
7361 ecs->stop_func_start
7362 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
b2175913
MS
7363
7364 stop_func_sal = find_pc_line (stop_pc, 0);
7365
7366 /* OK, we're just going to keep stepping here. */
7367 if (stop_func_sal.pc == stop_pc)
7368 {
7369 /* We're there already. Just stop stepping now. */
bdc36728 7370 end_stepping_range (ecs);
b2175913
MS
7371 }
7372 else
7373 {
7374 /* Else just reset the step range and keep going.
7375 No step-resume breakpoint, they don't work for
7376 epilogues, which can have multiple entry paths. */
16c381f0
JK
7377 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
7378 ecs->event_thread->control.step_range_end = stop_func_sal.end;
b2175913
MS
7379 keep_going (ecs);
7380 }
7381 return;
7382}
7383
d3169d93 7384/* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
44cbf7b5
AC
7385 This is used to both functions and to skip over code. */
7386
7387static void
2c03e5be
PA
7388insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
7389 struct symtab_and_line sr_sal,
7390 struct frame_id sr_id,
7391 enum bptype sr_type)
44cbf7b5 7392{
611c83ae
PA
7393 /* There should never be more than one step-resume or longjmp-resume
7394 breakpoint per thread, so we should never be setting a new
44cbf7b5 7395 step_resume_breakpoint when one is already active. */
8358c15c 7396 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
2c03e5be 7397 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
d3169d93
DJ
7398
7399 if (debug_infrun)
7400 fprintf_unfiltered (gdb_stdlog,
5af949e3
UW
7401 "infrun: inserting step-resume breakpoint at %s\n",
7402 paddress (gdbarch, sr_sal.pc));
d3169d93 7403
8358c15c 7404 inferior_thread ()->control.step_resume_breakpoint
2c03e5be
PA
7405 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
7406}
7407
9da8c2a0 7408void
2c03e5be
PA
7409insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
7410 struct symtab_and_line sr_sal,
7411 struct frame_id sr_id)
7412{
7413 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
7414 sr_sal, sr_id,
7415 bp_step_resume);
44cbf7b5 7416}
7ce450bd 7417
2c03e5be
PA
7418/* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7419 This is used to skip a potential signal handler.
7ce450bd 7420
14e60db5
DJ
7421 This is called with the interrupted function's frame. The signal
7422 handler, when it returns, will resume the interrupted function at
7423 RETURN_FRAME.pc. */
d303a6c7
AC
7424
7425static void
2c03e5be 7426insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
d303a6c7 7427{
f4c1edd8 7428 gdb_assert (return_frame != NULL);
d303a6c7 7429
51abb421
PA
7430 struct gdbarch *gdbarch = get_frame_arch (return_frame);
7431
7432 symtab_and_line sr_sal;
568d6575 7433 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
d303a6c7 7434 sr_sal.section = find_pc_overlay (sr_sal.pc);
6c95b8df 7435 sr_sal.pspace = get_frame_program_space (return_frame);
d303a6c7 7436
2c03e5be
PA
7437 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
7438 get_stack_frame_id (return_frame),
7439 bp_hp_step_resume);
d303a6c7
AC
7440}
7441
2c03e5be
PA
7442/* Insert a "step-resume breakpoint" at the previous frame's PC. This
7443 is used to skip a function after stepping into it (for "next" or if
7444 the called function has no debugging information).
14e60db5
DJ
7445
7446 The current function has almost always been reached by single
7447 stepping a call or return instruction. NEXT_FRAME belongs to the
7448 current function, and the breakpoint will be set at the caller's
7449 resume address.
7450
7451 This is a separate function rather than reusing
2c03e5be 7452 insert_hp_step_resume_breakpoint_at_frame in order to avoid
14e60db5 7453 get_prev_frame, which may stop prematurely (see the implementation
c7ce8faa 7454 of frame_unwind_caller_id for an example). */
14e60db5
DJ
7455
7456static void
7457insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
7458{
14e60db5
DJ
7459 /* We shouldn't have gotten here if we don't know where the call site
7460 is. */
c7ce8faa 7461 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
14e60db5 7462
51abb421 7463 struct gdbarch *gdbarch = frame_unwind_caller_arch (next_frame);
14e60db5 7464
51abb421 7465 symtab_and_line sr_sal;
c7ce8faa
DJ
7466 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
7467 frame_unwind_caller_pc (next_frame));
14e60db5 7468 sr_sal.section = find_pc_overlay (sr_sal.pc);
6c95b8df 7469 sr_sal.pspace = frame_unwind_program_space (next_frame);
14e60db5 7470
a6d9a66e 7471 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
c7ce8faa 7472 frame_unwind_caller_id (next_frame));
14e60db5
DJ
7473}
7474
611c83ae
PA
7475/* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7476 new breakpoint at the target of a jmp_buf. The handling of
7477 longjmp-resume uses the same mechanisms used for handling
7478 "step-resume" breakpoints. */
7479
7480static void
a6d9a66e 7481insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
611c83ae 7482{
e81a37f7
TT
7483 /* There should never be more than one longjmp-resume breakpoint per
7484 thread, so we should never be setting a new
611c83ae 7485 longjmp_resume_breakpoint when one is already active. */
e81a37f7 7486 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
611c83ae
PA
7487
7488 if (debug_infrun)
7489 fprintf_unfiltered (gdb_stdlog,
5af949e3
UW
7490 "infrun: inserting longjmp-resume breakpoint at %s\n",
7491 paddress (gdbarch, pc));
611c83ae 7492
e81a37f7 7493 inferior_thread ()->control.exception_resume_breakpoint =
a6d9a66e 7494 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
611c83ae
PA
7495}
7496
186c406b
TT
7497/* Insert an exception resume breakpoint. TP is the thread throwing
7498 the exception. The block B is the block of the unwinder debug hook
7499 function. FRAME is the frame corresponding to the call to this
7500 function. SYM is the symbol of the function argument holding the
7501 target PC of the exception. */
7502
7503static void
7504insert_exception_resume_breakpoint (struct thread_info *tp,
3977b71f 7505 const struct block *b,
186c406b
TT
7506 struct frame_info *frame,
7507 struct symbol *sym)
7508{
492d29ea 7509 TRY
186c406b 7510 {
63e43d3a 7511 struct block_symbol vsym;
186c406b
TT
7512 struct value *value;
7513 CORE_ADDR handler;
7514 struct breakpoint *bp;
7515
63e43d3a
PMR
7516 vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
7517 value = read_var_value (vsym.symbol, vsym.block, frame);
186c406b
TT
7518 /* If the value was optimized out, revert to the old behavior. */
7519 if (! value_optimized_out (value))
7520 {
7521 handler = value_as_address (value);
7522
7523 if (debug_infrun)
7524 fprintf_unfiltered (gdb_stdlog,
7525 "infrun: exception resume at %lx\n",
7526 (unsigned long) handler);
7527
7528 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7529 handler, bp_exception_resume);
c70a6932
JK
7530
7531 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7532 frame = NULL;
7533
5d5658a1 7534 bp->thread = tp->global_num;
186c406b
TT
7535 inferior_thread ()->control.exception_resume_breakpoint = bp;
7536 }
7537 }
492d29ea
PA
7538 CATCH (e, RETURN_MASK_ERROR)
7539 {
7540 /* We want to ignore errors here. */
7541 }
7542 END_CATCH
186c406b
TT
7543}
7544
28106bc2
SDJ
7545/* A helper for check_exception_resume that sets an
7546 exception-breakpoint based on a SystemTap probe. */
7547
7548static void
7549insert_exception_resume_from_probe (struct thread_info *tp,
729662a5 7550 const struct bound_probe *probe,
28106bc2
SDJ
7551 struct frame_info *frame)
7552{
7553 struct value *arg_value;
7554 CORE_ADDR handler;
7555 struct breakpoint *bp;
7556
7557 arg_value = probe_safe_evaluate_at_pc (frame, 1);
7558 if (!arg_value)
7559 return;
7560
7561 handler = value_as_address (arg_value);
7562
7563 if (debug_infrun)
7564 fprintf_unfiltered (gdb_stdlog,
7565 "infrun: exception resume at %s\n",
6bac7473 7566 paddress (get_objfile_arch (probe->objfile),
28106bc2
SDJ
7567 handler));
7568
7569 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7570 handler, bp_exception_resume);
5d5658a1 7571 bp->thread = tp->global_num;
28106bc2
SDJ
7572 inferior_thread ()->control.exception_resume_breakpoint = bp;
7573}
7574
186c406b
TT
7575/* This is called when an exception has been intercepted. Check to
7576 see whether the exception's destination is of interest, and if so,
7577 set an exception resume breakpoint there. */
7578
7579static void
7580check_exception_resume (struct execution_control_state *ecs,
28106bc2 7581 struct frame_info *frame)
186c406b 7582{
729662a5 7583 struct bound_probe probe;
28106bc2
SDJ
7584 struct symbol *func;
7585
7586 /* First see if this exception unwinding breakpoint was set via a
7587 SystemTap probe point. If so, the probe has two arguments: the
7588 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7589 set a breakpoint there. */
6bac7473 7590 probe = find_probe_by_pc (get_frame_pc (frame));
729662a5 7591 if (probe.probe)
28106bc2 7592 {
729662a5 7593 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
28106bc2
SDJ
7594 return;
7595 }
7596
7597 func = get_frame_function (frame);
7598 if (!func)
7599 return;
186c406b 7600
492d29ea 7601 TRY
186c406b 7602 {
3977b71f 7603 const struct block *b;
8157b174 7604 struct block_iterator iter;
186c406b
TT
7605 struct symbol *sym;
7606 int argno = 0;
7607
7608 /* The exception breakpoint is a thread-specific breakpoint on
7609 the unwinder's debug hook, declared as:
7610
7611 void _Unwind_DebugHook (void *cfa, void *handler);
7612
7613 The CFA argument indicates the frame to which control is
7614 about to be transferred. HANDLER is the destination PC.
7615
7616 We ignore the CFA and set a temporary breakpoint at HANDLER.
7617 This is not extremely efficient but it avoids issues in gdb
7618 with computing the DWARF CFA, and it also works even in weird
7619 cases such as throwing an exception from inside a signal
7620 handler. */
7621
7622 b = SYMBOL_BLOCK_VALUE (func);
7623 ALL_BLOCK_SYMBOLS (b, iter, sym)
7624 {
7625 if (!SYMBOL_IS_ARGUMENT (sym))
7626 continue;
7627
7628 if (argno == 0)
7629 ++argno;
7630 else
7631 {
7632 insert_exception_resume_breakpoint (ecs->event_thread,
7633 b, frame, sym);
7634 break;
7635 }
7636 }
7637 }
492d29ea
PA
7638 CATCH (e, RETURN_MASK_ERROR)
7639 {
7640 }
7641 END_CATCH
186c406b
TT
7642}
7643
104c1213 7644static void
22bcd14b 7645stop_waiting (struct execution_control_state *ecs)
104c1213 7646{
527159b7 7647 if (debug_infrun)
22bcd14b 7648 fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
527159b7 7649
cd0fc7c3
SS
7650 /* Let callers know we don't want to wait for the inferior anymore. */
7651 ecs->wait_some_more = 0;
fbea99ea
PA
7652
7653 /* If all-stop, but the target is always in non-stop mode, stop all
7654 threads now that we're presenting the stop to the user. */
7655 if (!non_stop && target_is_non_stop_p ())
7656 stop_all_threads ();
cd0fc7c3
SS
7657}
7658
4d9d9d04
PA
7659/* Like keep_going, but passes the signal to the inferior, even if the
7660 signal is set to nopass. */
d4f3574e
SS
7661
7662static void
4d9d9d04 7663keep_going_pass_signal (struct execution_control_state *ecs)
d4f3574e 7664{
c4dbc9af
PA
7665 /* Make sure normal_stop is called if we get a QUIT handled before
7666 reaching resume. */
7667 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
7668
4d9d9d04 7669 gdb_assert (ptid_equal (ecs->event_thread->ptid, inferior_ptid));
372316f1 7670 gdb_assert (!ecs->event_thread->resumed);
4d9d9d04 7671
d4f3574e 7672 /* Save the pc before execution, to compare with pc after stop. */
fb14de7b
UW
7673 ecs->event_thread->prev_pc
7674 = regcache_read_pc (get_thread_regcache (ecs->ptid));
d4f3574e 7675
4d9d9d04 7676 if (ecs->event_thread->control.trap_expected)
d4f3574e 7677 {
4d9d9d04
PA
7678 struct thread_info *tp = ecs->event_thread;
7679
7680 if (debug_infrun)
7681 fprintf_unfiltered (gdb_stdlog,
7682 "infrun: %s has trap_expected set, "
7683 "resuming to collect trap\n",
7684 target_pid_to_str (tp->ptid));
7685
a9ba6bae
PA
7686 /* We haven't yet gotten our trap, and either: intercepted a
7687 non-signal event (e.g., a fork); or took a signal which we
7688 are supposed to pass through to the inferior. Simply
7689 continue. */
c4dbc9af 7690 discard_cleanups (old_cleanups);
64ce06e4 7691 resume (ecs->event_thread->suspend.stop_signal);
d4f3574e 7692 }
372316f1
PA
7693 else if (step_over_info_valid_p ())
7694 {
7695 /* Another thread is stepping over a breakpoint in-line. If
7696 this thread needs a step-over too, queue the request. In
7697 either case, this resume must be deferred for later. */
7698 struct thread_info *tp = ecs->event_thread;
7699
7700 if (ecs->hit_singlestep_breakpoint
7701 || thread_still_needs_step_over (tp))
7702 {
7703 if (debug_infrun)
7704 fprintf_unfiltered (gdb_stdlog,
7705 "infrun: step-over already in progress: "
7706 "step-over for %s deferred\n",
7707 target_pid_to_str (tp->ptid));
7708 thread_step_over_chain_enqueue (tp);
7709 }
7710 else
7711 {
7712 if (debug_infrun)
7713 fprintf_unfiltered (gdb_stdlog,
7714 "infrun: step-over in progress: "
7715 "resume of %s deferred\n",
7716 target_pid_to_str (tp->ptid));
7717 }
7718
7719 discard_cleanups (old_cleanups);
7720 }
d4f3574e
SS
7721 else
7722 {
31e77af2 7723 struct regcache *regcache = get_current_regcache ();
963f9c80
PA
7724 int remove_bp;
7725 int remove_wps;
8d297bbf 7726 step_over_what step_what;
31e77af2 7727
d4f3574e 7728 /* Either the trap was not expected, but we are continuing
a9ba6bae
PA
7729 anyway (if we got a signal, the user asked it be passed to
7730 the child)
7731 -- or --
7732 We got our expected trap, but decided we should resume from
7733 it.
d4f3574e 7734
a9ba6bae 7735 We're going to run this baby now!
d4f3574e 7736
c36b740a
VP
7737 Note that insert_breakpoints won't try to re-insert
7738 already inserted breakpoints. Therefore, we don't
7739 care if breakpoints were already inserted, or not. */
a9ba6bae 7740
31e77af2
PA
7741 /* If we need to step over a breakpoint, and we're not using
7742 displaced stepping to do so, insert all breakpoints
7743 (watchpoints, etc.) but the one we're stepping over, step one
7744 instruction, and then re-insert the breakpoint when that step
7745 is finished. */
963f9c80 7746
6c4cfb24
PA
7747 step_what = thread_still_needs_step_over (ecs->event_thread);
7748
963f9c80 7749 remove_bp = (ecs->hit_singlestep_breakpoint
6c4cfb24
PA
7750 || (step_what & STEP_OVER_BREAKPOINT));
7751 remove_wps = (step_what & STEP_OVER_WATCHPOINT);
963f9c80 7752
cb71640d
PA
7753 /* We can't use displaced stepping if we need to step past a
7754 watchpoint. The instruction copied to the scratch pad would
7755 still trigger the watchpoint. */
7756 if (remove_bp
3fc8eb30 7757 && (remove_wps || !use_displaced_stepping (ecs->event_thread)))
45e8c884 7758 {
31e77af2 7759 set_step_over_info (get_regcache_aspace (regcache),
21edc42f
YQ
7760 regcache_read_pc (regcache), remove_wps,
7761 ecs->event_thread->global_num);
45e8c884 7762 }
963f9c80 7763 else if (remove_wps)
21edc42f 7764 set_step_over_info (NULL, 0, remove_wps, -1);
372316f1
PA
7765
7766 /* If we now need to do an in-line step-over, we need to stop
7767 all other threads. Note this must be done before
7768 insert_breakpoints below, because that removes the breakpoint
7769 we're about to step over, otherwise other threads could miss
7770 it. */
fbea99ea 7771 if (step_over_info_valid_p () && target_is_non_stop_p ())
372316f1 7772 stop_all_threads ();
abbb1732 7773
31e77af2 7774 /* Stop stepping if inserting breakpoints fails. */
492d29ea 7775 TRY
31e77af2
PA
7776 {
7777 insert_breakpoints ();
7778 }
492d29ea 7779 CATCH (e, RETURN_MASK_ERROR)
31e77af2
PA
7780 {
7781 exception_print (gdb_stderr, e);
22bcd14b 7782 stop_waiting (ecs);
de1fe8c8 7783 discard_cleanups (old_cleanups);
31e77af2 7784 return;
d4f3574e 7785 }
492d29ea 7786 END_CATCH
d4f3574e 7787
963f9c80 7788 ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
d4f3574e 7789
c4dbc9af 7790 discard_cleanups (old_cleanups);
64ce06e4 7791 resume (ecs->event_thread->suspend.stop_signal);
d4f3574e
SS
7792 }
7793
488f131b 7794 prepare_to_wait (ecs);
d4f3574e
SS
7795}
7796
4d9d9d04
PA
7797/* Called when we should continue running the inferior, because the
7798 current event doesn't cause a user visible stop. This does the
7799 resuming part; waiting for the next event is done elsewhere. */
7800
7801static void
7802keep_going (struct execution_control_state *ecs)
7803{
7804 if (ecs->event_thread->control.trap_expected
7805 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
7806 ecs->event_thread->control.trap_expected = 0;
7807
7808 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7809 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7810 keep_going_pass_signal (ecs);
7811}
7812
104c1213
JM
7813/* This function normally comes after a resume, before
7814 handle_inferior_event exits. It takes care of any last bits of
7815 housekeeping, and sets the all-important wait_some_more flag. */
cd0fc7c3 7816
104c1213
JM
7817static void
7818prepare_to_wait (struct execution_control_state *ecs)
cd0fc7c3 7819{
527159b7 7820 if (debug_infrun)
8a9de0e4 7821 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
104c1213 7822
104c1213 7823 ecs->wait_some_more = 1;
0b333c5e
PA
7824
7825 if (!target_is_async_p ())
7826 mark_infrun_async_event_handler ();
c906108c 7827}
11cf8741 7828
fd664c91 7829/* We are done with the step range of a step/next/si/ni command.
b57bacec 7830 Called once for each n of a "step n" operation. */
fd664c91
PA
7831
7832static void
bdc36728 7833end_stepping_range (struct execution_control_state *ecs)
fd664c91 7834{
bdc36728 7835 ecs->event_thread->control.stop_step = 1;
bdc36728 7836 stop_waiting (ecs);
fd664c91
PA
7837}
7838
33d62d64
JK
7839/* Several print_*_reason functions to print why the inferior has stopped.
7840 We always print something when the inferior exits, or receives a signal.
7841 The rest of the cases are dealt with later on in normal_stop and
7842 print_it_typical. Ideally there should be a call to one of these
7843 print_*_reason functions functions from handle_inferior_event each time
22bcd14b 7844 stop_waiting is called.
33d62d64 7845
fd664c91
PA
7846 Note that we don't call these directly, instead we delegate that to
7847 the interpreters, through observers. Interpreters then call these
7848 with whatever uiout is right. */
33d62d64 7849
fd664c91
PA
7850void
7851print_end_stepping_range_reason (struct ui_out *uiout)
33d62d64 7852{
fd664c91 7853 /* For CLI-like interpreters, print nothing. */
33d62d64 7854
112e8700 7855 if (uiout->is_mi_like_p ())
fd664c91 7856 {
112e8700 7857 uiout->field_string ("reason",
fd664c91
PA
7858 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
7859 }
7860}
33d62d64 7861
fd664c91
PA
7862void
7863print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
11cf8741 7864{
33d62d64 7865 annotate_signalled ();
112e8700
SM
7866 if (uiout->is_mi_like_p ())
7867 uiout->field_string
7868 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
7869 uiout->text ("\nProgram terminated with signal ");
33d62d64 7870 annotate_signal_name ();
112e8700 7871 uiout->field_string ("signal-name",
2ea28649 7872 gdb_signal_to_name (siggnal));
33d62d64 7873 annotate_signal_name_end ();
112e8700 7874 uiout->text (", ");
33d62d64 7875 annotate_signal_string ();
112e8700 7876 uiout->field_string ("signal-meaning",
2ea28649 7877 gdb_signal_to_string (siggnal));
33d62d64 7878 annotate_signal_string_end ();
112e8700
SM
7879 uiout->text (".\n");
7880 uiout->text ("The program no longer exists.\n");
33d62d64
JK
7881}
7882
fd664c91
PA
7883void
7884print_exited_reason (struct ui_out *uiout, int exitstatus)
33d62d64 7885{
fda326dd
TT
7886 struct inferior *inf = current_inferior ();
7887 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
7888
33d62d64
JK
7889 annotate_exited (exitstatus);
7890 if (exitstatus)
7891 {
112e8700
SM
7892 if (uiout->is_mi_like_p ())
7893 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));
7894 uiout->text ("[Inferior ");
7895 uiout->text (plongest (inf->num));
7896 uiout->text (" (");
7897 uiout->text (pidstr);
7898 uiout->text (") exited with code ");
7899 uiout->field_fmt ("exit-code", "0%o", (unsigned int) exitstatus);
7900 uiout->text ("]\n");
33d62d64
JK
7901 }
7902 else
11cf8741 7903 {
112e8700
SM
7904 if (uiout->is_mi_like_p ())
7905 uiout->field_string
7906 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
7907 uiout->text ("[Inferior ");
7908 uiout->text (plongest (inf->num));
7909 uiout->text (" (");
7910 uiout->text (pidstr);
7911 uiout->text (") exited normally]\n");
33d62d64 7912 }
33d62d64
JK
7913}
7914
012b3a21
WT
7915/* Some targets/architectures can do extra processing/display of
7916 segmentation faults. E.g., Intel MPX boundary faults.
7917 Call the architecture dependent function to handle the fault. */
7918
7919static void
7920handle_segmentation_fault (struct ui_out *uiout)
7921{
7922 struct regcache *regcache = get_current_regcache ();
7923 struct gdbarch *gdbarch = get_regcache_arch (regcache);
7924
7925 if (gdbarch_handle_segmentation_fault_p (gdbarch))
7926 gdbarch_handle_segmentation_fault (gdbarch, uiout);
7927}
7928
fd664c91
PA
7929void
7930print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
33d62d64 7931{
f303dbd6
PA
7932 struct thread_info *thr = inferior_thread ();
7933
33d62d64
JK
7934 annotate_signal ();
7935
112e8700 7936 if (uiout->is_mi_like_p ())
f303dbd6
PA
7937 ;
7938 else if (show_thread_that_caused_stop ())
33d62d64 7939 {
f303dbd6 7940 const char *name;
33d62d64 7941
112e8700
SM
7942 uiout->text ("\nThread ");
7943 uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
f303dbd6
PA
7944
7945 name = thr->name != NULL ? thr->name : target_thread_name (thr);
7946 if (name != NULL)
7947 {
112e8700
SM
7948 uiout->text (" \"");
7949 uiout->field_fmt ("name", "%s", name);
7950 uiout->text ("\"");
f303dbd6 7951 }
33d62d64 7952 }
f303dbd6 7953 else
112e8700 7954 uiout->text ("\nProgram");
f303dbd6 7955
112e8700
SM
7956 if (siggnal == GDB_SIGNAL_0 && !uiout->is_mi_like_p ())
7957 uiout->text (" stopped");
33d62d64
JK
7958 else
7959 {
112e8700 7960 uiout->text (" received signal ");
8b93c638 7961 annotate_signal_name ();
112e8700
SM
7962 if (uiout->is_mi_like_p ())
7963 uiout->field_string
7964 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
7965 uiout->field_string ("signal-name", gdb_signal_to_name (siggnal));
8b93c638 7966 annotate_signal_name_end ();
112e8700 7967 uiout->text (", ");
8b93c638 7968 annotate_signal_string ();
112e8700 7969 uiout->field_string ("signal-meaning", gdb_signal_to_string (siggnal));
012b3a21
WT
7970
7971 if (siggnal == GDB_SIGNAL_SEGV)
7972 handle_segmentation_fault (uiout);
7973
8b93c638 7974 annotate_signal_string_end ();
33d62d64 7975 }
112e8700 7976 uiout->text (".\n");
33d62d64 7977}
252fbfc8 7978
fd664c91
PA
7979void
7980print_no_history_reason (struct ui_out *uiout)
33d62d64 7981{
112e8700 7982 uiout->text ("\nNo more reverse-execution history.\n");
11cf8741 7983}
43ff13b4 7984
0c7e1a46
PA
7985/* Print current location without a level number, if we have changed
7986 functions or hit a breakpoint. Print source line if we have one.
7987 bpstat_print contains the logic deciding in detail what to print,
7988 based on the event(s) that just occurred. */
7989
243a9253
PA
7990static void
7991print_stop_location (struct target_waitstatus *ws)
0c7e1a46
PA
7992{
7993 int bpstat_ret;
f486487f 7994 enum print_what source_flag;
0c7e1a46
PA
7995 int do_frame_printing = 1;
7996 struct thread_info *tp = inferior_thread ();
7997
7998 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
7999 switch (bpstat_ret)
8000 {
8001 case PRINT_UNKNOWN:
8002 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8003 should) carry around the function and does (or should) use
8004 that when doing a frame comparison. */
8005 if (tp->control.stop_step
8006 && frame_id_eq (tp->control.step_frame_id,
8007 get_frame_id (get_current_frame ()))
885eeb5b 8008 && tp->control.step_start_function == find_pc_function (stop_pc))
0c7e1a46
PA
8009 {
8010 /* Finished step, just print source line. */
8011 source_flag = SRC_LINE;
8012 }
8013 else
8014 {
8015 /* Print location and source line. */
8016 source_flag = SRC_AND_LOC;
8017 }
8018 break;
8019 case PRINT_SRC_AND_LOC:
8020 /* Print location and source line. */
8021 source_flag = SRC_AND_LOC;
8022 break;
8023 case PRINT_SRC_ONLY:
8024 source_flag = SRC_LINE;
8025 break;
8026 case PRINT_NOTHING:
8027 /* Something bogus. */
8028 source_flag = SRC_LINE;
8029 do_frame_printing = 0;
8030 break;
8031 default:
8032 internal_error (__FILE__, __LINE__, _("Unknown value."));
8033 }
8034
8035 /* The behavior of this routine with respect to the source
8036 flag is:
8037 SRC_LINE: Print only source line
8038 LOCATION: Print only location
8039 SRC_AND_LOC: Print location and source line. */
8040 if (do_frame_printing)
8041 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
243a9253
PA
8042}
8043
243a9253
PA
8044/* See infrun.h. */
8045
8046void
8047print_stop_event (struct ui_out *uiout)
8048{
243a9253
PA
8049 struct target_waitstatus last;
8050 ptid_t last_ptid;
8051 struct thread_info *tp;
8052
8053 get_last_target_status (&last_ptid, &last);
8054
67ad9399
TT
8055 {
8056 scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
0c7e1a46 8057
67ad9399 8058 print_stop_location (&last);
243a9253 8059
67ad9399
TT
8060 /* Display the auto-display expressions. */
8061 do_displays ();
8062 }
243a9253
PA
8063
8064 tp = inferior_thread ();
8065 if (tp->thread_fsm != NULL
8066 && thread_fsm_finished_p (tp->thread_fsm))
8067 {
8068 struct return_value_info *rv;
8069
8070 rv = thread_fsm_return_value (tp->thread_fsm);
8071 if (rv != NULL)
8072 print_return_value (uiout, rv);
8073 }
0c7e1a46
PA
8074}
8075
388a7084
PA
8076/* See infrun.h. */
8077
8078void
8079maybe_remove_breakpoints (void)
8080{
8081 if (!breakpoints_should_be_inserted_now () && target_has_execution)
8082 {
8083 if (remove_breakpoints ())
8084 {
8085 target_terminal_ours_for_output ();
8086 printf_filtered (_("Cannot remove breakpoints because "
8087 "program is no longer writable.\nFurther "
8088 "execution is probably impossible.\n"));
8089 }
8090 }
8091}
8092
4c2f2a79
PA
8093/* The execution context that just caused a normal stop. */
8094
8095struct stop_context
8096{
8097 /* The stop ID. */
8098 ULONGEST stop_id;
c906108c 8099
4c2f2a79 8100 /* The event PTID. */
c906108c 8101
4c2f2a79
PA
8102 ptid_t ptid;
8103
8104 /* If stopp for a thread event, this is the thread that caused the
8105 stop. */
8106 struct thread_info *thread;
8107
8108 /* The inferior that caused the stop. */
8109 int inf_num;
8110};
8111
8112/* Returns a new stop context. If stopped for a thread event, this
8113 takes a strong reference to the thread. */
8114
8115static struct stop_context *
8116save_stop_context (void)
8117{
224c3ddb 8118 struct stop_context *sc = XNEW (struct stop_context);
4c2f2a79
PA
8119
8120 sc->stop_id = get_stop_id ();
8121 sc->ptid = inferior_ptid;
8122 sc->inf_num = current_inferior ()->num;
8123
8124 if (!ptid_equal (inferior_ptid, null_ptid))
8125 {
8126 /* Take a strong reference so that the thread can't be deleted
8127 yet. */
8128 sc->thread = inferior_thread ();
803bdfe4 8129 sc->thread->incref ();
4c2f2a79
PA
8130 }
8131 else
8132 sc->thread = NULL;
8133
8134 return sc;
8135}
8136
8137/* Release a stop context previously created with save_stop_context.
8138 Releases the strong reference to the thread as well. */
8139
8140static void
8141release_stop_context_cleanup (void *arg)
8142{
9a3c8263 8143 struct stop_context *sc = (struct stop_context *) arg;
4c2f2a79
PA
8144
8145 if (sc->thread != NULL)
803bdfe4 8146 sc->thread->decref ();
4c2f2a79
PA
8147 xfree (sc);
8148}
8149
8150/* Return true if the current context no longer matches the saved stop
8151 context. */
8152
8153static int
8154stop_context_changed (struct stop_context *prev)
8155{
8156 if (!ptid_equal (prev->ptid, inferior_ptid))
8157 return 1;
8158 if (prev->inf_num != current_inferior ()->num)
8159 return 1;
8160 if (prev->thread != NULL && prev->thread->state != THREAD_STOPPED)
8161 return 1;
8162 if (get_stop_id () != prev->stop_id)
8163 return 1;
8164 return 0;
8165}
8166
8167/* See infrun.h. */
8168
8169int
96baa820 8170normal_stop (void)
c906108c 8171{
73b65bb0
DJ
8172 struct target_waitstatus last;
8173 ptid_t last_ptid;
29f49a6a 8174 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
e1316e60 8175 ptid_t pid_ptid;
73b65bb0
DJ
8176
8177 get_last_target_status (&last_ptid, &last);
8178
4c2f2a79
PA
8179 new_stop_id ();
8180
29f49a6a
PA
8181 /* If an exception is thrown from this point on, make sure to
8182 propagate GDB's knowledge of the executing state to the
8183 frontend/user running state. A QUIT is an easy exception to see
8184 here, so do this before any filtered output. */
c35b1492
PA
8185 if (!non_stop)
8186 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
e1316e60
PA
8187 else if (last.kind == TARGET_WAITKIND_SIGNALLED
8188 || last.kind == TARGET_WAITKIND_EXITED)
8189 {
8190 /* On some targets, we may still have live threads in the
8191 inferior when we get a process exit event. E.g., for
8192 "checkpoint", when the current checkpoint/fork exits,
8193 linux-fork.c automatically switches to another fork from
8194 within target_mourn_inferior. */
8195 if (!ptid_equal (inferior_ptid, null_ptid))
8196 {
8197 pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
8198 make_cleanup (finish_thread_state_cleanup, &pid_ptid);
8199 }
8200 }
8201 else if (last.kind != TARGET_WAITKIND_NO_RESUMED)
c35b1492 8202 make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
29f49a6a 8203
b57bacec
PA
8204 /* As we're presenting a stop, and potentially removing breakpoints,
8205 update the thread list so we can tell whether there are threads
8206 running on the target. With target remote, for example, we can
8207 only learn about new threads when we explicitly update the thread
8208 list. Do this before notifying the interpreters about signal
8209 stops, end of stepping ranges, etc., so that the "new thread"
8210 output is emitted before e.g., "Program received signal FOO",
8211 instead of after. */
8212 update_thread_list ();
8213
8214 if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
8215 observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
8216
c906108c
SS
8217 /* As with the notification of thread events, we want to delay
8218 notifying the user that we've switched thread context until
8219 the inferior actually stops.
8220
73b65bb0
DJ
8221 There's no point in saying anything if the inferior has exited.
8222 Note that SIGNALLED here means "exited with a signal", not
b65dc60b
PA
8223 "received a signal".
8224
8225 Also skip saying anything in non-stop mode. In that mode, as we
8226 don't want GDB to switch threads behind the user's back, to avoid
8227 races where the user is typing a command to apply to thread x,
8228 but GDB switches to thread y before the user finishes entering
8229 the command, fetch_inferior_event installs a cleanup to restore
8230 the current thread back to the thread the user had selected right
8231 after this event is handled, so we're not really switching, only
8232 informing of a stop. */
4f8d22e3
PA
8233 if (!non_stop
8234 && !ptid_equal (previous_inferior_ptid, inferior_ptid)
73b65bb0
DJ
8235 && target_has_execution
8236 && last.kind != TARGET_WAITKIND_SIGNALLED
0e5bf2a8
PA
8237 && last.kind != TARGET_WAITKIND_EXITED
8238 && last.kind != TARGET_WAITKIND_NO_RESUMED)
c906108c 8239 {
0e454242 8240 SWITCH_THRU_ALL_UIS ()
3b12939d
PA
8241 {
8242 target_terminal_ours_for_output ();
8243 printf_filtered (_("[Switching to %s]\n"),
8244 target_pid_to_str (inferior_ptid));
8245 annotate_thread_changed ();
8246 }
39f77062 8247 previous_inferior_ptid = inferior_ptid;
c906108c 8248 }
c906108c 8249
0e5bf2a8
PA
8250 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
8251 {
0e454242 8252 SWITCH_THRU_ALL_UIS ()
3b12939d
PA
8253 if (current_ui->prompt_state == PROMPT_BLOCKED)
8254 {
8255 target_terminal_ours_for_output ();
8256 printf_filtered (_("No unwaited-for children left.\n"));
8257 }
0e5bf2a8
PA
8258 }
8259
b57bacec 8260 /* Note: this depends on the update_thread_list call above. */
388a7084 8261 maybe_remove_breakpoints ();
c906108c 8262
c906108c
SS
8263 /* If an auto-display called a function and that got a signal,
8264 delete that auto-display to avoid an infinite recursion. */
8265
8266 if (stopped_by_random_signal)
8267 disable_current_display ();
8268
0e454242 8269 SWITCH_THRU_ALL_UIS ()
3b12939d
PA
8270 {
8271 async_enable_stdin ();
8272 }
c906108c 8273
388a7084
PA
8274 /* Let the user/frontend see the threads as stopped. */
8275 do_cleanups (old_chain);
8276
8277 /* Select innermost stack frame - i.e., current frame is frame 0,
8278 and current location is based on that. Handle the case where the
8279 dummy call is returning after being stopped. E.g. the dummy call
8280 previously hit a breakpoint. (If the dummy call returns
8281 normally, we won't reach here.) Do this before the stop hook is
8282 run, so that it doesn't get to see the temporary dummy frame,
8283 which is not where we'll present the stop. */
8284 if (has_stack_frames ())
8285 {
8286 if (stop_stack_dummy == STOP_STACK_DUMMY)
8287 {
8288 /* Pop the empty frame that contains the stack dummy. This
8289 also restores inferior state prior to the call (struct
8290 infcall_suspend_state). */
8291 struct frame_info *frame = get_current_frame ();
8292
8293 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
8294 frame_pop (frame);
8295 /* frame_pop calls reinit_frame_cache as the last thing it
8296 does which means there's now no selected frame. */
8297 }
8298
8299 select_frame (get_current_frame ());
8300
8301 /* Set the current source location. */
8302 set_current_sal_from_frame (get_current_frame ());
8303 }
dd7e2d2b
PA
8304
8305 /* Look up the hook_stop and run it (CLI internally handles problem
8306 of stop_command's pre-hook not existing). */
4c2f2a79
PA
8307 if (stop_command != NULL)
8308 {
8309 struct stop_context *saved_context = save_stop_context ();
8310 struct cleanup *old_chain
8311 = make_cleanup (release_stop_context_cleanup, saved_context);
8312
8313 catch_errors (hook_stop_stub, stop_command,
8314 "Error while running hook_stop:\n", RETURN_MASK_ALL);
8315
8316 /* If the stop hook resumes the target, then there's no point in
8317 trying to notify about the previous stop; its context is
8318 gone. Likewise if the command switches thread or inferior --
8319 the observers would print a stop for the wrong
8320 thread/inferior. */
8321 if (stop_context_changed (saved_context))
8322 {
8323 do_cleanups (old_chain);
8324 return 1;
8325 }
8326 do_cleanups (old_chain);
8327 }
dd7e2d2b 8328
388a7084
PA
8329 /* Notify observers about the stop. This is where the interpreters
8330 print the stop event. */
8331 if (!ptid_equal (inferior_ptid, null_ptid))
8332 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
8333 stop_print_frame);
8334 else
8335 observer_notify_normal_stop (NULL, stop_print_frame);
347bddb7 8336
243a9253
PA
8337 annotate_stopped ();
8338
48844aa6
PA
8339 if (target_has_execution)
8340 {
8341 if (last.kind != TARGET_WAITKIND_SIGNALLED
8342 && last.kind != TARGET_WAITKIND_EXITED)
8343 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8344 Delete any breakpoint that is to be deleted at the next stop. */
16c381f0 8345 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
94cc34af 8346 }
6c95b8df
PA
8347
8348 /* Try to get rid of automatically added inferiors that are no
8349 longer needed. Keeping those around slows down things linearly.
8350 Note that this never removes the current inferior. */
8351 prune_inferiors ();
4c2f2a79
PA
8352
8353 return 0;
c906108c
SS
8354}
8355
8356static int
96baa820 8357hook_stop_stub (void *cmd)
c906108c 8358{
5913bcb0 8359 execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
c906108c
SS
8360 return (0);
8361}
8362\f
c5aa993b 8363int
96baa820 8364signal_stop_state (int signo)
c906108c 8365{
d6b48e9c 8366 return signal_stop[signo];
c906108c
SS
8367}
8368
c5aa993b 8369int
96baa820 8370signal_print_state (int signo)
c906108c
SS
8371{
8372 return signal_print[signo];
8373}
8374
c5aa993b 8375int
96baa820 8376signal_pass_state (int signo)
c906108c
SS
8377{
8378 return signal_program[signo];
8379}
8380
2455069d
UW
8381static void
8382signal_cache_update (int signo)
8383{
8384 if (signo == -1)
8385 {
a493e3e2 8386 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
2455069d
UW
8387 signal_cache_update (signo);
8388
8389 return;
8390 }
8391
8392 signal_pass[signo] = (signal_stop[signo] == 0
8393 && signal_print[signo] == 0
ab04a2af
TT
8394 && signal_program[signo] == 1
8395 && signal_catch[signo] == 0);
2455069d
UW
8396}
8397
488f131b 8398int
7bda5e4a 8399signal_stop_update (int signo, int state)
d4f3574e
SS
8400{
8401 int ret = signal_stop[signo];
abbb1732 8402
d4f3574e 8403 signal_stop[signo] = state;
2455069d 8404 signal_cache_update (signo);
d4f3574e
SS
8405 return ret;
8406}
8407
488f131b 8408int
7bda5e4a 8409signal_print_update (int signo, int state)
d4f3574e
SS
8410{
8411 int ret = signal_print[signo];
abbb1732 8412
d4f3574e 8413 signal_print[signo] = state;
2455069d 8414 signal_cache_update (signo);
d4f3574e
SS
8415 return ret;
8416}
8417
488f131b 8418int
7bda5e4a 8419signal_pass_update (int signo, int state)
d4f3574e
SS
8420{
8421 int ret = signal_program[signo];
abbb1732 8422
d4f3574e 8423 signal_program[signo] = state;
2455069d 8424 signal_cache_update (signo);
d4f3574e
SS
8425 return ret;
8426}
8427
ab04a2af
TT
8428/* Update the global 'signal_catch' from INFO and notify the
8429 target. */
8430
8431void
8432signal_catch_update (const unsigned int *info)
8433{
8434 int i;
8435
8436 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
8437 signal_catch[i] = info[i] > 0;
8438 signal_cache_update (-1);
8439 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8440}
8441
c906108c 8442static void
96baa820 8443sig_print_header (void)
c906108c 8444{
3e43a32a
MS
8445 printf_filtered (_("Signal Stop\tPrint\tPass "
8446 "to program\tDescription\n"));
c906108c
SS
8447}
8448
8449static void
2ea28649 8450sig_print_info (enum gdb_signal oursig)
c906108c 8451{
2ea28649 8452 const char *name = gdb_signal_to_name (oursig);
c906108c 8453 int name_padding = 13 - strlen (name);
96baa820 8454
c906108c
SS
8455 if (name_padding <= 0)
8456 name_padding = 0;
8457
8458 printf_filtered ("%s", name);
488f131b 8459 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
c906108c
SS
8460 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
8461 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
8462 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
2ea28649 8463 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
c906108c
SS
8464}
8465
8466/* Specify how various signals in the inferior should be handled. */
8467
8468static void
96baa820 8469handle_command (char *args, int from_tty)
c906108c 8470{
c906108c
SS
8471 int digits, wordlen;
8472 int sigfirst, signum, siglast;
2ea28649 8473 enum gdb_signal oursig;
c906108c
SS
8474 int allsigs;
8475 int nsigs;
8476 unsigned char *sigs;
c906108c
SS
8477
8478 if (args == NULL)
8479 {
e2e0b3e5 8480 error_no_arg (_("signal to handle"));
c906108c
SS
8481 }
8482
1777feb0 8483 /* Allocate and zero an array of flags for which signals to handle. */
c906108c 8484
a493e3e2 8485 nsigs = (int) GDB_SIGNAL_LAST;
c906108c
SS
8486 sigs = (unsigned char *) alloca (nsigs);
8487 memset (sigs, 0, nsigs);
8488
1777feb0 8489 /* Break the command line up into args. */
c906108c 8490
773a1edc 8491 gdb_argv built_argv (args);
c906108c
SS
8492
8493 /* Walk through the args, looking for signal oursigs, signal names, and
8494 actions. Signal numbers and signal names may be interspersed with
8495 actions, with the actions being performed for all signals cumulatively
1777feb0 8496 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
c906108c 8497
773a1edc 8498 for (char *arg : built_argv)
c906108c 8499 {
773a1edc
TT
8500 wordlen = strlen (arg);
8501 for (digits = 0; isdigit (arg[digits]); digits++)
c906108c
SS
8502 {;
8503 }
8504 allsigs = 0;
8505 sigfirst = siglast = -1;
8506
773a1edc 8507 if (wordlen >= 1 && !strncmp (arg, "all", wordlen))
c906108c
SS
8508 {
8509 /* Apply action to all signals except those used by the
1777feb0 8510 debugger. Silently skip those. */
c906108c
SS
8511 allsigs = 1;
8512 sigfirst = 0;
8513 siglast = nsigs - 1;
8514 }
773a1edc 8515 else if (wordlen >= 1 && !strncmp (arg, "stop", wordlen))
c906108c
SS
8516 {
8517 SET_SIGS (nsigs, sigs, signal_stop);
8518 SET_SIGS (nsigs, sigs, signal_print);
8519 }
773a1edc 8520 else if (wordlen >= 1 && !strncmp (arg, "ignore", wordlen))
c906108c
SS
8521 {
8522 UNSET_SIGS (nsigs, sigs, signal_program);
8523 }
773a1edc 8524 else if (wordlen >= 2 && !strncmp (arg, "print", wordlen))
c906108c
SS
8525 {
8526 SET_SIGS (nsigs, sigs, signal_print);
8527 }
773a1edc 8528 else if (wordlen >= 2 && !strncmp (arg, "pass", wordlen))
c906108c
SS
8529 {
8530 SET_SIGS (nsigs, sigs, signal_program);
8531 }
773a1edc 8532 else if (wordlen >= 3 && !strncmp (arg, "nostop", wordlen))
c906108c
SS
8533 {
8534 UNSET_SIGS (nsigs, sigs, signal_stop);
8535 }
773a1edc 8536 else if (wordlen >= 3 && !strncmp (arg, "noignore", wordlen))
c906108c
SS
8537 {
8538 SET_SIGS (nsigs, sigs, signal_program);
8539 }
773a1edc 8540 else if (wordlen >= 4 && !strncmp (arg, "noprint", wordlen))
c906108c
SS
8541 {
8542 UNSET_SIGS (nsigs, sigs, signal_print);
8543 UNSET_SIGS (nsigs, sigs, signal_stop);
8544 }
773a1edc 8545 else if (wordlen >= 4 && !strncmp (arg, "nopass", wordlen))
c906108c
SS
8546 {
8547 UNSET_SIGS (nsigs, sigs, signal_program);
8548 }
8549 else if (digits > 0)
8550 {
8551 /* It is numeric. The numeric signal refers to our own
8552 internal signal numbering from target.h, not to host/target
8553 signal number. This is a feature; users really should be
8554 using symbolic names anyway, and the common ones like
8555 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8556
8557 sigfirst = siglast = (int)
773a1edc
TT
8558 gdb_signal_from_command (atoi (arg));
8559 if (arg[digits] == '-')
c906108c
SS
8560 {
8561 siglast = (int)
773a1edc 8562 gdb_signal_from_command (atoi (arg + digits + 1));
c906108c
SS
8563 }
8564 if (sigfirst > siglast)
8565 {
1777feb0 8566 /* Bet he didn't figure we'd think of this case... */
c906108c
SS
8567 signum = sigfirst;
8568 sigfirst = siglast;
8569 siglast = signum;
8570 }
8571 }
8572 else
8573 {
773a1edc 8574 oursig = gdb_signal_from_name (arg);
a493e3e2 8575 if (oursig != GDB_SIGNAL_UNKNOWN)
c906108c
SS
8576 {
8577 sigfirst = siglast = (int) oursig;
8578 }
8579 else
8580 {
8581 /* Not a number and not a recognized flag word => complain. */
773a1edc 8582 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg);
c906108c
SS
8583 }
8584 }
8585
8586 /* If any signal numbers or symbol names were found, set flags for
1777feb0 8587 which signals to apply actions to. */
c906108c
SS
8588
8589 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
8590 {
2ea28649 8591 switch ((enum gdb_signal) signum)
c906108c 8592 {
a493e3e2
PA
8593 case GDB_SIGNAL_TRAP:
8594 case GDB_SIGNAL_INT:
c906108c
SS
8595 if (!allsigs && !sigs[signum])
8596 {
9e2f0ad4 8597 if (query (_("%s is used by the debugger.\n\
3e43a32a 8598Are you sure you want to change it? "),
2ea28649 8599 gdb_signal_to_name ((enum gdb_signal) signum)))
c906108c
SS
8600 {
8601 sigs[signum] = 1;
8602 }
8603 else
8604 {
a3f17187 8605 printf_unfiltered (_("Not confirmed, unchanged.\n"));
c906108c
SS
8606 gdb_flush (gdb_stdout);
8607 }
8608 }
8609 break;
a493e3e2
PA
8610 case GDB_SIGNAL_0:
8611 case GDB_SIGNAL_DEFAULT:
8612 case GDB_SIGNAL_UNKNOWN:
c906108c
SS
8613 /* Make sure that "all" doesn't print these. */
8614 break;
8615 default:
8616 sigs[signum] = 1;
8617 break;
8618 }
8619 }
c906108c
SS
8620 }
8621
3a031f65
PA
8622 for (signum = 0; signum < nsigs; signum++)
8623 if (sigs[signum])
8624 {
2455069d 8625 signal_cache_update (-1);
a493e3e2
PA
8626 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8627 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
c906108c 8628
3a031f65
PA
8629 if (from_tty)
8630 {
8631 /* Show the results. */
8632 sig_print_header ();
8633 for (; signum < nsigs; signum++)
8634 if (sigs[signum])
aead7601 8635 sig_print_info ((enum gdb_signal) signum);
3a031f65
PA
8636 }
8637
8638 break;
8639 }
c906108c
SS
8640}
8641
de0bea00
MF
8642/* Complete the "handle" command. */
8643
eb3ff9a5 8644static void
de0bea00 8645handle_completer (struct cmd_list_element *ignore,
eb3ff9a5 8646 completion_tracker &tracker,
6f937416 8647 const char *text, const char *word)
de0bea00 8648{
de0bea00
MF
8649 static const char * const keywords[] =
8650 {
8651 "all",
8652 "stop",
8653 "ignore",
8654 "print",
8655 "pass",
8656 "nostop",
8657 "noignore",
8658 "noprint",
8659 "nopass",
8660 NULL,
8661 };
8662
eb3ff9a5
PA
8663 signal_completer (ignore, tracker, text, word);
8664 complete_on_enum (tracker, keywords, word, word);
de0bea00
MF
8665}
8666
2ea28649
PA
8667enum gdb_signal
8668gdb_signal_from_command (int num)
ed01b82c
PA
8669{
8670 if (num >= 1 && num <= 15)
2ea28649 8671 return (enum gdb_signal) num;
ed01b82c
PA
8672 error (_("Only signals 1-15 are valid as numeric signals.\n\
8673Use \"info signals\" for a list of symbolic signals."));
8674}
8675
c906108c
SS
8676/* Print current contents of the tables set by the handle command.
8677 It is possible we should just be printing signals actually used
8678 by the current target (but for things to work right when switching
8679 targets, all signals should be in the signal tables). */
8680
8681static void
11db9430 8682info_signals_command (char *signum_exp, int from_tty)
c906108c 8683{
2ea28649 8684 enum gdb_signal oursig;
abbb1732 8685
c906108c
SS
8686 sig_print_header ();
8687
8688 if (signum_exp)
8689 {
8690 /* First see if this is a symbol name. */
2ea28649 8691 oursig = gdb_signal_from_name (signum_exp);
a493e3e2 8692 if (oursig == GDB_SIGNAL_UNKNOWN)
c906108c
SS
8693 {
8694 /* No, try numeric. */
8695 oursig =
2ea28649 8696 gdb_signal_from_command (parse_and_eval_long (signum_exp));
c906108c
SS
8697 }
8698 sig_print_info (oursig);
8699 return;
8700 }
8701
8702 printf_filtered ("\n");
8703 /* These ugly casts brought to you by the native VAX compiler. */
a493e3e2
PA
8704 for (oursig = GDB_SIGNAL_FIRST;
8705 (int) oursig < (int) GDB_SIGNAL_LAST;
2ea28649 8706 oursig = (enum gdb_signal) ((int) oursig + 1))
c906108c
SS
8707 {
8708 QUIT;
8709
a493e3e2
PA
8710 if (oursig != GDB_SIGNAL_UNKNOWN
8711 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
c906108c
SS
8712 sig_print_info (oursig);
8713 }
8714
3e43a32a
MS
8715 printf_filtered (_("\nUse the \"handle\" command "
8716 "to change these tables.\n"));
c906108c 8717}
4aa995e1
PA
8718
8719/* The $_siginfo convenience variable is a bit special. We don't know
8720 for sure the type of the value until we actually have a chance to
7a9dd1b2 8721 fetch the data. The type can change depending on gdbarch, so it is
4aa995e1
PA
8722 also dependent on which thread you have selected.
8723
8724 1. making $_siginfo be an internalvar that creates a new value on
8725 access.
8726
8727 2. making the value of $_siginfo be an lval_computed value. */
8728
8729/* This function implements the lval_computed support for reading a
8730 $_siginfo value. */
8731
8732static void
8733siginfo_value_read (struct value *v)
8734{
8735 LONGEST transferred;
8736
a911d87a
PA
8737 /* If we can access registers, so can we access $_siginfo. Likewise
8738 vice versa. */
8739 validate_registers_access ();
c709acd1 8740
4aa995e1
PA
8741 transferred =
8742 target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO,
8743 NULL,
8744 value_contents_all_raw (v),
8745 value_offset (v),
8746 TYPE_LENGTH (value_type (v)));
8747
8748 if (transferred != TYPE_LENGTH (value_type (v)))
8749 error (_("Unable to read siginfo"));
8750}
8751
8752/* This function implements the lval_computed support for writing a
8753 $_siginfo value. */
8754
8755static void
8756siginfo_value_write (struct value *v, struct value *fromval)
8757{
8758 LONGEST transferred;
8759
a911d87a
PA
8760 /* If we can access registers, so can we access $_siginfo. Likewise
8761 vice versa. */
8762 validate_registers_access ();
c709acd1 8763
4aa995e1
PA
8764 transferred = target_write (&current_target,
8765 TARGET_OBJECT_SIGNAL_INFO,
8766 NULL,
8767 value_contents_all_raw (fromval),
8768 value_offset (v),
8769 TYPE_LENGTH (value_type (fromval)));
8770
8771 if (transferred != TYPE_LENGTH (value_type (fromval)))
8772 error (_("Unable to write siginfo"));
8773}
8774
c8f2448a 8775static const struct lval_funcs siginfo_value_funcs =
4aa995e1
PA
8776 {
8777 siginfo_value_read,
8778 siginfo_value_write
8779 };
8780
8781/* Return a new value with the correct type for the siginfo object of
78267919
UW
8782 the current thread using architecture GDBARCH. Return a void value
8783 if there's no object available. */
4aa995e1 8784
2c0b251b 8785static struct value *
22d2b532
SDJ
8786siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
8787 void *ignore)
4aa995e1 8788{
4aa995e1 8789 if (target_has_stack
78267919
UW
8790 && !ptid_equal (inferior_ptid, null_ptid)
8791 && gdbarch_get_siginfo_type_p (gdbarch))
4aa995e1 8792 {
78267919 8793 struct type *type = gdbarch_get_siginfo_type (gdbarch);
abbb1732 8794
78267919 8795 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
4aa995e1
PA
8796 }
8797
78267919 8798 return allocate_value (builtin_type (gdbarch)->builtin_void);
4aa995e1
PA
8799}
8800
c906108c 8801\f
16c381f0
JK
8802/* infcall_suspend_state contains state about the program itself like its
8803 registers and any signal it received when it last stopped.
8804 This state must be restored regardless of how the inferior function call
8805 ends (either successfully, or after it hits a breakpoint or signal)
8806 if the program is to properly continue where it left off. */
8807
8808struct infcall_suspend_state
7a292a7a 8809{
16c381f0 8810 struct thread_suspend_state thread_suspend;
16c381f0
JK
8811
8812 /* Other fields: */
7a292a7a 8813 CORE_ADDR stop_pc;
b89667eb 8814 struct regcache *registers;
1736ad11 8815
35515841 8816 /* Format of SIGINFO_DATA or NULL if it is not present. */
1736ad11
JK
8817 struct gdbarch *siginfo_gdbarch;
8818
8819 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8820 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8821 content would be invalid. */
8822 gdb_byte *siginfo_data;
b89667eb
DE
8823};
8824
16c381f0
JK
8825struct infcall_suspend_state *
8826save_infcall_suspend_state (void)
b89667eb 8827{
16c381f0 8828 struct infcall_suspend_state *inf_state;
b89667eb 8829 struct thread_info *tp = inferior_thread ();
1736ad11
JK
8830 struct regcache *regcache = get_current_regcache ();
8831 struct gdbarch *gdbarch = get_regcache_arch (regcache);
8832 gdb_byte *siginfo_data = NULL;
8833
8834 if (gdbarch_get_siginfo_type_p (gdbarch))
8835 {
8836 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8837 size_t len = TYPE_LENGTH (type);
8838 struct cleanup *back_to;
8839
224c3ddb 8840 siginfo_data = (gdb_byte *) xmalloc (len);
1736ad11
JK
8841 back_to = make_cleanup (xfree, siginfo_data);
8842
8843 if (target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
8844 siginfo_data, 0, len) == len)
8845 discard_cleanups (back_to);
8846 else
8847 {
8848 /* Errors ignored. */
8849 do_cleanups (back_to);
8850 siginfo_data = NULL;
8851 }
8852 }
8853
41bf6aca 8854 inf_state = XCNEW (struct infcall_suspend_state);
1736ad11
JK
8855
8856 if (siginfo_data)
8857 {
8858 inf_state->siginfo_gdbarch = gdbarch;
8859 inf_state->siginfo_data = siginfo_data;
8860 }
b89667eb 8861
16c381f0 8862 inf_state->thread_suspend = tp->suspend;
16c381f0 8863
35515841 8864 /* run_inferior_call will not use the signal due to its `proceed' call with
a493e3e2
PA
8865 GDB_SIGNAL_0 anyway. */
8866 tp->suspend.stop_signal = GDB_SIGNAL_0;
35515841 8867
b89667eb
DE
8868 inf_state->stop_pc = stop_pc;
8869
1736ad11 8870 inf_state->registers = regcache_dup (regcache);
b89667eb
DE
8871
8872 return inf_state;
8873}
8874
8875/* Restore inferior session state to INF_STATE. */
8876
8877void
16c381f0 8878restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
b89667eb
DE
8879{
8880 struct thread_info *tp = inferior_thread ();
1736ad11
JK
8881 struct regcache *regcache = get_current_regcache ();
8882 struct gdbarch *gdbarch = get_regcache_arch (regcache);
b89667eb 8883
16c381f0 8884 tp->suspend = inf_state->thread_suspend;
16c381f0 8885
b89667eb
DE
8886 stop_pc = inf_state->stop_pc;
8887
1736ad11
JK
8888 if (inf_state->siginfo_gdbarch == gdbarch)
8889 {
8890 struct type *type = gdbarch_get_siginfo_type (gdbarch);
1736ad11
JK
8891
8892 /* Errors ignored. */
8893 target_write (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
6acef6cd 8894 inf_state->siginfo_data, 0, TYPE_LENGTH (type));
1736ad11
JK
8895 }
8896
b89667eb
DE
8897 /* The inferior can be gone if the user types "print exit(0)"
8898 (and perhaps other times). */
8899 if (target_has_execution)
8900 /* NB: The register write goes through to the target. */
1736ad11 8901 regcache_cpy (regcache, inf_state->registers);
803b5f95 8902
16c381f0 8903 discard_infcall_suspend_state (inf_state);
b89667eb
DE
8904}
8905
8906static void
16c381f0 8907do_restore_infcall_suspend_state_cleanup (void *state)
b89667eb 8908{
9a3c8263 8909 restore_infcall_suspend_state ((struct infcall_suspend_state *) state);
b89667eb
DE
8910}
8911
8912struct cleanup *
16c381f0
JK
8913make_cleanup_restore_infcall_suspend_state
8914 (struct infcall_suspend_state *inf_state)
b89667eb 8915{
16c381f0 8916 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
b89667eb
DE
8917}
8918
8919void
16c381f0 8920discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
b89667eb
DE
8921{
8922 regcache_xfree (inf_state->registers);
803b5f95 8923 xfree (inf_state->siginfo_data);
b89667eb
DE
8924 xfree (inf_state);
8925}
8926
8927struct regcache *
16c381f0 8928get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
b89667eb
DE
8929{
8930 return inf_state->registers;
8931}
8932
16c381f0
JK
8933/* infcall_control_state contains state regarding gdb's control of the
8934 inferior itself like stepping control. It also contains session state like
8935 the user's currently selected frame. */
b89667eb 8936
16c381f0 8937struct infcall_control_state
b89667eb 8938{
16c381f0
JK
8939 struct thread_control_state thread_control;
8940 struct inferior_control_state inferior_control;
d82142e2
JK
8941
8942 /* Other fields: */
8943 enum stop_stack_kind stop_stack_dummy;
8944 int stopped_by_random_signal;
7a292a7a 8945
b89667eb 8946 /* ID if the selected frame when the inferior function call was made. */
101dcfbe 8947 struct frame_id selected_frame_id;
7a292a7a
SS
8948};
8949
c906108c 8950/* Save all of the information associated with the inferior<==>gdb
b89667eb 8951 connection. */
c906108c 8952
16c381f0
JK
8953struct infcall_control_state *
8954save_infcall_control_state (void)
c906108c 8955{
8d749320
SM
8956 struct infcall_control_state *inf_status =
8957 XNEW (struct infcall_control_state);
4e1c45ea 8958 struct thread_info *tp = inferior_thread ();
d6b48e9c 8959 struct inferior *inf = current_inferior ();
7a292a7a 8960
16c381f0
JK
8961 inf_status->thread_control = tp->control;
8962 inf_status->inferior_control = inf->control;
d82142e2 8963
8358c15c 8964 tp->control.step_resume_breakpoint = NULL;
5b79abe7 8965 tp->control.exception_resume_breakpoint = NULL;
8358c15c 8966
16c381f0
JK
8967 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8968 chain. If caller's caller is walking the chain, they'll be happier if we
8969 hand them back the original chain when restore_infcall_control_state is
8970 called. */
8971 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
d82142e2
JK
8972
8973 /* Other fields: */
8974 inf_status->stop_stack_dummy = stop_stack_dummy;
8975 inf_status->stopped_by_random_signal = stopped_by_random_signal;
c5aa993b 8976
206415a3 8977 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
b89667eb 8978
7a292a7a 8979 return inf_status;
c906108c
SS
8980}
8981
c906108c 8982static int
96baa820 8983restore_selected_frame (void *args)
c906108c 8984{
488f131b 8985 struct frame_id *fid = (struct frame_id *) args;
c906108c 8986 struct frame_info *frame;
c906108c 8987
101dcfbe 8988 frame = frame_find_by_id (*fid);
c906108c 8989
aa0cd9c1
AC
8990 /* If inf_status->selected_frame_id is NULL, there was no previously
8991 selected frame. */
101dcfbe 8992 if (frame == NULL)
c906108c 8993 {
8a3fe4f8 8994 warning (_("Unable to restore previously selected frame."));
c906108c
SS
8995 return 0;
8996 }
8997
0f7d239c 8998 select_frame (frame);
c906108c
SS
8999
9000 return (1);
9001}
9002
b89667eb
DE
9003/* Restore inferior session state to INF_STATUS. */
9004
c906108c 9005void
16c381f0 9006restore_infcall_control_state (struct infcall_control_state *inf_status)
c906108c 9007{
4e1c45ea 9008 struct thread_info *tp = inferior_thread ();
d6b48e9c 9009 struct inferior *inf = current_inferior ();
4e1c45ea 9010
8358c15c
JK
9011 if (tp->control.step_resume_breakpoint)
9012 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
9013
5b79abe7
TT
9014 if (tp->control.exception_resume_breakpoint)
9015 tp->control.exception_resume_breakpoint->disposition
9016 = disp_del_at_next_stop;
9017
d82142e2 9018 /* Handle the bpstat_copy of the chain. */
16c381f0 9019 bpstat_clear (&tp->control.stop_bpstat);
d82142e2 9020
16c381f0
JK
9021 tp->control = inf_status->thread_control;
9022 inf->control = inf_status->inferior_control;
d82142e2
JK
9023
9024 /* Other fields: */
9025 stop_stack_dummy = inf_status->stop_stack_dummy;
9026 stopped_by_random_signal = inf_status->stopped_by_random_signal;
c906108c 9027
b89667eb 9028 if (target_has_stack)
c906108c 9029 {
c906108c 9030 /* The point of catch_errors is that if the stack is clobbered,
101dcfbe
AC
9031 walking the stack might encounter a garbage pointer and
9032 error() trying to dereference it. */
488f131b
JB
9033 if (catch_errors
9034 (restore_selected_frame, &inf_status->selected_frame_id,
9035 "Unable to restore previously selected frame:\n",
9036 RETURN_MASK_ERROR) == 0)
c906108c
SS
9037 /* Error in restoring the selected frame. Select the innermost
9038 frame. */
0f7d239c 9039 select_frame (get_current_frame ());
c906108c 9040 }
c906108c 9041
72cec141 9042 xfree (inf_status);
7a292a7a 9043}
c906108c 9044
74b7792f 9045static void
16c381f0 9046do_restore_infcall_control_state_cleanup (void *sts)
74b7792f 9047{
9a3c8263 9048 restore_infcall_control_state ((struct infcall_control_state *) sts);
74b7792f
AC
9049}
9050
9051struct cleanup *
16c381f0
JK
9052make_cleanup_restore_infcall_control_state
9053 (struct infcall_control_state *inf_status)
74b7792f 9054{
16c381f0 9055 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
74b7792f
AC
9056}
9057
c906108c 9058void
16c381f0 9059discard_infcall_control_state (struct infcall_control_state *inf_status)
7a292a7a 9060{
8358c15c
JK
9061 if (inf_status->thread_control.step_resume_breakpoint)
9062 inf_status->thread_control.step_resume_breakpoint->disposition
9063 = disp_del_at_next_stop;
9064
5b79abe7
TT
9065 if (inf_status->thread_control.exception_resume_breakpoint)
9066 inf_status->thread_control.exception_resume_breakpoint->disposition
9067 = disp_del_at_next_stop;
9068
1777feb0 9069 /* See save_infcall_control_state for info on stop_bpstat. */
16c381f0 9070 bpstat_clear (&inf_status->thread_control.stop_bpstat);
8358c15c 9071
72cec141 9072 xfree (inf_status);
7a292a7a 9073}
b89667eb 9074\f
7f89fd65 9075/* See infrun.h. */
0c557179
SDJ
9076
9077void
9078clear_exit_convenience_vars (void)
9079{
9080 clear_internalvar (lookup_internalvar ("_exitsignal"));
9081 clear_internalvar (lookup_internalvar ("_exitcode"));
9082}
c5aa993b 9083\f
488f131b 9084
b2175913
MS
9085/* User interface for reverse debugging:
9086 Set exec-direction / show exec-direction commands
9087 (returns error unless target implements to_set_exec_direction method). */
9088
170742de 9089enum exec_direction_kind execution_direction = EXEC_FORWARD;
b2175913
MS
9090static const char exec_forward[] = "forward";
9091static const char exec_reverse[] = "reverse";
9092static const char *exec_direction = exec_forward;
40478521 9093static const char *const exec_direction_names[] = {
b2175913
MS
9094 exec_forward,
9095 exec_reverse,
9096 NULL
9097};
9098
9099static void
9100set_exec_direction_func (char *args, int from_tty,
9101 struct cmd_list_element *cmd)
9102{
9103 if (target_can_execute_reverse)
9104 {
9105 if (!strcmp (exec_direction, exec_forward))
9106 execution_direction = EXEC_FORWARD;
9107 else if (!strcmp (exec_direction, exec_reverse))
9108 execution_direction = EXEC_REVERSE;
9109 }
8bbed405
MS
9110 else
9111 {
9112 exec_direction = exec_forward;
9113 error (_("Target does not support this operation."));
9114 }
b2175913
MS
9115}
9116
9117static void
9118show_exec_direction_func (struct ui_file *out, int from_tty,
9119 struct cmd_list_element *cmd, const char *value)
9120{
9121 switch (execution_direction) {
9122 case EXEC_FORWARD:
9123 fprintf_filtered (out, _("Forward.\n"));
9124 break;
9125 case EXEC_REVERSE:
9126 fprintf_filtered (out, _("Reverse.\n"));
9127 break;
b2175913 9128 default:
d8b34453
PA
9129 internal_error (__FILE__, __LINE__,
9130 _("bogus execution_direction value: %d"),
9131 (int) execution_direction);
b2175913
MS
9132 }
9133}
9134
d4db2f36
PA
9135static void
9136show_schedule_multiple (struct ui_file *file, int from_tty,
9137 struct cmd_list_element *c, const char *value)
9138{
3e43a32a
MS
9139 fprintf_filtered (file, _("Resuming the execution of threads "
9140 "of all processes is %s.\n"), value);
d4db2f36 9141}
ad52ddc6 9142
22d2b532
SDJ
9143/* Implementation of `siginfo' variable. */
9144
9145static const struct internalvar_funcs siginfo_funcs =
9146{
9147 siginfo_make_value,
9148 NULL,
9149 NULL
9150};
9151
372316f1
PA
9152/* Callback for infrun's target events source. This is marked when a
9153 thread has a pending status to process. */
9154
9155static void
9156infrun_async_inferior_event_handler (gdb_client_data data)
9157{
372316f1
PA
9158 inferior_event_handler (INF_REG_EVENT, NULL);
9159}
9160
c906108c 9161void
96baa820 9162_initialize_infrun (void)
c906108c 9163{
52f0bd74
AC
9164 int i;
9165 int numsigs;
de0bea00 9166 struct cmd_list_element *c;
c906108c 9167
372316f1
PA
9168 /* Register extra event sources in the event loop. */
9169 infrun_async_inferior_event_token
9170 = create_async_event_handler (infrun_async_inferior_event_handler, NULL);
9171
11db9430 9172 add_info ("signals", info_signals_command, _("\
1bedd215
AC
9173What debugger does when program gets various signals.\n\
9174Specify a signal as argument to print info on that signal only."));
c906108c
SS
9175 add_info_alias ("handle", "signals", 0);
9176
de0bea00 9177 c = add_com ("handle", class_run, handle_command, _("\
dfbd5e7b 9178Specify how to handle signals.\n\
486c7739 9179Usage: handle SIGNAL [ACTIONS]\n\
c906108c 9180Args are signals and actions to apply to those signals.\n\
dfbd5e7b 9181If no actions are specified, the current settings for the specified signals\n\
486c7739
MF
9182will be displayed instead.\n\
9183\n\
c906108c
SS
9184Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9185from 1-15 are allowed for compatibility with old versions of GDB.\n\
9186Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9187The special arg \"all\" is recognized to mean all signals except those\n\
1bedd215 9188used by the debugger, typically SIGTRAP and SIGINT.\n\
486c7739 9189\n\
1bedd215 9190Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
c906108c
SS
9191\"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9192Stop means reenter debugger if this signal happens (implies print).\n\
9193Print means print a message if this signal happens.\n\
9194Pass means let program see this signal; otherwise program doesn't know.\n\
9195Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
dfbd5e7b
PA
9196Pass and Stop may be combined.\n\
9197\n\
9198Multiple signals may be specified. Signal numbers and signal names\n\
9199may be interspersed with actions, with the actions being performed for\n\
9200all signals cumulatively specified."));
de0bea00 9201 set_cmd_completer (c, handle_completer);
486c7739 9202
c906108c 9203 if (!dbx_commands)
1a966eab
AC
9204 stop_command = add_cmd ("stop", class_obscure,
9205 not_just_help_class_command, _("\
9206There is no `stop' command, but you can set a hook on `stop'.\n\
c906108c 9207This allows you to set a list of commands to be run each time execution\n\
1a966eab 9208of the program stops."), &cmdlist);
c906108c 9209
ccce17b0 9210 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
85c07804
AC
9211Set inferior debugging."), _("\
9212Show inferior debugging."), _("\
9213When non-zero, inferior specific debugging is enabled."),
ccce17b0
YQ
9214 NULL,
9215 show_debug_infrun,
9216 &setdebuglist, &showdebuglist);
527159b7 9217
3e43a32a
MS
9218 add_setshow_boolean_cmd ("displaced", class_maintenance,
9219 &debug_displaced, _("\
237fc4c9
PA
9220Set displaced stepping debugging."), _("\
9221Show displaced stepping debugging."), _("\
9222When non-zero, displaced stepping specific debugging is enabled."),
9223 NULL,
9224 show_debug_displaced,
9225 &setdebuglist, &showdebuglist);
9226
ad52ddc6
PA
9227 add_setshow_boolean_cmd ("non-stop", no_class,
9228 &non_stop_1, _("\
9229Set whether gdb controls the inferior in non-stop mode."), _("\
9230Show whether gdb controls the inferior in non-stop mode."), _("\
9231When debugging a multi-threaded program and this setting is\n\
9232off (the default, also called all-stop mode), when one thread stops\n\
9233(for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9234all other threads in the program while you interact with the thread of\n\
9235interest. When you continue or step a thread, you can allow the other\n\
9236threads to run, or have them remain stopped, but while you inspect any\n\
9237thread's state, all threads stop.\n\
9238\n\
9239In non-stop mode, when one thread stops, other threads can continue\n\
9240to run freely. You'll be able to step each thread independently,\n\
9241leave it stopped or free to run as needed."),
9242 set_non_stop,
9243 show_non_stop,
9244 &setlist,
9245 &showlist);
9246
a493e3e2 9247 numsigs = (int) GDB_SIGNAL_LAST;
8d749320
SM
9248 signal_stop = XNEWVEC (unsigned char, numsigs);
9249 signal_print = XNEWVEC (unsigned char, numsigs);
9250 signal_program = XNEWVEC (unsigned char, numsigs);
9251 signal_catch = XNEWVEC (unsigned char, numsigs);
9252 signal_pass = XNEWVEC (unsigned char, numsigs);
c906108c
SS
9253 for (i = 0; i < numsigs; i++)
9254 {
9255 signal_stop[i] = 1;
9256 signal_print[i] = 1;
9257 signal_program[i] = 1;
ab04a2af 9258 signal_catch[i] = 0;
c906108c
SS
9259 }
9260
4d9d9d04
PA
9261 /* Signals caused by debugger's own actions should not be given to
9262 the program afterwards.
9263
9264 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9265 explicitly specifies that it should be delivered to the target
9266 program. Typically, that would occur when a user is debugging a
9267 target monitor on a simulator: the target monitor sets a
9268 breakpoint; the simulator encounters this breakpoint and halts
9269 the simulation handing control to GDB; GDB, noting that the stop
9270 address doesn't map to any known breakpoint, returns control back
9271 to the simulator; the simulator then delivers the hardware
9272 equivalent of a GDB_SIGNAL_TRAP to the program being
9273 debugged. */
a493e3e2
PA
9274 signal_program[GDB_SIGNAL_TRAP] = 0;
9275 signal_program[GDB_SIGNAL_INT] = 0;
c906108c
SS
9276
9277 /* Signals that are not errors should not normally enter the debugger. */
a493e3e2
PA
9278 signal_stop[GDB_SIGNAL_ALRM] = 0;
9279 signal_print[GDB_SIGNAL_ALRM] = 0;
9280 signal_stop[GDB_SIGNAL_VTALRM] = 0;
9281 signal_print[GDB_SIGNAL_VTALRM] = 0;
9282 signal_stop[GDB_SIGNAL_PROF] = 0;
9283 signal_print[GDB_SIGNAL_PROF] = 0;
9284 signal_stop[GDB_SIGNAL_CHLD] = 0;
9285 signal_print[GDB_SIGNAL_CHLD] = 0;
9286 signal_stop[GDB_SIGNAL_IO] = 0;
9287 signal_print[GDB_SIGNAL_IO] = 0;
9288 signal_stop[GDB_SIGNAL_POLL] = 0;
9289 signal_print[GDB_SIGNAL_POLL] = 0;
9290 signal_stop[GDB_SIGNAL_URG] = 0;
9291 signal_print[GDB_SIGNAL_URG] = 0;
9292 signal_stop[GDB_SIGNAL_WINCH] = 0;
9293 signal_print[GDB_SIGNAL_WINCH] = 0;
9294 signal_stop[GDB_SIGNAL_PRIO] = 0;
9295 signal_print[GDB_SIGNAL_PRIO] = 0;
c906108c 9296
cd0fc7c3
SS
9297 /* These signals are used internally by user-level thread
9298 implementations. (See signal(5) on Solaris.) Like the above
9299 signals, a healthy program receives and handles them as part of
9300 its normal operation. */
a493e3e2
PA
9301 signal_stop[GDB_SIGNAL_LWP] = 0;
9302 signal_print[GDB_SIGNAL_LWP] = 0;
9303 signal_stop[GDB_SIGNAL_WAITING] = 0;
9304 signal_print[GDB_SIGNAL_WAITING] = 0;
9305 signal_stop[GDB_SIGNAL_CANCEL] = 0;
9306 signal_print[GDB_SIGNAL_CANCEL] = 0;
bc7b765a
JB
9307 signal_stop[GDB_SIGNAL_LIBRT] = 0;
9308 signal_print[GDB_SIGNAL_LIBRT] = 0;
cd0fc7c3 9309
2455069d
UW
9310 /* Update cached state. */
9311 signal_cache_update (-1);
9312
85c07804
AC
9313 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
9314 &stop_on_solib_events, _("\
9315Set stopping for shared library events."), _("\
9316Show stopping for shared library events."), _("\
c906108c
SS
9317If nonzero, gdb will give control to the user when the dynamic linker\n\
9318notifies gdb of shared library events. The most common event of interest\n\
85c07804 9319to the user would be loading/unloading of a new library."),
f9e14852 9320 set_stop_on_solib_events,
920d2a44 9321 show_stop_on_solib_events,
85c07804 9322 &setlist, &showlist);
c906108c 9323
7ab04401
AC
9324 add_setshow_enum_cmd ("follow-fork-mode", class_run,
9325 follow_fork_mode_kind_names,
9326 &follow_fork_mode_string, _("\
9327Set debugger response to a program call of fork or vfork."), _("\
9328Show debugger response to a program call of fork or vfork."), _("\
c906108c
SS
9329A fork or vfork creates a new process. follow-fork-mode can be:\n\
9330 parent - the original process is debugged after a fork\n\
9331 child - the new process is debugged after a fork\n\
ea1dd7bc 9332The unfollowed process will continue to run.\n\
7ab04401
AC
9333By default, the debugger will follow the parent process."),
9334 NULL,
920d2a44 9335 show_follow_fork_mode_string,
7ab04401
AC
9336 &setlist, &showlist);
9337
6c95b8df
PA
9338 add_setshow_enum_cmd ("follow-exec-mode", class_run,
9339 follow_exec_mode_names,
9340 &follow_exec_mode_string, _("\
9341Set debugger response to a program call of exec."), _("\
9342Show debugger response to a program call of exec."), _("\
9343An exec call replaces the program image of a process.\n\
9344\n\
9345follow-exec-mode can be:\n\
9346\n\
cce7e648 9347 new - the debugger creates a new inferior and rebinds the process\n\
6c95b8df
PA
9348to this new inferior. The program the process was running before\n\
9349the exec call can be restarted afterwards by restarting the original\n\
9350inferior.\n\
9351\n\
9352 same - the debugger keeps the process bound to the same inferior.\n\
9353The new executable image replaces the previous executable loaded in\n\
9354the inferior. Restarting the inferior after the exec call restarts\n\
9355the executable the process was running after the exec call.\n\
9356\n\
9357By default, the debugger will use the same inferior."),
9358 NULL,
9359 show_follow_exec_mode_string,
9360 &setlist, &showlist);
9361
7ab04401
AC
9362 add_setshow_enum_cmd ("scheduler-locking", class_run,
9363 scheduler_enums, &scheduler_mode, _("\
9364Set mode for locking scheduler during execution."), _("\
9365Show mode for locking scheduler during execution."), _("\
f2665db5
MM
9366off == no locking (threads may preempt at any time)\n\
9367on == full locking (no thread except the current thread may run)\n\
9368 This applies to both normal execution and replay mode.\n\
9369step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9370 In this mode, other threads may run during other commands.\n\
9371 This applies to both normal execution and replay mode.\n\
9372replay == scheduler locked in replay mode and unlocked during normal execution."),
7ab04401 9373 set_schedlock_func, /* traps on target vector */
920d2a44 9374 show_scheduler_mode,
7ab04401 9375 &setlist, &showlist);
5fbbeb29 9376
d4db2f36
PA
9377 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
9378Set mode for resuming threads of all processes."), _("\
9379Show mode for resuming threads of all processes."), _("\
9380When on, execution commands (such as 'continue' or 'next') resume all\n\
9381threads of all processes. When off (which is the default), execution\n\
9382commands only resume the threads of the current process. The set of\n\
9383threads that are resumed is further refined by the scheduler-locking\n\
9384mode (see help set scheduler-locking)."),
9385 NULL,
9386 show_schedule_multiple,
9387 &setlist, &showlist);
9388
5bf193a2
AC
9389 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
9390Set mode of the step operation."), _("\
9391Show mode of the step operation."), _("\
9392When set, doing a step over a function without debug line information\n\
9393will stop at the first instruction of that function. Otherwise, the\n\
9394function is skipped and the step command stops at a different source line."),
9395 NULL,
920d2a44 9396 show_step_stop_if_no_debug,
5bf193a2 9397 &setlist, &showlist);
ca6724c1 9398
72d0e2c5
YQ
9399 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
9400 &can_use_displaced_stepping, _("\
237fc4c9
PA
9401Set debugger's willingness to use displaced stepping."), _("\
9402Show debugger's willingness to use displaced stepping."), _("\
fff08868
HZ
9403If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9404supported by the target architecture. If off, gdb will not use displaced\n\
9405stepping to step over breakpoints, even if such is supported by the target\n\
9406architecture. If auto (which is the default), gdb will use displaced stepping\n\
9407if the target architecture supports it and non-stop mode is active, but will not\n\
9408use it in all-stop mode (see help set non-stop)."),
72d0e2c5
YQ
9409 NULL,
9410 show_can_use_displaced_stepping,
9411 &setlist, &showlist);
237fc4c9 9412
b2175913
MS
9413 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
9414 &exec_direction, _("Set direction of execution.\n\
9415Options are 'forward' or 'reverse'."),
9416 _("Show direction of execution (forward/reverse)."),
9417 _("Tells gdb whether to execute forward or backward."),
9418 set_exec_direction_func, show_exec_direction_func,
9419 &setlist, &showlist);
9420
6c95b8df
PA
9421 /* Set/show detach-on-fork: user-settable mode. */
9422
9423 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
9424Set whether gdb will detach the child of a fork."), _("\
9425Show whether gdb will detach the child of a fork."), _("\
9426Tells gdb whether to detach the child of a fork."),
9427 NULL, NULL, &setlist, &showlist);
9428
03583c20
UW
9429 /* Set/show disable address space randomization mode. */
9430
9431 add_setshow_boolean_cmd ("disable-randomization", class_support,
9432 &disable_randomization, _("\
9433Set disabling of debuggee's virtual address space randomization."), _("\
9434Show disabling of debuggee's virtual address space randomization."), _("\
9435When this mode is on (which is the default), randomization of the virtual\n\
9436address space is disabled. Standalone programs run with the randomization\n\
9437enabled by default on some platforms."),
9438 &set_disable_randomization,
9439 &show_disable_randomization,
9440 &setlist, &showlist);
9441
ca6724c1 9442 /* ptid initializations */
ca6724c1
KB
9443 inferior_ptid = null_ptid;
9444 target_last_wait_ptid = minus_one_ptid;
5231c1fd
PA
9445
9446 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
252fbfc8 9447 observer_attach_thread_stop_requested (infrun_thread_stop_requested);
a07daef3 9448 observer_attach_thread_exit (infrun_thread_thread_exit);
fc1cf338 9449 observer_attach_inferior_exit (infrun_inferior_exit);
4aa995e1
PA
9450
9451 /* Explicitly create without lookup, since that tries to create a
9452 value with a void typed value, and when we get here, gdbarch
9453 isn't initialized yet. At this point, we're quite sure there
9454 isn't another convenience variable of the same name. */
22d2b532 9455 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
d914c394
SS
9456
9457 add_setshow_boolean_cmd ("observer", no_class,
9458 &observer_mode_1, _("\
9459Set whether gdb controls the inferior in observer mode."), _("\
9460Show whether gdb controls the inferior in observer mode."), _("\
9461In observer mode, GDB can get data from the inferior, but not\n\
9462affect its execution. Registers and memory may not be changed,\n\
9463breakpoints may not be set, and the program cannot be interrupted\n\
9464or signalled."),
9465 set_observer_mode,
9466 show_observer_mode,
9467 &setlist,
9468 &showlist);
c906108c 9469}
This page took 2.922168 seconds and 4 git commands to generate.