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