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