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