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