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