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