Place displaced step data directly in inferior structure
[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 "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
71 /* Prototypes for local functions */
72
73 static void sig_print_info (enum gdb_signal);
74
75 static void sig_print_header (void);
76
77 static int follow_fork (void);
78
79 static int follow_fork_inferior (int follow_child, int detach_fork);
80
81 static void follow_inferior_reset_breakpoints (void);
82
83 static int currently_stepping (struct thread_info *tp);
84
85 void nullify_last_target_wait_ptid (void);
86
87 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
88
89 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
90
91 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
92
93 static int maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc);
94
95 static void resume (gdb_signal sig);
96
97 /* Asynchronous signal handler registered as event loop source for
98    when we have pending events ready to be passed to the core.  */
99 static struct async_event_handler *infrun_async_inferior_event_token;
100
101 /* Stores whether infrun_async was previously enabled or disabled.
102    Starts off as -1, indicating "never enabled/disabled".  */
103 static int infrun_is_async = -1;
104
105 /* See infrun.h.  */
106
107 void
108 infrun_async (int enable)
109 {
110   if (infrun_is_async != enable)
111     {
112       infrun_is_async = enable;
113
114       if (debug_infrun)
115         fprintf_unfiltered (gdb_stdlog,
116                             "infrun: infrun_async(%d)\n",
117                             enable);
118
119       if (enable)
120         mark_async_event_handler (infrun_async_inferior_event_token);
121       else
122         clear_async_event_handler (infrun_async_inferior_event_token);
123     }
124 }
125
126 /* See infrun.h.  */
127
128 void
129 mark_infrun_async_event_handler (void)
130 {
131   mark_async_event_handler (infrun_async_inferior_event_token);
132 }
133
134 /* When set, stop the 'step' command if we enter a function which has
135    no line number information.  The normal behavior is that we step
136    over such function.  */
137 int step_stop_if_no_debug = 0;
138 static void
139 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
140                             struct cmd_list_element *c, const char *value)
141 {
142   fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
143 }
144
145 /* proceed and normal_stop use this to notify the user when the
146    inferior stopped in a different thread than it had been running
147    in.  */
148
149 static ptid_t previous_inferior_ptid;
150
151 /* If set (default for legacy reasons), when following a fork, GDB
152    will detach from one of the fork branches, child or parent.
153    Exactly which branch is detached depends on 'set follow-fork-mode'
154    setting.  */
155
156 static int detach_fork = 1;
157
158 int debug_displaced = 0;
159 static void
160 show_debug_displaced (struct ui_file *file, int from_tty,
161                       struct cmd_list_element *c, const char *value)
162 {
163   fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
164 }
165
166 unsigned int debug_infrun = 0;
167 static void
168 show_debug_infrun (struct ui_file *file, int from_tty,
169                    struct cmd_list_element *c, const char *value)
170 {
171   fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
172 }
173
174
175 /* Support for disabling address space randomization.  */
176
177 int disable_randomization = 1;
178
179 static void
180 show_disable_randomization (struct ui_file *file, int from_tty,
181                             struct cmd_list_element *c, const char *value)
182 {
183   if (target_supports_disable_randomization ())
184     fprintf_filtered (file,
185                       _("Disabling randomization of debuggee's "
186                         "virtual address space is %s.\n"),
187                       value);
188   else
189     fputs_filtered (_("Disabling randomization of debuggee's "
190                       "virtual address space is unsupported on\n"
191                       "this platform.\n"), file);
192 }
193
194 static void
195 set_disable_randomization (const char *args, int from_tty,
196                            struct cmd_list_element *c)
197 {
198   if (!target_supports_disable_randomization ())
199     error (_("Disabling randomization of debuggee's "
200              "virtual address space is unsupported on\n"
201              "this platform."));
202 }
203
204 /* User interface for non-stop mode.  */
205
206 int non_stop = 0;
207 static int non_stop_1 = 0;
208
209 static void
210 set_non_stop (const char *args, int from_tty,
211               struct cmd_list_element *c)
212 {
213   if (target_has_execution)
214     {
215       non_stop_1 = non_stop;
216       error (_("Cannot change this setting while the inferior is running."));
217     }
218
219   non_stop = non_stop_1;
220 }
221
222 static void
223 show_non_stop (struct ui_file *file, int from_tty,
224                struct cmd_list_element *c, const char *value)
225 {
226   fprintf_filtered (file,
227                     _("Controlling the inferior in non-stop mode is %s.\n"),
228                     value);
229 }
230
231 /* "Observer mode" is somewhat like a more extreme version of
232    non-stop, in which all GDB operations that might affect the
233    target's execution have been disabled.  */
234
235 int observer_mode = 0;
236 static int observer_mode_1 = 0;
237
238 static void
239 set_observer_mode (const char *args, int from_tty,
240                    struct cmd_list_element *c)
241 {
242   if (target_has_execution)
243     {
244       observer_mode_1 = observer_mode;
245       error (_("Cannot change this setting while the inferior is running."));
246     }
247
248   observer_mode = observer_mode_1;
249
250   may_write_registers = !observer_mode;
251   may_write_memory = !observer_mode;
252   may_insert_breakpoints = !observer_mode;
253   may_insert_tracepoints = !observer_mode;
254   /* We can insert fast tracepoints in or out of observer mode,
255      but enable them if we're going into this mode.  */
256   if (observer_mode)
257     may_insert_fast_tracepoints = 1;
258   may_stop = !observer_mode;
259   update_target_permissions ();
260
261   /* Going *into* observer mode we must force non-stop, then
262      going out we leave it that way.  */
263   if (observer_mode)
264     {
265       pagination_enabled = 0;
266       non_stop = non_stop_1 = 1;
267     }
268
269   if (from_tty)
270     printf_filtered (_("Observer mode is now %s.\n"),
271                      (observer_mode ? "on" : "off"));
272 }
273
274 static void
275 show_observer_mode (struct ui_file *file, int from_tty,
276                     struct cmd_list_element *c, const char *value)
277 {
278   fprintf_filtered (file, _("Observer mode is %s.\n"), value);
279 }
280
281 /* This updates the value of observer mode based on changes in
282    permissions.  Note that we are deliberately ignoring the values of
283    may-write-registers and may-write-memory, since the user may have
284    reason to enable these during a session, for instance to turn on a
285    debugging-related global.  */
286
287 void
288 update_observer_mode (void)
289 {
290   int newval;
291
292   newval = (!may_insert_breakpoints
293             && !may_insert_tracepoints
294             && may_insert_fast_tracepoints
295             && !may_stop
296             && non_stop);
297
298   /* Let the user know if things change.  */
299   if (newval != observer_mode)
300     printf_filtered (_("Observer mode is now %s.\n"),
301                      (newval ? "on" : "off"));
302
303   observer_mode = observer_mode_1 = newval;
304 }
305
306 /* Tables of how to react to signals; the user sets them.  */
307
308 static unsigned char *signal_stop;
309 static unsigned char *signal_print;
310 static unsigned char *signal_program;
311
312 /* Table of signals that are registered with "catch signal".  A
313    non-zero entry indicates that the signal is caught by some "catch
314    signal" command.  This has size GDB_SIGNAL_LAST, to accommodate all
315    signals.  */
316 static unsigned char *signal_catch;
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;
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 ((int) GDB_SIGNAL_LAST, 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 (0, NULL);
2222   else
2223     target_pass_signals ((int) GDB_SIGNAL_LAST, 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 /* A cleanup wrapper.  */
3251
3252 static void
3253 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg)
3254 {
3255   delete_just_stopped_threads_infrun_breakpoints ();
3256 }
3257
3258 /* See infrun.h.  */
3259
3260 void
3261 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
3262                            const struct target_waitstatus *ws)
3263 {
3264   std::string status_string = target_waitstatus_to_string (ws);
3265   string_file stb;
3266
3267   /* The text is split over several lines because it was getting too long.
3268      Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3269      output as a unit; we want only one timestamp printed if debug_timestamp
3270      is set.  */
3271
3272   stb.printf ("infrun: target_wait (%d.%ld.%ld",
3273               waiton_ptid.pid (),
3274               waiton_ptid.lwp (),
3275               waiton_ptid.tid ());
3276   if (waiton_ptid.pid () != -1)
3277     stb.printf (" [%s]", target_pid_to_str (waiton_ptid));
3278   stb.printf (", status) =\n");
3279   stb.printf ("infrun:   %d.%ld.%ld [%s],\n",
3280               result_ptid.pid (),
3281               result_ptid.lwp (),
3282               result_ptid.tid (),
3283               target_pid_to_str (result_ptid));
3284   stb.printf ("infrun:   %s\n", status_string.c_str ());
3285
3286   /* This uses %s in part to handle %'s in the text, but also to avoid
3287      a gcc error: the format attribute requires a string literal.  */
3288   fprintf_unfiltered (gdb_stdlog, "%s", stb.c_str ());
3289 }
3290
3291 /* Select a thread at random, out of those which are resumed and have
3292    had events.  */
3293
3294 static struct thread_info *
3295 random_pending_event_thread (ptid_t waiton_ptid)
3296 {
3297   int num_events = 0;
3298
3299   auto has_event = [] (thread_info *tp)
3300     {
3301       return (tp->resumed
3302               && tp->suspend.waitstatus_pending_p);
3303     };
3304
3305   /* First see how many events we have.  Count only resumed threads
3306      that have an event pending.  */
3307   for (thread_info *tp : all_non_exited_threads (waiton_ptid))
3308     if (has_event (tp))
3309       num_events++;
3310
3311   if (num_events == 0)
3312     return NULL;
3313
3314   /* Now randomly pick a thread out of those that have had events.  */
3315   int random_selector = (int) ((num_events * (double) rand ())
3316                                / (RAND_MAX + 1.0));
3317
3318   if (debug_infrun && num_events > 1)
3319     fprintf_unfiltered (gdb_stdlog,
3320                         "infrun: Found %d events, selecting #%d\n",
3321                         num_events, random_selector);
3322
3323   /* Select the Nth thread that has had an event.  */
3324   for (thread_info *tp : all_non_exited_threads (waiton_ptid))
3325     if (has_event (tp))
3326       if (random_selector-- == 0)
3327         return tp;
3328
3329   gdb_assert_not_reached ("event thread not found");
3330 }
3331
3332 /* Wrapper for target_wait that first checks whether threads have
3333    pending statuses to report before actually asking the target for
3334    more events.  */
3335
3336 static ptid_t
3337 do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
3338 {
3339   ptid_t event_ptid;
3340   struct thread_info *tp;
3341
3342   /* First check if there is a resumed thread with a wait status
3343      pending.  */
3344   if (ptid == minus_one_ptid || ptid.is_pid ())
3345     {
3346       tp = random_pending_event_thread (ptid);
3347     }
3348   else
3349     {
3350       if (debug_infrun)
3351         fprintf_unfiltered (gdb_stdlog,
3352                             "infrun: Waiting for specific thread %s.\n",
3353                             target_pid_to_str (ptid));
3354
3355       /* We have a specific thread to check.  */
3356       tp = find_thread_ptid (ptid);
3357       gdb_assert (tp != NULL);
3358       if (!tp->suspend.waitstatus_pending_p)
3359         tp = NULL;
3360     }
3361
3362   if (tp != NULL
3363       && (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3364           || tp->suspend.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
3365     {
3366       struct regcache *regcache = get_thread_regcache (tp);
3367       struct gdbarch *gdbarch = regcache->arch ();
3368       CORE_ADDR pc;
3369       int discard = 0;
3370
3371       pc = regcache_read_pc (regcache);
3372
3373       if (pc != tp->suspend.stop_pc)
3374         {
3375           if (debug_infrun)
3376             fprintf_unfiltered (gdb_stdlog,
3377                                 "infrun: PC of %s changed.  was=%s, now=%s\n",
3378                                 target_pid_to_str (tp->ptid),
3379                                 paddress (gdbarch, tp->suspend.stop_pc),
3380                                 paddress (gdbarch, pc));
3381           discard = 1;
3382         }
3383       else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
3384         {
3385           if (debug_infrun)
3386             fprintf_unfiltered (gdb_stdlog,
3387                                 "infrun: previous breakpoint of %s, at %s gone\n",
3388                                 target_pid_to_str (tp->ptid),
3389                                 paddress (gdbarch, pc));
3390
3391           discard = 1;
3392         }
3393
3394       if (discard)
3395         {
3396           if (debug_infrun)
3397             fprintf_unfiltered (gdb_stdlog,
3398                                 "infrun: pending event of %s cancelled.\n",
3399                                 target_pid_to_str (tp->ptid));
3400
3401           tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
3402           tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3403         }
3404     }
3405
3406   if (tp != NULL)
3407     {
3408       if (debug_infrun)
3409         {
3410           std::string statstr
3411             = target_waitstatus_to_string (&tp->suspend.waitstatus);
3412
3413           fprintf_unfiltered (gdb_stdlog,
3414                               "infrun: Using pending wait status %s for %s.\n",
3415                               statstr.c_str (),
3416                               target_pid_to_str (tp->ptid));
3417         }
3418
3419       /* Now that we've selected our final event LWP, un-adjust its PC
3420          if it was a software breakpoint (and the target doesn't
3421          always adjust the PC itself).  */
3422       if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3423           && !target_supports_stopped_by_sw_breakpoint ())
3424         {
3425           struct regcache *regcache;
3426           struct gdbarch *gdbarch;
3427           int decr_pc;
3428
3429           regcache = get_thread_regcache (tp);
3430           gdbarch = regcache->arch ();
3431
3432           decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3433           if (decr_pc != 0)
3434             {
3435               CORE_ADDR pc;
3436
3437               pc = regcache_read_pc (regcache);
3438               regcache_write_pc (regcache, pc + decr_pc);
3439             }
3440         }
3441
3442       tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3443       *status = tp->suspend.waitstatus;
3444       tp->suspend.waitstatus_pending_p = 0;
3445
3446       /* Wake up the event loop again, until all pending events are
3447          processed.  */
3448       if (target_is_async_p ())
3449         mark_async_event_handler (infrun_async_inferior_event_token);
3450       return tp->ptid;
3451     }
3452
3453   /* But if we don't find one, we'll have to wait.  */
3454
3455   if (deprecated_target_wait_hook)
3456     event_ptid = deprecated_target_wait_hook (ptid, status, options);
3457   else
3458     event_ptid = target_wait (ptid, status, options);
3459
3460   return event_ptid;
3461 }
3462
3463 /* Prepare and stabilize the inferior for detaching it.  E.g.,
3464    detaching while a thread is displaced stepping is a recipe for
3465    crashing it, as nothing would readjust the PC out of the scratch
3466    pad.  */
3467
3468 void
3469 prepare_for_detach (void)
3470 {
3471   struct inferior *inf = current_inferior ();
3472   ptid_t pid_ptid = ptid_t (inf->pid);
3473
3474   displaced_step_inferior_state *displaced = get_displaced_stepping_state (inf);
3475
3476   /* Is any thread of this process displaced stepping?  If not,
3477      there's nothing else to do.  */
3478   if (displaced->step_thread == nullptr)
3479     return;
3480
3481   if (debug_infrun)
3482     fprintf_unfiltered (gdb_stdlog,
3483                         "displaced-stepping in-process while detaching");
3484
3485   scoped_restore restore_detaching = make_scoped_restore (&inf->detaching, true);
3486
3487   while (displaced->step_thread != nullptr)
3488     {
3489       struct execution_control_state ecss;
3490       struct execution_control_state *ecs;
3491
3492       ecs = &ecss;
3493       memset (ecs, 0, sizeof (*ecs));
3494
3495       overlay_cache_invalid = 1;
3496       /* Flush target cache before starting to handle each event.
3497          Target was running and cache could be stale.  This is just a
3498          heuristic.  Running threads may modify target memory, but we
3499          don't get any event.  */
3500       target_dcache_invalidate ();
3501
3502       ecs->ptid = do_target_wait (pid_ptid, &ecs->ws, 0);
3503
3504       if (debug_infrun)
3505         print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
3506
3507       /* If an error happens while handling the event, propagate GDB's
3508          knowledge of the executing state to the frontend/user running
3509          state.  */
3510       scoped_finish_thread_state finish_state (minus_one_ptid);
3511
3512       /* Now figure out what to do with the result of the result.  */
3513       handle_inferior_event (ecs);
3514
3515       /* No error, don't finish the state yet.  */
3516       finish_state.release ();
3517
3518       /* Breakpoints and watchpoints are not installed on the target
3519          at this point, and signals are passed directly to the
3520          inferior, so this must mean the process is gone.  */
3521       if (!ecs->wait_some_more)
3522         {
3523           restore_detaching.release ();
3524           error (_("Program exited while detaching"));
3525         }
3526     }
3527
3528   restore_detaching.release ();
3529 }
3530
3531 /* Wait for control to return from inferior to debugger.
3532
3533    If inferior gets a signal, we may decide to start it up again
3534    instead of returning.  That is why there is a loop in this function.
3535    When this function actually returns it means the inferior
3536    should be left stopped and GDB should read more commands.  */
3537
3538 void
3539 wait_for_inferior (void)
3540 {
3541   struct cleanup *old_cleanups;
3542
3543   if (debug_infrun)
3544     fprintf_unfiltered
3545       (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3546
3547   old_cleanups
3548     = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup,
3549                     NULL);
3550
3551   /* If an error happens while handling the event, propagate GDB's
3552      knowledge of the executing state to the frontend/user running
3553      state.  */
3554   scoped_finish_thread_state finish_state (minus_one_ptid);
3555
3556   while (1)
3557     {
3558       struct execution_control_state ecss;
3559       struct execution_control_state *ecs = &ecss;
3560       ptid_t waiton_ptid = minus_one_ptid;
3561
3562       memset (ecs, 0, sizeof (*ecs));
3563
3564       overlay_cache_invalid = 1;
3565
3566       /* Flush target cache before starting to handle each event.
3567          Target was running and cache could be stale.  This is just a
3568          heuristic.  Running threads may modify target memory, but we
3569          don't get any event.  */
3570       target_dcache_invalidate ();
3571
3572       ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws, 0);
3573
3574       if (debug_infrun)
3575         print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3576
3577       /* Now figure out what to do with the result of the result.  */
3578       handle_inferior_event (ecs);
3579
3580       if (!ecs->wait_some_more)
3581         break;
3582     }
3583
3584   /* No error, don't finish the state yet.  */
3585   finish_state.release ();
3586
3587   do_cleanups (old_cleanups);
3588 }
3589
3590 /* Cleanup that reinstalls the readline callback handler, if the
3591    target is running in the background.  If while handling the target
3592    event something triggered a secondary prompt, like e.g., a
3593    pagination prompt, we'll have removed the callback handler (see
3594    gdb_readline_wrapper_line).  Need to do this as we go back to the
3595    event loop, ready to process further input.  Note this has no
3596    effect if the handler hasn't actually been removed, because calling
3597    rl_callback_handler_install resets the line buffer, thus losing
3598    input.  */
3599
3600 static void
3601 reinstall_readline_callback_handler_cleanup (void *arg)
3602 {
3603   struct ui *ui = current_ui;
3604
3605   if (!ui->async)
3606     {
3607       /* We're not going back to the top level event loop yet.  Don't
3608          install the readline callback, as it'd prep the terminal,
3609          readline-style (raw, noecho) (e.g., --batch).  We'll install
3610          it the next time the prompt is displayed, when we're ready
3611          for input.  */
3612       return;
3613     }
3614
3615   if (ui->command_editing && ui->prompt_state != PROMPT_BLOCKED)
3616     gdb_rl_callback_handler_reinstall ();
3617 }
3618
3619 /* Clean up the FSMs of threads that are now stopped.  In non-stop,
3620    that's just the event thread.  In all-stop, that's all threads.  */
3621
3622 static void
3623 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
3624 {
3625   if (ecs->event_thread != NULL
3626       && ecs->event_thread->thread_fsm != NULL)
3627     thread_fsm_clean_up (ecs->event_thread->thread_fsm,
3628                          ecs->event_thread);
3629
3630   if (!non_stop)
3631     {
3632       for (thread_info *thr : all_non_exited_threads ())
3633         {
3634           if (thr->thread_fsm == NULL)
3635             continue;
3636           if (thr == ecs->event_thread)
3637             continue;
3638
3639           switch_to_thread (thr);
3640           thread_fsm_clean_up (thr->thread_fsm, thr);
3641         }
3642
3643       if (ecs->event_thread != NULL)
3644         switch_to_thread (ecs->event_thread);
3645     }
3646 }
3647
3648 /* Helper for all_uis_check_sync_execution_done that works on the
3649    current UI.  */
3650
3651 static void
3652 check_curr_ui_sync_execution_done (void)
3653 {
3654   struct ui *ui = current_ui;
3655
3656   if (ui->prompt_state == PROMPT_NEEDED
3657       && ui->async
3658       && !gdb_in_secondary_prompt_p (ui))
3659     {
3660       target_terminal::ours ();
3661       gdb::observers::sync_execution_done.notify ();
3662       ui_register_input_event_handler (ui);
3663     }
3664 }
3665
3666 /* See infrun.h.  */
3667
3668 void
3669 all_uis_check_sync_execution_done (void)
3670 {
3671   SWITCH_THRU_ALL_UIS ()
3672     {
3673       check_curr_ui_sync_execution_done ();
3674     }
3675 }
3676
3677 /* See infrun.h.  */
3678
3679 void
3680 all_uis_on_sync_execution_starting (void)
3681 {
3682   SWITCH_THRU_ALL_UIS ()
3683     {
3684       if (current_ui->prompt_state == PROMPT_NEEDED)
3685         async_disable_stdin ();
3686     }
3687 }
3688
3689 /* Asynchronous version of wait_for_inferior.  It is called by the
3690    event loop whenever a change of state is detected on the file
3691    descriptor corresponding to the target.  It can be called more than
3692    once to complete a single execution command.  In such cases we need
3693    to keep the state in a global variable ECSS.  If it is the last time
3694    that this function is called for a single execution command, then
3695    report to the user that the inferior has stopped, and do the
3696    necessary cleanups.  */
3697
3698 void
3699 fetch_inferior_event (void *client_data)
3700 {
3701   struct execution_control_state ecss;
3702   struct execution_control_state *ecs = &ecss;
3703   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3704   int cmd_done = 0;
3705   ptid_t waiton_ptid = minus_one_ptid;
3706
3707   memset (ecs, 0, sizeof (*ecs));
3708
3709   /* Events are always processed with the main UI as current UI.  This
3710      way, warnings, debug output, etc. are always consistently sent to
3711      the main console.  */
3712   scoped_restore save_ui = make_scoped_restore (&current_ui, main_ui);
3713
3714   /* End up with readline processing input, if necessary.  */
3715   make_cleanup (reinstall_readline_callback_handler_cleanup, NULL);
3716
3717   /* We're handling a live event, so make sure we're doing live
3718      debugging.  If we're looking at traceframes while the target is
3719      running, we're going to need to get back to that mode after
3720      handling the event.  */
3721   gdb::optional<scoped_restore_current_traceframe> maybe_restore_traceframe;
3722   if (non_stop)
3723     {
3724       maybe_restore_traceframe.emplace ();
3725       set_current_traceframe (-1);
3726     }
3727
3728   gdb::optional<scoped_restore_current_thread> maybe_restore_thread;
3729
3730   if (non_stop)
3731     /* In non-stop mode, the user/frontend should not notice a thread
3732        switch due to internal events.  Make sure we reverse to the
3733        user selected thread and frame after handling the event and
3734        running any breakpoint commands.  */
3735     maybe_restore_thread.emplace ();
3736
3737   overlay_cache_invalid = 1;
3738   /* Flush target cache before starting to handle each event.  Target
3739      was running and cache could be stale.  This is just a heuristic.
3740      Running threads may modify target memory, but we don't get any
3741      event.  */
3742   target_dcache_invalidate ();
3743
3744   scoped_restore save_exec_dir
3745     = make_scoped_restore (&execution_direction, target_execution_direction ());
3746
3747   ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
3748                               target_can_async_p () ? TARGET_WNOHANG : 0);
3749
3750   if (debug_infrun)
3751     print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3752
3753   /* If an error happens while handling the event, propagate GDB's
3754      knowledge of the executing state to the frontend/user running
3755      state.  */
3756   ptid_t finish_ptid = !target_is_non_stop_p () ? minus_one_ptid : ecs->ptid;
3757   scoped_finish_thread_state finish_state (finish_ptid);
3758
3759   /* Get executed before make_cleanup_restore_current_thread above to apply
3760      still for the thread which has thrown the exception.  */
3761   struct cleanup *ts_old_chain = make_bpstat_clear_actions_cleanup ();
3762
3763   make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
3764
3765   /* Now figure out what to do with the result of the result.  */
3766   handle_inferior_event (ecs);
3767
3768   if (!ecs->wait_some_more)
3769     {
3770       struct inferior *inf = find_inferior_ptid (ecs->ptid);
3771       int should_stop = 1;
3772       struct thread_info *thr = ecs->event_thread;
3773
3774       delete_just_stopped_threads_infrun_breakpoints ();
3775
3776       if (thr != NULL)
3777         {
3778           struct thread_fsm *thread_fsm = thr->thread_fsm;
3779
3780           if (thread_fsm != NULL)
3781             should_stop = thread_fsm_should_stop (thread_fsm, thr);
3782         }
3783
3784       if (!should_stop)
3785         {
3786           keep_going (ecs);
3787         }
3788       else
3789         {
3790           int should_notify_stop = 1;
3791           int proceeded = 0;
3792
3793           clean_up_just_stopped_threads_fsms (ecs);
3794
3795           if (thr != NULL && thr->thread_fsm != NULL)
3796             {
3797               should_notify_stop
3798                 = thread_fsm_should_notify_stop (thr->thread_fsm);
3799             }
3800
3801           if (should_notify_stop)
3802             {
3803               /* We may not find an inferior if this was a process exit.  */
3804               if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3805                 proceeded = normal_stop ();
3806             }
3807
3808           if (!proceeded)
3809             {
3810               inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3811               cmd_done = 1;
3812             }
3813         }
3814     }
3815
3816   discard_cleanups (ts_old_chain);
3817
3818   /* No error, don't finish the thread states yet.  */
3819   finish_state.release ();
3820
3821   /* Revert thread and frame.  */
3822   do_cleanups (old_chain);
3823
3824   /* If a UI was in sync execution mode, and now isn't, restore its
3825      prompt (a synchronous execution command has finished, and we're
3826      ready for input).  */
3827   all_uis_check_sync_execution_done ();
3828
3829   if (cmd_done
3830       && exec_done_display_p
3831       && (inferior_ptid == null_ptid
3832           || inferior_thread ()->state != THREAD_RUNNING))
3833     printf_unfiltered (_("completed.\n"));
3834 }
3835
3836 /* Record the frame and location we're currently stepping through.  */
3837 void
3838 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3839 {
3840   struct thread_info *tp = inferior_thread ();
3841
3842   tp->control.step_frame_id = get_frame_id (frame);
3843   tp->control.step_stack_frame_id = get_stack_frame_id (frame);
3844
3845   tp->current_symtab = sal.symtab;
3846   tp->current_line = sal.line;
3847 }
3848
3849 /* Clear context switchable stepping state.  */
3850
3851 void
3852 init_thread_stepping_state (struct thread_info *tss)
3853 {
3854   tss->stepped_breakpoint = 0;
3855   tss->stepping_over_breakpoint = 0;
3856   tss->stepping_over_watchpoint = 0;
3857   tss->step_after_step_resume_breakpoint = 0;
3858 }
3859
3860 /* Set the cached copy of the last ptid/waitstatus.  */
3861
3862 void
3863 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
3864 {
3865   target_last_wait_ptid = ptid;
3866   target_last_waitstatus = status;
3867 }
3868
3869 /* Return the cached copy of the last pid/waitstatus returned by
3870    target_wait()/deprecated_target_wait_hook().  The data is actually
3871    cached by handle_inferior_event(), which gets called immediately
3872    after target_wait()/deprecated_target_wait_hook().  */
3873
3874 void
3875 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
3876 {
3877   *ptidp = target_last_wait_ptid;
3878   *status = target_last_waitstatus;
3879 }
3880
3881 void
3882 nullify_last_target_wait_ptid (void)
3883 {
3884   target_last_wait_ptid = minus_one_ptid;
3885 }
3886
3887 /* Switch thread contexts.  */
3888
3889 static void
3890 context_switch (execution_control_state *ecs)
3891 {
3892   if (debug_infrun
3893       && ecs->ptid != inferior_ptid
3894       && ecs->event_thread != inferior_thread ())
3895     {
3896       fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
3897                           target_pid_to_str (inferior_ptid));
3898       fprintf_unfiltered (gdb_stdlog, "to %s\n",
3899                           target_pid_to_str (ecs->ptid));
3900     }
3901
3902   switch_to_thread (ecs->event_thread);
3903 }
3904
3905 /* If the target can't tell whether we've hit breakpoints
3906    (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
3907    check whether that could have been caused by a breakpoint.  If so,
3908    adjust the PC, per gdbarch_decr_pc_after_break.  */
3909
3910 static void
3911 adjust_pc_after_break (struct thread_info *thread,
3912                        struct target_waitstatus *ws)
3913 {
3914   struct regcache *regcache;
3915   struct gdbarch *gdbarch;
3916   CORE_ADDR breakpoint_pc, decr_pc;
3917
3918   /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP.  If
3919      we aren't, just return.
3920
3921      We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3922      affected by gdbarch_decr_pc_after_break.  Other waitkinds which are
3923      implemented by software breakpoints should be handled through the normal
3924      breakpoint layer.
3925
3926      NOTE drow/2004-01-31: On some targets, breakpoints may generate
3927      different signals (SIGILL or SIGEMT for instance), but it is less
3928      clear where the PC is pointing afterwards.  It may not match
3929      gdbarch_decr_pc_after_break.  I don't know any specific target that
3930      generates these signals at breakpoints (the code has been in GDB since at
3931      least 1992) so I can not guess how to handle them here.
3932
3933      In earlier versions of GDB, a target with 
3934      gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3935      watchpoint affected by gdbarch_decr_pc_after_break.  I haven't found any
3936      target with both of these set in GDB history, and it seems unlikely to be
3937      correct, so gdbarch_have_nonsteppable_watchpoint is not checked here.  */
3938
3939   if (ws->kind != TARGET_WAITKIND_STOPPED)
3940     return;
3941
3942   if (ws->value.sig != GDB_SIGNAL_TRAP)
3943     return;
3944
3945   /* In reverse execution, when a breakpoint is hit, the instruction
3946      under it has already been de-executed.  The reported PC always
3947      points at the breakpoint address, so adjusting it further would
3948      be wrong.  E.g., consider this case on a decr_pc_after_break == 1
3949      architecture:
3950
3951        B1         0x08000000 :   INSN1
3952        B2         0x08000001 :   INSN2
3953                   0x08000002 :   INSN3
3954             PC -> 0x08000003 :   INSN4
3955
3956      Say you're stopped at 0x08000003 as above.  Reverse continuing
3957      from that point should hit B2 as below.  Reading the PC when the
3958      SIGTRAP is reported should read 0x08000001 and INSN2 should have
3959      been de-executed already.
3960
3961        B1         0x08000000 :   INSN1
3962        B2   PC -> 0x08000001 :   INSN2
3963                   0x08000002 :   INSN3
3964                   0x08000003 :   INSN4
3965
3966      We can't apply the same logic as for forward execution, because
3967      we would wrongly adjust the PC to 0x08000000, since there's a
3968      breakpoint at PC - 1.  We'd then report a hit on B1, although
3969      INSN1 hadn't been de-executed yet.  Doing nothing is the correct
3970      behaviour.  */
3971   if (execution_direction == EXEC_REVERSE)
3972     return;
3973
3974   /* If the target can tell whether the thread hit a SW breakpoint,
3975      trust it.  Targets that can tell also adjust the PC
3976      themselves.  */
3977   if (target_supports_stopped_by_sw_breakpoint ())
3978     return;
3979
3980   /* Note that relying on whether a breakpoint is planted in memory to
3981      determine this can fail.  E.g,. the breakpoint could have been
3982      removed since.  Or the thread could have been told to step an
3983      instruction the size of a breakpoint instruction, and only
3984      _after_ was a breakpoint inserted at its address.  */
3985
3986   /* If this target does not decrement the PC after breakpoints, then
3987      we have nothing to do.  */
3988   regcache = get_thread_regcache (thread);
3989   gdbarch = regcache->arch ();
3990
3991   decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3992   if (decr_pc == 0)
3993     return;
3994
3995   const address_space *aspace = regcache->aspace ();
3996
3997   /* Find the location where (if we've hit a breakpoint) the
3998      breakpoint would be.  */
3999   breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
4000
4001   /* If the target can't tell whether a software breakpoint triggered,
4002      fallback to figuring it out based on breakpoints we think were
4003      inserted in the target, and on whether the thread was stepped or
4004      continued.  */
4005
4006   /* Check whether there actually is a software breakpoint inserted at
4007      that location.
4008
4009      If in non-stop mode, a race condition is possible where we've
4010      removed a breakpoint, but stop events for that breakpoint were
4011      already queued and arrive later.  To suppress those spurious
4012      SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4013      and retire them after a number of stop events are reported.  Note
4014      this is an heuristic and can thus get confused.  The real fix is
4015      to get the "stopped by SW BP and needs adjustment" info out of
4016      the target/kernel (and thus never reach here; see above).  */
4017   if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
4018       || (target_is_non_stop_p ()
4019           && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
4020     {
4021       gdb::optional<scoped_restore_tmpl<int>> restore_operation_disable;
4022
4023       if (record_full_is_used ())
4024         restore_operation_disable.emplace
4025           (record_full_gdb_operation_disable_set ());
4026
4027       /* When using hardware single-step, a SIGTRAP is reported for both
4028          a completed single-step and a software breakpoint.  Need to
4029          differentiate between the two, as the latter needs adjusting
4030          but the former does not.
4031
4032          The SIGTRAP can be due to a completed hardware single-step only if 
4033           - we didn't insert software single-step breakpoints
4034           - this thread is currently being stepped
4035
4036          If any of these events did not occur, we must have stopped due
4037          to hitting a software breakpoint, and have to back up to the
4038          breakpoint address.
4039
4040          As a special case, we could have hardware single-stepped a
4041          software breakpoint.  In this case (prev_pc == breakpoint_pc),
4042          we also need to back up to the breakpoint address.  */
4043
4044       if (thread_has_single_step_breakpoints_set (thread)
4045           || !currently_stepping (thread)
4046           || (thread->stepped_breakpoint
4047               && thread->prev_pc == breakpoint_pc))
4048         regcache_write_pc (regcache, breakpoint_pc);
4049     }
4050 }
4051
4052 static int
4053 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
4054 {
4055   for (frame = get_prev_frame (frame);
4056        frame != NULL;
4057        frame = get_prev_frame (frame))
4058     {
4059       if (frame_id_eq (get_frame_id (frame), step_frame_id))
4060         return 1;
4061       if (get_frame_type (frame) != INLINE_FRAME)
4062         break;
4063     }
4064
4065   return 0;
4066 }
4067
4068 /* If the event thread has the stop requested flag set, pretend it
4069    stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4070    target_stop).  */
4071
4072 static bool
4073 handle_stop_requested (struct execution_control_state *ecs)
4074 {
4075   if (ecs->event_thread->stop_requested)
4076     {
4077       ecs->ws.kind = TARGET_WAITKIND_STOPPED;
4078       ecs->ws.value.sig = GDB_SIGNAL_0;
4079       handle_signal_stop (ecs);
4080       return true;
4081     }
4082   return false;
4083 }
4084
4085 /* Auxiliary function that handles syscall entry/return events.
4086    It returns 1 if the inferior should keep going (and GDB
4087    should ignore the event), or 0 if the event deserves to be
4088    processed.  */
4089
4090 static int
4091 handle_syscall_event (struct execution_control_state *ecs)
4092 {
4093   struct regcache *regcache;
4094   int syscall_number;
4095
4096   context_switch (ecs);
4097
4098   regcache = get_thread_regcache (ecs->event_thread);
4099   syscall_number = ecs->ws.value.syscall_number;
4100   ecs->event_thread->suspend.stop_pc = regcache_read_pc (regcache);
4101
4102   if (catch_syscall_enabled () > 0
4103       && catching_syscall_number (syscall_number) > 0)
4104     {
4105       if (debug_infrun)
4106         fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
4107                             syscall_number);
4108
4109       ecs->event_thread->control.stop_bpstat
4110         = bpstat_stop_status (regcache->aspace (),
4111                               ecs->event_thread->suspend.stop_pc,
4112                               ecs->event_thread, &ecs->ws);
4113
4114       if (handle_stop_requested (ecs))
4115         return 0;
4116
4117       if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4118         {
4119           /* Catchpoint hit.  */
4120           return 0;
4121         }
4122     }
4123
4124   if (handle_stop_requested (ecs))
4125     return 0;
4126
4127   /* If no catchpoint triggered for this, then keep going.  */
4128   keep_going (ecs);
4129   return 1;
4130 }
4131
4132 /* Lazily fill in the execution_control_state's stop_func_* fields.  */
4133
4134 static void
4135 fill_in_stop_func (struct gdbarch *gdbarch,
4136                    struct execution_control_state *ecs)
4137 {
4138   if (!ecs->stop_func_filled_in)
4139     {
4140       /* Don't care about return value; stop_func_start and stop_func_name
4141          will both be 0 if it doesn't work.  */
4142       find_function_entry_range_from_pc (ecs->event_thread->suspend.stop_pc,
4143                                          &ecs->stop_func_name,
4144                                          &ecs->stop_func_start,
4145                                          &ecs->stop_func_end);
4146       ecs->stop_func_start
4147         += gdbarch_deprecated_function_start_offset (gdbarch);
4148
4149       if (gdbarch_skip_entrypoint_p (gdbarch))
4150         ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
4151                                                         ecs->stop_func_start);
4152
4153       ecs->stop_func_filled_in = 1;
4154     }
4155 }
4156
4157
4158 /* Return the STOP_SOON field of the inferior pointed at by ECS.  */
4159
4160 static enum stop_kind
4161 get_inferior_stop_soon (execution_control_state *ecs)
4162 {
4163   struct inferior *inf = find_inferior_ptid (ecs->ptid);
4164
4165   gdb_assert (inf != NULL);
4166   return inf->control.stop_soon;
4167 }
4168
4169 /* Wait for one event.  Store the resulting waitstatus in WS, and
4170    return the event ptid.  */
4171
4172 static ptid_t
4173 wait_one (struct target_waitstatus *ws)
4174 {
4175   ptid_t event_ptid;
4176   ptid_t wait_ptid = minus_one_ptid;
4177
4178   overlay_cache_invalid = 1;
4179
4180   /* Flush target cache before starting to handle each event.
4181      Target was running and cache could be stale.  This is just a
4182      heuristic.  Running threads may modify target memory, but we
4183      don't get any event.  */
4184   target_dcache_invalidate ();
4185
4186   if (deprecated_target_wait_hook)
4187     event_ptid = deprecated_target_wait_hook (wait_ptid, ws, 0);
4188   else
4189     event_ptid = target_wait (wait_ptid, ws, 0);
4190
4191   if (debug_infrun)
4192     print_target_wait_results (wait_ptid, event_ptid, ws);
4193
4194   return event_ptid;
4195 }
4196
4197 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4198    instead of the current thread.  */
4199 #define THREAD_STOPPED_BY(REASON)               \
4200 static int                                      \
4201 thread_stopped_by_ ## REASON (ptid_t ptid)      \
4202 {                                               \
4203   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); \
4204   inferior_ptid = ptid;                         \
4205                                                 \
4206   return target_stopped_by_ ## REASON ();       \
4207 }
4208
4209 /* Generate thread_stopped_by_watchpoint.  */
4210 THREAD_STOPPED_BY (watchpoint)
4211 /* Generate thread_stopped_by_sw_breakpoint.  */
4212 THREAD_STOPPED_BY (sw_breakpoint)
4213 /* Generate thread_stopped_by_hw_breakpoint.  */
4214 THREAD_STOPPED_BY (hw_breakpoint)
4215
4216 /* Save the thread's event and stop reason to process it later.  */
4217
4218 static void
4219 save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws)
4220 {
4221   if (debug_infrun)
4222     {
4223       std::string statstr = target_waitstatus_to_string (ws);
4224
4225       fprintf_unfiltered (gdb_stdlog,
4226                           "infrun: saving status %s for %d.%ld.%ld\n",
4227                           statstr.c_str (),
4228                           tp->ptid.pid (),
4229                           tp->ptid.lwp (),
4230                           tp->ptid.tid ());
4231     }
4232
4233   /* Record for later.  */
4234   tp->suspend.waitstatus = *ws;
4235   tp->suspend.waitstatus_pending_p = 1;
4236
4237   struct regcache *regcache = get_thread_regcache (tp);
4238   const address_space *aspace = regcache->aspace ();
4239
4240   if (ws->kind == TARGET_WAITKIND_STOPPED
4241       && ws->value.sig == GDB_SIGNAL_TRAP)
4242     {
4243       CORE_ADDR pc = regcache_read_pc (regcache);
4244
4245       adjust_pc_after_break (tp, &tp->suspend.waitstatus);
4246
4247       if (thread_stopped_by_watchpoint (tp->ptid))
4248         {
4249           tp->suspend.stop_reason
4250             = TARGET_STOPPED_BY_WATCHPOINT;
4251         }
4252       else if (target_supports_stopped_by_sw_breakpoint ()
4253                && thread_stopped_by_sw_breakpoint (tp->ptid))
4254         {
4255           tp->suspend.stop_reason
4256             = TARGET_STOPPED_BY_SW_BREAKPOINT;
4257         }
4258       else if (target_supports_stopped_by_hw_breakpoint ()
4259                && thread_stopped_by_hw_breakpoint (tp->ptid))
4260         {
4261           tp->suspend.stop_reason
4262             = TARGET_STOPPED_BY_HW_BREAKPOINT;
4263         }
4264       else if (!target_supports_stopped_by_hw_breakpoint ()
4265                && hardware_breakpoint_inserted_here_p (aspace,
4266                                                        pc))
4267         {
4268           tp->suspend.stop_reason
4269             = TARGET_STOPPED_BY_HW_BREAKPOINT;
4270         }
4271       else if (!target_supports_stopped_by_sw_breakpoint ()
4272                && software_breakpoint_inserted_here_p (aspace,
4273                                                        pc))
4274         {
4275           tp->suspend.stop_reason
4276             = TARGET_STOPPED_BY_SW_BREAKPOINT;
4277         }
4278       else if (!thread_has_single_step_breakpoints_set (tp)
4279                && currently_stepping (tp))
4280         {
4281           tp->suspend.stop_reason
4282             = TARGET_STOPPED_BY_SINGLE_STEP;
4283         }
4284     }
4285 }
4286
4287 /* A cleanup that disables thread create/exit events.  */
4288
4289 static void
4290 disable_thread_events (void *arg)
4291 {
4292   target_thread_events (0);
4293 }
4294
4295 /* See infrun.h.  */
4296
4297 void
4298 stop_all_threads (void)
4299 {
4300   /* We may need multiple passes to discover all threads.  */
4301   int pass;
4302   int iterations = 0;
4303   struct cleanup *old_chain;
4304
4305   gdb_assert (target_is_non_stop_p ());
4306
4307   if (debug_infrun)
4308     fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
4309
4310   scoped_restore_current_thread restore_thread;
4311
4312   target_thread_events (1);
4313   old_chain = make_cleanup (disable_thread_events, NULL);
4314
4315   /* Request threads to stop, and then wait for the stops.  Because
4316      threads we already know about can spawn more threads while we're
4317      trying to stop them, and we only learn about new threads when we
4318      update the thread list, do this in a loop, and keep iterating
4319      until two passes find no threads that need to be stopped.  */
4320   for (pass = 0; pass < 2; pass++, iterations++)
4321     {
4322       if (debug_infrun)
4323         fprintf_unfiltered (gdb_stdlog,
4324                             "infrun: stop_all_threads, pass=%d, "
4325                             "iterations=%d\n", pass, iterations);
4326       while (1)
4327         {
4328           ptid_t event_ptid;
4329           struct target_waitstatus ws;
4330           int need_wait = 0;
4331
4332           update_thread_list ();
4333
4334           /* Go through all threads looking for threads that we need
4335              to tell the target to stop.  */
4336           for (thread_info *t : all_non_exited_threads ())
4337             {
4338               if (t->executing)
4339                 {
4340                   /* If already stopping, don't request a stop again.
4341                      We just haven't seen the notification yet.  */
4342                   if (!t->stop_requested)
4343                     {
4344                       if (debug_infrun)
4345                         fprintf_unfiltered (gdb_stdlog,
4346                                             "infrun:   %s executing, "
4347                                             "need stop\n",
4348                                             target_pid_to_str (t->ptid));
4349                       target_stop (t->ptid);
4350                       t->stop_requested = 1;
4351                     }
4352                   else
4353                     {
4354                       if (debug_infrun)
4355                         fprintf_unfiltered (gdb_stdlog,
4356                                             "infrun:   %s executing, "
4357                                             "already stopping\n",
4358                                             target_pid_to_str (t->ptid));
4359                     }
4360
4361                   if (t->stop_requested)
4362                     need_wait = 1;
4363                 }
4364               else
4365                 {
4366                   if (debug_infrun)
4367                     fprintf_unfiltered (gdb_stdlog,
4368                                         "infrun:   %s not executing\n",
4369                                         target_pid_to_str (t->ptid));
4370
4371                   /* The thread may be not executing, but still be
4372                      resumed with a pending status to process.  */
4373                   t->resumed = 0;
4374                 }
4375             }
4376
4377           if (!need_wait)
4378             break;
4379
4380           /* If we find new threads on the second iteration, restart
4381              over.  We want to see two iterations in a row with all
4382              threads stopped.  */
4383           if (pass > 0)
4384             pass = -1;
4385
4386           event_ptid = wait_one (&ws);
4387
4388           if (ws.kind == TARGET_WAITKIND_NO_RESUMED)
4389             {
4390               /* All resumed threads exited.  */
4391             }
4392           else if (ws.kind == TARGET_WAITKIND_THREAD_EXITED
4393                    || ws.kind == TARGET_WAITKIND_EXITED
4394                    || ws.kind == TARGET_WAITKIND_SIGNALLED)
4395             {
4396               if (debug_infrun)
4397                 {
4398                   ptid_t ptid = ptid_t (ws.value.integer);
4399
4400                   fprintf_unfiltered (gdb_stdlog,
4401                                       "infrun: %s exited while "
4402                                       "stopping threads\n",
4403                                       target_pid_to_str (ptid));
4404                 }
4405             }
4406           else
4407             {
4408               thread_info *t = find_thread_ptid (event_ptid);
4409               if (t == NULL)
4410                 t = add_thread (event_ptid);
4411
4412               t->stop_requested = 0;
4413               t->executing = 0;
4414               t->resumed = 0;
4415               t->control.may_range_step = 0;
4416
4417               /* This may be the first time we see the inferior report
4418                  a stop.  */
4419               inferior *inf = find_inferior_ptid (event_ptid);
4420               if (inf->needs_setup)
4421                 {
4422                   switch_to_thread_no_regs (t);
4423                   setup_inferior (0);
4424                 }
4425
4426               if (ws.kind == TARGET_WAITKIND_STOPPED
4427                   && ws.value.sig == GDB_SIGNAL_0)
4428                 {
4429                   /* We caught the event that we intended to catch, so
4430                      there's no event pending.  */
4431                   t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
4432                   t->suspend.waitstatus_pending_p = 0;
4433
4434                   if (displaced_step_fixup (t, GDB_SIGNAL_0) < 0)
4435                     {
4436                       /* Add it back to the step-over queue.  */
4437                       if (debug_infrun)
4438                         {
4439                           fprintf_unfiltered (gdb_stdlog,
4440                                               "infrun: displaced-step of %s "
4441                                               "canceled: adding back to the "
4442                                               "step-over queue\n",
4443                                               target_pid_to_str (t->ptid));
4444                         }
4445                       t->control.trap_expected = 0;
4446                       thread_step_over_chain_enqueue (t);
4447                     }
4448                 }
4449               else
4450                 {
4451                   enum gdb_signal sig;
4452                   struct regcache *regcache;
4453
4454                   if (debug_infrun)
4455                     {
4456                       std::string statstr = target_waitstatus_to_string (&ws);
4457
4458                       fprintf_unfiltered (gdb_stdlog,
4459                                           "infrun: target_wait %s, saving "
4460                                           "status for %d.%ld.%ld\n",
4461                                           statstr.c_str (),
4462                                           t->ptid.pid (),
4463                                           t->ptid.lwp (),
4464                                           t->ptid.tid ());
4465                     }
4466
4467                   /* Record for later.  */
4468                   save_waitstatus (t, &ws);
4469
4470                   sig = (ws.kind == TARGET_WAITKIND_STOPPED
4471                          ? ws.value.sig : GDB_SIGNAL_0);
4472
4473                   if (displaced_step_fixup (t, sig) < 0)
4474                     {
4475                       /* Add it back to the step-over queue.  */
4476                       t->control.trap_expected = 0;
4477                       thread_step_over_chain_enqueue (t);
4478                     }
4479
4480                   regcache = get_thread_regcache (t);
4481                   t->suspend.stop_pc = regcache_read_pc (regcache);
4482
4483                   if (debug_infrun)
4484                     {
4485                       fprintf_unfiltered (gdb_stdlog,
4486                                           "infrun: saved stop_pc=%s for %s "
4487                                           "(currently_stepping=%d)\n",
4488                                           paddress (target_gdbarch (),
4489                                                     t->suspend.stop_pc),
4490                                           target_pid_to_str (t->ptid),
4491                                           currently_stepping (t));
4492                     }
4493                 }
4494             }
4495         }
4496     }
4497
4498   do_cleanups (old_chain);
4499
4500   if (debug_infrun)
4501     fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
4502 }
4503
4504 /* Handle a TARGET_WAITKIND_NO_RESUMED event.  */
4505
4506 static int
4507 handle_no_resumed (struct execution_control_state *ecs)
4508 {
4509   if (target_can_async_p ())
4510     {
4511       struct ui *ui;
4512       int any_sync = 0;
4513
4514       ALL_UIS (ui)
4515         {
4516           if (ui->prompt_state == PROMPT_BLOCKED)
4517             {
4518               any_sync = 1;
4519               break;
4520             }
4521         }
4522       if (!any_sync)
4523         {
4524           /* There were no unwaited-for children left in the target, but,
4525              we're not synchronously waiting for events either.  Just
4526              ignore.  */
4527
4528           if (debug_infrun)
4529             fprintf_unfiltered (gdb_stdlog,
4530                                 "infrun: TARGET_WAITKIND_NO_RESUMED "
4531                                 "(ignoring: bg)\n");
4532           prepare_to_wait (ecs);
4533           return 1;
4534         }
4535     }
4536
4537   /* Otherwise, if we were running a synchronous execution command, we
4538      may need to cancel it and give the user back the terminal.
4539
4540      In non-stop mode, the target can't tell whether we've already
4541      consumed previous stop events, so it can end up sending us a
4542      no-resumed event like so:
4543
4544        #0 - thread 1 is left stopped
4545
4546        #1 - thread 2 is resumed and hits breakpoint
4547                -> TARGET_WAITKIND_STOPPED
4548
4549        #2 - thread 3 is resumed and exits
4550             this is the last resumed thread, so
4551                -> TARGET_WAITKIND_NO_RESUMED
4552
4553        #3 - gdb processes stop for thread 2 and decides to re-resume
4554             it.
4555
4556        #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
4557             thread 2 is now resumed, so the event should be ignored.
4558
4559      IOW, if the stop for thread 2 doesn't end a foreground command,
4560      then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
4561      event.  But it could be that the event meant that thread 2 itself
4562      (or whatever other thread was the last resumed thread) exited.
4563
4564      To address this we refresh the thread list and check whether we
4565      have resumed threads _now_.  In the example above, this removes
4566      thread 3 from the thread list.  If thread 2 was re-resumed, we
4567      ignore this event.  If we find no thread resumed, then we cancel
4568      the synchronous command show "no unwaited-for " to the user.  */
4569   update_thread_list ();
4570
4571   for (thread_info *thread : all_non_exited_threads ())
4572     {
4573       if (thread->executing
4574           || thread->suspend.waitstatus_pending_p)
4575         {
4576           /* There were no unwaited-for children left in the target at
4577              some point, but there are now.  Just ignore.  */
4578           if (debug_infrun)
4579             fprintf_unfiltered (gdb_stdlog,
4580                                 "infrun: TARGET_WAITKIND_NO_RESUMED "
4581                                 "(ignoring: found resumed)\n");
4582           prepare_to_wait (ecs);
4583           return 1;
4584         }
4585     }
4586
4587   /* Note however that we may find no resumed thread because the whole
4588      process exited meanwhile (thus updating the thread list results
4589      in an empty thread list).  In this case we know we'll be getting
4590      a process exit event shortly.  */
4591   for (inferior *inf : all_inferiors ())
4592     {
4593       if (inf->pid == 0)
4594         continue;
4595
4596       thread_info *thread = any_live_thread_of_inferior (inf);
4597       if (thread == NULL)
4598         {
4599           if (debug_infrun)
4600             fprintf_unfiltered (gdb_stdlog,
4601                                 "infrun: TARGET_WAITKIND_NO_RESUMED "
4602                                 "(expect process exit)\n");
4603           prepare_to_wait (ecs);
4604           return 1;
4605         }
4606     }
4607
4608   /* Go ahead and report the event.  */
4609   return 0;
4610 }
4611
4612 /* Given an execution control state that has been freshly filled in by
4613    an event from the inferior, figure out what it means and take
4614    appropriate action.
4615
4616    The alternatives are:
4617
4618    1) stop_waiting and return; to really stop and return to the
4619    debugger.
4620
4621    2) keep_going and return; to wait for the next event (set
4622    ecs->event_thread->stepping_over_breakpoint to 1 to single step
4623    once).  */
4624
4625 static void
4626 handle_inferior_event_1 (struct execution_control_state *ecs)
4627 {
4628   enum stop_kind stop_soon;
4629
4630   if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
4631     {
4632       /* We had an event in the inferior, but we are not interested in
4633          handling it at this level.  The lower layers have already
4634          done what needs to be done, if anything.
4635
4636          One of the possible circumstances for this is when the
4637          inferior produces output for the console.  The inferior has
4638          not stopped, and we are ignoring the event.  Another possible
4639          circumstance is any event which the lower level knows will be
4640          reported multiple times without an intervening resume.  */
4641       if (debug_infrun)
4642         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
4643       prepare_to_wait (ecs);
4644       return;
4645     }
4646
4647   if (ecs->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
4648     {
4649       if (debug_infrun)
4650         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_EXITED\n");
4651       prepare_to_wait (ecs);
4652       return;
4653     }
4654
4655   if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
4656       && handle_no_resumed (ecs))
4657     return;
4658
4659   /* Cache the last pid/waitstatus.  */
4660   set_last_target_status (ecs->ptid, ecs->ws);
4661
4662   /* Always clear state belonging to the previous time we stopped.  */
4663   stop_stack_dummy = STOP_NONE;
4664
4665   if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
4666     {
4667       /* No unwaited-for children left.  IOW, all resumed children
4668          have exited.  */
4669       if (debug_infrun)
4670         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4671
4672       stop_print_frame = 0;
4673       stop_waiting (ecs);
4674       return;
4675     }
4676
4677   if (ecs->ws.kind != TARGET_WAITKIND_EXITED
4678       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
4679     {
4680       ecs->event_thread = find_thread_ptid (ecs->ptid);
4681       /* If it's a new thread, add it to the thread database.  */
4682       if (ecs->event_thread == NULL)
4683         ecs->event_thread = add_thread (ecs->ptid);
4684
4685       /* Disable range stepping.  If the next step request could use a
4686          range, this will be end up re-enabled then.  */
4687       ecs->event_thread->control.may_range_step = 0;
4688     }
4689
4690   /* Dependent on valid ECS->EVENT_THREAD.  */
4691   adjust_pc_after_break (ecs->event_thread, &ecs->ws);
4692
4693   /* Dependent on the current PC value modified by adjust_pc_after_break.  */
4694   reinit_frame_cache ();
4695
4696   breakpoint_retire_moribund ();
4697
4698   /* First, distinguish signals caused by the debugger from signals
4699      that have to do with the program's own actions.  Note that
4700      breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4701      on the operating system version.  Here we detect when a SIGILL or
4702      SIGEMT is really a breakpoint and change it to SIGTRAP.  We do
4703      something similar for SIGSEGV, since a SIGSEGV will be generated
4704      when we're trying to execute a breakpoint instruction on a
4705      non-executable stack.  This happens for call dummy breakpoints
4706      for architectures like SPARC that place call dummies on the
4707      stack.  */
4708   if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
4709       && (ecs->ws.value.sig == GDB_SIGNAL_ILL
4710           || ecs->ws.value.sig == GDB_SIGNAL_SEGV
4711           || ecs->ws.value.sig == GDB_SIGNAL_EMT))
4712     {
4713       struct regcache *regcache = get_thread_regcache (ecs->event_thread);
4714
4715       if (breakpoint_inserted_here_p (regcache->aspace (),
4716                                       regcache_read_pc (regcache)))
4717         {
4718           if (debug_infrun)
4719             fprintf_unfiltered (gdb_stdlog,
4720                                 "infrun: Treating signal as SIGTRAP\n");
4721           ecs->ws.value.sig = GDB_SIGNAL_TRAP;
4722         }
4723     }
4724
4725   /* Mark the non-executing threads accordingly.  In all-stop, all
4726      threads of all processes are stopped when we get any event
4727      reported.  In non-stop mode, only the event thread stops.  */
4728   {
4729     ptid_t mark_ptid;
4730
4731     if (!target_is_non_stop_p ())
4732       mark_ptid = minus_one_ptid;
4733     else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
4734              || ecs->ws.kind == TARGET_WAITKIND_EXITED)
4735       {
4736         /* If we're handling a process exit in non-stop mode, even
4737            though threads haven't been deleted yet, one would think
4738            that there is nothing to do, as threads of the dead process
4739            will be soon deleted, and threads of any other process were
4740            left running.  However, on some targets, threads survive a
4741            process exit event.  E.g., for the "checkpoint" command,
4742            when the current checkpoint/fork exits, linux-fork.c
4743            automatically switches to another fork from within
4744            target_mourn_inferior, by associating the same
4745            inferior/thread to another fork.  We haven't mourned yet at
4746            this point, but we must mark any threads left in the
4747            process as not-executing so that finish_thread_state marks
4748            them stopped (in the user's perspective) if/when we present
4749            the stop to the user.  */
4750         mark_ptid = ptid_t (ecs->ptid.pid ());
4751       }
4752     else
4753       mark_ptid = ecs->ptid;
4754
4755     set_executing (mark_ptid, 0);
4756
4757     /* Likewise the resumed flag.  */
4758     set_resumed (mark_ptid, 0);
4759   }
4760
4761   switch (ecs->ws.kind)
4762     {
4763     case TARGET_WAITKIND_LOADED:
4764       if (debug_infrun)
4765         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
4766       context_switch (ecs);
4767       /* Ignore gracefully during startup of the inferior, as it might
4768          be the shell which has just loaded some objects, otherwise
4769          add the symbols for the newly loaded objects.  Also ignore at
4770          the beginning of an attach or remote session; we will query
4771          the full list of libraries once the connection is
4772          established.  */
4773
4774       stop_soon = get_inferior_stop_soon (ecs);
4775       if (stop_soon == NO_STOP_QUIETLY)
4776         {
4777           struct regcache *regcache;
4778
4779           regcache = get_thread_regcache (ecs->event_thread);
4780
4781           handle_solib_event ();
4782
4783           ecs->event_thread->control.stop_bpstat
4784             = bpstat_stop_status (regcache->aspace (),
4785                                   ecs->event_thread->suspend.stop_pc,
4786                                   ecs->event_thread, &ecs->ws);
4787
4788           if (handle_stop_requested (ecs))
4789             return;
4790
4791           if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4792             {
4793               /* A catchpoint triggered.  */
4794               process_event_stop_test (ecs);
4795               return;
4796             }
4797
4798           /* If requested, stop when the dynamic linker notifies
4799              gdb of events.  This allows the user to get control
4800              and place breakpoints in initializer routines for
4801              dynamically loaded objects (among other things).  */
4802           ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4803           if (stop_on_solib_events)
4804             {
4805               /* Make sure we print "Stopped due to solib-event" in
4806                  normal_stop.  */
4807               stop_print_frame = 1;
4808
4809               stop_waiting (ecs);
4810               return;
4811             }
4812         }
4813
4814       /* If we are skipping through a shell, or through shared library
4815          loading that we aren't interested in, resume the program.  If
4816          we're running the program normally, also resume.  */
4817       if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
4818         {
4819           /* Loading of shared libraries might have changed breakpoint
4820              addresses.  Make sure new breakpoints are inserted.  */
4821           if (stop_soon == NO_STOP_QUIETLY)
4822             insert_breakpoints ();
4823           resume (GDB_SIGNAL_0);
4824           prepare_to_wait (ecs);
4825           return;
4826         }
4827
4828       /* But stop if we're attaching or setting up a remote
4829          connection.  */
4830       if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
4831           || stop_soon == STOP_QUIETLY_REMOTE)
4832         {
4833           if (debug_infrun)
4834             fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
4835           stop_waiting (ecs);
4836           return;
4837         }
4838
4839       internal_error (__FILE__, __LINE__,
4840                       _("unhandled stop_soon: %d"), (int) stop_soon);
4841
4842     case TARGET_WAITKIND_SPURIOUS:
4843       if (debug_infrun)
4844         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
4845       if (handle_stop_requested (ecs))
4846         return;
4847       context_switch (ecs);
4848       resume (GDB_SIGNAL_0);
4849       prepare_to_wait (ecs);
4850       return;
4851
4852     case TARGET_WAITKIND_THREAD_CREATED:
4853       if (debug_infrun)
4854         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_CREATED\n");
4855       if (handle_stop_requested (ecs))
4856         return;
4857       context_switch (ecs);
4858       if (!switch_back_to_stepped_thread (ecs))
4859         keep_going (ecs);
4860       return;
4861
4862     case TARGET_WAITKIND_EXITED:
4863     case TARGET_WAITKIND_SIGNALLED:
4864       if (debug_infrun)
4865         {
4866           if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
4867             fprintf_unfiltered (gdb_stdlog,
4868                                 "infrun: TARGET_WAITKIND_EXITED\n");
4869           else
4870             fprintf_unfiltered (gdb_stdlog,
4871                                 "infrun: TARGET_WAITKIND_SIGNALLED\n");
4872         }
4873
4874       inferior_ptid = ecs->ptid;
4875       set_current_inferior (find_inferior_ptid (ecs->ptid));
4876       set_current_program_space (current_inferior ()->pspace);
4877       handle_vfork_child_exec_or_exit (0);
4878       target_terminal::ours (); /* Must do this before mourn anyway.  */
4879
4880       /* Clearing any previous state of convenience variables.  */
4881       clear_exit_convenience_vars ();
4882
4883       if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
4884         {
4885           /* Record the exit code in the convenience variable $_exitcode, so
4886              that the user can inspect this again later.  */
4887           set_internalvar_integer (lookup_internalvar ("_exitcode"),
4888                                    (LONGEST) ecs->ws.value.integer);
4889
4890           /* Also record this in the inferior itself.  */
4891           current_inferior ()->has_exit_code = 1;
4892           current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
4893
4894           /* Support the --return-child-result option.  */
4895           return_child_result_value = ecs->ws.value.integer;
4896
4897           gdb::observers::exited.notify (ecs->ws.value.integer);
4898         }
4899       else
4900         {
4901           struct gdbarch *gdbarch = current_inferior ()->gdbarch;
4902
4903           if (gdbarch_gdb_signal_to_target_p (gdbarch))
4904             {
4905               /* Set the value of the internal variable $_exitsignal,
4906                  which holds the signal uncaught by the inferior.  */
4907               set_internalvar_integer (lookup_internalvar ("_exitsignal"),
4908                                        gdbarch_gdb_signal_to_target (gdbarch,
4909                                                           ecs->ws.value.sig));
4910             }
4911           else
4912             {
4913               /* We don't have access to the target's method used for
4914                  converting between signal numbers (GDB's internal
4915                  representation <-> target's representation).
4916                  Therefore, we cannot do a good job at displaying this
4917                  information to the user.  It's better to just warn
4918                  her about it (if infrun debugging is enabled), and
4919                  give up.  */
4920               if (debug_infrun)
4921                 fprintf_filtered (gdb_stdlog, _("\
4922 Cannot fill $_exitsignal with the correct signal number.\n"));
4923             }
4924
4925           gdb::observers::signal_exited.notify (ecs->ws.value.sig);
4926         }
4927
4928       gdb_flush (gdb_stdout);
4929       target_mourn_inferior (inferior_ptid);
4930       stop_print_frame = 0;
4931       stop_waiting (ecs);
4932       return;
4933
4934       /* The following are the only cases in which we keep going;
4935          the above cases end in a continue or goto.  */
4936     case TARGET_WAITKIND_FORKED:
4937     case TARGET_WAITKIND_VFORKED:
4938       if (debug_infrun)
4939         {
4940           if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
4941             fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
4942           else
4943             fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
4944         }
4945
4946       /* Check whether the inferior is displaced stepping.  */
4947       {
4948         struct regcache *regcache = get_thread_regcache (ecs->event_thread);
4949         struct gdbarch *gdbarch = regcache->arch ();
4950
4951         /* If checking displaced stepping is supported, and thread
4952            ecs->ptid is displaced stepping.  */
4953         if (displaced_step_in_progress_thread (ecs->event_thread))
4954           {
4955             struct inferior *parent_inf
4956               = find_inferior_ptid (ecs->ptid);
4957             struct regcache *child_regcache;
4958             CORE_ADDR parent_pc;
4959
4960             /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
4961                indicating that the displaced stepping of syscall instruction
4962                has been done.  Perform cleanup for parent process here.  Note
4963                that this operation also cleans up the child process for vfork,
4964                because their pages are shared.  */
4965             displaced_step_fixup (ecs->event_thread, GDB_SIGNAL_TRAP);
4966             /* Start a new step-over in another thread if there's one
4967                that needs it.  */
4968             start_step_over ();
4969
4970             if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
4971               {
4972                 struct displaced_step_inferior_state *displaced
4973                   = get_displaced_stepping_state (parent_inf);
4974
4975                 /* Restore scratch pad for child process.  */
4976                 displaced_step_restore (displaced, ecs->ws.value.related_pid);
4977               }
4978
4979             /* Since the vfork/fork syscall instruction was executed in the scratchpad,
4980                the child's PC is also within the scratchpad.  Set the child's PC
4981                to the parent's PC value, which has already been fixed up.
4982                FIXME: we use the parent's aspace here, although we're touching
4983                the child, because the child hasn't been added to the inferior
4984                list yet at this point.  */
4985
4986             child_regcache
4987               = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
4988                                                  gdbarch,
4989                                                  parent_inf->aspace);
4990             /* Read PC value of parent process.  */
4991             parent_pc = regcache_read_pc (regcache);
4992
4993             if (debug_displaced)
4994               fprintf_unfiltered (gdb_stdlog,
4995                                   "displaced: write child pc from %s to %s\n",
4996                                   paddress (gdbarch,
4997                                             regcache_read_pc (child_regcache)),
4998                                   paddress (gdbarch, parent_pc));
4999
5000             regcache_write_pc (child_regcache, parent_pc);
5001           }
5002       }
5003
5004       context_switch (ecs);
5005
5006       /* Immediately detach breakpoints from the child before there's
5007          any chance of letting the user delete breakpoints from the
5008          breakpoint lists.  If we don't do this early, it's easy to
5009          leave left over traps in the child, vis: "break foo; catch
5010          fork; c; <fork>; del; c; <child calls foo>".  We only follow
5011          the fork on the last `continue', and by that time the
5012          breakpoint at "foo" is long gone from the breakpoint table.
5013          If we vforked, then we don't need to unpatch here, since both
5014          parent and child are sharing the same memory pages; we'll
5015          need to unpatch at follow/detach time instead to be certain
5016          that new breakpoints added between catchpoint hit time and
5017          vfork follow are detached.  */
5018       if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
5019         {
5020           /* This won't actually modify the breakpoint list, but will
5021              physically remove the breakpoints from the child.  */
5022           detach_breakpoints (ecs->ws.value.related_pid);
5023         }
5024
5025       delete_just_stopped_threads_single_step_breakpoints ();
5026
5027       /* In case the event is caught by a catchpoint, remember that
5028          the event is to be followed at the next resume of the thread,
5029          and not immediately.  */
5030       ecs->event_thread->pending_follow = ecs->ws;
5031
5032       ecs->event_thread->suspend.stop_pc
5033         = regcache_read_pc (get_thread_regcache (ecs->event_thread));
5034
5035       ecs->event_thread->control.stop_bpstat
5036         = bpstat_stop_status (get_current_regcache ()->aspace (),
5037                               ecs->event_thread->suspend.stop_pc,
5038                               ecs->event_thread, &ecs->ws);
5039
5040       if (handle_stop_requested (ecs))
5041         return;
5042
5043       /* If no catchpoint triggered for this, then keep going.  Note
5044          that we're interested in knowing the bpstat actually causes a
5045          stop, not just if it may explain the signal.  Software
5046          watchpoints, for example, always appear in the bpstat.  */
5047       if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5048         {
5049           int should_resume;
5050           int follow_child
5051             = (follow_fork_mode_string == follow_fork_mode_child);
5052
5053           ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5054
5055           should_resume = follow_fork ();
5056
5057           thread_info *parent = ecs->event_thread;
5058           thread_info *child = find_thread_ptid (ecs->ws.value.related_pid);
5059
5060           /* At this point, the parent is marked running, and the
5061              child is marked stopped.  */
5062
5063           /* If not resuming the parent, mark it stopped.  */
5064           if (follow_child && !detach_fork && !non_stop && !sched_multi)
5065             parent->set_running (false);
5066
5067           /* If resuming the child, mark it running.  */
5068           if (follow_child || (!detach_fork && (non_stop || sched_multi)))
5069             child->set_running (true);
5070
5071           /* In non-stop mode, also resume the other branch.  */
5072           if (!detach_fork && (non_stop
5073                                || (sched_multi && target_is_non_stop_p ())))
5074             {
5075               if (follow_child)
5076                 switch_to_thread (parent);
5077               else
5078                 switch_to_thread (child);
5079
5080               ecs->event_thread = inferior_thread ();
5081               ecs->ptid = inferior_ptid;
5082               keep_going (ecs);
5083             }
5084
5085           if (follow_child)
5086             switch_to_thread (child);
5087           else
5088             switch_to_thread (parent);
5089
5090           ecs->event_thread = inferior_thread ();
5091           ecs->ptid = inferior_ptid;
5092
5093           if (should_resume)
5094             keep_going (ecs);
5095           else
5096             stop_waiting (ecs);
5097           return;
5098         }
5099       process_event_stop_test (ecs);
5100       return;
5101
5102     case TARGET_WAITKIND_VFORK_DONE:
5103       /* Done with the shared memory region.  Re-insert breakpoints in
5104          the parent, and keep going.  */
5105
5106       if (debug_infrun)
5107         fprintf_unfiltered (gdb_stdlog,
5108                             "infrun: TARGET_WAITKIND_VFORK_DONE\n");
5109
5110       context_switch (ecs);
5111
5112       current_inferior ()->waiting_for_vfork_done = 0;
5113       current_inferior ()->pspace->breakpoints_not_allowed = 0;
5114
5115       if (handle_stop_requested (ecs))
5116         return;
5117
5118       /* This also takes care of reinserting breakpoints in the
5119          previously locked inferior.  */
5120       keep_going (ecs);
5121       return;
5122
5123     case TARGET_WAITKIND_EXECD:
5124       if (debug_infrun)
5125         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
5126
5127       /* Note we can't read registers yet (the stop_pc), because we
5128          don't yet know the inferior's post-exec architecture.
5129          'stop_pc' is explicitly read below instead.  */
5130       switch_to_thread_no_regs (ecs->event_thread);
5131
5132       /* Do whatever is necessary to the parent branch of the vfork.  */
5133       handle_vfork_child_exec_or_exit (1);
5134
5135       /* This causes the eventpoints and symbol table to be reset.
5136          Must do this now, before trying to determine whether to
5137          stop.  */
5138       follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
5139
5140       /* In follow_exec we may have deleted the original thread and
5141          created a new one.  Make sure that the event thread is the
5142          execd thread for that case (this is a nop otherwise).  */
5143       ecs->event_thread = inferior_thread ();
5144
5145       ecs->event_thread->suspend.stop_pc
5146         = regcache_read_pc (get_thread_regcache (ecs->event_thread));
5147
5148       ecs->event_thread->control.stop_bpstat
5149         = bpstat_stop_status (get_current_regcache ()->aspace (),
5150                               ecs->event_thread->suspend.stop_pc,
5151                               ecs->event_thread, &ecs->ws);
5152
5153       /* Note that this may be referenced from inside
5154          bpstat_stop_status above, through inferior_has_execd.  */
5155       xfree (ecs->ws.value.execd_pathname);
5156       ecs->ws.value.execd_pathname = NULL;
5157
5158       if (handle_stop_requested (ecs))
5159         return;
5160
5161       /* If no catchpoint triggered for this, then keep going.  */
5162       if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5163         {
5164           ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5165           keep_going (ecs);
5166           return;
5167         }
5168       process_event_stop_test (ecs);
5169       return;
5170
5171       /* Be careful not to try to gather much state about a thread
5172          that's in a syscall.  It's frequently a losing proposition.  */
5173     case TARGET_WAITKIND_SYSCALL_ENTRY:
5174       if (debug_infrun)
5175         fprintf_unfiltered (gdb_stdlog,
5176                             "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
5177       /* Getting the current syscall number.  */
5178       if (handle_syscall_event (ecs) == 0)
5179         process_event_stop_test (ecs);
5180       return;
5181
5182       /* Before examining the threads further, step this thread to
5183          get it entirely out of the syscall.  (We get notice of the
5184          event when the thread is just on the verge of exiting a
5185          syscall.  Stepping one instruction seems to get it back
5186          into user code.)  */
5187     case TARGET_WAITKIND_SYSCALL_RETURN:
5188       if (debug_infrun)
5189         fprintf_unfiltered (gdb_stdlog,
5190                             "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5191       if (handle_syscall_event (ecs) == 0)
5192         process_event_stop_test (ecs);
5193       return;
5194
5195     case TARGET_WAITKIND_STOPPED:
5196       if (debug_infrun)
5197         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
5198       handle_signal_stop (ecs);
5199       return;
5200
5201     case TARGET_WAITKIND_NO_HISTORY:
5202       if (debug_infrun)
5203         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5204       /* Reverse execution: target ran out of history info.  */
5205
5206       /* Switch to the stopped thread.  */
5207       context_switch (ecs);
5208       if (debug_infrun)
5209         fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
5210
5211       delete_just_stopped_threads_single_step_breakpoints ();
5212       ecs->event_thread->suspend.stop_pc
5213         = regcache_read_pc (get_thread_regcache (inferior_thread ()));
5214
5215       if (handle_stop_requested (ecs))
5216         return;
5217
5218       gdb::observers::no_history.notify ();
5219       stop_waiting (ecs);
5220       return;
5221     }
5222 }
5223
5224 /* A wrapper around handle_inferior_event_1, which also makes sure
5225    that all temporary struct value objects that were created during
5226    the handling of the event get deleted at the end.  */
5227
5228 static void
5229 handle_inferior_event (struct execution_control_state *ecs)
5230 {
5231   struct value *mark = value_mark ();
5232
5233   handle_inferior_event_1 (ecs);
5234   /* Purge all temporary values created during the event handling,
5235      as it could be a long time before we return to the command level
5236      where such values would otherwise be purged.  */
5237   value_free_to_mark (mark);
5238 }
5239
5240 /* Restart threads back to what they were trying to do back when we
5241    paused them for an in-line step-over.  The EVENT_THREAD thread is
5242    ignored.  */
5243
5244 static void
5245 restart_threads (struct thread_info *event_thread)
5246 {
5247   /* In case the instruction just stepped spawned a new thread.  */
5248   update_thread_list ();
5249
5250   for (thread_info *tp : all_non_exited_threads ())
5251     {
5252       if (tp == event_thread)
5253         {
5254           if (debug_infrun)
5255             fprintf_unfiltered (gdb_stdlog,
5256                                 "infrun: restart threads: "
5257                                 "[%s] is event thread\n",
5258                                 target_pid_to_str (tp->ptid));
5259           continue;
5260         }
5261
5262       if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
5263         {
5264           if (debug_infrun)
5265             fprintf_unfiltered (gdb_stdlog,
5266                                 "infrun: restart threads: "
5267                                 "[%s] not meant to be running\n",
5268                                 target_pid_to_str (tp->ptid));
5269           continue;
5270         }
5271
5272       if (tp->resumed)
5273         {
5274           if (debug_infrun)
5275             fprintf_unfiltered (gdb_stdlog,
5276                                 "infrun: restart threads: [%s] resumed\n",
5277                                 target_pid_to_str (tp->ptid));
5278           gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
5279           continue;
5280         }
5281
5282       if (thread_is_in_step_over_chain (tp))
5283         {
5284           if (debug_infrun)
5285             fprintf_unfiltered (gdb_stdlog,
5286                                 "infrun: restart threads: "
5287                                 "[%s] needs step-over\n",
5288                                 target_pid_to_str (tp->ptid));
5289           gdb_assert (!tp->resumed);
5290           continue;
5291         }
5292
5293
5294       if (tp->suspend.waitstatus_pending_p)
5295         {
5296           if (debug_infrun)
5297             fprintf_unfiltered (gdb_stdlog,
5298                                 "infrun: restart threads: "
5299                                 "[%s] has pending status\n",
5300                                 target_pid_to_str (tp->ptid));
5301           tp->resumed = 1;
5302           continue;
5303         }
5304
5305       gdb_assert (!tp->stop_requested);
5306
5307       /* If some thread needs to start a step-over at this point, it
5308          should still be in the step-over queue, and thus skipped
5309          above.  */
5310       if (thread_still_needs_step_over (tp))
5311         {
5312           internal_error (__FILE__, __LINE__,
5313                           "thread [%s] needs a step-over, but not in "
5314                           "step-over queue\n",
5315                           target_pid_to_str (tp->ptid));
5316         }
5317
5318       if (currently_stepping (tp))
5319         {
5320           if (debug_infrun)
5321             fprintf_unfiltered (gdb_stdlog,
5322                                 "infrun: restart threads: [%s] was stepping\n",
5323                                 target_pid_to_str (tp->ptid));
5324           keep_going_stepped_thread (tp);
5325         }
5326       else
5327         {
5328           struct execution_control_state ecss;
5329           struct execution_control_state *ecs = &ecss;
5330
5331           if (debug_infrun)
5332             fprintf_unfiltered (gdb_stdlog,
5333                                 "infrun: restart threads: [%s] continuing\n",
5334                                 target_pid_to_str (tp->ptid));
5335           reset_ecs (ecs, tp);
5336           switch_to_thread (tp);
5337           keep_going_pass_signal (ecs);
5338         }
5339     }
5340 }
5341
5342 /* Callback for iterate_over_threads.  Find a resumed thread that has
5343    a pending waitstatus.  */
5344
5345 static int
5346 resumed_thread_with_pending_status (struct thread_info *tp,
5347                                     void *arg)
5348 {
5349   return (tp->resumed
5350           && tp->suspend.waitstatus_pending_p);
5351 }
5352
5353 /* Called when we get an event that may finish an in-line or
5354    out-of-line (displaced stepping) step-over started previously.
5355    Return true if the event is processed and we should go back to the
5356    event loop; false if the caller should continue processing the
5357    event.  */
5358
5359 static int
5360 finish_step_over (struct execution_control_state *ecs)
5361 {
5362   int had_step_over_info;
5363
5364   displaced_step_fixup (ecs->event_thread,
5365                         ecs->event_thread->suspend.stop_signal);
5366
5367   had_step_over_info = step_over_info_valid_p ();
5368
5369   if (had_step_over_info)
5370     {
5371       /* If we're stepping over a breakpoint with all threads locked,
5372          then only the thread that was stepped should be reporting
5373          back an event.  */
5374       gdb_assert (ecs->event_thread->control.trap_expected);
5375
5376       clear_step_over_info ();
5377     }
5378
5379   if (!target_is_non_stop_p ())
5380     return 0;
5381
5382   /* Start a new step-over in another thread if there's one that
5383      needs it.  */
5384   start_step_over ();
5385
5386   /* If we were stepping over a breakpoint before, and haven't started
5387      a new in-line step-over sequence, then restart all other threads
5388      (except the event thread).  We can't do this in all-stop, as then
5389      e.g., we wouldn't be able to issue any other remote packet until
5390      these other threads stop.  */
5391   if (had_step_over_info && !step_over_info_valid_p ())
5392     {
5393       struct thread_info *pending;
5394
5395       /* If we only have threads with pending statuses, the restart
5396          below won't restart any thread and so nothing re-inserts the
5397          breakpoint we just stepped over.  But we need it inserted
5398          when we later process the pending events, otherwise if
5399          another thread has a pending event for this breakpoint too,
5400          we'd discard its event (because the breakpoint that
5401          originally caused the event was no longer inserted).  */
5402       context_switch (ecs);
5403       insert_breakpoints ();
5404
5405       restart_threads (ecs->event_thread);
5406
5407       /* If we have events pending, go through handle_inferior_event
5408          again, picking up a pending event at random.  This avoids
5409          thread starvation.  */
5410
5411       /* But not if we just stepped over a watchpoint in order to let
5412          the instruction execute so we can evaluate its expression.
5413          The set of watchpoints that triggered is recorded in the
5414          breakpoint objects themselves (see bp->watchpoint_triggered).
5415          If we processed another event first, that other event could
5416          clobber this info.  */
5417       if (ecs->event_thread->stepping_over_watchpoint)
5418         return 0;
5419
5420       pending = iterate_over_threads (resumed_thread_with_pending_status,
5421                                       NULL);
5422       if (pending != NULL)
5423         {
5424           struct thread_info *tp = ecs->event_thread;
5425           struct regcache *regcache;
5426
5427           if (debug_infrun)
5428             {
5429               fprintf_unfiltered (gdb_stdlog,
5430                                   "infrun: found resumed threads with "
5431                                   "pending events, saving status\n");
5432             }
5433
5434           gdb_assert (pending != tp);
5435
5436           /* Record the event thread's event for later.  */
5437           save_waitstatus (tp, &ecs->ws);
5438           /* This was cleared early, by handle_inferior_event.  Set it
5439              so this pending event is considered by
5440              do_target_wait.  */
5441           tp->resumed = 1;
5442
5443           gdb_assert (!tp->executing);
5444
5445           regcache = get_thread_regcache (tp);
5446           tp->suspend.stop_pc = regcache_read_pc (regcache);
5447
5448           if (debug_infrun)
5449             {
5450               fprintf_unfiltered (gdb_stdlog,
5451                                   "infrun: saved stop_pc=%s for %s "
5452                                   "(currently_stepping=%d)\n",
5453                                   paddress (target_gdbarch (),
5454                                             tp->suspend.stop_pc),
5455                                   target_pid_to_str (tp->ptid),
5456                                   currently_stepping (tp));
5457             }
5458
5459           /* This in-line step-over finished; clear this so we won't
5460              start a new one.  This is what handle_signal_stop would
5461              do, if we returned false.  */
5462           tp->stepping_over_breakpoint = 0;
5463
5464           /* Wake up the event loop again.  */
5465           mark_async_event_handler (infrun_async_inferior_event_token);
5466
5467           prepare_to_wait (ecs);
5468           return 1;
5469         }
5470     }
5471
5472   return 0;
5473 }
5474
5475 /* Come here when the program has stopped with a signal.  */
5476
5477 static void
5478 handle_signal_stop (struct execution_control_state *ecs)
5479 {
5480   struct frame_info *frame;
5481   struct gdbarch *gdbarch;
5482   int stopped_by_watchpoint;
5483   enum stop_kind stop_soon;
5484   int random_signal;
5485
5486   gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
5487
5488   ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
5489
5490   /* Do we need to clean up the state of a thread that has
5491      completed a displaced single-step?  (Doing so usually affects
5492      the PC, so do it here, before we set stop_pc.)  */
5493   if (finish_step_over (ecs))
5494     return;
5495
5496   /* If we either finished a single-step or hit a breakpoint, but
5497      the user wanted this thread to be stopped, pretend we got a
5498      SIG0 (generic unsignaled stop).  */
5499   if (ecs->event_thread->stop_requested
5500       && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5501     ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5502
5503   ecs->event_thread->suspend.stop_pc
5504     = regcache_read_pc (get_thread_regcache (ecs->event_thread));
5505
5506   if (debug_infrun)
5507     {
5508       struct regcache *regcache = get_thread_regcache (ecs->event_thread);
5509       struct gdbarch *reg_gdbarch = regcache->arch ();
5510       scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
5511
5512       inferior_ptid = ecs->ptid;
5513
5514       fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
5515                           paddress (reg_gdbarch,
5516                                     ecs->event_thread->suspend.stop_pc));
5517       if (target_stopped_by_watchpoint ())
5518         {
5519           CORE_ADDR addr;
5520
5521           fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
5522
5523           if (target_stopped_data_address (current_top_target (), &addr))
5524             fprintf_unfiltered (gdb_stdlog,
5525                                 "infrun: stopped data address = %s\n",
5526                                 paddress (reg_gdbarch, addr));
5527           else
5528             fprintf_unfiltered (gdb_stdlog,
5529                                 "infrun: (no data address available)\n");
5530         }
5531     }
5532
5533   /* This is originated from start_remote(), start_inferior() and
5534      shared libraries hook functions.  */
5535   stop_soon = get_inferior_stop_soon (ecs);
5536   if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
5537     {
5538       context_switch (ecs);
5539       if (debug_infrun)
5540         fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
5541       stop_print_frame = 1;
5542       stop_waiting (ecs);
5543       return;
5544     }
5545
5546   /* This originates from attach_command().  We need to overwrite
5547      the stop_signal here, because some kernels don't ignore a
5548      SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5549      See more comments in inferior.h.  On the other hand, if we
5550      get a non-SIGSTOP, report it to the user - assume the backend
5551      will handle the SIGSTOP if it should show up later.
5552
5553      Also consider that the attach is complete when we see a
5554      SIGTRAP.  Some systems (e.g. Windows), and stubs supporting
5555      target extended-remote report it instead of a SIGSTOP
5556      (e.g. gdbserver).  We already rely on SIGTRAP being our
5557      signal, so this is no exception.
5558
5559      Also consider that the attach is complete when we see a
5560      GDB_SIGNAL_0.  In non-stop mode, GDB will explicitly tell
5561      the target to stop all threads of the inferior, in case the
5562      low level attach operation doesn't stop them implicitly.  If
5563      they weren't stopped implicitly, then the stub will report a
5564      GDB_SIGNAL_0, meaning: stopped for no particular reason
5565      other than GDB's request.  */
5566   if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5567       && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
5568           || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5569           || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
5570     {
5571       stop_print_frame = 1;
5572       stop_waiting (ecs);
5573       ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5574       return;
5575     }
5576
5577   /* See if something interesting happened to the non-current thread.  If
5578      so, then switch to that thread.  */
5579   if (ecs->ptid != inferior_ptid)
5580     {
5581       if (debug_infrun)
5582         fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
5583
5584       context_switch (ecs);
5585
5586       if (deprecated_context_hook)
5587         deprecated_context_hook (ecs->event_thread->global_num);
5588     }
5589
5590   /* At this point, get hold of the now-current thread's frame.  */
5591   frame = get_current_frame ();
5592   gdbarch = get_frame_arch (frame);
5593
5594   /* Pull the single step breakpoints out of the target.  */
5595   if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5596     {
5597       struct regcache *regcache;
5598       CORE_ADDR pc;
5599
5600       regcache = get_thread_regcache (ecs->event_thread);
5601       const address_space *aspace = regcache->aspace ();
5602
5603       pc = regcache_read_pc (regcache);
5604
5605       /* However, before doing so, if this single-step breakpoint was
5606          actually for another thread, set this thread up for moving
5607          past it.  */
5608       if (!thread_has_single_step_breakpoint_here (ecs->event_thread,
5609                                                    aspace, pc))
5610         {
5611           if (single_step_breakpoint_inserted_here_p (aspace, pc))
5612             {
5613               if (debug_infrun)
5614                 {
5615                   fprintf_unfiltered (gdb_stdlog,
5616                                       "infrun: [%s] hit another thread's "
5617                                       "single-step breakpoint\n",
5618                                       target_pid_to_str (ecs->ptid));
5619                 }
5620               ecs->hit_singlestep_breakpoint = 1;
5621             }
5622         }
5623       else
5624         {
5625           if (debug_infrun)
5626             {
5627               fprintf_unfiltered (gdb_stdlog,
5628                                   "infrun: [%s] hit its "
5629                                   "single-step breakpoint\n",
5630                                   target_pid_to_str (ecs->ptid));
5631             }
5632         }
5633     }
5634   delete_just_stopped_threads_single_step_breakpoints ();
5635
5636   if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5637       && ecs->event_thread->control.trap_expected
5638       && ecs->event_thread->stepping_over_watchpoint)
5639     stopped_by_watchpoint = 0;
5640   else
5641     stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
5642
5643   /* If necessary, step over this watchpoint.  We'll be back to display
5644      it in a moment.  */
5645   if (stopped_by_watchpoint
5646       && (target_have_steppable_watchpoint
5647           || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
5648     {
5649       /* At this point, we are stopped at an instruction which has
5650          attempted to write to a piece of memory under control of
5651          a watchpoint.  The instruction hasn't actually executed
5652          yet.  If we were to evaluate the watchpoint expression
5653          now, we would get the old value, and therefore no change
5654          would seem to have occurred.
5655
5656          In order to make watchpoints work `right', we really need
5657          to complete the memory write, and then evaluate the
5658          watchpoint expression.  We do this by single-stepping the
5659          target.
5660
5661          It may not be necessary to disable the watchpoint to step over
5662          it.  For example, the PA can (with some kernel cooperation)
5663          single step over a watchpoint without disabling the watchpoint.
5664
5665          It is far more common to need to disable a watchpoint to step
5666          the inferior over it.  If we have non-steppable watchpoints,
5667          we must disable the current watchpoint; it's simplest to
5668          disable all watchpoints.
5669
5670          Any breakpoint at PC must also be stepped over -- if there's
5671          one, it will have already triggered before the watchpoint
5672          triggered, and we either already reported it to the user, or
5673          it didn't cause a stop and we called keep_going.  In either
5674          case, if there was a breakpoint at PC, we must be trying to
5675          step past it.  */
5676       ecs->event_thread->stepping_over_watchpoint = 1;
5677       keep_going (ecs);
5678       return;
5679     }
5680
5681   ecs->event_thread->stepping_over_breakpoint = 0;
5682   ecs->event_thread->stepping_over_watchpoint = 0;
5683   bpstat_clear (&ecs->event_thread->control.stop_bpstat);
5684   ecs->event_thread->control.stop_step = 0;
5685   stop_print_frame = 1;
5686   stopped_by_random_signal = 0;
5687   bpstat stop_chain = NULL;
5688
5689   /* Hide inlined functions starting here, unless we just performed stepi or
5690      nexti.  After stepi and nexti, always show the innermost frame (not any
5691      inline function call sites).  */
5692   if (ecs->event_thread->control.step_range_end != 1)
5693     {
5694       const address_space *aspace
5695         = get_thread_regcache (ecs->event_thread)->aspace ();
5696
5697       /* skip_inline_frames is expensive, so we avoid it if we can
5698          determine that the address is one where functions cannot have
5699          been inlined.  This improves performance with inferiors that
5700          load a lot of shared libraries, because the solib event
5701          breakpoint is defined as the address of a function (i.e. not
5702          inline).  Note that we have to check the previous PC as well
5703          as the current one to catch cases when we have just
5704          single-stepped off a breakpoint prior to reinstating it.
5705          Note that we're assuming that the code we single-step to is
5706          not inline, but that's not definitive: there's nothing
5707          preventing the event breakpoint function from containing
5708          inlined code, and the single-step ending up there.  If the
5709          user had set a breakpoint on that inlined code, the missing
5710          skip_inline_frames call would break things.  Fortunately
5711          that's an extremely unlikely scenario.  */
5712       if (!pc_at_non_inline_function (aspace,
5713                                       ecs->event_thread->suspend.stop_pc,
5714                                       &ecs->ws)
5715           && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5716                && ecs->event_thread->control.trap_expected
5717                && pc_at_non_inline_function (aspace,
5718                                              ecs->event_thread->prev_pc,
5719                                              &ecs->ws)))
5720         {
5721           stop_chain = build_bpstat_chain (aspace,
5722                                            ecs->event_thread->suspend.stop_pc,
5723                                            &ecs->ws);
5724           skip_inline_frames (ecs->event_thread, stop_chain);
5725
5726           /* Re-fetch current thread's frame in case that invalidated
5727              the frame cache.  */
5728           frame = get_current_frame ();
5729           gdbarch = get_frame_arch (frame);
5730         }
5731     }
5732
5733   if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5734       && ecs->event_thread->control.trap_expected
5735       && gdbarch_single_step_through_delay_p (gdbarch)
5736       && currently_stepping (ecs->event_thread))
5737     {
5738       /* We're trying to step off a breakpoint.  Turns out that we're
5739          also on an instruction that needs to be stepped multiple
5740          times before it's been fully executing.  E.g., architectures
5741          with a delay slot.  It needs to be stepped twice, once for
5742          the instruction and once for the delay slot.  */
5743       int step_through_delay
5744         = gdbarch_single_step_through_delay (gdbarch, frame);
5745
5746       if (debug_infrun && step_through_delay)
5747         fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
5748       if (ecs->event_thread->control.step_range_end == 0
5749           && step_through_delay)
5750         {
5751           /* The user issued a continue when stopped at a breakpoint.
5752              Set up for another trap and get out of here.  */
5753          ecs->event_thread->stepping_over_breakpoint = 1;
5754          keep_going (ecs);
5755          return;
5756         }
5757       else if (step_through_delay)
5758         {
5759           /* The user issued a step when stopped at a breakpoint.
5760              Maybe we should stop, maybe we should not - the delay
5761              slot *might* correspond to a line of source.  In any
5762              case, don't decide that here, just set 
5763              ecs->stepping_over_breakpoint, making sure we 
5764              single-step again before breakpoints are re-inserted.  */
5765           ecs->event_thread->stepping_over_breakpoint = 1;
5766         }
5767     }
5768
5769   /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5770      handles this event.  */
5771   ecs->event_thread->control.stop_bpstat
5772     = bpstat_stop_status (get_current_regcache ()->aspace (),
5773                           ecs->event_thread->suspend.stop_pc,
5774                           ecs->event_thread, &ecs->ws, stop_chain);
5775
5776   /* Following in case break condition called a
5777      function.  */
5778   stop_print_frame = 1;
5779
5780   /* This is where we handle "moribund" watchpoints.  Unlike
5781      software breakpoints traps, hardware watchpoint traps are
5782      always distinguishable from random traps.  If no high-level
5783      watchpoint is associated with the reported stop data address
5784      anymore, then the bpstat does not explain the signal ---
5785      simply make sure to ignore it if `stopped_by_watchpoint' is
5786      set.  */
5787
5788   if (debug_infrun
5789       && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5790       && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5791                                   GDB_SIGNAL_TRAP)
5792       && stopped_by_watchpoint)
5793     fprintf_unfiltered (gdb_stdlog,
5794                         "infrun: no user watchpoint explains "
5795                         "watchpoint SIGTRAP, ignoring\n");
5796
5797   /* NOTE: cagney/2003-03-29: These checks for a random signal
5798      at one stage in the past included checks for an inferior
5799      function call's call dummy's return breakpoint.  The original
5800      comment, that went with the test, read:
5801
5802      ``End of a stack dummy.  Some systems (e.g. Sony news) give
5803      another signal besides SIGTRAP, so check here as well as
5804      above.''
5805
5806      If someone ever tries to get call dummys on a
5807      non-executable stack to work (where the target would stop
5808      with something like a SIGSEGV), then those tests might need
5809      to be re-instated.  Given, however, that the tests were only
5810      enabled when momentary breakpoints were not being used, I
5811      suspect that it won't be the case.
5812
5813      NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5814      be necessary for call dummies on a non-executable stack on
5815      SPARC.  */
5816
5817   /* See if the breakpoints module can explain the signal.  */
5818   random_signal
5819     = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5820                                ecs->event_thread->suspend.stop_signal);
5821
5822   /* Maybe this was a trap for a software breakpoint that has since
5823      been removed.  */
5824   if (random_signal && target_stopped_by_sw_breakpoint ())
5825     {
5826       if (program_breakpoint_here_p (gdbarch,
5827                                      ecs->event_thread->suspend.stop_pc))
5828         {
5829           struct regcache *regcache;
5830           int decr_pc;
5831
5832           /* Re-adjust PC to what the program would see if GDB was not
5833              debugging it.  */
5834           regcache = get_thread_regcache (ecs->event_thread);
5835           decr_pc = gdbarch_decr_pc_after_break (gdbarch);
5836           if (decr_pc != 0)
5837             {
5838               gdb::optional<scoped_restore_tmpl<int>>
5839                 restore_operation_disable;
5840
5841               if (record_full_is_used ())
5842                 restore_operation_disable.emplace
5843                   (record_full_gdb_operation_disable_set ());
5844
5845               regcache_write_pc (regcache,
5846                                  ecs->event_thread->suspend.stop_pc + decr_pc);
5847             }
5848         }
5849       else
5850         {
5851           /* A delayed software breakpoint event.  Ignore the trap.  */
5852           if (debug_infrun)
5853             fprintf_unfiltered (gdb_stdlog,
5854                                 "infrun: delayed software breakpoint "
5855                                 "trap, ignoring\n");
5856           random_signal = 0;
5857         }
5858     }
5859
5860   /* Maybe this was a trap for a hardware breakpoint/watchpoint that
5861      has since been removed.  */
5862   if (random_signal && target_stopped_by_hw_breakpoint ())
5863     {
5864       /* A delayed hardware breakpoint event.  Ignore the trap.  */
5865       if (debug_infrun)
5866         fprintf_unfiltered (gdb_stdlog,
5867                             "infrun: delayed hardware breakpoint/watchpoint "
5868                             "trap, ignoring\n");
5869       random_signal = 0;
5870     }
5871
5872   /* If not, perhaps stepping/nexting can.  */
5873   if (random_signal)
5874     random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5875                       && currently_stepping (ecs->event_thread));
5876
5877   /* Perhaps the thread hit a single-step breakpoint of _another_
5878      thread.  Single-step breakpoints are transparent to the
5879      breakpoints module.  */
5880   if (random_signal)
5881     random_signal = !ecs->hit_singlestep_breakpoint;
5882
5883   /* No?  Perhaps we got a moribund watchpoint.  */
5884   if (random_signal)
5885     random_signal = !stopped_by_watchpoint;
5886
5887   /* Always stop if the user explicitly requested this thread to
5888      remain stopped.  */
5889   if (ecs->event_thread->stop_requested)
5890     {
5891       random_signal = 1;
5892       if (debug_infrun)
5893         fprintf_unfiltered (gdb_stdlog, "infrun: user-requested stop\n");
5894     }
5895
5896   /* For the program's own signals, act according to
5897      the signal handling tables.  */
5898
5899   if (random_signal)
5900     {
5901       /* Signal not for debugging purposes.  */
5902       struct inferior *inf = find_inferior_ptid (ecs->ptid);
5903       enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
5904
5905       if (debug_infrun)
5906          fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
5907                              gdb_signal_to_symbol_string (stop_signal));
5908
5909       stopped_by_random_signal = 1;
5910
5911       /* Always stop on signals if we're either just gaining control
5912          of the program, or the user explicitly requested this thread
5913          to remain stopped.  */
5914       if (stop_soon != NO_STOP_QUIETLY
5915           || ecs->event_thread->stop_requested
5916           || (!inf->detaching
5917               && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
5918         {
5919           stop_waiting (ecs);
5920           return;
5921         }
5922
5923       /* Notify observers the signal has "handle print" set.  Note we
5924          returned early above if stopping; normal_stop handles the
5925          printing in that case.  */
5926       if (signal_print[ecs->event_thread->suspend.stop_signal])
5927         {
5928           /* The signal table tells us to print about this signal.  */
5929           target_terminal::ours_for_output ();
5930           gdb::observers::signal_received.notify (ecs->event_thread->suspend.stop_signal);
5931           target_terminal::inferior ();
5932         }
5933
5934       /* Clear the signal if it should not be passed.  */
5935       if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
5936         ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5937
5938       if (ecs->event_thread->prev_pc == ecs->event_thread->suspend.stop_pc
5939           && ecs->event_thread->control.trap_expected
5940           && ecs->event_thread->control.step_resume_breakpoint == NULL)
5941         {
5942           /* We were just starting a new sequence, attempting to
5943              single-step off of a breakpoint and expecting a SIGTRAP.
5944              Instead this signal arrives.  This signal will take us out
5945              of the stepping range so GDB needs to remember to, when
5946              the signal handler returns, resume stepping off that
5947              breakpoint.  */
5948           /* To simplify things, "continue" is forced to use the same
5949              code paths as single-step - set a breakpoint at the
5950              signal return address and then, once hit, step off that
5951              breakpoint.  */
5952           if (debug_infrun)
5953             fprintf_unfiltered (gdb_stdlog,
5954                                 "infrun: signal arrived while stepping over "
5955                                 "breakpoint\n");
5956
5957           insert_hp_step_resume_breakpoint_at_frame (frame);
5958           ecs->event_thread->step_after_step_resume_breakpoint = 1;
5959           /* Reset trap_expected to ensure breakpoints are re-inserted.  */
5960           ecs->event_thread->control.trap_expected = 0;
5961
5962           /* If we were nexting/stepping some other thread, switch to
5963              it, so that we don't continue it, losing control.  */
5964           if (!switch_back_to_stepped_thread (ecs))
5965             keep_going (ecs);
5966           return;
5967         }
5968
5969       if (ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
5970           && (pc_in_thread_step_range (ecs->event_thread->suspend.stop_pc,
5971                                        ecs->event_thread)
5972               || ecs->event_thread->control.step_range_end == 1)
5973           && frame_id_eq (get_stack_frame_id (frame),
5974                           ecs->event_thread->control.step_stack_frame_id)
5975           && ecs->event_thread->control.step_resume_breakpoint == NULL)
5976         {
5977           /* The inferior is about to take a signal that will take it
5978              out of the single step range.  Set a breakpoint at the
5979              current PC (which is presumably where the signal handler
5980              will eventually return) and then allow the inferior to
5981              run free.
5982
5983              Note that this is only needed for a signal delivered
5984              while in the single-step range.  Nested signals aren't a
5985              problem as they eventually all return.  */
5986           if (debug_infrun)
5987             fprintf_unfiltered (gdb_stdlog,
5988                                 "infrun: signal may take us out of "
5989                                 "single-step range\n");
5990
5991           clear_step_over_info ();
5992           insert_hp_step_resume_breakpoint_at_frame (frame);
5993           ecs->event_thread->step_after_step_resume_breakpoint = 1;
5994           /* Reset trap_expected to ensure breakpoints are re-inserted.  */
5995           ecs->event_thread->control.trap_expected = 0;
5996           keep_going (ecs);
5997           return;
5998         }
5999
6000       /* Note: step_resume_breakpoint may be non-NULL.  This occures
6001          when either there's a nested signal, or when there's a
6002          pending signal enabled just as the signal handler returns
6003          (leaving the inferior at the step-resume-breakpoint without
6004          actually executing it).  Either way continue until the
6005          breakpoint is really hit.  */
6006
6007       if (!switch_back_to_stepped_thread (ecs))
6008         {
6009           if (debug_infrun)
6010             fprintf_unfiltered (gdb_stdlog,
6011                                 "infrun: random signal, keep going\n");
6012
6013           keep_going (ecs);
6014         }
6015       return;
6016     }
6017
6018   process_event_stop_test (ecs);
6019 }
6020
6021 /* Come here when we've got some debug event / signal we can explain
6022    (IOW, not a random signal), and test whether it should cause a
6023    stop, or whether we should resume the inferior (transparently).
6024    E.g., could be a breakpoint whose condition evaluates false; we
6025    could be still stepping within the line; etc.  */
6026
6027 static void
6028 process_event_stop_test (struct execution_control_state *ecs)
6029 {
6030   struct symtab_and_line stop_pc_sal;
6031   struct frame_info *frame;
6032   struct gdbarch *gdbarch;
6033   CORE_ADDR jmp_buf_pc;
6034   struct bpstat_what what;
6035
6036   /* Handle cases caused by hitting a breakpoint.  */
6037
6038   frame = get_current_frame ();
6039   gdbarch = get_frame_arch (frame);
6040
6041   what = bpstat_what (ecs->event_thread->control.stop_bpstat);
6042
6043   if (what.call_dummy)
6044     {
6045       stop_stack_dummy = what.call_dummy;
6046     }
6047
6048   /* A few breakpoint types have callbacks associated (e.g.,
6049      bp_jit_event).  Run them now.  */
6050   bpstat_run_callbacks (ecs->event_thread->control.stop_bpstat);
6051
6052   /* If we hit an internal event that triggers symbol changes, the
6053      current frame will be invalidated within bpstat_what (e.g., if we
6054      hit an internal solib event).  Re-fetch it.  */
6055   frame = get_current_frame ();
6056   gdbarch = get_frame_arch (frame);
6057
6058   switch (what.main_action)
6059     {
6060     case BPSTAT_WHAT_SET_LONGJMP_RESUME:
6061       /* If we hit the breakpoint at longjmp while stepping, we
6062          install a momentary breakpoint at the target of the
6063          jmp_buf.  */
6064
6065       if (debug_infrun)
6066         fprintf_unfiltered (gdb_stdlog,
6067                             "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
6068
6069       ecs->event_thread->stepping_over_breakpoint = 1;
6070
6071       if (what.is_longjmp)
6072         {
6073           struct value *arg_value;
6074
6075           /* If we set the longjmp breakpoint via a SystemTap probe,
6076              then use it to extract the arguments.  The destination PC
6077              is the third argument to the probe.  */
6078           arg_value = probe_safe_evaluate_at_pc (frame, 2);
6079           if (arg_value)
6080             {
6081               jmp_buf_pc = value_as_address (arg_value);
6082               jmp_buf_pc = gdbarch_addr_bits_remove (gdbarch, jmp_buf_pc);
6083             }
6084           else if (!gdbarch_get_longjmp_target_p (gdbarch)
6085                    || !gdbarch_get_longjmp_target (gdbarch,
6086                                                    frame, &jmp_buf_pc))
6087             {
6088               if (debug_infrun)
6089                 fprintf_unfiltered (gdb_stdlog,
6090                                     "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
6091                                     "(!gdbarch_get_longjmp_target)\n");
6092               keep_going (ecs);
6093               return;
6094             }
6095
6096           /* Insert a breakpoint at resume address.  */
6097           insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
6098         }
6099       else
6100         check_exception_resume (ecs, frame);
6101       keep_going (ecs);
6102       return;
6103
6104     case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
6105       {
6106         struct frame_info *init_frame;
6107
6108         /* There are several cases to consider.
6109
6110            1. The initiating frame no longer exists.  In this case we
6111            must stop, because the exception or longjmp has gone too
6112            far.
6113
6114            2. The initiating frame exists, and is the same as the
6115            current frame.  We stop, because the exception or longjmp
6116            has been caught.
6117
6118            3. The initiating frame exists and is different from the
6119            current frame.  This means the exception or longjmp has
6120            been caught beneath the initiating frame, so keep going.
6121
6122            4. longjmp breakpoint has been placed just to protect
6123            against stale dummy frames and user is not interested in
6124            stopping around longjmps.  */
6125
6126         if (debug_infrun)
6127           fprintf_unfiltered (gdb_stdlog,
6128                               "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
6129
6130         gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
6131                     != NULL);
6132         delete_exception_resume_breakpoint (ecs->event_thread);
6133
6134         if (what.is_longjmp)
6135           {
6136             check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
6137
6138             if (!frame_id_p (ecs->event_thread->initiating_frame))
6139               {
6140                 /* Case 4.  */
6141                 keep_going (ecs);
6142                 return;
6143               }
6144           }
6145
6146         init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
6147
6148         if (init_frame)
6149           {
6150             struct frame_id current_id
6151               = get_frame_id (get_current_frame ());
6152             if (frame_id_eq (current_id,
6153                              ecs->event_thread->initiating_frame))
6154               {
6155                 /* Case 2.  Fall through.  */
6156               }
6157             else
6158               {
6159                 /* Case 3.  */
6160                 keep_going (ecs);
6161                 return;
6162               }
6163           }
6164
6165         /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6166            exists.  */
6167         delete_step_resume_breakpoint (ecs->event_thread);
6168
6169         end_stepping_range (ecs);
6170       }
6171       return;
6172
6173     case BPSTAT_WHAT_SINGLE:
6174       if (debug_infrun)
6175         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
6176       ecs->event_thread->stepping_over_breakpoint = 1;
6177       /* Still need to check other stuff, at least the case where we
6178          are stepping and step out of the right range.  */
6179       break;
6180
6181     case BPSTAT_WHAT_STEP_RESUME:
6182       if (debug_infrun)
6183         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6184
6185       delete_step_resume_breakpoint (ecs->event_thread);
6186       if (ecs->event_thread->control.proceed_to_finish
6187           && execution_direction == EXEC_REVERSE)
6188         {
6189           struct thread_info *tp = ecs->event_thread;
6190
6191           /* We are finishing a function in reverse, and just hit the
6192              step-resume breakpoint at the start address of the
6193              function, and we're almost there -- just need to back up
6194              by one more single-step, which should take us back to the
6195              function call.  */
6196           tp->control.step_range_start = tp->control.step_range_end = 1;
6197           keep_going (ecs);
6198           return;
6199         }
6200       fill_in_stop_func (gdbarch, ecs);
6201       if (ecs->event_thread->suspend.stop_pc == ecs->stop_func_start
6202           && execution_direction == EXEC_REVERSE)
6203         {
6204           /* We are stepping over a function call in reverse, and just
6205              hit the step-resume breakpoint at the start address of
6206              the function.  Go back to single-stepping, which should
6207              take us back to the function call.  */
6208           ecs->event_thread->stepping_over_breakpoint = 1;
6209           keep_going (ecs);
6210           return;
6211         }
6212       break;
6213
6214     case BPSTAT_WHAT_STOP_NOISY:
6215       if (debug_infrun)
6216         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6217       stop_print_frame = 1;
6218
6219       /* Assume the thread stopped for a breapoint.  We'll still check
6220          whether a/the breakpoint is there when the thread is next
6221          resumed.  */
6222       ecs->event_thread->stepping_over_breakpoint = 1;
6223
6224       stop_waiting (ecs);
6225       return;
6226
6227     case BPSTAT_WHAT_STOP_SILENT:
6228       if (debug_infrun)
6229         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6230       stop_print_frame = 0;
6231
6232       /* Assume the thread stopped for a breapoint.  We'll still check
6233          whether a/the breakpoint is there when the thread is next
6234          resumed.  */
6235       ecs->event_thread->stepping_over_breakpoint = 1;
6236       stop_waiting (ecs);
6237       return;
6238
6239     case BPSTAT_WHAT_HP_STEP_RESUME:
6240       if (debug_infrun)
6241         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6242
6243       delete_step_resume_breakpoint (ecs->event_thread);
6244       if (ecs->event_thread->step_after_step_resume_breakpoint)
6245         {
6246           /* Back when the step-resume breakpoint was inserted, we
6247              were trying to single-step off a breakpoint.  Go back to
6248              doing that.  */
6249           ecs->event_thread->step_after_step_resume_breakpoint = 0;
6250           ecs->event_thread->stepping_over_breakpoint = 1;
6251           keep_going (ecs);
6252           return;
6253         }
6254       break;
6255
6256     case BPSTAT_WHAT_KEEP_CHECKING:
6257       break;
6258     }
6259
6260   /* If we stepped a permanent breakpoint and we had a high priority
6261      step-resume breakpoint for the address we stepped, but we didn't
6262      hit it, then we must have stepped into the signal handler.  The
6263      step-resume was only necessary to catch the case of _not_
6264      stepping into the handler, so delete it, and fall through to
6265      checking whether the step finished.  */
6266   if (ecs->event_thread->stepped_breakpoint)
6267     {
6268       struct breakpoint *sr_bp
6269         = ecs->event_thread->control.step_resume_breakpoint;
6270
6271       if (sr_bp != NULL
6272           && sr_bp->loc->permanent
6273           && sr_bp->type == bp_hp_step_resume
6274           && sr_bp->loc->address == ecs->event_thread->prev_pc)
6275         {
6276           if (debug_infrun)
6277             fprintf_unfiltered (gdb_stdlog,
6278                                 "infrun: stepped permanent breakpoint, stopped in "
6279                                 "handler\n");
6280           delete_step_resume_breakpoint (ecs->event_thread);
6281           ecs->event_thread->step_after_step_resume_breakpoint = 0;
6282         }
6283     }
6284
6285   /* We come here if we hit a breakpoint but should not stop for it.
6286      Possibly we also were stepping and should stop for that.  So fall
6287      through and test for stepping.  But, if not stepping, do not
6288      stop.  */
6289
6290   /* In all-stop mode, if we're currently stepping but have stopped in
6291      some other thread, we need to switch back to the stepped thread.  */
6292   if (switch_back_to_stepped_thread (ecs))
6293     return;
6294
6295   if (ecs->event_thread->control.step_resume_breakpoint)
6296     {
6297       if (debug_infrun)
6298          fprintf_unfiltered (gdb_stdlog,
6299                              "infrun: step-resume breakpoint is inserted\n");
6300
6301       /* Having a step-resume breakpoint overrides anything
6302          else having to do with stepping commands until
6303          that breakpoint is reached.  */
6304       keep_going (ecs);
6305       return;
6306     }
6307
6308   if (ecs->event_thread->control.step_range_end == 0)
6309     {
6310       if (debug_infrun)
6311          fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
6312       /* Likewise if we aren't even stepping.  */
6313       keep_going (ecs);
6314       return;
6315     }
6316
6317   /* Re-fetch current thread's frame in case the code above caused
6318      the frame cache to be re-initialized, making our FRAME variable
6319      a dangling pointer.  */
6320   frame = get_current_frame ();
6321   gdbarch = get_frame_arch (frame);
6322   fill_in_stop_func (gdbarch, ecs);
6323
6324   /* If stepping through a line, keep going if still within it.
6325
6326      Note that step_range_end is the address of the first instruction
6327      beyond the step range, and NOT the address of the last instruction
6328      within it!
6329
6330      Note also that during reverse execution, we may be stepping
6331      through a function epilogue and therefore must detect when
6332      the current-frame changes in the middle of a line.  */
6333
6334   if (pc_in_thread_step_range (ecs->event_thread->suspend.stop_pc,
6335                                ecs->event_thread)
6336       && (execution_direction != EXEC_REVERSE
6337           || frame_id_eq (get_frame_id (frame),
6338                           ecs->event_thread->control.step_frame_id)))
6339     {
6340       if (debug_infrun)
6341         fprintf_unfiltered
6342           (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
6343            paddress (gdbarch, ecs->event_thread->control.step_range_start),
6344            paddress (gdbarch, ecs->event_thread->control.step_range_end));
6345
6346       /* Tentatively re-enable range stepping; `resume' disables it if
6347          necessary (e.g., if we're stepping over a breakpoint or we
6348          have software watchpoints).  */
6349       ecs->event_thread->control.may_range_step = 1;
6350
6351       /* When stepping backward, stop at beginning of line range
6352          (unless it's the function entry point, in which case
6353          keep going back to the call point).  */
6354       CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6355       if (stop_pc == ecs->event_thread->control.step_range_start
6356           && stop_pc != ecs->stop_func_start
6357           && execution_direction == EXEC_REVERSE)
6358         end_stepping_range (ecs);
6359       else
6360         keep_going (ecs);
6361
6362       return;
6363     }
6364
6365   /* We stepped out of the stepping range.  */
6366
6367   /* If we are stepping at the source level and entered the runtime
6368      loader dynamic symbol resolution code...
6369
6370      EXEC_FORWARD: we keep on single stepping until we exit the run
6371      time loader code and reach the callee's address.
6372
6373      EXEC_REVERSE: we've already executed the callee (backward), and
6374      the runtime loader code is handled just like any other
6375      undebuggable function call.  Now we need only keep stepping
6376      backward through the trampoline code, and that's handled further
6377      down, so there is nothing for us to do here.  */
6378
6379   if (execution_direction != EXEC_REVERSE
6380       && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6381       && in_solib_dynsym_resolve_code (ecs->event_thread->suspend.stop_pc))
6382     {
6383       CORE_ADDR pc_after_resolver =
6384         gdbarch_skip_solib_resolver (gdbarch,
6385                                      ecs->event_thread->suspend.stop_pc);
6386
6387       if (debug_infrun)
6388          fprintf_unfiltered (gdb_stdlog,
6389                              "infrun: stepped into dynsym resolve code\n");
6390
6391       if (pc_after_resolver)
6392         {
6393           /* Set up a step-resume breakpoint at the address
6394              indicated by SKIP_SOLIB_RESOLVER.  */
6395           symtab_and_line sr_sal;
6396           sr_sal.pc = pc_after_resolver;
6397           sr_sal.pspace = get_frame_program_space (frame);
6398
6399           insert_step_resume_breakpoint_at_sal (gdbarch,
6400                                                 sr_sal, null_frame_id);
6401         }
6402
6403       keep_going (ecs);
6404       return;
6405     }
6406
6407   /* Step through an indirect branch thunk.  */
6408   if (ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
6409       && gdbarch_in_indirect_branch_thunk (gdbarch,
6410                                            ecs->event_thread->suspend.stop_pc))
6411     {
6412       if (debug_infrun)
6413          fprintf_unfiltered (gdb_stdlog,
6414                              "infrun: stepped into indirect branch thunk\n");
6415       keep_going (ecs);
6416       return;
6417     }
6418
6419   if (ecs->event_thread->control.step_range_end != 1
6420       && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6421           || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6422       && get_frame_type (frame) == SIGTRAMP_FRAME)
6423     {
6424       if (debug_infrun)
6425          fprintf_unfiltered (gdb_stdlog,
6426                              "infrun: stepped into signal trampoline\n");
6427       /* The inferior, while doing a "step" or "next", has ended up in
6428          a signal trampoline (either by a signal being delivered or by
6429          the signal handler returning).  Just single-step until the
6430          inferior leaves the trampoline (either by calling the handler
6431          or returning).  */
6432       keep_going (ecs);
6433       return;
6434     }
6435
6436   /* If we're in the return path from a shared library trampoline,
6437      we want to proceed through the trampoline when stepping.  */
6438   /* macro/2012-04-25: This needs to come before the subroutine
6439      call check below as on some targets return trampolines look
6440      like subroutine calls (MIPS16 return thunks).  */
6441   if (gdbarch_in_solib_return_trampoline (gdbarch,
6442                                           ecs->event_thread->suspend.stop_pc,
6443                                           ecs->stop_func_name)
6444       && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6445     {
6446       /* Determine where this trampoline returns.  */
6447       CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6448       CORE_ADDR real_stop_pc
6449         = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6450
6451       if (debug_infrun)
6452          fprintf_unfiltered (gdb_stdlog,
6453                              "infrun: stepped into solib return tramp\n");
6454
6455       /* Only proceed through if we know where it's going.  */
6456       if (real_stop_pc)
6457         {
6458           /* And put the step-breakpoint there and go until there.  */
6459           symtab_and_line sr_sal;
6460           sr_sal.pc = real_stop_pc;
6461           sr_sal.section = find_pc_overlay (sr_sal.pc);
6462           sr_sal.pspace = get_frame_program_space (frame);
6463
6464           /* Do not specify what the fp should be when we stop since
6465              on some machines the prologue is where the new fp value
6466              is established.  */
6467           insert_step_resume_breakpoint_at_sal (gdbarch,
6468                                                 sr_sal, null_frame_id);
6469
6470           /* Restart without fiddling with the step ranges or
6471              other state.  */
6472           keep_going (ecs);
6473           return;
6474         }
6475     }
6476
6477   /* Check for subroutine calls.  The check for the current frame
6478      equalling the step ID is not necessary - the check of the
6479      previous frame's ID is sufficient - but it is a common case and
6480      cheaper than checking the previous frame's ID.
6481
6482      NOTE: frame_id_eq will never report two invalid frame IDs as
6483      being equal, so to get into this block, both the current and
6484      previous frame must have valid frame IDs.  */
6485   /* The outer_frame_id check is a heuristic to detect stepping
6486      through startup code.  If we step over an instruction which
6487      sets the stack pointer from an invalid value to a valid value,
6488      we may detect that as a subroutine call from the mythical
6489      "outermost" function.  This could be fixed by marking
6490      outermost frames as !stack_p,code_p,special_p.  Then the
6491      initial outermost frame, before sp was valid, would
6492      have code_addr == &_start.  See the comment in frame_id_eq
6493      for more.  */
6494   if (!frame_id_eq (get_stack_frame_id (frame),
6495                     ecs->event_thread->control.step_stack_frame_id)
6496       && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6497                        ecs->event_thread->control.step_stack_frame_id)
6498           && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
6499                             outer_frame_id)
6500               || (ecs->event_thread->control.step_start_function
6501                   != find_pc_function (ecs->event_thread->suspend.stop_pc)))))
6502     {
6503       CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6504       CORE_ADDR real_stop_pc;
6505
6506       if (debug_infrun)
6507          fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
6508
6509       if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
6510         {
6511           /* I presume that step_over_calls is only 0 when we're
6512              supposed to be stepping at the assembly language level
6513              ("stepi").  Just stop.  */
6514           /* And this works the same backward as frontward.  MVS */
6515           end_stepping_range (ecs);
6516           return;
6517         }
6518
6519       /* Reverse stepping through solib trampolines.  */
6520
6521       if (execution_direction == EXEC_REVERSE
6522           && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
6523           && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6524               || (ecs->stop_func_start == 0
6525                   && in_solib_dynsym_resolve_code (stop_pc))))
6526         {
6527           /* Any solib trampoline code can be handled in reverse
6528              by simply continuing to single-step.  We have already
6529              executed the solib function (backwards), and a few 
6530              steps will take us back through the trampoline to the
6531              caller.  */
6532           keep_going (ecs);
6533           return;
6534         }
6535
6536       if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6537         {
6538           /* We're doing a "next".
6539
6540              Normal (forward) execution: set a breakpoint at the
6541              callee's return address (the address at which the caller
6542              will resume).
6543
6544              Reverse (backward) execution.  set the step-resume
6545              breakpoint at the start of the function that we just
6546              stepped into (backwards), and continue to there.  When we
6547              get there, we'll need to single-step back to the caller.  */
6548
6549           if (execution_direction == EXEC_REVERSE)
6550             {
6551               /* If we're already at the start of the function, we've either
6552                  just stepped backward into a single instruction function,
6553                  or stepped back out of a signal handler to the first instruction
6554                  of the function.  Just keep going, which will single-step back
6555                  to the caller.  */
6556               if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
6557                 {
6558                   /* Normal function call return (static or dynamic).  */
6559                   symtab_and_line sr_sal;
6560                   sr_sal.pc = ecs->stop_func_start;
6561                   sr_sal.pspace = get_frame_program_space (frame);
6562                   insert_step_resume_breakpoint_at_sal (gdbarch,
6563                                                         sr_sal, null_frame_id);
6564                 }
6565             }
6566           else
6567             insert_step_resume_breakpoint_at_caller (frame);
6568
6569           keep_going (ecs);
6570           return;
6571         }
6572
6573       /* If we are in a function call trampoline (a stub between the
6574          calling routine and the real function), locate the real
6575          function.  That's what tells us (a) whether we want to step
6576          into it at all, and (b) what prologue we want to run to the
6577          end of, if we do step into it.  */
6578       real_stop_pc = skip_language_trampoline (frame, stop_pc);
6579       if (real_stop_pc == 0)
6580         real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6581       if (real_stop_pc != 0)
6582         ecs->stop_func_start = real_stop_pc;
6583
6584       if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
6585         {
6586           symtab_and_line sr_sal;
6587           sr_sal.pc = ecs->stop_func_start;
6588           sr_sal.pspace = get_frame_program_space (frame);
6589
6590           insert_step_resume_breakpoint_at_sal (gdbarch,
6591                                                 sr_sal, null_frame_id);
6592           keep_going (ecs);
6593           return;
6594         }
6595
6596       /* If we have line number information for the function we are
6597          thinking of stepping into and the function isn't on the skip
6598          list, step into it.
6599
6600          If there are several symtabs at that PC (e.g. with include
6601          files), just want to know whether *any* of them have line
6602          numbers.  find_pc_line handles this.  */
6603       {
6604         struct symtab_and_line tmp_sal;
6605
6606         tmp_sal = find_pc_line (ecs->stop_func_start, 0);
6607         if (tmp_sal.line != 0
6608             && !function_name_is_marked_for_skip (ecs->stop_func_name,
6609                                                   tmp_sal))
6610           {
6611             if (execution_direction == EXEC_REVERSE)
6612               handle_step_into_function_backward (gdbarch, ecs);
6613             else
6614               handle_step_into_function (gdbarch, ecs);
6615             return;
6616           }
6617       }
6618
6619       /* If we have no line number and the step-stop-if-no-debug is
6620          set, we stop the step so that the user has a chance to switch
6621          in assembly mode.  */
6622       if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6623           && step_stop_if_no_debug)
6624         {
6625           end_stepping_range (ecs);
6626           return;
6627         }
6628
6629       if (execution_direction == EXEC_REVERSE)
6630         {
6631           /* If we're already at the start of the function, we've either just
6632              stepped backward into a single instruction function without line
6633              number info, or stepped back out of a signal handler to the first
6634              instruction of the function without line number info.  Just keep
6635              going, which will single-step back to the caller.  */
6636           if (ecs->stop_func_start != stop_pc)
6637             {
6638               /* Set a breakpoint at callee's start address.
6639                  From there we can step once and be back in the caller.  */
6640               symtab_and_line sr_sal;
6641               sr_sal.pc = ecs->stop_func_start;
6642               sr_sal.pspace = get_frame_program_space (frame);
6643               insert_step_resume_breakpoint_at_sal (gdbarch,
6644                                                     sr_sal, null_frame_id);
6645             }
6646         }
6647       else
6648         /* Set a breakpoint at callee's return address (the address
6649            at which the caller will resume).  */
6650         insert_step_resume_breakpoint_at_caller (frame);
6651
6652       keep_going (ecs);
6653       return;
6654     }
6655
6656   /* Reverse stepping through solib trampolines.  */
6657
6658   if (execution_direction == EXEC_REVERSE
6659       && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6660     {
6661       CORE_ADDR stop_pc = ecs->event_thread->suspend.stop_pc;
6662
6663       if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6664           || (ecs->stop_func_start == 0
6665               && in_solib_dynsym_resolve_code (stop_pc)))
6666         {
6667           /* Any solib trampoline code can be handled in reverse
6668              by simply continuing to single-step.  We have already
6669              executed the solib function (backwards), and a few 
6670              steps will take us back through the trampoline to the
6671              caller.  */
6672           keep_going (ecs);
6673           return;
6674         }
6675       else if (in_solib_dynsym_resolve_code (stop_pc))
6676         {
6677           /* Stepped backward into the solib dynsym resolver.
6678              Set a breakpoint at its start and continue, then
6679              one more step will take us out.  */
6680           symtab_and_line sr_sal;
6681           sr_sal.pc = ecs->stop_func_start;
6682           sr_sal.pspace = get_frame_program_space (frame);
6683           insert_step_resume_breakpoint_at_sal (gdbarch, 
6684                                                 sr_sal, null_frame_id);
6685           keep_going (ecs);
6686           return;
6687         }
6688     }
6689
6690   stop_pc_sal = find_pc_line (ecs->event_thread->suspend.stop_pc, 0);
6691
6692   /* NOTE: tausq/2004-05-24: This if block used to be done before all
6693      the trampoline processing logic, however, there are some trampolines 
6694      that have no names, so we should do trampoline handling first.  */
6695   if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6696       && ecs->stop_func_name == NULL
6697       && stop_pc_sal.line == 0)
6698     {
6699       if (debug_infrun)
6700          fprintf_unfiltered (gdb_stdlog,
6701                              "infrun: stepped into undebuggable function\n");
6702
6703       /* The inferior just stepped into, or returned to, an
6704          undebuggable function (where there is no debugging information
6705          and no line number corresponding to the address where the
6706          inferior stopped).  Since we want to skip this kind of code,
6707          we keep going until the inferior returns from this
6708          function - unless the user has asked us not to (via
6709          set step-mode) or we no longer know how to get back
6710          to the call site.  */
6711       if (step_stop_if_no_debug
6712           || !frame_id_p (frame_unwind_caller_id (frame)))
6713         {
6714           /* If we have no line number and the step-stop-if-no-debug
6715              is set, we stop the step so that the user has a chance to
6716              switch in assembly mode.  */
6717           end_stepping_range (ecs);
6718           return;
6719         }
6720       else
6721         {
6722           /* Set a breakpoint at callee's return address (the address
6723              at which the caller will resume).  */
6724           insert_step_resume_breakpoint_at_caller (frame);
6725           keep_going (ecs);
6726           return;
6727         }
6728     }
6729
6730   if (ecs->event_thread->control.step_range_end == 1)
6731     {
6732       /* It is stepi or nexti.  We always want to stop stepping after
6733          one instruction.  */
6734       if (debug_infrun)
6735          fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
6736       end_stepping_range (ecs);
6737       return;
6738     }
6739
6740   if (stop_pc_sal.line == 0)
6741     {
6742       /* We have no line number information.  That means to stop
6743          stepping (does this always happen right after one instruction,
6744          when we do "s" in a function with no line numbers,
6745          or can this happen as a result of a return or longjmp?).  */
6746       if (debug_infrun)
6747          fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
6748       end_stepping_range (ecs);
6749       return;
6750     }
6751
6752   /* Look for "calls" to inlined functions, part one.  If the inline
6753      frame machinery detected some skipped call sites, we have entered
6754      a new inline function.  */
6755
6756   if (frame_id_eq (get_frame_id (get_current_frame ()),
6757                    ecs->event_thread->control.step_frame_id)
6758       && inline_skipped_frames (ecs->event_thread))
6759     {
6760       if (debug_infrun)
6761         fprintf_unfiltered (gdb_stdlog,
6762                             "infrun: stepped into inlined function\n");
6763
6764       symtab_and_line call_sal = find_frame_sal (get_current_frame ());
6765
6766       if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
6767         {
6768           /* For "step", we're going to stop.  But if the call site
6769              for this inlined function is on the same source line as
6770              we were previously stepping, go down into the function
6771              first.  Otherwise stop at the call site.  */
6772
6773           if (call_sal.line == ecs->event_thread->current_line
6774               && call_sal.symtab == ecs->event_thread->current_symtab)
6775             step_into_inline_frame (ecs->event_thread);
6776
6777           end_stepping_range (ecs);
6778           return;
6779         }
6780       else
6781         {
6782           /* For "next", we should stop at the call site if it is on a
6783              different source line.  Otherwise continue through the
6784              inlined function.  */
6785           if (call_sal.line == ecs->event_thread->current_line
6786               && call_sal.symtab == ecs->event_thread->current_symtab)
6787             keep_going (ecs);
6788           else
6789             end_stepping_range (ecs);
6790           return;
6791         }
6792     }
6793
6794   /* Look for "calls" to inlined functions, part two.  If we are still
6795      in the same real function we were stepping through, but we have
6796      to go further up to find the exact frame ID, we are stepping
6797      through a more inlined call beyond its call site.  */
6798
6799   if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6800       && !frame_id_eq (get_frame_id (get_current_frame ()),
6801                        ecs->event_thread->control.step_frame_id)
6802       && stepped_in_from (get_current_frame (),
6803                           ecs->event_thread->control.step_frame_id))
6804     {
6805       if (debug_infrun)
6806         fprintf_unfiltered (gdb_stdlog,
6807                             "infrun: stepping through inlined function\n");
6808
6809       if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6810         keep_going (ecs);
6811       else
6812         end_stepping_range (ecs);
6813       return;
6814     }
6815
6816   if ((ecs->event_thread->suspend.stop_pc == stop_pc_sal.pc)
6817       && (ecs->event_thread->current_line != stop_pc_sal.line
6818           || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
6819     {
6820       /* We are at the start of a different line.  So stop.  Note that
6821          we don't stop if we step into the middle of a different line.
6822          That is said to make things like for (;;) statements work
6823          better.  */
6824       if (debug_infrun)
6825          fprintf_unfiltered (gdb_stdlog,
6826                              "infrun: stepped to a different line\n");
6827       end_stepping_range (ecs);
6828       return;
6829     }
6830
6831   /* We aren't done stepping.
6832
6833      Optimize by setting the stepping range to the line.
6834      (We might not be in the original line, but if we entered a
6835      new line in mid-statement, we continue stepping.  This makes
6836      things like for(;;) statements work better.)  */
6837
6838   ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
6839   ecs->event_thread->control.step_range_end = stop_pc_sal.end;
6840   ecs->event_thread->control.may_range_step = 1;
6841   set_step_info (frame, stop_pc_sal);
6842
6843   if (debug_infrun)
6844      fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
6845   keep_going (ecs);
6846 }
6847
6848 /* In all-stop mode, if we're currently stepping but have stopped in
6849    some other thread, we may need to switch back to the stepped
6850    thread.  Returns true we set the inferior running, false if we left
6851    it stopped (and the event needs further processing).  */
6852
6853 static int
6854 switch_back_to_stepped_thread (struct execution_control_state *ecs)
6855 {
6856   if (!target_is_non_stop_p ())
6857     {
6858       struct thread_info *stepping_thread;
6859
6860       /* If any thread is blocked on some internal breakpoint, and we
6861          simply need to step over that breakpoint to get it going
6862          again, do that first.  */
6863
6864       /* However, if we see an event for the stepping thread, then we
6865          know all other threads have been moved past their breakpoints
6866          already.  Let the caller check whether the step is finished,
6867          etc., before deciding to move it past a breakpoint.  */
6868       if (ecs->event_thread->control.step_range_end != 0)
6869         return 0;
6870
6871       /* Check if the current thread is blocked on an incomplete
6872          step-over, interrupted by a random signal.  */
6873       if (ecs->event_thread->control.trap_expected
6874           && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
6875         {
6876           if (debug_infrun)
6877             {
6878               fprintf_unfiltered (gdb_stdlog,
6879                                   "infrun: need to finish step-over of [%s]\n",
6880                                   target_pid_to_str (ecs->event_thread->ptid));
6881             }
6882           keep_going (ecs);
6883           return 1;
6884         }
6885
6886       /* Check if the current thread is blocked by a single-step
6887          breakpoint of another thread.  */
6888       if (ecs->hit_singlestep_breakpoint)
6889        {
6890          if (debug_infrun)
6891            {
6892              fprintf_unfiltered (gdb_stdlog,
6893                                  "infrun: need to step [%s] over single-step "
6894                                  "breakpoint\n",
6895                                  target_pid_to_str (ecs->ptid));
6896            }
6897          keep_going (ecs);
6898          return 1;
6899        }
6900
6901       /* If this thread needs yet another step-over (e.g., stepping
6902          through a delay slot), do it first before moving on to
6903          another thread.  */
6904       if (thread_still_needs_step_over (ecs->event_thread))
6905         {
6906           if (debug_infrun)
6907             {
6908               fprintf_unfiltered (gdb_stdlog,
6909                                   "infrun: thread [%s] still needs step-over\n",
6910                                   target_pid_to_str (ecs->event_thread->ptid));
6911             }
6912           keep_going (ecs);
6913           return 1;
6914         }
6915
6916       /* If scheduler locking applies even if not stepping, there's no
6917          need to walk over threads.  Above we've checked whether the
6918          current thread is stepping.  If some other thread not the
6919          event thread is stepping, then it must be that scheduler
6920          locking is not in effect.  */
6921       if (schedlock_applies (ecs->event_thread))
6922         return 0;
6923
6924       /* Otherwise, we no longer expect a trap in the current thread.
6925          Clear the trap_expected flag before switching back -- this is
6926          what keep_going does as well, if we call it.  */
6927       ecs->event_thread->control.trap_expected = 0;
6928
6929       /* Likewise, clear the signal if it should not be passed.  */
6930       if (!signal_program[ecs->event_thread->suspend.stop_signal])
6931         ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6932
6933       /* Do all pending step-overs before actually proceeding with
6934          step/next/etc.  */
6935       if (start_step_over ())
6936         {
6937           prepare_to_wait (ecs);
6938           return 1;
6939         }
6940
6941       /* Look for the stepping/nexting thread.  */
6942       stepping_thread = NULL;
6943
6944       for (thread_info *tp : all_non_exited_threads ())
6945         {
6946           /* Ignore threads of processes the caller is not
6947              resuming.  */
6948           if (!sched_multi
6949               && tp->ptid.pid () != ecs->ptid.pid ())
6950             continue;
6951
6952           /* When stepping over a breakpoint, we lock all threads
6953              except the one that needs to move past the breakpoint.
6954              If a non-event thread has this set, the "incomplete
6955              step-over" check above should have caught it earlier.  */
6956           if (tp->control.trap_expected)
6957             {
6958               internal_error (__FILE__, __LINE__,
6959                               "[%s] has inconsistent state: "
6960                               "trap_expected=%d\n",
6961                               target_pid_to_str (tp->ptid),
6962                               tp->control.trap_expected);
6963             }
6964
6965           /* Did we find the stepping thread?  */
6966           if (tp->control.step_range_end)
6967             {
6968               /* Yep.  There should only one though.  */
6969               gdb_assert (stepping_thread == NULL);
6970
6971               /* The event thread is handled at the top, before we
6972                  enter this loop.  */
6973               gdb_assert (tp != ecs->event_thread);
6974
6975               /* If some thread other than the event thread is
6976                  stepping, then scheduler locking can't be in effect,
6977                  otherwise we wouldn't have resumed the current event
6978                  thread in the first place.  */
6979               gdb_assert (!schedlock_applies (tp));
6980
6981               stepping_thread = tp;
6982             }
6983         }
6984
6985       if (stepping_thread != NULL)
6986         {
6987           if (debug_infrun)
6988             fprintf_unfiltered (gdb_stdlog,
6989                                 "infrun: switching back to stepped thread\n");
6990
6991           if (keep_going_stepped_thread (stepping_thread))
6992             {
6993               prepare_to_wait (ecs);
6994               return 1;
6995             }
6996         }
6997     }
6998
6999   return 0;
7000 }
7001
7002 /* Set a previously stepped thread back to stepping.  Returns true on
7003    success, false if the resume is not possible (e.g., the thread
7004    vanished).  */
7005
7006 static int
7007 keep_going_stepped_thread (struct thread_info *tp)
7008 {
7009   struct frame_info *frame;
7010   struct execution_control_state ecss;
7011   struct execution_control_state *ecs = &ecss;
7012
7013   /* If the stepping thread exited, then don't try to switch back and
7014      resume it, which could fail in several different ways depending
7015      on the target.  Instead, just keep going.
7016
7017      We can find a stepping dead thread in the thread list in two
7018      cases:
7019
7020      - The target supports thread exit events, and when the target
7021        tries to delete the thread from the thread list, inferior_ptid
7022        pointed at the exiting thread.  In such case, calling
7023        delete_thread does not really remove the thread from the list;
7024        instead, the thread is left listed, with 'exited' state.
7025
7026      - The target's debug interface does not support thread exit
7027        events, and so we have no idea whatsoever if the previously
7028        stepping thread is still alive.  For that reason, we need to
7029        synchronously query the target now.  */
7030
7031   if (tp->state == THREAD_EXITED || !target_thread_alive (tp->ptid))
7032     {
7033       if (debug_infrun)
7034         fprintf_unfiltered (gdb_stdlog,
7035                             "infrun: not resuming previously  "
7036                             "stepped thread, it has vanished\n");
7037
7038       delete_thread (tp);
7039       return 0;
7040     }
7041
7042   if (debug_infrun)
7043     fprintf_unfiltered (gdb_stdlog,
7044                         "infrun: resuming previously stepped thread\n");
7045
7046   reset_ecs (ecs, tp);
7047   switch_to_thread (tp);
7048
7049   tp->suspend.stop_pc = regcache_read_pc (get_thread_regcache (tp));
7050   frame = get_current_frame ();
7051
7052   /* If the PC of the thread we were trying to single-step has
7053      changed, then that thread has trapped or been signaled, but the
7054      event has not been reported to GDB yet.  Re-poll the target
7055      looking for this particular thread's event (i.e. temporarily
7056      enable schedlock) by:
7057
7058      - setting a break at the current PC
7059      - resuming that particular thread, only (by setting trap
7060      expected)
7061
7062      This prevents us continuously moving the single-step breakpoint
7063      forward, one instruction at a time, overstepping.  */
7064
7065   if (tp->suspend.stop_pc != tp->prev_pc)
7066     {
7067       ptid_t resume_ptid;
7068
7069       if (debug_infrun)
7070         fprintf_unfiltered (gdb_stdlog,
7071                             "infrun: expected thread advanced also (%s -> %s)\n",
7072                             paddress (target_gdbarch (), tp->prev_pc),
7073                             paddress (target_gdbarch (), tp->suspend.stop_pc));
7074
7075       /* Clear the info of the previous step-over, as it's no longer
7076          valid (if the thread was trying to step over a breakpoint, it
7077          has already succeeded).  It's what keep_going would do too,
7078          if we called it.  Do this before trying to insert the sss
7079          breakpoint, otherwise if we were previously trying to step
7080          over this exact address in another thread, the breakpoint is
7081          skipped.  */
7082       clear_step_over_info ();
7083       tp->control.trap_expected = 0;
7084
7085       insert_single_step_breakpoint (get_frame_arch (frame),
7086                                      get_frame_address_space (frame),
7087                                      tp->suspend.stop_pc);
7088
7089       tp->resumed = 1;
7090       resume_ptid = internal_resume_ptid (tp->control.stepping_command);
7091       do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
7092     }
7093   else
7094     {
7095       if (debug_infrun)
7096         fprintf_unfiltered (gdb_stdlog,
7097                             "infrun: expected thread still hasn't advanced\n");
7098
7099       keep_going_pass_signal (ecs);
7100     }
7101   return 1;
7102 }
7103
7104 /* Is thread TP in the middle of (software or hardware)
7105    single-stepping?  (Note the result of this function must never be
7106    passed directly as target_resume's STEP parameter.)  */
7107
7108 static int
7109 currently_stepping (struct thread_info *tp)
7110 {
7111   return ((tp->control.step_range_end
7112            && tp->control.step_resume_breakpoint == NULL)
7113           || tp->control.trap_expected
7114           || tp->stepped_breakpoint
7115           || bpstat_should_step ());
7116 }
7117
7118 /* Inferior has stepped into a subroutine call with source code that
7119    we should not step over.  Do step to the first line of code in
7120    it.  */
7121
7122 static void
7123 handle_step_into_function (struct gdbarch *gdbarch,
7124                            struct execution_control_state *ecs)
7125 {
7126   fill_in_stop_func (gdbarch, ecs);
7127
7128   compunit_symtab *cust
7129     = find_pc_compunit_symtab (ecs->event_thread->suspend.stop_pc);
7130   if (cust != NULL && compunit_language (cust) != language_asm)
7131     ecs->stop_func_start
7132       = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
7133
7134   symtab_and_line stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
7135   /* Use the step_resume_break to step until the end of the prologue,
7136      even if that involves jumps (as it seems to on the vax under
7137      4.2).  */
7138   /* If the prologue ends in the middle of a source line, continue to
7139      the end of that source line (if it is still within the function).
7140      Otherwise, just go to end of prologue.  */
7141   if (stop_func_sal.end
7142       && stop_func_sal.pc != ecs->stop_func_start
7143       && stop_func_sal.end < ecs->stop_func_end)
7144     ecs->stop_func_start = stop_func_sal.end;
7145
7146   /* Architectures which require breakpoint adjustment might not be able
7147      to place a breakpoint at the computed address.  If so, the test
7148      ``ecs->stop_func_start == stop_pc'' will never succeed.  Adjust
7149      ecs->stop_func_start to an address at which a breakpoint may be
7150      legitimately placed.
7151
7152      Note:  kevinb/2004-01-19:  On FR-V, if this adjustment is not
7153      made, GDB will enter an infinite loop when stepping through
7154      optimized code consisting of VLIW instructions which contain
7155      subinstructions corresponding to different source lines.  On
7156      FR-V, it's not permitted to place a breakpoint on any but the
7157      first subinstruction of a VLIW instruction.  When a breakpoint is
7158      set, GDB will adjust the breakpoint address to the beginning of
7159      the VLIW instruction.  Thus, we need to make the corresponding
7160      adjustment here when computing the stop address.  */
7161
7162   if (gdbarch_adjust_breakpoint_address_p (gdbarch))
7163     {
7164       ecs->stop_func_start
7165         = gdbarch_adjust_breakpoint_address (gdbarch,
7166                                              ecs->stop_func_start);
7167     }
7168
7169   if (ecs->stop_func_start == ecs->event_thread->suspend.stop_pc)
7170     {
7171       /* We are already there: stop now.  */
7172       end_stepping_range (ecs);
7173       return;
7174     }
7175   else
7176     {
7177       /* Put the step-breakpoint there and go until there.  */
7178       symtab_and_line sr_sal;
7179       sr_sal.pc = ecs->stop_func_start;
7180       sr_sal.section = find_pc_overlay (ecs->stop_func_start);
7181       sr_sal.pspace = get_frame_program_space (get_current_frame ());
7182
7183       /* Do not specify what the fp should be when we stop since on
7184          some machines the prologue is where the new fp value is
7185          established.  */
7186       insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
7187
7188       /* And make sure stepping stops right away then.  */
7189       ecs->event_thread->control.step_range_end
7190         = ecs->event_thread->control.step_range_start;
7191     }
7192   keep_going (ecs);
7193 }
7194
7195 /* Inferior has stepped backward into a subroutine call with source
7196    code that we should not step over.  Do step to the beginning of the
7197    last line of code in it.  */
7198
7199 static void
7200 handle_step_into_function_backward (struct gdbarch *gdbarch,
7201                                     struct execution_control_state *ecs)
7202 {
7203   struct compunit_symtab *cust;
7204   struct symtab_and_line stop_func_sal;
7205
7206   fill_in_stop_func (gdbarch, ecs);
7207
7208   cust = find_pc_compunit_symtab (ecs->event_thread->suspend.stop_pc);
7209   if (cust != NULL && compunit_language (cust) != language_asm)
7210     ecs->stop_func_start
7211       = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
7212
7213   stop_func_sal = find_pc_line (ecs->event_thread->suspend.stop_pc, 0);
7214
7215   /* OK, we're just going to keep stepping here.  */
7216   if (stop_func_sal.pc == ecs->event_thread->suspend.stop_pc)
7217     {
7218       /* We're there already.  Just stop stepping now.  */
7219       end_stepping_range (ecs);
7220     }
7221   else
7222     {
7223       /* Else just reset the step range and keep going.
7224          No step-resume breakpoint, they don't work for
7225          epilogues, which can have multiple entry paths.  */
7226       ecs->event_thread->control.step_range_start = stop_func_sal.pc;
7227       ecs->event_thread->control.step_range_end = stop_func_sal.end;
7228       keep_going (ecs);
7229     }
7230   return;
7231 }
7232
7233 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7234    This is used to both functions and to skip over code.  */
7235
7236 static void
7237 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
7238                                         struct symtab_and_line sr_sal,
7239                                         struct frame_id sr_id,
7240                                         enum bptype sr_type)
7241 {
7242   /* There should never be more than one step-resume or longjmp-resume
7243      breakpoint per thread, so we should never be setting a new
7244      step_resume_breakpoint when one is already active.  */
7245   gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
7246   gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
7247
7248   if (debug_infrun)
7249     fprintf_unfiltered (gdb_stdlog,
7250                         "infrun: inserting step-resume breakpoint at %s\n",
7251                         paddress (gdbarch, sr_sal.pc));
7252
7253   inferior_thread ()->control.step_resume_breakpoint
7254     = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type).release ();
7255 }
7256
7257 void
7258 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
7259                                       struct symtab_and_line sr_sal,
7260                                       struct frame_id sr_id)
7261 {
7262   insert_step_resume_breakpoint_at_sal_1 (gdbarch,
7263                                           sr_sal, sr_id,
7264                                           bp_step_resume);
7265 }
7266
7267 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7268    This is used to skip a potential signal handler.
7269
7270    This is called with the interrupted function's frame.  The signal
7271    handler, when it returns, will resume the interrupted function at
7272    RETURN_FRAME.pc.  */
7273
7274 static void
7275 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
7276 {
7277   gdb_assert (return_frame != NULL);
7278
7279   struct gdbarch *gdbarch = get_frame_arch (return_frame);
7280
7281   symtab_and_line sr_sal;
7282   sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
7283   sr_sal.section = find_pc_overlay (sr_sal.pc);
7284   sr_sal.pspace = get_frame_program_space (return_frame);
7285
7286   insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
7287                                           get_stack_frame_id (return_frame),
7288                                           bp_hp_step_resume);
7289 }
7290
7291 /* Insert a "step-resume breakpoint" at the previous frame's PC.  This
7292    is used to skip a function after stepping into it (for "next" or if
7293    the called function has no debugging information).
7294
7295    The current function has almost always been reached by single
7296    stepping a call or return instruction.  NEXT_FRAME belongs to the
7297    current function, and the breakpoint will be set at the caller's
7298    resume address.
7299
7300    This is a separate function rather than reusing
7301    insert_hp_step_resume_breakpoint_at_frame in order to avoid
7302    get_prev_frame, which may stop prematurely (see the implementation
7303    of frame_unwind_caller_id for an example).  */
7304
7305 static void
7306 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
7307 {
7308   /* We shouldn't have gotten here if we don't know where the call site
7309      is.  */
7310   gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
7311
7312   struct gdbarch *gdbarch = frame_unwind_caller_arch (next_frame);
7313
7314   symtab_and_line sr_sal;
7315   sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
7316                                         frame_unwind_caller_pc (next_frame));
7317   sr_sal.section = find_pc_overlay (sr_sal.pc);
7318   sr_sal.pspace = frame_unwind_program_space (next_frame);
7319
7320   insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
7321                                         frame_unwind_caller_id (next_frame));
7322 }
7323
7324 /* Insert a "longjmp-resume" breakpoint at PC.  This is used to set a
7325    new breakpoint at the target of a jmp_buf.  The handling of
7326    longjmp-resume uses the same mechanisms used for handling
7327    "step-resume" breakpoints.  */
7328
7329 static void
7330 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
7331 {
7332   /* There should never be more than one longjmp-resume breakpoint per
7333      thread, so we should never be setting a new
7334      longjmp_resume_breakpoint when one is already active.  */
7335   gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
7336
7337   if (debug_infrun)
7338     fprintf_unfiltered (gdb_stdlog,
7339                         "infrun: inserting longjmp-resume breakpoint at %s\n",
7340                         paddress (gdbarch, pc));
7341
7342   inferior_thread ()->control.exception_resume_breakpoint =
7343     set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume).release ();
7344 }
7345
7346 /* Insert an exception resume breakpoint.  TP is the thread throwing
7347    the exception.  The block B is the block of the unwinder debug hook
7348    function.  FRAME is the frame corresponding to the call to this
7349    function.  SYM is the symbol of the function argument holding the
7350    target PC of the exception.  */
7351
7352 static void
7353 insert_exception_resume_breakpoint (struct thread_info *tp,
7354                                     const struct block *b,
7355                                     struct frame_info *frame,
7356                                     struct symbol *sym)
7357 {
7358   TRY
7359     {
7360       struct block_symbol vsym;
7361       struct value *value;
7362       CORE_ADDR handler;
7363       struct breakpoint *bp;
7364
7365       vsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
7366                                         b, VAR_DOMAIN);
7367       value = read_var_value (vsym.symbol, vsym.block, frame);
7368       /* If the value was optimized out, revert to the old behavior.  */
7369       if (! value_optimized_out (value))
7370         {
7371           handler = value_as_address (value);
7372
7373           if (debug_infrun)
7374             fprintf_unfiltered (gdb_stdlog,
7375                                 "infrun: exception resume at %lx\n",
7376                                 (unsigned long) handler);
7377
7378           bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7379                                                handler,
7380                                                bp_exception_resume).release ();
7381
7382           /* set_momentary_breakpoint_at_pc invalidates FRAME.  */
7383           frame = NULL;
7384
7385           bp->thread = tp->global_num;
7386           inferior_thread ()->control.exception_resume_breakpoint = bp;
7387         }
7388     }
7389   CATCH (e, RETURN_MASK_ERROR)
7390     {
7391       /* We want to ignore errors here.  */
7392     }
7393   END_CATCH
7394 }
7395
7396 /* A helper for check_exception_resume that sets an
7397    exception-breakpoint based on a SystemTap probe.  */
7398
7399 static void
7400 insert_exception_resume_from_probe (struct thread_info *tp,
7401                                     const struct bound_probe *probe,
7402                                     struct frame_info *frame)
7403 {
7404   struct value *arg_value;
7405   CORE_ADDR handler;
7406   struct breakpoint *bp;
7407
7408   arg_value = probe_safe_evaluate_at_pc (frame, 1);
7409   if (!arg_value)
7410     return;
7411
7412   handler = value_as_address (arg_value);
7413
7414   if (debug_infrun)
7415     fprintf_unfiltered (gdb_stdlog,
7416                         "infrun: exception resume at %s\n",
7417                         paddress (get_objfile_arch (probe->objfile),
7418                                   handler));
7419
7420   bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7421                                        handler, bp_exception_resume).release ();
7422   bp->thread = tp->global_num;
7423   inferior_thread ()->control.exception_resume_breakpoint = bp;
7424 }
7425
7426 /* This is called when an exception has been intercepted.  Check to
7427    see whether the exception's destination is of interest, and if so,
7428    set an exception resume breakpoint there.  */
7429
7430 static void
7431 check_exception_resume (struct execution_control_state *ecs,
7432                         struct frame_info *frame)
7433 {
7434   struct bound_probe probe;
7435   struct symbol *func;
7436
7437   /* First see if this exception unwinding breakpoint was set via a
7438      SystemTap probe point.  If so, the probe has two arguments: the
7439      CFA and the HANDLER.  We ignore the CFA, extract the handler, and
7440      set a breakpoint there.  */
7441   probe = find_probe_by_pc (get_frame_pc (frame));
7442   if (probe.prob)
7443     {
7444       insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
7445       return;
7446     }
7447
7448   func = get_frame_function (frame);
7449   if (!func)
7450     return;
7451
7452   TRY
7453     {
7454       const struct block *b;
7455       struct block_iterator iter;
7456       struct symbol *sym;
7457       int argno = 0;
7458
7459       /* The exception breakpoint is a thread-specific breakpoint on
7460          the unwinder's debug hook, declared as:
7461          
7462          void _Unwind_DebugHook (void *cfa, void *handler);
7463          
7464          The CFA argument indicates the frame to which control is
7465          about to be transferred.  HANDLER is the destination PC.
7466          
7467          We ignore the CFA and set a temporary breakpoint at HANDLER.
7468          This is not extremely efficient but it avoids issues in gdb
7469          with computing the DWARF CFA, and it also works even in weird
7470          cases such as throwing an exception from inside a signal
7471          handler.  */
7472
7473       b = SYMBOL_BLOCK_VALUE (func);
7474       ALL_BLOCK_SYMBOLS (b, iter, sym)
7475         {
7476           if (!SYMBOL_IS_ARGUMENT (sym))
7477             continue;
7478
7479           if (argno == 0)
7480             ++argno;
7481           else
7482             {
7483               insert_exception_resume_breakpoint (ecs->event_thread,
7484                                                   b, frame, sym);
7485               break;
7486             }
7487         }
7488     }
7489   CATCH (e, RETURN_MASK_ERROR)
7490     {
7491     }
7492   END_CATCH
7493 }
7494
7495 static void
7496 stop_waiting (struct execution_control_state *ecs)
7497 {
7498   if (debug_infrun)
7499     fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
7500
7501   /* Let callers know we don't want to wait for the inferior anymore.  */
7502   ecs->wait_some_more = 0;
7503
7504   /* If all-stop, but the target is always in non-stop mode, stop all
7505      threads now that we're presenting the stop to the user.  */
7506   if (!non_stop && target_is_non_stop_p ())
7507     stop_all_threads ();
7508 }
7509
7510 /* Like keep_going, but passes the signal to the inferior, even if the
7511    signal is set to nopass.  */
7512
7513 static void
7514 keep_going_pass_signal (struct execution_control_state *ecs)
7515 {
7516   gdb_assert (ecs->event_thread->ptid == inferior_ptid);
7517   gdb_assert (!ecs->event_thread->resumed);
7518
7519   /* Save the pc before execution, to compare with pc after stop.  */
7520   ecs->event_thread->prev_pc
7521     = regcache_read_pc (get_thread_regcache (ecs->event_thread));
7522
7523   if (ecs->event_thread->control.trap_expected)
7524     {
7525       struct thread_info *tp = ecs->event_thread;
7526
7527       if (debug_infrun)
7528         fprintf_unfiltered (gdb_stdlog,
7529                             "infrun: %s has trap_expected set, "
7530                             "resuming to collect trap\n",
7531                             target_pid_to_str (tp->ptid));
7532
7533       /* We haven't yet gotten our trap, and either: intercepted a
7534          non-signal event (e.g., a fork); or took a signal which we
7535          are supposed to pass through to the inferior.  Simply
7536          continue.  */
7537       resume (ecs->event_thread->suspend.stop_signal);
7538     }
7539   else if (step_over_info_valid_p ())
7540     {
7541       /* Another thread is stepping over a breakpoint in-line.  If
7542          this thread needs a step-over too, queue the request.  In
7543          either case, this resume must be deferred for later.  */
7544       struct thread_info *tp = ecs->event_thread;
7545
7546       if (ecs->hit_singlestep_breakpoint
7547           || thread_still_needs_step_over (tp))
7548         {
7549           if (debug_infrun)
7550             fprintf_unfiltered (gdb_stdlog,
7551                                 "infrun: step-over already in progress: "
7552                                 "step-over for %s deferred\n",
7553                                 target_pid_to_str (tp->ptid));
7554           thread_step_over_chain_enqueue (tp);
7555         }
7556       else
7557         {
7558           if (debug_infrun)
7559             fprintf_unfiltered (gdb_stdlog,
7560                                 "infrun: step-over in progress: "
7561                                 "resume of %s deferred\n",
7562                                 target_pid_to_str (tp->ptid));
7563         }
7564     }
7565   else
7566     {
7567       struct regcache *regcache = get_current_regcache ();
7568       int remove_bp;
7569       int remove_wps;
7570       step_over_what step_what;
7571
7572       /* Either the trap was not expected, but we are continuing
7573          anyway (if we got a signal, the user asked it be passed to
7574          the child)
7575          -- or --
7576          We got our expected trap, but decided we should resume from
7577          it.
7578
7579          We're going to run this baby now!
7580
7581          Note that insert_breakpoints won't try to re-insert
7582          already inserted breakpoints.  Therefore, we don't
7583          care if breakpoints were already inserted, or not.  */
7584
7585       /* If we need to step over a breakpoint, and we're not using
7586          displaced stepping to do so, insert all breakpoints
7587          (watchpoints, etc.) but the one we're stepping over, step one
7588          instruction, and then re-insert the breakpoint when that step
7589          is finished.  */
7590
7591       step_what = thread_still_needs_step_over (ecs->event_thread);
7592
7593       remove_bp = (ecs->hit_singlestep_breakpoint
7594                    || (step_what & STEP_OVER_BREAKPOINT));
7595       remove_wps = (step_what & STEP_OVER_WATCHPOINT);
7596
7597       /* We can't use displaced stepping if we need to step past a
7598          watchpoint.  The instruction copied to the scratch pad would
7599          still trigger the watchpoint.  */
7600       if (remove_bp
7601           && (remove_wps || !use_displaced_stepping (ecs->event_thread)))
7602         {
7603           set_step_over_info (regcache->aspace (),
7604                               regcache_read_pc (regcache), remove_wps,
7605                               ecs->event_thread->global_num);
7606         }
7607       else if (remove_wps)
7608         set_step_over_info (NULL, 0, remove_wps, -1);
7609
7610       /* If we now need to do an in-line step-over, we need to stop
7611          all other threads.  Note this must be done before
7612          insert_breakpoints below, because that removes the breakpoint
7613          we're about to step over, otherwise other threads could miss
7614          it.  */
7615       if (step_over_info_valid_p () && target_is_non_stop_p ())
7616         stop_all_threads ();
7617
7618       /* Stop stepping if inserting breakpoints fails.  */
7619       TRY
7620         {
7621           insert_breakpoints ();
7622         }
7623       CATCH (e, RETURN_MASK_ERROR)
7624         {
7625           exception_print (gdb_stderr, e);
7626           stop_waiting (ecs);
7627           clear_step_over_info ();
7628           return;
7629         }
7630       END_CATCH
7631
7632       ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
7633
7634       resume (ecs->event_thread->suspend.stop_signal);
7635     }
7636
7637   prepare_to_wait (ecs);
7638 }
7639
7640 /* Called when we should continue running the inferior, because the
7641    current event doesn't cause a user visible stop.  This does the
7642    resuming part; waiting for the next event is done elsewhere.  */
7643
7644 static void
7645 keep_going (struct execution_control_state *ecs)
7646 {
7647   if (ecs->event_thread->control.trap_expected
7648       && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
7649     ecs->event_thread->control.trap_expected = 0;
7650
7651   if (!signal_program[ecs->event_thread->suspend.stop_signal])
7652     ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7653   keep_going_pass_signal (ecs);
7654 }
7655
7656 /* This function normally comes after a resume, before
7657    handle_inferior_event exits.  It takes care of any last bits of
7658    housekeeping, and sets the all-important wait_some_more flag.  */
7659
7660 static void
7661 prepare_to_wait (struct execution_control_state *ecs)
7662 {
7663   if (debug_infrun)
7664     fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
7665
7666   ecs->wait_some_more = 1;
7667
7668   if (!target_is_async_p ())
7669     mark_infrun_async_event_handler ();
7670 }
7671
7672 /* We are done with the step range of a step/next/si/ni command.
7673    Called once for each n of a "step n" operation.  */
7674
7675 static void
7676 end_stepping_range (struct execution_control_state *ecs)
7677 {
7678   ecs->event_thread->control.stop_step = 1;
7679   stop_waiting (ecs);
7680 }
7681
7682 /* Several print_*_reason functions to print why the inferior has stopped.
7683    We always print something when the inferior exits, or receives a signal.
7684    The rest of the cases are dealt with later on in normal_stop and
7685    print_it_typical.  Ideally there should be a call to one of these
7686    print_*_reason functions functions from handle_inferior_event each time
7687    stop_waiting is called.
7688
7689    Note that we don't call these directly, instead we delegate that to
7690    the interpreters, through observers.  Interpreters then call these
7691    with whatever uiout is right.  */
7692
7693 void
7694 print_end_stepping_range_reason (struct ui_out *uiout)
7695 {
7696   /* For CLI-like interpreters, print nothing.  */
7697
7698   if (uiout->is_mi_like_p ())
7699     {
7700       uiout->field_string ("reason",
7701                            async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
7702     }
7703 }
7704
7705 void
7706 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7707 {
7708   annotate_signalled ();
7709   if (uiout->is_mi_like_p ())
7710     uiout->field_string
7711       ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
7712   uiout->text ("\nProgram terminated with signal ");
7713   annotate_signal_name ();
7714   uiout->field_string ("signal-name",
7715                        gdb_signal_to_name (siggnal));
7716   annotate_signal_name_end ();
7717   uiout->text (", ");
7718   annotate_signal_string ();
7719   uiout->field_string ("signal-meaning",
7720                        gdb_signal_to_string (siggnal));
7721   annotate_signal_string_end ();
7722   uiout->text (".\n");
7723   uiout->text ("The program no longer exists.\n");
7724 }
7725
7726 void
7727 print_exited_reason (struct ui_out *uiout, int exitstatus)
7728 {
7729   struct inferior *inf = current_inferior ();
7730   const char *pidstr = target_pid_to_str (ptid_t (inf->pid));
7731
7732   annotate_exited (exitstatus);
7733   if (exitstatus)
7734     {
7735       if (uiout->is_mi_like_p ())
7736         uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));
7737       uiout->text ("[Inferior ");
7738       uiout->text (plongest (inf->num));
7739       uiout->text (" (");
7740       uiout->text (pidstr);
7741       uiout->text (") exited with code ");
7742       uiout->field_fmt ("exit-code", "0%o", (unsigned int) exitstatus);
7743       uiout->text ("]\n");
7744     }
7745   else
7746     {
7747       if (uiout->is_mi_like_p ())
7748         uiout->field_string
7749           ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
7750       uiout->text ("[Inferior ");
7751       uiout->text (plongest (inf->num));
7752       uiout->text (" (");
7753       uiout->text (pidstr);
7754       uiout->text (") exited normally]\n");
7755     }
7756 }
7757
7758 /* Some targets/architectures can do extra processing/display of
7759    segmentation faults.  E.g., Intel MPX boundary faults.
7760    Call the architecture dependent function to handle the fault.  */
7761
7762 static void
7763 handle_segmentation_fault (struct ui_out *uiout)
7764 {
7765   struct regcache *regcache = get_current_regcache ();
7766   struct gdbarch *gdbarch = regcache->arch ();
7767
7768   if (gdbarch_handle_segmentation_fault_p (gdbarch))
7769     gdbarch_handle_segmentation_fault (gdbarch, uiout);
7770 }
7771
7772 void
7773 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7774 {
7775   struct thread_info *thr = inferior_thread ();
7776
7777   annotate_signal ();
7778
7779   if (uiout->is_mi_like_p ())
7780     ;
7781   else if (show_thread_that_caused_stop ())
7782     {
7783       const char *name;
7784
7785       uiout->text ("\nThread ");
7786       uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
7787
7788       name = thr->name != NULL ? thr->name : target_thread_name (thr);
7789       if (name != NULL)
7790         {
7791           uiout->text (" \"");
7792           uiout->field_fmt ("name", "%s", name);
7793           uiout->text ("\"");
7794         }
7795     }
7796   else
7797     uiout->text ("\nProgram");
7798
7799   if (siggnal == GDB_SIGNAL_0 && !uiout->is_mi_like_p ())
7800     uiout->text (" stopped");
7801   else
7802     {
7803       uiout->text (" received signal ");
7804       annotate_signal_name ();
7805       if (uiout->is_mi_like_p ())
7806         uiout->field_string
7807           ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
7808       uiout->field_string ("signal-name", gdb_signal_to_name (siggnal));
7809       annotate_signal_name_end ();
7810       uiout->text (", ");
7811       annotate_signal_string ();
7812       uiout->field_string ("signal-meaning", gdb_signal_to_string (siggnal));
7813
7814       if (siggnal == GDB_SIGNAL_SEGV)
7815         handle_segmentation_fault (uiout);
7816
7817       annotate_signal_string_end ();
7818     }
7819   uiout->text (".\n");
7820 }
7821
7822 void
7823 print_no_history_reason (struct ui_out *uiout)
7824 {
7825   uiout->text ("\nNo more reverse-execution history.\n");
7826 }
7827
7828 /* Print current location without a level number, if we have changed
7829    functions or hit a breakpoint.  Print source line if we have one.
7830    bpstat_print contains the logic deciding in detail what to print,
7831    based on the event(s) that just occurred.  */
7832
7833 static void
7834 print_stop_location (struct target_waitstatus *ws)
7835 {
7836   int bpstat_ret;
7837   enum print_what source_flag;
7838   int do_frame_printing = 1;
7839   struct thread_info *tp = inferior_thread ();
7840
7841   bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
7842   switch (bpstat_ret)
7843     {
7844     case PRINT_UNKNOWN:
7845       /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
7846          should) carry around the function and does (or should) use
7847          that when doing a frame comparison.  */
7848       if (tp->control.stop_step
7849           && frame_id_eq (tp->control.step_frame_id,
7850                           get_frame_id (get_current_frame ()))
7851           && (tp->control.step_start_function
7852               == find_pc_function (tp->suspend.stop_pc)))
7853         {
7854           /* Finished step, just print source line.  */
7855           source_flag = SRC_LINE;
7856         }
7857       else
7858         {
7859           /* Print location and source line.  */
7860           source_flag = SRC_AND_LOC;
7861         }
7862       break;
7863     case PRINT_SRC_AND_LOC:
7864       /* Print location and source line.  */
7865       source_flag = SRC_AND_LOC;
7866       break;
7867     case PRINT_SRC_ONLY:
7868       source_flag = SRC_LINE;
7869       break;
7870     case PRINT_NOTHING:
7871       /* Something bogus.  */
7872       source_flag = SRC_LINE;
7873       do_frame_printing = 0;
7874       break;
7875     default:
7876       internal_error (__FILE__, __LINE__, _("Unknown value."));
7877     }
7878
7879   /* The behavior of this routine with respect to the source
7880      flag is:
7881      SRC_LINE: Print only source line
7882      LOCATION: Print only location
7883      SRC_AND_LOC: Print location and source line.  */
7884   if (do_frame_printing)
7885     print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
7886 }
7887
7888 /* See infrun.h.  */
7889
7890 void
7891 print_stop_event (struct ui_out *uiout)
7892 {
7893   struct target_waitstatus last;
7894   ptid_t last_ptid;
7895   struct thread_info *tp;
7896
7897   get_last_target_status (&last_ptid, &last);
7898
7899   {
7900     scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
7901
7902     print_stop_location (&last);
7903
7904     /* Display the auto-display expressions.  */
7905     do_displays ();
7906   }
7907
7908   tp = inferior_thread ();
7909   if (tp->thread_fsm != NULL
7910       && thread_fsm_finished_p (tp->thread_fsm))
7911     {
7912       struct return_value_info *rv;
7913
7914       rv = thread_fsm_return_value (tp->thread_fsm);
7915       if (rv != NULL)
7916         print_return_value (uiout, rv);
7917     }
7918 }
7919
7920 /* See infrun.h.  */
7921
7922 void
7923 maybe_remove_breakpoints (void)
7924 {
7925   if (!breakpoints_should_be_inserted_now () && target_has_execution)
7926     {
7927       if (remove_breakpoints ())
7928         {
7929           target_terminal::ours_for_output ();
7930           printf_filtered (_("Cannot remove breakpoints because "
7931                              "program is no longer writable.\nFurther "
7932                              "execution is probably impossible.\n"));
7933         }
7934     }
7935 }
7936
7937 /* The execution context that just caused a normal stop.  */
7938
7939 struct stop_context
7940 {
7941   stop_context ();
7942   ~stop_context ();
7943
7944   DISABLE_COPY_AND_ASSIGN (stop_context);
7945
7946   bool changed () const;
7947
7948   /* The stop ID.  */
7949   ULONGEST stop_id;
7950
7951   /* The event PTID.  */
7952
7953   ptid_t ptid;
7954
7955   /* If stopp for a thread event, this is the thread that caused the
7956      stop.  */
7957   struct thread_info *thread;
7958
7959   /* The inferior that caused the stop.  */
7960   int inf_num;
7961 };
7962
7963 /* Initializes a new stop context.  If stopped for a thread event, this
7964    takes a strong reference to the thread.  */
7965
7966 stop_context::stop_context ()
7967 {
7968   stop_id = get_stop_id ();
7969   ptid = inferior_ptid;
7970   inf_num = current_inferior ()->num;
7971
7972   if (inferior_ptid != null_ptid)
7973     {
7974       /* Take a strong reference so that the thread can't be deleted
7975          yet.  */
7976       thread = inferior_thread ();
7977       thread->incref ();
7978     }
7979   else
7980     thread = NULL;
7981 }
7982
7983 /* Release a stop context previously created with save_stop_context.
7984    Releases the strong reference to the thread as well. */
7985
7986 stop_context::~stop_context ()
7987 {
7988   if (thread != NULL)
7989     thread->decref ();
7990 }
7991
7992 /* Return true if the current context no longer matches the saved stop
7993    context.  */
7994
7995 bool
7996 stop_context::changed () const
7997 {
7998   if (ptid != inferior_ptid)
7999     return true;
8000   if (inf_num != current_inferior ()->num)
8001     return true;
8002   if (thread != NULL && thread->state != THREAD_STOPPED)
8003     return true;
8004   if (get_stop_id () != stop_id)
8005     return true;
8006   return false;
8007 }
8008
8009 /* See infrun.h.  */
8010
8011 int
8012 normal_stop (void)
8013 {
8014   struct target_waitstatus last;
8015   ptid_t last_ptid;
8016
8017   get_last_target_status (&last_ptid, &last);
8018
8019   new_stop_id ();
8020
8021   /* If an exception is thrown from this point on, make sure to
8022      propagate GDB's knowledge of the executing state to the
8023      frontend/user running state.  A QUIT is an easy exception to see
8024      here, so do this before any filtered output.  */
8025
8026   gdb::optional<scoped_finish_thread_state> maybe_finish_thread_state;
8027
8028   if (!non_stop)
8029     maybe_finish_thread_state.emplace (minus_one_ptid);
8030   else if (last.kind == TARGET_WAITKIND_SIGNALLED
8031            || last.kind == TARGET_WAITKIND_EXITED)
8032     {
8033       /* On some targets, we may still have live threads in the
8034          inferior when we get a process exit event.  E.g., for
8035          "checkpoint", when the current checkpoint/fork exits,
8036          linux-fork.c automatically switches to another fork from
8037          within target_mourn_inferior.  */
8038       if (inferior_ptid != null_ptid)
8039         maybe_finish_thread_state.emplace (ptid_t (inferior_ptid.pid ()));
8040     }
8041   else if (last.kind != TARGET_WAITKIND_NO_RESUMED)
8042     maybe_finish_thread_state.emplace (inferior_ptid);
8043
8044   /* As we're presenting a stop, and potentially removing breakpoints,
8045      update the thread list so we can tell whether there are threads
8046      running on the target.  With target remote, for example, we can
8047      only learn about new threads when we explicitly update the thread
8048      list.  Do this before notifying the interpreters about signal
8049      stops, end of stepping ranges, etc., so that the "new thread"
8050      output is emitted before e.g., "Program received signal FOO",
8051      instead of after.  */
8052   update_thread_list ();
8053
8054   if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
8055     gdb::observers::signal_received.notify (inferior_thread ()->suspend.stop_signal);
8056
8057   /* As with the notification of thread events, we want to delay
8058      notifying the user that we've switched thread context until
8059      the inferior actually stops.
8060
8061      There's no point in saying anything if the inferior has exited.
8062      Note that SIGNALLED here means "exited with a signal", not
8063      "received a signal".
8064
8065      Also skip saying anything in non-stop mode.  In that mode, as we
8066      don't want GDB to switch threads behind the user's back, to avoid
8067      races where the user is typing a command to apply to thread x,
8068      but GDB switches to thread y before the user finishes entering
8069      the command, fetch_inferior_event installs a cleanup to restore
8070      the current thread back to the thread the user had selected right
8071      after this event is handled, so we're not really switching, only
8072      informing of a stop.  */
8073   if (!non_stop
8074       && previous_inferior_ptid != inferior_ptid
8075       && target_has_execution
8076       && last.kind != TARGET_WAITKIND_SIGNALLED
8077       && last.kind != TARGET_WAITKIND_EXITED
8078       && last.kind != TARGET_WAITKIND_NO_RESUMED)
8079     {
8080       SWITCH_THRU_ALL_UIS ()
8081         {
8082           target_terminal::ours_for_output ();
8083           printf_filtered (_("[Switching to %s]\n"),
8084                            target_pid_to_str (inferior_ptid));
8085           annotate_thread_changed ();
8086         }
8087       previous_inferior_ptid = inferior_ptid;
8088     }
8089
8090   if (last.kind == TARGET_WAITKIND_NO_RESUMED)
8091     {
8092       SWITCH_THRU_ALL_UIS ()
8093         if (current_ui->prompt_state == PROMPT_BLOCKED)
8094           {
8095             target_terminal::ours_for_output ();
8096             printf_filtered (_("No unwaited-for children left.\n"));
8097           }
8098     }
8099
8100   /* Note: this depends on the update_thread_list call above.  */
8101   maybe_remove_breakpoints ();
8102
8103   /* If an auto-display called a function and that got a signal,
8104      delete that auto-display to avoid an infinite recursion.  */
8105
8106   if (stopped_by_random_signal)
8107     disable_current_display ();
8108
8109   SWITCH_THRU_ALL_UIS ()
8110     {
8111       async_enable_stdin ();
8112     }
8113
8114   /* Let the user/frontend see the threads as stopped.  */
8115   maybe_finish_thread_state.reset ();
8116
8117   /* Select innermost stack frame - i.e., current frame is frame 0,
8118      and current location is based on that.  Handle the case where the
8119      dummy call is returning after being stopped.  E.g. the dummy call
8120      previously hit a breakpoint.  (If the dummy call returns
8121      normally, we won't reach here.)  Do this before the stop hook is
8122      run, so that it doesn't get to see the temporary dummy frame,
8123      which is not where we'll present the stop.  */
8124   if (has_stack_frames ())
8125     {
8126       if (stop_stack_dummy == STOP_STACK_DUMMY)
8127         {
8128           /* Pop the empty frame that contains the stack dummy.  This
8129              also restores inferior state prior to the call (struct
8130              infcall_suspend_state).  */
8131           struct frame_info *frame = get_current_frame ();
8132
8133           gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
8134           frame_pop (frame);
8135           /* frame_pop calls reinit_frame_cache as the last thing it
8136              does which means there's now no selected frame.  */
8137         }
8138
8139       select_frame (get_current_frame ());
8140
8141       /* Set the current source location.  */
8142       set_current_sal_from_frame (get_current_frame ());
8143     }
8144
8145   /* Look up the hook_stop and run it (CLI internally handles problem
8146      of stop_command's pre-hook not existing).  */
8147   if (stop_command != NULL)
8148     {
8149       stop_context saved_context;
8150
8151       TRY
8152         {
8153           execute_cmd_pre_hook (stop_command);
8154         }
8155       CATCH (ex, RETURN_MASK_ALL)
8156         {
8157           exception_fprintf (gdb_stderr, ex,
8158                              "Error while running hook_stop:\n");
8159         }
8160       END_CATCH
8161
8162       /* If the stop hook resumes the target, then there's no point in
8163          trying to notify about the previous stop; its context is
8164          gone.  Likewise if the command switches thread or inferior --
8165          the observers would print a stop for the wrong
8166          thread/inferior.  */
8167       if (saved_context.changed ())
8168         return 1;
8169     }
8170
8171   /* Notify observers about the stop.  This is where the interpreters
8172      print the stop event.  */
8173   if (inferior_ptid != null_ptid)
8174     gdb::observers::normal_stop.notify (inferior_thread ()->control.stop_bpstat,
8175                                  stop_print_frame);
8176   else
8177     gdb::observers::normal_stop.notify (NULL, stop_print_frame);
8178
8179   annotate_stopped ();
8180
8181   if (target_has_execution)
8182     {
8183       if (last.kind != TARGET_WAITKIND_SIGNALLED
8184           && last.kind != TARGET_WAITKIND_EXITED)
8185         /* Delete the breakpoint we stopped at, if it wants to be deleted.
8186            Delete any breakpoint that is to be deleted at the next stop.  */
8187         breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
8188     }
8189
8190   /* Try to get rid of automatically added inferiors that are no
8191      longer needed.  Keeping those around slows down things linearly.
8192      Note that this never removes the current inferior.  */
8193   prune_inferiors ();
8194
8195   return 0;
8196 }
8197 \f
8198 int
8199 signal_stop_state (int signo)
8200 {
8201   return signal_stop[signo];
8202 }
8203
8204 int
8205 signal_print_state (int signo)
8206 {
8207   return signal_print[signo];
8208 }
8209
8210 int
8211 signal_pass_state (int signo)
8212 {
8213   return signal_program[signo];
8214 }
8215
8216 static void
8217 signal_cache_update (int signo)
8218 {
8219   if (signo == -1)
8220     {
8221       for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
8222         signal_cache_update (signo);
8223
8224       return;
8225     }
8226
8227   signal_pass[signo] = (signal_stop[signo] == 0
8228                         && signal_print[signo] == 0
8229                         && signal_program[signo] == 1
8230                         && signal_catch[signo] == 0);
8231 }
8232
8233 int
8234 signal_stop_update (int signo, int state)
8235 {
8236   int ret = signal_stop[signo];
8237
8238   signal_stop[signo] = state;
8239   signal_cache_update (signo);
8240   return ret;
8241 }
8242
8243 int
8244 signal_print_update (int signo, int state)
8245 {
8246   int ret = signal_print[signo];
8247
8248   signal_print[signo] = state;
8249   signal_cache_update (signo);
8250   return ret;
8251 }
8252
8253 int
8254 signal_pass_update (int signo, int state)
8255 {
8256   int ret = signal_program[signo];
8257
8258   signal_program[signo] = state;
8259   signal_cache_update (signo);
8260   return ret;
8261 }
8262
8263 /* Update the global 'signal_catch' from INFO and notify the
8264    target.  */
8265
8266 void
8267 signal_catch_update (const unsigned int *info)
8268 {
8269   int i;
8270
8271   for (i = 0; i < GDB_SIGNAL_LAST; ++i)
8272     signal_catch[i] = info[i] > 0;
8273   signal_cache_update (-1);
8274   target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8275 }
8276
8277 static void
8278 sig_print_header (void)
8279 {
8280   printf_filtered (_("Signal        Stop\tPrint\tPass "
8281                      "to program\tDescription\n"));
8282 }
8283
8284 static void
8285 sig_print_info (enum gdb_signal oursig)
8286 {
8287   const char *name = gdb_signal_to_name (oursig);
8288   int name_padding = 13 - strlen (name);
8289
8290   if (name_padding <= 0)
8291     name_padding = 0;
8292
8293   printf_filtered ("%s", name);
8294   printf_filtered ("%*.*s ", name_padding, name_padding, "                 ");
8295   printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
8296   printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
8297   printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
8298   printf_filtered ("%s\n", gdb_signal_to_string (oursig));
8299 }
8300
8301 /* Specify how various signals in the inferior should be handled.  */
8302
8303 static void
8304 handle_command (const char *args, int from_tty)
8305 {
8306   int digits, wordlen;
8307   int sigfirst, siglast;
8308   enum gdb_signal oursig;
8309   int allsigs;
8310   int nsigs;
8311   unsigned char *sigs;
8312
8313   if (args == NULL)
8314     {
8315       error_no_arg (_("signal to handle"));
8316     }
8317
8318   /* Allocate and zero an array of flags for which signals to handle.  */
8319
8320   nsigs = (int) GDB_SIGNAL_LAST;
8321   sigs = (unsigned char *) alloca (nsigs);
8322   memset (sigs, 0, nsigs);
8323
8324   /* Break the command line up into args.  */
8325
8326   gdb_argv built_argv (args);
8327
8328   /* Walk through the args, looking for signal oursigs, signal names, and
8329      actions.  Signal numbers and signal names may be interspersed with
8330      actions, with the actions being performed for all signals cumulatively
8331      specified.  Signal ranges can be specified as <LOW>-<HIGH>.  */
8332
8333   for (char *arg : built_argv)
8334     {
8335       wordlen = strlen (arg);
8336       for (digits = 0; isdigit (arg[digits]); digits++)
8337         {;
8338         }
8339       allsigs = 0;
8340       sigfirst = siglast = -1;
8341
8342       if (wordlen >= 1 && !strncmp (arg, "all", wordlen))
8343         {
8344           /* Apply action to all signals except those used by the
8345              debugger.  Silently skip those.  */
8346           allsigs = 1;
8347           sigfirst = 0;
8348           siglast = nsigs - 1;
8349         }
8350       else if (wordlen >= 1 && !strncmp (arg, "stop", wordlen))
8351         {
8352           SET_SIGS (nsigs, sigs, signal_stop);
8353           SET_SIGS (nsigs, sigs, signal_print);
8354         }
8355       else if (wordlen >= 1 && !strncmp (arg, "ignore", wordlen))
8356         {
8357           UNSET_SIGS (nsigs, sigs, signal_program);
8358         }
8359       else if (wordlen >= 2 && !strncmp (arg, "print", wordlen))
8360         {
8361           SET_SIGS (nsigs, sigs, signal_print);
8362         }
8363       else if (wordlen >= 2 && !strncmp (arg, "pass", wordlen))
8364         {
8365           SET_SIGS (nsigs, sigs, signal_program);
8366         }
8367       else if (wordlen >= 3 && !strncmp (arg, "nostop", wordlen))
8368         {
8369           UNSET_SIGS (nsigs, sigs, signal_stop);
8370         }
8371       else if (wordlen >= 3 && !strncmp (arg, "noignore", wordlen))
8372         {
8373           SET_SIGS (nsigs, sigs, signal_program);
8374         }
8375       else if (wordlen >= 4 && !strncmp (arg, "noprint", wordlen))
8376         {
8377           UNSET_SIGS (nsigs, sigs, signal_print);
8378           UNSET_SIGS (nsigs, sigs, signal_stop);
8379         }
8380       else if (wordlen >= 4 && !strncmp (arg, "nopass", wordlen))
8381         {
8382           UNSET_SIGS (nsigs, sigs, signal_program);
8383         }
8384       else if (digits > 0)
8385         {
8386           /* It is numeric.  The numeric signal refers to our own
8387              internal signal numbering from target.h, not to host/target
8388              signal  number.  This is a feature; users really should be
8389              using symbolic names anyway, and the common ones like
8390              SIGHUP, SIGINT, SIGALRM, etc. will work right anyway.  */
8391
8392           sigfirst = siglast = (int)
8393             gdb_signal_from_command (atoi (arg));
8394           if (arg[digits] == '-')
8395             {
8396               siglast = (int)
8397                 gdb_signal_from_command (atoi (arg + digits + 1));
8398             }
8399           if (sigfirst > siglast)
8400             {
8401               /* Bet he didn't figure we'd think of this case...  */
8402               std::swap (sigfirst, siglast);
8403             }
8404         }
8405       else
8406         {
8407           oursig = gdb_signal_from_name (arg);
8408           if (oursig != GDB_SIGNAL_UNKNOWN)
8409             {
8410               sigfirst = siglast = (int) oursig;
8411             }
8412           else
8413             {
8414               /* Not a number and not a recognized flag word => complain.  */
8415               error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg);
8416             }
8417         }
8418
8419       /* If any signal numbers or symbol names were found, set flags for
8420          which signals to apply actions to.  */
8421
8422       for (int signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
8423         {
8424           switch ((enum gdb_signal) signum)
8425             {
8426             case GDB_SIGNAL_TRAP:
8427             case GDB_SIGNAL_INT:
8428               if (!allsigs && !sigs[signum])
8429                 {
8430                   if (query (_("%s is used by the debugger.\n\
8431 Are you sure you want to change it? "),
8432                              gdb_signal_to_name ((enum gdb_signal) signum)))
8433                     {
8434                       sigs[signum] = 1;
8435                     }
8436                   else
8437                     {
8438                       printf_unfiltered (_("Not confirmed, unchanged.\n"));
8439                       gdb_flush (gdb_stdout);
8440                     }
8441                 }
8442               break;
8443             case GDB_SIGNAL_0:
8444             case GDB_SIGNAL_DEFAULT:
8445             case GDB_SIGNAL_UNKNOWN:
8446               /* Make sure that "all" doesn't print these.  */
8447               break;
8448             default:
8449               sigs[signum] = 1;
8450               break;
8451             }
8452         }
8453     }
8454
8455   for (int signum = 0; signum < nsigs; signum++)
8456     if (sigs[signum])
8457       {
8458         signal_cache_update (-1);
8459         target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8460         target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
8461
8462         if (from_tty)
8463           {
8464             /* Show the results.  */
8465             sig_print_header ();
8466             for (; signum < nsigs; signum++)
8467               if (sigs[signum])
8468                 sig_print_info ((enum gdb_signal) signum);
8469           }
8470
8471         break;
8472       }
8473 }
8474
8475 /* Complete the "handle" command.  */
8476
8477 static void
8478 handle_completer (struct cmd_list_element *ignore,
8479                   completion_tracker &tracker,
8480                   const char *text, const char *word)
8481 {
8482   static const char * const keywords[] =
8483     {
8484       "all",
8485       "stop",
8486       "ignore",
8487       "print",
8488       "pass",
8489       "nostop",
8490       "noignore",
8491       "noprint",
8492       "nopass",
8493       NULL,
8494     };
8495
8496   signal_completer (ignore, tracker, text, word);
8497   complete_on_enum (tracker, keywords, word, word);
8498 }
8499
8500 enum gdb_signal
8501 gdb_signal_from_command (int num)
8502 {
8503   if (num >= 1 && num <= 15)
8504     return (enum gdb_signal) num;
8505   error (_("Only signals 1-15 are valid as numeric signals.\n\
8506 Use \"info signals\" for a list of symbolic signals."));
8507 }
8508
8509 /* Print current contents of the tables set by the handle command.
8510    It is possible we should just be printing signals actually used
8511    by the current target (but for things to work right when switching
8512    targets, all signals should be in the signal tables).  */
8513
8514 static void
8515 info_signals_command (const char *signum_exp, int from_tty)
8516 {
8517   enum gdb_signal oursig;
8518
8519   sig_print_header ();
8520
8521   if (signum_exp)
8522     {
8523       /* First see if this is a symbol name.  */
8524       oursig = gdb_signal_from_name (signum_exp);
8525       if (oursig == GDB_SIGNAL_UNKNOWN)
8526         {
8527           /* No, try numeric.  */
8528           oursig =
8529             gdb_signal_from_command (parse_and_eval_long (signum_exp));
8530         }
8531       sig_print_info (oursig);
8532       return;
8533     }
8534
8535   printf_filtered ("\n");
8536   /* These ugly casts brought to you by the native VAX compiler.  */
8537   for (oursig = GDB_SIGNAL_FIRST;
8538        (int) oursig < (int) GDB_SIGNAL_LAST;
8539        oursig = (enum gdb_signal) ((int) oursig + 1))
8540     {
8541       QUIT;
8542
8543       if (oursig != GDB_SIGNAL_UNKNOWN
8544           && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
8545         sig_print_info (oursig);
8546     }
8547
8548   printf_filtered (_("\nUse the \"handle\" command "
8549                      "to change these tables.\n"));
8550 }
8551
8552 /* The $_siginfo convenience variable is a bit special.  We don't know
8553    for sure the type of the value until we actually have a chance to
8554    fetch the data.  The type can change depending on gdbarch, so it is
8555    also dependent on which thread you have selected.
8556
8557      1. making $_siginfo be an internalvar that creates a new value on
8558      access.
8559
8560      2. making the value of $_siginfo be an lval_computed value.  */
8561
8562 /* This function implements the lval_computed support for reading a
8563    $_siginfo value.  */
8564
8565 static void
8566 siginfo_value_read (struct value *v)
8567 {
8568   LONGEST transferred;
8569
8570   /* If we can access registers, so can we access $_siginfo.  Likewise
8571      vice versa.  */
8572   validate_registers_access ();
8573
8574   transferred =
8575     target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO,
8576                  NULL,
8577                  value_contents_all_raw (v),
8578                  value_offset (v),
8579                  TYPE_LENGTH (value_type (v)));
8580
8581   if (transferred != TYPE_LENGTH (value_type (v)))
8582     error (_("Unable to read siginfo"));
8583 }
8584
8585 /* This function implements the lval_computed support for writing a
8586    $_siginfo value.  */
8587
8588 static void
8589 siginfo_value_write (struct value *v, struct value *fromval)
8590 {
8591   LONGEST transferred;
8592
8593   /* If we can access registers, so can we access $_siginfo.  Likewise
8594      vice versa.  */
8595   validate_registers_access ();
8596
8597   transferred = target_write (current_top_target (),
8598                               TARGET_OBJECT_SIGNAL_INFO,
8599                               NULL,
8600                               value_contents_all_raw (fromval),
8601                               value_offset (v),
8602                               TYPE_LENGTH (value_type (fromval)));
8603
8604   if (transferred != TYPE_LENGTH (value_type (fromval)))
8605     error (_("Unable to write siginfo"));
8606 }
8607
8608 static const struct lval_funcs siginfo_value_funcs =
8609   {
8610     siginfo_value_read,
8611     siginfo_value_write
8612   };
8613
8614 /* Return a new value with the correct type for the siginfo object of
8615    the current thread using architecture GDBARCH.  Return a void value
8616    if there's no object available.  */
8617
8618 static struct value *
8619 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
8620                     void *ignore)
8621 {
8622   if (target_has_stack
8623       && inferior_ptid != null_ptid
8624       && gdbarch_get_siginfo_type_p (gdbarch))
8625     {
8626       struct type *type = gdbarch_get_siginfo_type (gdbarch);
8627
8628       return allocate_computed_value (type, &siginfo_value_funcs, NULL);
8629     }
8630
8631   return allocate_value (builtin_type (gdbarch)->builtin_void);
8632 }
8633
8634 \f
8635 /* infcall_suspend_state contains state about the program itself like its
8636    registers and any signal it received when it last stopped.
8637    This state must be restored regardless of how the inferior function call
8638    ends (either successfully, or after it hits a breakpoint or signal)
8639    if the program is to properly continue where it left off.  */
8640
8641 class infcall_suspend_state
8642 {
8643 public:
8644   /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
8645      once the inferior function call has finished.  */
8646   infcall_suspend_state (struct gdbarch *gdbarch,
8647                          const struct thread_info *tp,
8648                          struct regcache *regcache)
8649     : m_thread_suspend (tp->suspend),
8650       m_registers (new readonly_detached_regcache (*regcache))
8651   {
8652     gdb::unique_xmalloc_ptr<gdb_byte> siginfo_data;
8653
8654     if (gdbarch_get_siginfo_type_p (gdbarch))
8655       {
8656         struct type *type = gdbarch_get_siginfo_type (gdbarch);
8657         size_t len = TYPE_LENGTH (type);
8658
8659         siginfo_data.reset ((gdb_byte *) xmalloc (len));
8660
8661         if (target_read (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
8662                          siginfo_data.get (), 0, len) != len)
8663           {
8664             /* Errors ignored.  */
8665             siginfo_data.reset (nullptr);
8666           }
8667       }
8668
8669     if (siginfo_data)
8670       {
8671         m_siginfo_gdbarch = gdbarch;
8672         m_siginfo_data = std::move (siginfo_data);
8673       }
8674   }
8675
8676   /* Return a pointer to the stored register state.  */
8677
8678   readonly_detached_regcache *registers () const
8679   {
8680     return m_registers.get ();
8681   }
8682
8683   /* Restores the stored state into GDBARCH, TP, and REGCACHE.  */
8684
8685   void restore (struct gdbarch *gdbarch,
8686                 struct thread_info *tp,
8687                 struct regcache *regcache) const
8688   {
8689     tp->suspend = m_thread_suspend;
8690
8691     if (m_siginfo_gdbarch == gdbarch)
8692       {
8693         struct type *type = gdbarch_get_siginfo_type (gdbarch);
8694
8695         /* Errors ignored.  */
8696         target_write (current_top_target (), TARGET_OBJECT_SIGNAL_INFO, NULL,
8697                       m_siginfo_data.get (), 0, TYPE_LENGTH (type));
8698       }
8699
8700     /* The inferior can be gone if the user types "print exit(0)"
8701        (and perhaps other times).  */
8702     if (target_has_execution)
8703       /* NB: The register write goes through to the target.  */
8704       regcache->restore (registers ());
8705   }
8706
8707 private:
8708   /* How the current thread stopped before the inferior function call was
8709      executed.  */
8710   struct thread_suspend_state m_thread_suspend;
8711
8712   /* The registers before the inferior function call was executed.  */
8713   std::unique_ptr<readonly_detached_regcache> m_registers;
8714
8715   /* Format of SIGINFO_DATA or NULL if it is not present.  */
8716   struct gdbarch *m_siginfo_gdbarch = nullptr;
8717
8718   /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8719      TYPE_LENGTH (gdbarch_get_siginfo_type ()).  For different gdbarch the
8720      content would be invalid.  */
8721   gdb::unique_xmalloc_ptr<gdb_byte> m_siginfo_data;
8722 };
8723
8724 infcall_suspend_state_up
8725 save_infcall_suspend_state ()
8726 {
8727   struct thread_info *tp = inferior_thread ();
8728   struct regcache *regcache = get_current_regcache ();
8729   struct gdbarch *gdbarch = regcache->arch ();
8730
8731   infcall_suspend_state_up inf_state
8732     (new struct infcall_suspend_state (gdbarch, tp, regcache));
8733
8734   /* Having saved the current state, adjust the thread state, discarding
8735      any stop signal information.  The stop signal is not useful when
8736      starting an inferior function call, and run_inferior_call will not use
8737      the signal due to its `proceed' call with GDB_SIGNAL_0.  */
8738   tp->suspend.stop_signal = GDB_SIGNAL_0;
8739
8740   return inf_state;
8741 }
8742
8743 /* Restore inferior session state to INF_STATE.  */
8744
8745 void
8746 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8747 {
8748   struct thread_info *tp = inferior_thread ();
8749   struct regcache *regcache = get_current_regcache ();
8750   struct gdbarch *gdbarch = regcache->arch ();
8751
8752   inf_state->restore (gdbarch, tp, regcache);
8753   discard_infcall_suspend_state (inf_state);
8754 }
8755
8756 void
8757 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8758 {
8759   delete inf_state;
8760 }
8761
8762 readonly_detached_regcache *
8763 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
8764 {
8765   return inf_state->registers ();
8766 }
8767
8768 /* infcall_control_state contains state regarding gdb's control of the
8769    inferior itself like stepping control.  It also contains session state like
8770    the user's currently selected frame.  */
8771
8772 struct infcall_control_state
8773 {
8774   struct thread_control_state thread_control;
8775   struct inferior_control_state inferior_control;
8776
8777   /* Other fields:  */
8778   enum stop_stack_kind stop_stack_dummy = STOP_NONE;
8779   int stopped_by_random_signal = 0;
8780
8781   /* ID if the selected frame when the inferior function call was made.  */
8782   struct frame_id selected_frame_id {};
8783 };
8784
8785 /* Save all of the information associated with the inferior<==>gdb
8786    connection.  */
8787
8788 infcall_control_state_up
8789 save_infcall_control_state ()
8790 {
8791   infcall_control_state_up inf_status (new struct infcall_control_state);
8792   struct thread_info *tp = inferior_thread ();
8793   struct inferior *inf = current_inferior ();
8794
8795   inf_status->thread_control = tp->control;
8796   inf_status->inferior_control = inf->control;
8797
8798   tp->control.step_resume_breakpoint = NULL;
8799   tp->control.exception_resume_breakpoint = NULL;
8800
8801   /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8802      chain.  If caller's caller is walking the chain, they'll be happier if we
8803      hand them back the original chain when restore_infcall_control_state is
8804      called.  */
8805   tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
8806
8807   /* Other fields:  */
8808   inf_status->stop_stack_dummy = stop_stack_dummy;
8809   inf_status->stopped_by_random_signal = stopped_by_random_signal;
8810
8811   inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
8812
8813   return inf_status;
8814 }
8815
8816 static void
8817 restore_selected_frame (const frame_id &fid)
8818 {
8819   frame_info *frame = frame_find_by_id (fid);
8820
8821   /* If inf_status->selected_frame_id is NULL, there was no previously
8822      selected frame.  */
8823   if (frame == NULL)
8824     {
8825       warning (_("Unable to restore previously selected frame."));
8826       return;
8827     }
8828
8829   select_frame (frame);
8830 }
8831
8832 /* Restore inferior session state to INF_STATUS.  */
8833
8834 void
8835 restore_infcall_control_state (struct infcall_control_state *inf_status)
8836 {
8837   struct thread_info *tp = inferior_thread ();
8838   struct inferior *inf = current_inferior ();
8839
8840   if (tp->control.step_resume_breakpoint)
8841     tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
8842
8843   if (tp->control.exception_resume_breakpoint)
8844     tp->control.exception_resume_breakpoint->disposition
8845       = disp_del_at_next_stop;
8846
8847   /* Handle the bpstat_copy of the chain.  */
8848   bpstat_clear (&tp->control.stop_bpstat);
8849
8850   tp->control = inf_status->thread_control;
8851   inf->control = inf_status->inferior_control;
8852
8853   /* Other fields:  */
8854   stop_stack_dummy = inf_status->stop_stack_dummy;
8855   stopped_by_random_signal = inf_status->stopped_by_random_signal;
8856
8857   if (target_has_stack)
8858     {
8859       /* The point of the try/catch is that if the stack is clobbered,
8860          walking the stack might encounter a garbage pointer and
8861          error() trying to dereference it.  */
8862       TRY
8863         {
8864           restore_selected_frame (inf_status->selected_frame_id);
8865         }
8866       CATCH (ex, RETURN_MASK_ERROR)
8867         {
8868           exception_fprintf (gdb_stderr, ex,
8869                              "Unable to restore previously selected frame:\n");
8870           /* Error in restoring the selected frame.  Select the
8871              innermost frame.  */
8872           select_frame (get_current_frame ());
8873         }
8874       END_CATCH
8875     }
8876
8877   delete inf_status;
8878 }
8879
8880 void
8881 discard_infcall_control_state (struct infcall_control_state *inf_status)
8882 {
8883   if (inf_status->thread_control.step_resume_breakpoint)
8884     inf_status->thread_control.step_resume_breakpoint->disposition
8885       = disp_del_at_next_stop;
8886
8887   if (inf_status->thread_control.exception_resume_breakpoint)
8888     inf_status->thread_control.exception_resume_breakpoint->disposition
8889       = disp_del_at_next_stop;
8890
8891   /* See save_infcall_control_state for info on stop_bpstat.  */
8892   bpstat_clear (&inf_status->thread_control.stop_bpstat);
8893
8894   delete inf_status;
8895 }
8896 \f
8897 /* See infrun.h.  */
8898
8899 void
8900 clear_exit_convenience_vars (void)
8901 {
8902   clear_internalvar (lookup_internalvar ("_exitsignal"));
8903   clear_internalvar (lookup_internalvar ("_exitcode"));
8904 }
8905 \f
8906
8907 /* User interface for reverse debugging:
8908    Set exec-direction / show exec-direction commands
8909    (returns error unless target implements to_set_exec_direction method).  */
8910
8911 enum exec_direction_kind execution_direction = EXEC_FORWARD;
8912 static const char exec_forward[] = "forward";
8913 static const char exec_reverse[] = "reverse";
8914 static const char *exec_direction = exec_forward;
8915 static const char *const exec_direction_names[] = {
8916   exec_forward,
8917   exec_reverse,
8918   NULL
8919 };
8920
8921 static void
8922 set_exec_direction_func (const char *args, int from_tty,
8923                          struct cmd_list_element *cmd)
8924 {
8925   if (target_can_execute_reverse)
8926     {
8927       if (!strcmp (exec_direction, exec_forward))
8928         execution_direction = EXEC_FORWARD;
8929       else if (!strcmp (exec_direction, exec_reverse))
8930         execution_direction = EXEC_REVERSE;
8931     }
8932   else
8933     {
8934       exec_direction = exec_forward;
8935       error (_("Target does not support this operation."));
8936     }
8937 }
8938
8939 static void
8940 show_exec_direction_func (struct ui_file *out, int from_tty,
8941                           struct cmd_list_element *cmd, const char *value)
8942 {
8943   switch (execution_direction) {
8944   case EXEC_FORWARD:
8945     fprintf_filtered (out, _("Forward.\n"));
8946     break;
8947   case EXEC_REVERSE:
8948     fprintf_filtered (out, _("Reverse.\n"));
8949     break;
8950   default:
8951     internal_error (__FILE__, __LINE__,
8952                     _("bogus execution_direction value: %d"),
8953                     (int) execution_direction);
8954   }
8955 }
8956
8957 static void
8958 show_schedule_multiple (struct ui_file *file, int from_tty,
8959                         struct cmd_list_element *c, const char *value)
8960 {
8961   fprintf_filtered (file, _("Resuming the execution of threads "
8962                             "of all processes is %s.\n"), value);
8963 }
8964
8965 /* Implementation of `siginfo' variable.  */
8966
8967 static const struct internalvar_funcs siginfo_funcs =
8968 {
8969   siginfo_make_value,
8970   NULL,
8971   NULL
8972 };
8973
8974 /* Callback for infrun's target events source.  This is marked when a
8975    thread has a pending status to process.  */
8976
8977 static void
8978 infrun_async_inferior_event_handler (gdb_client_data data)
8979 {
8980   inferior_event_handler (INF_REG_EVENT, NULL);
8981 }
8982
8983 void
8984 _initialize_infrun (void)
8985 {
8986   int i;
8987   int numsigs;
8988   struct cmd_list_element *c;
8989
8990   /* Register extra event sources in the event loop.  */
8991   infrun_async_inferior_event_token
8992     = create_async_event_handler (infrun_async_inferior_event_handler, NULL);
8993
8994   add_info ("signals", info_signals_command, _("\
8995 What debugger does when program gets various signals.\n\
8996 Specify a signal as argument to print info on that signal only."));
8997   add_info_alias ("handle", "signals", 0);
8998
8999   c = add_com ("handle", class_run, handle_command, _("\
9000 Specify how to handle signals.\n\
9001 Usage: handle SIGNAL [ACTIONS]\n\
9002 Args are signals and actions to apply to those signals.\n\
9003 If no actions are specified, the current settings for the specified signals\n\
9004 will be displayed instead.\n\
9005 \n\
9006 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9007 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9008 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9009 The special arg \"all\" is recognized to mean all signals except those\n\
9010 used by the debugger, typically SIGTRAP and SIGINT.\n\
9011 \n\
9012 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9013 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9014 Stop means reenter debugger if this signal happens (implies print).\n\
9015 Print means print a message if this signal happens.\n\
9016 Pass means let program see this signal; otherwise program doesn't know.\n\
9017 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9018 Pass and Stop may be combined.\n\
9019 \n\
9020 Multiple signals may be specified.  Signal numbers and signal names\n\
9021 may be interspersed with actions, with the actions being performed for\n\
9022 all signals cumulatively specified."));
9023   set_cmd_completer (c, handle_completer);
9024
9025   if (!dbx_commands)
9026     stop_command = add_cmd ("stop", class_obscure,
9027                             not_just_help_class_command, _("\
9028 There is no `stop' command, but you can set a hook on `stop'.\n\
9029 This allows you to set a list of commands to be run each time execution\n\
9030 of the program stops."), &cmdlist);
9031
9032   add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
9033 Set inferior debugging."), _("\
9034 Show inferior debugging."), _("\
9035 When non-zero, inferior specific debugging is enabled."),
9036                              NULL,
9037                              show_debug_infrun,
9038                              &setdebuglist, &showdebuglist);
9039
9040   add_setshow_boolean_cmd ("displaced", class_maintenance,
9041                            &debug_displaced, _("\
9042 Set displaced stepping debugging."), _("\
9043 Show displaced stepping debugging."), _("\
9044 When non-zero, displaced stepping specific debugging is enabled."),
9045                             NULL,
9046                             show_debug_displaced,
9047                             &setdebuglist, &showdebuglist);
9048
9049   add_setshow_boolean_cmd ("non-stop", no_class,
9050                            &non_stop_1, _("\
9051 Set whether gdb controls the inferior in non-stop mode."), _("\
9052 Show whether gdb controls the inferior in non-stop mode."), _("\
9053 When debugging a multi-threaded program and this setting is\n\
9054 off (the default, also called all-stop mode), when one thread stops\n\
9055 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9056 all other threads in the program while you interact with the thread of\n\
9057 interest.  When you continue or step a thread, you can allow the other\n\
9058 threads to run, or have them remain stopped, but while you inspect any\n\
9059 thread's state, all threads stop.\n\
9060 \n\
9061 In non-stop mode, when one thread stops, other threads can continue\n\
9062 to run freely.  You'll be able to step each thread independently,\n\
9063 leave it stopped or free to run as needed."),
9064                            set_non_stop,
9065                            show_non_stop,
9066                            &setlist,
9067                            &showlist);
9068
9069   numsigs = (int) GDB_SIGNAL_LAST;
9070   signal_stop = XNEWVEC (unsigned char, numsigs);
9071   signal_print = XNEWVEC (unsigned char, numsigs);
9072   signal_program = XNEWVEC (unsigned char, numsigs);
9073   signal_catch = XNEWVEC (unsigned char, numsigs);
9074   signal_pass = XNEWVEC (unsigned char, numsigs);
9075   for (i = 0; i < numsigs; i++)
9076     {
9077       signal_stop[i] = 1;
9078       signal_print[i] = 1;
9079       signal_program[i] = 1;
9080       signal_catch[i] = 0;
9081     }
9082
9083   /* Signals caused by debugger's own actions should not be given to
9084      the program afterwards.
9085
9086      Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9087      explicitly specifies that it should be delivered to the target
9088      program.  Typically, that would occur when a user is debugging a
9089      target monitor on a simulator: the target monitor sets a
9090      breakpoint; the simulator encounters this breakpoint and halts
9091      the simulation handing control to GDB; GDB, noting that the stop
9092      address doesn't map to any known breakpoint, returns control back
9093      to the simulator; the simulator then delivers the hardware
9094      equivalent of a GDB_SIGNAL_TRAP to the program being
9095      debugged.  */
9096   signal_program[GDB_SIGNAL_TRAP] = 0;
9097   signal_program[GDB_SIGNAL_INT] = 0;
9098
9099   /* Signals that are not errors should not normally enter the debugger.  */
9100   signal_stop[GDB_SIGNAL_ALRM] = 0;
9101   signal_print[GDB_SIGNAL_ALRM] = 0;
9102   signal_stop[GDB_SIGNAL_VTALRM] = 0;
9103   signal_print[GDB_SIGNAL_VTALRM] = 0;
9104   signal_stop[GDB_SIGNAL_PROF] = 0;
9105   signal_print[GDB_SIGNAL_PROF] = 0;
9106   signal_stop[GDB_SIGNAL_CHLD] = 0;
9107   signal_print[GDB_SIGNAL_CHLD] = 0;
9108   signal_stop[GDB_SIGNAL_IO] = 0;
9109   signal_print[GDB_SIGNAL_IO] = 0;
9110   signal_stop[GDB_SIGNAL_POLL] = 0;
9111   signal_print[GDB_SIGNAL_POLL] = 0;
9112   signal_stop[GDB_SIGNAL_URG] = 0;
9113   signal_print[GDB_SIGNAL_URG] = 0;
9114   signal_stop[GDB_SIGNAL_WINCH] = 0;
9115   signal_print[GDB_SIGNAL_WINCH] = 0;
9116   signal_stop[GDB_SIGNAL_PRIO] = 0;
9117   signal_print[GDB_SIGNAL_PRIO] = 0;
9118
9119   /* These signals are used internally by user-level thread
9120      implementations.  (See signal(5) on Solaris.)  Like the above
9121      signals, a healthy program receives and handles them as part of
9122      its normal operation.  */
9123   signal_stop[GDB_SIGNAL_LWP] = 0;
9124   signal_print[GDB_SIGNAL_LWP] = 0;
9125   signal_stop[GDB_SIGNAL_WAITING] = 0;
9126   signal_print[GDB_SIGNAL_WAITING] = 0;
9127   signal_stop[GDB_SIGNAL_CANCEL] = 0;
9128   signal_print[GDB_SIGNAL_CANCEL] = 0;
9129   signal_stop[GDB_SIGNAL_LIBRT] = 0;
9130   signal_print[GDB_SIGNAL_LIBRT] = 0;
9131
9132   /* Update cached state.  */
9133   signal_cache_update (-1);
9134
9135   add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
9136                             &stop_on_solib_events, _("\
9137 Set stopping for shared library events."), _("\
9138 Show stopping for shared library events."), _("\
9139 If nonzero, gdb will give control to the user when the dynamic linker\n\
9140 notifies gdb of shared library events.  The most common event of interest\n\
9141 to the user would be loading/unloading of a new library."),
9142                             set_stop_on_solib_events,
9143                             show_stop_on_solib_events,
9144                             &setlist, &showlist);
9145
9146   add_setshow_enum_cmd ("follow-fork-mode", class_run,
9147                         follow_fork_mode_kind_names,
9148                         &follow_fork_mode_string, _("\
9149 Set debugger response to a program call of fork or vfork."), _("\
9150 Show debugger response to a program call of fork or vfork."), _("\
9151 A fork or vfork creates a new process.  follow-fork-mode can be:\n\
9152   parent  - the original process is debugged after a fork\n\
9153   child   - the new process is debugged after a fork\n\
9154 The unfollowed process will continue to run.\n\
9155 By default, the debugger will follow the parent process."),
9156                         NULL,
9157                         show_follow_fork_mode_string,
9158                         &setlist, &showlist);
9159
9160   add_setshow_enum_cmd ("follow-exec-mode", class_run,
9161                         follow_exec_mode_names,
9162                         &follow_exec_mode_string, _("\
9163 Set debugger response to a program call of exec."), _("\
9164 Show debugger response to a program call of exec."), _("\
9165 An exec call replaces the program image of a process.\n\
9166 \n\
9167 follow-exec-mode can be:\n\
9168 \n\
9169   new - the debugger creates a new inferior and rebinds the process\n\
9170 to this new inferior.  The program the process was running before\n\
9171 the exec call can be restarted afterwards by restarting the original\n\
9172 inferior.\n\
9173 \n\
9174   same - the debugger keeps the process bound to the same inferior.\n\
9175 The new executable image replaces the previous executable loaded in\n\
9176 the inferior.  Restarting the inferior after the exec call restarts\n\
9177 the executable the process was running after the exec call.\n\
9178 \n\
9179 By default, the debugger will use the same inferior."),
9180                         NULL,
9181                         show_follow_exec_mode_string,
9182                         &setlist, &showlist);
9183
9184   add_setshow_enum_cmd ("scheduler-locking", class_run, 
9185                         scheduler_enums, &scheduler_mode, _("\
9186 Set mode for locking scheduler during execution."), _("\
9187 Show mode for locking scheduler during execution."), _("\
9188 off    == no locking (threads may preempt at any time)\n\
9189 on     == full locking (no thread except the current thread may run)\n\
9190           This applies to both normal execution and replay mode.\n\
9191 step   == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9192           In this mode, other threads may run during other commands.\n\
9193           This applies to both normal execution and replay mode.\n\
9194 replay == scheduler locked in replay mode and unlocked during normal execution."),
9195                         set_schedlock_func,     /* traps on target vector */
9196                         show_scheduler_mode,
9197                         &setlist, &showlist);
9198
9199   add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
9200 Set mode for resuming threads of all processes."), _("\
9201 Show mode for resuming threads of all processes."), _("\
9202 When on, execution commands (such as 'continue' or 'next') resume all\n\
9203 threads of all processes.  When off (which is the default), execution\n\
9204 commands only resume the threads of the current process.  The set of\n\
9205 threads that are resumed is further refined by the scheduler-locking\n\
9206 mode (see help set scheduler-locking)."),
9207                            NULL,
9208                            show_schedule_multiple,
9209                            &setlist, &showlist);
9210
9211   add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
9212 Set mode of the step operation."), _("\
9213 Show mode of the step operation."), _("\
9214 When set, doing a step over a function without debug line information\n\
9215 will stop at the first instruction of that function. Otherwise, the\n\
9216 function is skipped and the step command stops at a different source line."),
9217                            NULL,
9218                            show_step_stop_if_no_debug,
9219                            &setlist, &showlist);
9220
9221   add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
9222                                 &can_use_displaced_stepping, _("\
9223 Set debugger's willingness to use displaced stepping."), _("\
9224 Show debugger's willingness to use displaced stepping."), _("\
9225 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9226 supported by the target architecture.  If off, gdb will not use displaced\n\
9227 stepping to step over breakpoints, even if such is supported by the target\n\
9228 architecture.  If auto (which is the default), gdb will use displaced stepping\n\
9229 if the target architecture supports it and non-stop mode is active, but will not\n\
9230 use it in all-stop mode (see help set non-stop)."),
9231                                 NULL,
9232                                 show_can_use_displaced_stepping,
9233                                 &setlist, &showlist);
9234
9235   add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
9236                         &exec_direction, _("Set direction of execution.\n\
9237 Options are 'forward' or 'reverse'."),
9238                         _("Show direction of execution (forward/reverse)."),
9239                         _("Tells gdb whether to execute forward or backward."),
9240                         set_exec_direction_func, show_exec_direction_func,
9241                         &setlist, &showlist);
9242
9243   /* Set/show detach-on-fork: user-settable mode.  */
9244
9245   add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
9246 Set whether gdb will detach the child of a fork."), _("\
9247 Show whether gdb will detach the child of a fork."), _("\
9248 Tells gdb whether to detach the child of a fork."),
9249                            NULL, NULL, &setlist, &showlist);
9250
9251   /* Set/show disable address space randomization mode.  */
9252
9253   add_setshow_boolean_cmd ("disable-randomization", class_support,
9254                            &disable_randomization, _("\
9255 Set disabling of debuggee's virtual address space randomization."), _("\
9256 Show disabling of debuggee's virtual address space randomization."), _("\
9257 When this mode is on (which is the default), randomization of the virtual\n\
9258 address space is disabled.  Standalone programs run with the randomization\n\
9259 enabled by default on some platforms."),
9260                            &set_disable_randomization,
9261                            &show_disable_randomization,
9262                            &setlist, &showlist);
9263
9264   /* ptid initializations */
9265   inferior_ptid = null_ptid;
9266   target_last_wait_ptid = minus_one_ptid;
9267
9268   gdb::observers::thread_ptid_changed.attach (infrun_thread_ptid_changed);
9269   gdb::observers::thread_stop_requested.attach (infrun_thread_stop_requested);
9270   gdb::observers::thread_exit.attach (infrun_thread_thread_exit);
9271   gdb::observers::inferior_exit.attach (infrun_inferior_exit);
9272
9273   /* Explicitly create without lookup, since that tries to create a
9274      value with a void typed value, and when we get here, gdbarch
9275      isn't initialized yet.  At this point, we're quite sure there
9276      isn't another convenience variable of the same name.  */
9277   create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
9278
9279   add_setshow_boolean_cmd ("observer", no_class,
9280                            &observer_mode_1, _("\
9281 Set whether gdb controls the inferior in observer mode."), _("\
9282 Show whether gdb controls the inferior in observer mode."), _("\
9283 In observer mode, GDB can get data from the inferior, but not\n\
9284 affect its execution.  Registers and memory may not be changed,\n\
9285 breakpoints may not be set, and the program cannot be interrupted\n\
9286 or signalled."),
9287                            set_observer_mode,
9288                            show_observer_mode,
9289                            &setlist,
9290                            &showlist);
9291 }