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