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