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