7b437858ec8b09b992f92a8827bcbd07c68db909
[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-2014 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
64 /* Prototypes for local functions */
65
66 static void signals_info (char *, int);
67
68 static void handle_command (char *, int);
69
70 static void sig_print_info (enum gdb_signal);
71
72 static void sig_print_header (void);
73
74 static void resume_cleanups (void *);
75
76 static int hook_stop_stub (void *);
77
78 static int restore_selected_frame (void *);
79
80 static int follow_fork (void);
81
82 static int follow_fork_inferior (int follow_child, int detach_fork);
83
84 static void follow_inferior_reset_breakpoints (void);
85
86 static void set_schedlock_func (char *args, int from_tty,
87                                 struct cmd_list_element *c);
88
89 static int currently_stepping (struct thread_info *tp);
90
91 static void xdb_handle_command (char *args, int from_tty);
92
93 void _initialize_infrun (void);
94
95 void nullify_last_target_wait_ptid (void);
96
97 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
98
99 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
100
101 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
102
103 /* When set, stop the 'step' command if we enter a function which has
104    no line number information.  The normal behavior is that we step
105    over such function.  */
106 int step_stop_if_no_debug = 0;
107 static void
108 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
109                             struct cmd_list_element *c, const char *value)
110 {
111   fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
112 }
113
114 /* In asynchronous mode, but simulating synchronous execution.  */
115
116 int sync_execution = 0;
117
118 /* proceed and normal_stop use this to notify the user when the
119    inferior stopped in a different thread than it had been running
120    in.  */
121
122 static ptid_t previous_inferior_ptid;
123
124 /* If set (default for legacy reasons), when following a fork, GDB
125    will detach from one of the fork branches, child or parent.
126    Exactly which branch is detached depends on 'set follow-fork-mode'
127    setting.  */
128
129 static int detach_fork = 1;
130
131 int debug_displaced = 0;
132 static void
133 show_debug_displaced (struct ui_file *file, int from_tty,
134                       struct cmd_list_element *c, const char *value)
135 {
136   fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
137 }
138
139 unsigned int debug_infrun = 0;
140 static void
141 show_debug_infrun (struct ui_file *file, int from_tty,
142                    struct cmd_list_element *c, const char *value)
143 {
144   fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
145 }
146
147
148 /* Support for disabling address space randomization.  */
149
150 int disable_randomization = 1;
151
152 static void
153 show_disable_randomization (struct ui_file *file, int from_tty,
154                             struct cmd_list_element *c, const char *value)
155 {
156   if (target_supports_disable_randomization ())
157     fprintf_filtered (file,
158                       _("Disabling randomization of debuggee's "
159                         "virtual address space is %s.\n"),
160                       value);
161   else
162     fputs_filtered (_("Disabling randomization of debuggee's "
163                       "virtual address space is unsupported on\n"
164                       "this platform.\n"), file);
165 }
166
167 static void
168 set_disable_randomization (char *args, int from_tty,
169                            struct cmd_list_element *c)
170 {
171   if (!target_supports_disable_randomization ())
172     error (_("Disabling randomization of debuggee's "
173              "virtual address space is unsupported on\n"
174              "this platform."));
175 }
176
177 /* User interface for non-stop mode.  */
178
179 int non_stop = 0;
180 static int non_stop_1 = 0;
181
182 static void
183 set_non_stop (char *args, int from_tty,
184               struct cmd_list_element *c)
185 {
186   if (target_has_execution)
187     {
188       non_stop_1 = non_stop;
189       error (_("Cannot change this setting while the inferior is running."));
190     }
191
192   non_stop = non_stop_1;
193 }
194
195 static void
196 show_non_stop (struct ui_file *file, int from_tty,
197                struct cmd_list_element *c, const char *value)
198 {
199   fprintf_filtered (file,
200                     _("Controlling the inferior in non-stop mode is %s.\n"),
201                     value);
202 }
203
204 /* "Observer mode" is somewhat like a more extreme version of
205    non-stop, in which all GDB operations that might affect the
206    target's execution have been disabled.  */
207
208 int observer_mode = 0;
209 static int observer_mode_1 = 0;
210
211 static void
212 set_observer_mode (char *args, int from_tty,
213                    struct cmd_list_element *c)
214 {
215   if (target_has_execution)
216     {
217       observer_mode_1 = observer_mode;
218       error (_("Cannot change this setting while the inferior is running."));
219     }
220
221   observer_mode = observer_mode_1;
222
223   may_write_registers = !observer_mode;
224   may_write_memory = !observer_mode;
225   may_insert_breakpoints = !observer_mode;
226   may_insert_tracepoints = !observer_mode;
227   /* We can insert fast tracepoints in or out of observer mode,
228      but enable them if we're going into this mode.  */
229   if (observer_mode)
230     may_insert_fast_tracepoints = 1;
231   may_stop = !observer_mode;
232   update_target_permissions ();
233
234   /* Going *into* observer mode we must force non-stop, then
235      going out we leave it that way.  */
236   if (observer_mode)
237     {
238       pagination_enabled = 0;
239       non_stop = non_stop_1 = 1;
240     }
241
242   if (from_tty)
243     printf_filtered (_("Observer mode is now %s.\n"),
244                      (observer_mode ? "on" : "off"));
245 }
246
247 static void
248 show_observer_mode (struct ui_file *file, int from_tty,
249                     struct cmd_list_element *c, const char *value)
250 {
251   fprintf_filtered (file, _("Observer mode is %s.\n"), value);
252 }
253
254 /* This updates the value of observer mode based on changes in
255    permissions.  Note that we are deliberately ignoring the values of
256    may-write-registers and may-write-memory, since the user may have
257    reason to enable these during a session, for instance to turn on a
258    debugging-related global.  */
259
260 void
261 update_observer_mode (void)
262 {
263   int newval;
264
265   newval = (!may_insert_breakpoints
266             && !may_insert_tracepoints
267             && may_insert_fast_tracepoints
268             && !may_stop
269             && non_stop);
270
271   /* Let the user know if things change.  */
272   if (newval != observer_mode)
273     printf_filtered (_("Observer mode is now %s.\n"),
274                      (newval ? "on" : "off"));
275
276   observer_mode = observer_mode_1 = newval;
277 }
278
279 /* Tables of how to react to signals; the user sets them.  */
280
281 static unsigned char *signal_stop;
282 static unsigned char *signal_print;
283 static unsigned char *signal_program;
284
285 /* Table of signals that are registered with "catch signal".  A
286    non-zero entry indicates that the signal is caught by some "catch
287    signal" command.  This has size GDB_SIGNAL_LAST, to accommodate all
288    signals.  */
289 static unsigned char *signal_catch;
290
291 /* Table of signals that the target may silently handle.
292    This is automatically determined from the flags above,
293    and simply cached here.  */
294 static unsigned char *signal_pass;
295
296 #define SET_SIGS(nsigs,sigs,flags) \
297   do { \
298     int signum = (nsigs); \
299     while (signum-- > 0) \
300       if ((sigs)[signum]) \
301         (flags)[signum] = 1; \
302   } while (0)
303
304 #define UNSET_SIGS(nsigs,sigs,flags) \
305   do { \
306     int signum = (nsigs); \
307     while (signum-- > 0) \
308       if ((sigs)[signum]) \
309         (flags)[signum] = 0; \
310   } while (0)
311
312 /* Update the target's copy of SIGNAL_PROGRAM.  The sole purpose of
313    this function is to avoid exporting `signal_program'.  */
314
315 void
316 update_signals_program_target (void)
317 {
318   target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
319 }
320
321 /* Value to pass to target_resume() to cause all threads to resume.  */
322
323 #define RESUME_ALL minus_one_ptid
324
325 /* Command list pointer for the "stop" placeholder.  */
326
327 static struct cmd_list_element *stop_command;
328
329 /* Function inferior was in as of last step command.  */
330
331 static struct symbol *step_start_function;
332
333 /* Nonzero if we want to give control to the user when we're notified
334    of shared library events by the dynamic linker.  */
335 int stop_on_solib_events;
336
337 /* Enable or disable optional shared library event breakpoints
338    as appropriate when the above flag is changed.  */
339
340 static void
341 set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
342 {
343   update_solib_breakpoints ();
344 }
345
346 static void
347 show_stop_on_solib_events (struct ui_file *file, int from_tty,
348                            struct cmd_list_element *c, const char *value)
349 {
350   fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
351                     value);
352 }
353
354 /* Nonzero means expecting a trace trap
355    and should stop the inferior and return silently when it happens.  */
356
357 int stop_after_trap;
358
359 /* Save register contents here when executing a "finish" command or are
360    about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set.
361    Thus this contains the return value from the called function (assuming
362    values are returned in a register).  */
363
364 struct regcache *stop_registers;
365
366 /* Nonzero after stop if current stack frame should be printed.  */
367
368 static int stop_print_frame;
369
370 /* This is a cached copy of the pid/waitstatus of the last event
371    returned by target_wait()/deprecated_target_wait_hook().  This
372    information is returned by get_last_target_status().  */
373 static ptid_t target_last_wait_ptid;
374 static struct target_waitstatus target_last_waitstatus;
375
376 static void context_switch (ptid_t ptid);
377
378 void init_thread_stepping_state (struct thread_info *tss);
379
380 static void init_infwait_state (void);
381
382 static const char follow_fork_mode_child[] = "child";
383 static const char follow_fork_mode_parent[] = "parent";
384
385 static const char *const follow_fork_mode_kind_names[] = {
386   follow_fork_mode_child,
387   follow_fork_mode_parent,
388   NULL
389 };
390
391 static const char *follow_fork_mode_string = follow_fork_mode_parent;
392 static void
393 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
394                               struct cmd_list_element *c, const char *value)
395 {
396   fprintf_filtered (file,
397                     _("Debugger response to a program "
398                       "call of fork or vfork is \"%s\".\n"),
399                     value);
400 }
401 \f
402
403 /* Handle changes to the inferior list based on the type of fork,
404    which process is being followed, and whether the other process
405    should be detached.  On entry inferior_ptid must be the ptid of
406    the fork parent.  At return inferior_ptid is the ptid of the
407    followed inferior.  */
408
409 static int
410 follow_fork_inferior (int follow_child, int detach_fork)
411 {
412   int has_vforked;
413   int parent_pid, child_pid;
414
415   has_vforked = (inferior_thread ()->pending_follow.kind
416                  == TARGET_WAITKIND_VFORKED);
417   parent_pid = ptid_get_lwp (inferior_ptid);
418   if (parent_pid == 0)
419     parent_pid = ptid_get_pid (inferior_ptid);
420   child_pid
421     = ptid_get_pid (inferior_thread ()->pending_follow.value.related_pid);
422
423   if (has_vforked
424       && !non_stop /* Non-stop always resumes both branches.  */
425       && (!target_is_async_p () || sync_execution)
426       && !(follow_child || detach_fork || sched_multi))
427     {
428       /* The parent stays blocked inside the vfork syscall until the
429          child execs or exits.  If we don't let the child run, then
430          the parent stays blocked.  If we're telling the parent to run
431          in the foreground, the user will not be able to ctrl-c to get
432          back the terminal, effectively hanging the debug session.  */
433       fprintf_filtered (gdb_stderr, _("\
434 Can not resume the parent process over vfork in the foreground while\n\
435 holding the child stopped.  Try \"set detach-on-fork\" or \
436 \"set schedule-multiple\".\n"));
437       /* FIXME output string > 80 columns.  */
438       return 1;
439     }
440
441   if (!follow_child)
442     {
443       /* Detach new forked process?  */
444       if (detach_fork)
445         {
446           struct cleanup *old_chain;
447
448           /* Before detaching from the child, remove all breakpoints
449              from it.  If we forked, then this has already been taken
450              care of by infrun.c.  If we vforked however, any
451              breakpoint inserted in the parent is visible in the
452              child, even those added while stopped in a vfork
453              catchpoint.  This will remove the breakpoints from the
454              parent also, but they'll be reinserted below.  */
455           if (has_vforked)
456             {
457               /* Keep breakpoints list in sync.  */
458               remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
459             }
460
461           if (info_verbose || debug_infrun)
462             {
463               target_terminal_ours ();
464               fprintf_filtered (gdb_stdlog,
465                                 "Detaching after fork from "
466                                 "child process %d.\n",
467                                 child_pid);
468             }
469         }
470       else
471         {
472           struct inferior *parent_inf, *child_inf;
473           struct cleanup *old_chain;
474
475           /* Add process to GDB's tables.  */
476           child_inf = add_inferior (child_pid);
477
478           parent_inf = current_inferior ();
479           child_inf->attach_flag = parent_inf->attach_flag;
480           copy_terminal_info (child_inf, parent_inf);
481           child_inf->gdbarch = parent_inf->gdbarch;
482           copy_inferior_target_desc_info (child_inf, parent_inf);
483
484           old_chain = save_inferior_ptid ();
485           save_current_program_space ();
486
487           inferior_ptid = ptid_build (child_pid, child_pid, 0);
488           add_thread (inferior_ptid);
489           child_inf->symfile_flags = SYMFILE_NO_READ;
490
491           /* If this is a vfork child, then the address-space is
492              shared with the parent.  */
493           if (has_vforked)
494             {
495               child_inf->pspace = parent_inf->pspace;
496               child_inf->aspace = parent_inf->aspace;
497
498               /* The parent will be frozen until the child is done
499                  with the shared region.  Keep track of the
500                  parent.  */
501               child_inf->vfork_parent = parent_inf;
502               child_inf->pending_detach = 0;
503               parent_inf->vfork_child = child_inf;
504               parent_inf->pending_detach = 0;
505             }
506           else
507             {
508               child_inf->aspace = new_address_space ();
509               child_inf->pspace = add_program_space (child_inf->aspace);
510               child_inf->removable = 1;
511               set_current_program_space (child_inf->pspace);
512               clone_program_space (child_inf->pspace, parent_inf->pspace);
513
514               /* Let the shared library layer (e.g., solib-svr4) learn
515                  about this new process, relocate the cloned exec, pull
516                  in shared libraries, and install the solib event
517                  breakpoint.  If a "cloned-VM" event was propagated
518                  better throughout the core, this wouldn't be
519                  required.  */
520               solib_create_inferior_hook (0);
521             }
522
523           do_cleanups (old_chain);
524         }
525
526       if (has_vforked)
527         {
528           struct inferior *parent_inf;
529
530           parent_inf = current_inferior ();
531
532           /* If we detached from the child, then we have to be careful
533              to not insert breakpoints in the parent until the child
534              is done with the shared memory region.  However, if we're
535              staying attached to the child, then we can and should
536              insert breakpoints, so that we can debug it.  A
537              subsequent child exec or exit is enough to know when does
538              the child stops using the parent's address space.  */
539           parent_inf->waiting_for_vfork_done = detach_fork;
540           parent_inf->pspace->breakpoints_not_allowed = detach_fork;
541         }
542     }
543   else
544     {
545       /* Follow the child.  */
546       struct inferior *parent_inf, *child_inf;
547       struct program_space *parent_pspace;
548
549       if (info_verbose || debug_infrun)
550         {
551           target_terminal_ours ();
552           if (has_vforked)
553             fprintf_filtered (gdb_stdlog,
554                               _("Attaching after process %d "
555                                 "vfork to child process %d.\n"),
556                               parent_pid, child_pid);
557           else
558             fprintf_filtered (gdb_stdlog,
559                               _("Attaching after process %d "
560                                 "fork to child process %d.\n"),
561                               parent_pid, child_pid);
562         }
563
564       /* Add the new inferior first, so that the target_detach below
565          doesn't unpush the target.  */
566
567       child_inf = add_inferior (child_pid);
568
569       parent_inf = current_inferior ();
570       child_inf->attach_flag = parent_inf->attach_flag;
571       copy_terminal_info (child_inf, parent_inf);
572       child_inf->gdbarch = parent_inf->gdbarch;
573       copy_inferior_target_desc_info (child_inf, parent_inf);
574
575       parent_pspace = parent_inf->pspace;
576
577       /* If we're vforking, we want to hold on to the parent until the
578          child exits or execs.  At child exec or exit time we can
579          remove the old breakpoints from the parent and detach or
580          resume debugging it.  Otherwise, detach the parent now; we'll
581          want to reuse it's program/address spaces, but we can't set
582          them to the child before removing breakpoints from the
583          parent, otherwise, the breakpoints module could decide to
584          remove breakpoints from the wrong process (since they'd be
585          assigned to the same address space).  */
586
587       if (has_vforked)
588         {
589           gdb_assert (child_inf->vfork_parent == NULL);
590           gdb_assert (parent_inf->vfork_child == NULL);
591           child_inf->vfork_parent = parent_inf;
592           child_inf->pending_detach = 0;
593           parent_inf->vfork_child = child_inf;
594           parent_inf->pending_detach = detach_fork;
595           parent_inf->waiting_for_vfork_done = 0;
596         }
597       else if (detach_fork)
598         target_detach (NULL, 0);
599
600       /* Note that the detach above makes PARENT_INF dangling.  */
601
602       /* Add the child thread to the appropriate lists, and switch to
603          this new thread, before cloning the program space, and
604          informing the solib layer about this new process.  */
605
606       inferior_ptid = ptid_build (child_pid, child_pid, 0);
607       add_thread (inferior_ptid);
608
609       /* If this is a vfork child, then the address-space is shared
610          with the parent.  If we detached from the parent, then we can
611          reuse the parent's program/address spaces.  */
612       if (has_vforked || detach_fork)
613         {
614           child_inf->pspace = parent_pspace;
615           child_inf->aspace = child_inf->pspace->aspace;
616         }
617       else
618         {
619           child_inf->aspace = new_address_space ();
620           child_inf->pspace = add_program_space (child_inf->aspace);
621           child_inf->removable = 1;
622           child_inf->symfile_flags = SYMFILE_NO_READ;
623           set_current_program_space (child_inf->pspace);
624           clone_program_space (child_inf->pspace, parent_pspace);
625
626           /* Let the shared library layer (e.g., solib-svr4) learn
627              about this new process, relocate the cloned exec, pull in
628              shared libraries, and install the solib event breakpoint.
629              If a "cloned-VM" event was propagated better throughout
630              the core, this wouldn't be required.  */
631           solib_create_inferior_hook (0);
632         }
633     }
634
635   return target_follow_fork (follow_child, detach_fork);
636 }
637
638 /* Tell the target to follow the fork we're stopped at.  Returns true
639    if the inferior should be resumed; false, if the target for some
640    reason decided it's best not to resume.  */
641
642 static int
643 follow_fork (void)
644 {
645   int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
646   int should_resume = 1;
647   struct thread_info *tp;
648
649   /* Copy user stepping state to the new inferior thread.  FIXME: the
650      followed fork child thread should have a copy of most of the
651      parent thread structure's run control related fields, not just these.
652      Initialized to avoid "may be used uninitialized" warnings from gcc.  */
653   struct breakpoint *step_resume_breakpoint = NULL;
654   struct breakpoint *exception_resume_breakpoint = NULL;
655   CORE_ADDR step_range_start = 0;
656   CORE_ADDR step_range_end = 0;
657   struct frame_id step_frame_id = { 0 };
658   struct interp *command_interp = NULL;
659
660   if (!non_stop)
661     {
662       ptid_t wait_ptid;
663       struct target_waitstatus wait_status;
664
665       /* Get the last target status returned by target_wait().  */
666       get_last_target_status (&wait_ptid, &wait_status);
667
668       /* If not stopped at a fork event, then there's nothing else to
669          do.  */
670       if (wait_status.kind != TARGET_WAITKIND_FORKED
671           && wait_status.kind != TARGET_WAITKIND_VFORKED)
672         return 1;
673
674       /* Check if we switched over from WAIT_PTID, since the event was
675          reported.  */
676       if (!ptid_equal (wait_ptid, minus_one_ptid)
677           && !ptid_equal (inferior_ptid, wait_ptid))
678         {
679           /* We did.  Switch back to WAIT_PTID thread, to tell the
680              target to follow it (in either direction).  We'll
681              afterwards refuse to resume, and inform the user what
682              happened.  */
683           switch_to_thread (wait_ptid);
684           should_resume = 0;
685         }
686     }
687
688   tp = inferior_thread ();
689
690   /* If there were any forks/vforks that were caught and are now to be
691      followed, then do so now.  */
692   switch (tp->pending_follow.kind)
693     {
694     case TARGET_WAITKIND_FORKED:
695     case TARGET_WAITKIND_VFORKED:
696       {
697         ptid_t parent, child;
698
699         /* If the user did a next/step, etc, over a fork call,
700            preserve the stepping state in the fork child.  */
701         if (follow_child && should_resume)
702           {
703             step_resume_breakpoint = clone_momentary_breakpoint
704                                          (tp->control.step_resume_breakpoint);
705             step_range_start = tp->control.step_range_start;
706             step_range_end = tp->control.step_range_end;
707             step_frame_id = tp->control.step_frame_id;
708             exception_resume_breakpoint
709               = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
710             command_interp = tp->control.command_interp;
711
712             /* For now, delete the parent's sr breakpoint, otherwise,
713                parent/child sr breakpoints are considered duplicates,
714                and the child version will not be installed.  Remove
715                this when the breakpoints module becomes aware of
716                inferiors and address spaces.  */
717             delete_step_resume_breakpoint (tp);
718             tp->control.step_range_start = 0;
719             tp->control.step_range_end = 0;
720             tp->control.step_frame_id = null_frame_id;
721             delete_exception_resume_breakpoint (tp);
722             tp->control.command_interp = NULL;
723           }
724
725         parent = inferior_ptid;
726         child = tp->pending_follow.value.related_pid;
727
728         /* Set up inferior(s) as specified by the caller, and tell the
729            target to do whatever is necessary to follow either parent
730            or child.  */
731         if (follow_fork_inferior (follow_child, detach_fork))
732           {
733             /* Target refused to follow, or there's some other reason
734                we shouldn't resume.  */
735             should_resume = 0;
736           }
737         else
738           {
739             /* This pending follow fork event is now handled, one way
740                or another.  The previous selected thread may be gone
741                from the lists by now, but if it is still around, need
742                to clear the pending follow request.  */
743             tp = find_thread_ptid (parent);
744             if (tp)
745               tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
746
747             /* This makes sure we don't try to apply the "Switched
748                over from WAIT_PID" logic above.  */
749             nullify_last_target_wait_ptid ();
750
751             /* If we followed the child, switch to it...  */
752             if (follow_child)
753               {
754                 switch_to_thread (child);
755
756                 /* ... and preserve the stepping state, in case the
757                    user was stepping over the fork call.  */
758                 if (should_resume)
759                   {
760                     tp = inferior_thread ();
761                     tp->control.step_resume_breakpoint
762                       = step_resume_breakpoint;
763                     tp->control.step_range_start = step_range_start;
764                     tp->control.step_range_end = step_range_end;
765                     tp->control.step_frame_id = step_frame_id;
766                     tp->control.exception_resume_breakpoint
767                       = exception_resume_breakpoint;
768                     tp->control.command_interp = command_interp;
769                   }
770                 else
771                   {
772                     /* If we get here, it was because we're trying to
773                        resume from a fork catchpoint, but, the user
774                        has switched threads away from the thread that
775                        forked.  In that case, the resume command
776                        issued is most likely not applicable to the
777                        child, so just warn, and refuse to resume.  */
778                     warning (_("Not resuming: switched threads "
779                                "before following fork child.\n"));
780                   }
781
782                 /* Reset breakpoints in the child as appropriate.  */
783                 follow_inferior_reset_breakpoints ();
784               }
785             else
786               switch_to_thread (parent);
787           }
788       }
789       break;
790     case TARGET_WAITKIND_SPURIOUS:
791       /* Nothing to follow.  */
792       break;
793     default:
794       internal_error (__FILE__, __LINE__,
795                       "Unexpected pending_follow.kind %d\n",
796                       tp->pending_follow.kind);
797       break;
798     }
799
800   return should_resume;
801 }
802
803 static void
804 follow_inferior_reset_breakpoints (void)
805 {
806   struct thread_info *tp = inferior_thread ();
807
808   /* Was there a step_resume breakpoint?  (There was if the user
809      did a "next" at the fork() call.)  If so, explicitly reset its
810      thread number.  Cloned step_resume breakpoints are disabled on
811      creation, so enable it here now that it is associated with the
812      correct thread.
813
814      step_resumes are a form of bp that are made to be per-thread.
815      Since we created the step_resume bp when the parent process
816      was being debugged, and now are switching to the child process,
817      from the breakpoint package's viewpoint, that's a switch of
818      "threads".  We must update the bp's notion of which thread
819      it is for, or it'll be ignored when it triggers.  */
820
821   if (tp->control.step_resume_breakpoint)
822     {
823       breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
824       tp->control.step_resume_breakpoint->loc->enabled = 1;
825     }
826
827   /* Treat exception_resume breakpoints like step_resume breakpoints.  */
828   if (tp->control.exception_resume_breakpoint)
829     {
830       breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
831       tp->control.exception_resume_breakpoint->loc->enabled = 1;
832     }
833
834   /* Reinsert all breakpoints in the child.  The user may have set
835      breakpoints after catching the fork, in which case those
836      were never set in the child, but only in the parent.  This makes
837      sure the inserted breakpoints match the breakpoint list.  */
838
839   breakpoint_re_set ();
840   insert_breakpoints ();
841 }
842
843 /* The child has exited or execed: resume threads of the parent the
844    user wanted to be executing.  */
845
846 static int
847 proceed_after_vfork_done (struct thread_info *thread,
848                           void *arg)
849 {
850   int pid = * (int *) arg;
851
852   if (ptid_get_pid (thread->ptid) == pid
853       && is_running (thread->ptid)
854       && !is_executing (thread->ptid)
855       && !thread->stop_requested
856       && thread->suspend.stop_signal == GDB_SIGNAL_0)
857     {
858       if (debug_infrun)
859         fprintf_unfiltered (gdb_stdlog,
860                             "infrun: resuming vfork parent thread %s\n",
861                             target_pid_to_str (thread->ptid));
862
863       switch_to_thread (thread->ptid);
864       clear_proceed_status (0);
865       proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
866     }
867
868   return 0;
869 }
870
871 /* Called whenever we notice an exec or exit event, to handle
872    detaching or resuming a vfork parent.  */
873
874 static void
875 handle_vfork_child_exec_or_exit (int exec)
876 {
877   struct inferior *inf = current_inferior ();
878
879   if (inf->vfork_parent)
880     {
881       int resume_parent = -1;
882
883       /* This exec or exit marks the end of the shared memory region
884          between the parent and the child.  If the user wanted to
885          detach from the parent, now is the time.  */
886
887       if (inf->vfork_parent->pending_detach)
888         {
889           struct thread_info *tp;
890           struct cleanup *old_chain;
891           struct program_space *pspace;
892           struct address_space *aspace;
893
894           /* follow-fork child, detach-on-fork on.  */
895
896           inf->vfork_parent->pending_detach = 0;
897
898           if (!exec)
899             {
900               /* If we're handling a child exit, then inferior_ptid
901                  points at the inferior's pid, not to a thread.  */
902               old_chain = save_inferior_ptid ();
903               save_current_program_space ();
904               save_current_inferior ();
905             }
906           else
907             old_chain = save_current_space_and_thread ();
908
909           /* We're letting loose of the parent.  */
910           tp = any_live_thread_of_process (inf->vfork_parent->pid);
911           switch_to_thread (tp->ptid);
912
913           /* We're about to detach from the parent, which implicitly
914              removes breakpoints from its address space.  There's a
915              catch here: we want to reuse the spaces for the child,
916              but, parent/child are still sharing the pspace at this
917              point, although the exec in reality makes the kernel give
918              the child a fresh set of new pages.  The problem here is
919              that the breakpoints module being unaware of this, would
920              likely chose the child process to write to the parent
921              address space.  Swapping the child temporarily away from
922              the spaces has the desired effect.  Yes, this is "sort
923              of" a hack.  */
924
925           pspace = inf->pspace;
926           aspace = inf->aspace;
927           inf->aspace = NULL;
928           inf->pspace = NULL;
929
930           if (debug_infrun || info_verbose)
931             {
932               target_terminal_ours ();
933
934               if (exec)
935                 fprintf_filtered (gdb_stdlog,
936                                   "Detaching vfork parent process "
937                                   "%d after child exec.\n",
938                                   inf->vfork_parent->pid);
939               else
940                 fprintf_filtered (gdb_stdlog,
941                                   "Detaching vfork parent process "
942                                   "%d after child exit.\n",
943                                   inf->vfork_parent->pid);
944             }
945
946           target_detach (NULL, 0);
947
948           /* Put it back.  */
949           inf->pspace = pspace;
950           inf->aspace = aspace;
951
952           do_cleanups (old_chain);
953         }
954       else if (exec)
955         {
956           /* We're staying attached to the parent, so, really give the
957              child a new address space.  */
958           inf->pspace = add_program_space (maybe_new_address_space ());
959           inf->aspace = inf->pspace->aspace;
960           inf->removable = 1;
961           set_current_program_space (inf->pspace);
962
963           resume_parent = inf->vfork_parent->pid;
964
965           /* Break the bonds.  */
966           inf->vfork_parent->vfork_child = NULL;
967         }
968       else
969         {
970           struct cleanup *old_chain;
971           struct program_space *pspace;
972
973           /* If this is a vfork child exiting, then the pspace and
974              aspaces were shared with the parent.  Since we're
975              reporting the process exit, we'll be mourning all that is
976              found in the address space, and switching to null_ptid,
977              preparing to start a new inferior.  But, since we don't
978              want to clobber the parent's address/program spaces, we
979              go ahead and create a new one for this exiting
980              inferior.  */
981
982           /* Switch to null_ptid, so that clone_program_space doesn't want
983              to read the selected frame of a dead process.  */
984           old_chain = save_inferior_ptid ();
985           inferior_ptid = null_ptid;
986
987           /* This inferior is dead, so avoid giving the breakpoints
988              module the option to write through to it (cloning a
989              program space resets breakpoints).  */
990           inf->aspace = NULL;
991           inf->pspace = NULL;
992           pspace = add_program_space (maybe_new_address_space ());
993           set_current_program_space (pspace);
994           inf->removable = 1;
995           inf->symfile_flags = SYMFILE_NO_READ;
996           clone_program_space (pspace, inf->vfork_parent->pspace);
997           inf->pspace = pspace;
998           inf->aspace = pspace->aspace;
999
1000           /* Put back inferior_ptid.  We'll continue mourning this
1001              inferior.  */
1002           do_cleanups (old_chain);
1003
1004           resume_parent = inf->vfork_parent->pid;
1005           /* Break the bonds.  */
1006           inf->vfork_parent->vfork_child = NULL;
1007         }
1008
1009       inf->vfork_parent = NULL;
1010
1011       gdb_assert (current_program_space == inf->pspace);
1012
1013       if (non_stop && resume_parent != -1)
1014         {
1015           /* If the user wanted the parent to be running, let it go
1016              free now.  */
1017           struct cleanup *old_chain = make_cleanup_restore_current_thread ();
1018
1019           if (debug_infrun)
1020             fprintf_unfiltered (gdb_stdlog,
1021                                 "infrun: resuming vfork parent process %d\n",
1022                                 resume_parent);
1023
1024           iterate_over_threads (proceed_after_vfork_done, &resume_parent);
1025
1026           do_cleanups (old_chain);
1027         }
1028     }
1029 }
1030
1031 /* Enum strings for "set|show follow-exec-mode".  */
1032
1033 static const char follow_exec_mode_new[] = "new";
1034 static const char follow_exec_mode_same[] = "same";
1035 static const char *const follow_exec_mode_names[] =
1036 {
1037   follow_exec_mode_new,
1038   follow_exec_mode_same,
1039   NULL,
1040 };
1041
1042 static const char *follow_exec_mode_string = follow_exec_mode_same;
1043 static void
1044 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1045                               struct cmd_list_element *c, const char *value)
1046 {
1047   fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"),  value);
1048 }
1049
1050 /* EXECD_PATHNAME is assumed to be non-NULL.  */
1051
1052 static void
1053 follow_exec (ptid_t pid, char *execd_pathname)
1054 {
1055   struct thread_info *th = inferior_thread ();
1056   struct inferior *inf = current_inferior ();
1057
1058   /* This is an exec event that we actually wish to pay attention to.
1059      Refresh our symbol table to the newly exec'd program, remove any
1060      momentary bp's, etc.
1061
1062      If there are breakpoints, they aren't really inserted now,
1063      since the exec() transformed our inferior into a fresh set
1064      of instructions.
1065
1066      We want to preserve symbolic breakpoints on the list, since
1067      we have hopes that they can be reset after the new a.out's
1068      symbol table is read.
1069
1070      However, any "raw" breakpoints must be removed from the list
1071      (e.g., the solib bp's), since their address is probably invalid
1072      now.
1073
1074      And, we DON'T want to call delete_breakpoints() here, since
1075      that may write the bp's "shadow contents" (the instruction
1076      value that was overwritten witha TRAP instruction).  Since
1077      we now have a new a.out, those shadow contents aren't valid.  */
1078
1079   mark_breakpoints_out ();
1080
1081   update_breakpoints_after_exec ();
1082
1083   /* If there was one, it's gone now.  We cannot truly step-to-next
1084      statement through an exec().  */
1085   th->control.step_resume_breakpoint = NULL;
1086   th->control.exception_resume_breakpoint = NULL;
1087   th->control.step_range_start = 0;
1088   th->control.step_range_end = 0;
1089
1090   /* The target reports the exec event to the main thread, even if
1091      some other thread does the exec, and even if the main thread was
1092      already stopped --- if debugging in non-stop mode, it's possible
1093      the user had the main thread held stopped in the previous image
1094      --- release it now.  This is the same behavior as step-over-exec
1095      with scheduler-locking on in all-stop mode.  */
1096   th->stop_requested = 0;
1097
1098   /* What is this a.out's name?  */
1099   printf_unfiltered (_("%s is executing new program: %s\n"),
1100                      target_pid_to_str (inferior_ptid),
1101                      execd_pathname);
1102
1103   /* We've followed the inferior through an exec.  Therefore, the
1104      inferior has essentially been killed & reborn.  */
1105
1106   gdb_flush (gdb_stdout);
1107
1108   breakpoint_init_inferior (inf_execd);
1109
1110   if (gdb_sysroot && *gdb_sysroot)
1111     {
1112       char *name = alloca (strlen (gdb_sysroot)
1113                             + strlen (execd_pathname)
1114                             + 1);
1115
1116       strcpy (name, gdb_sysroot);
1117       strcat (name, execd_pathname);
1118       execd_pathname = name;
1119     }
1120
1121   /* Reset the shared library package.  This ensures that we get a
1122      shlib event when the child reaches "_start", at which point the
1123      dld will have had a chance to initialize the child.  */
1124   /* Also, loading a symbol file below may trigger symbol lookups, and
1125      we don't want those to be satisfied by the libraries of the
1126      previous incarnation of this process.  */
1127   no_shared_libraries (NULL, 0);
1128
1129   if (follow_exec_mode_string == follow_exec_mode_new)
1130     {
1131       struct program_space *pspace;
1132
1133       /* The user wants to keep the old inferior and program spaces
1134          around.  Create a new fresh one, and switch to it.  */
1135
1136       inf = add_inferior (current_inferior ()->pid);
1137       pspace = add_program_space (maybe_new_address_space ());
1138       inf->pspace = pspace;
1139       inf->aspace = pspace->aspace;
1140
1141       exit_inferior_num_silent (current_inferior ()->num);
1142
1143       set_current_inferior (inf);
1144       set_current_program_space (pspace);
1145     }
1146   else
1147     {
1148       /* The old description may no longer be fit for the new image.
1149          E.g, a 64-bit process exec'ed a 32-bit process.  Clear the
1150          old description; we'll read a new one below.  No need to do
1151          this on "follow-exec-mode new", as the old inferior stays
1152          around (its description is later cleared/refetched on
1153          restart).  */
1154       target_clear_description ();
1155     }
1156
1157   gdb_assert (current_program_space == inf->pspace);
1158
1159   /* That a.out is now the one to use.  */
1160   exec_file_attach (execd_pathname, 0);
1161
1162   /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1163      (Position Independent Executable) main symbol file will get applied by
1164      solib_create_inferior_hook below.  breakpoint_re_set would fail to insert
1165      the breakpoints with the zero displacement.  */
1166
1167   symbol_file_add (execd_pathname,
1168                    (inf->symfile_flags
1169                     | SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET),
1170                    NULL, 0);
1171
1172   if ((inf->symfile_flags & SYMFILE_NO_READ) == 0)
1173     set_initial_language ();
1174
1175   /* If the target can specify a description, read it.  Must do this
1176      after flipping to the new executable (because the target supplied
1177      description must be compatible with the executable's
1178      architecture, and the old executable may e.g., be 32-bit, while
1179      the new one 64-bit), and before anything involving memory or
1180      registers.  */
1181   target_find_description ();
1182
1183   solib_create_inferior_hook (0);
1184
1185   jit_inferior_created_hook ();
1186
1187   breakpoint_re_set ();
1188
1189   /* Reinsert all breakpoints.  (Those which were symbolic have
1190      been reset to the proper address in the new a.out, thanks
1191      to symbol_file_command...).  */
1192   insert_breakpoints ();
1193
1194   /* The next resume of this inferior should bring it to the shlib
1195      startup breakpoints.  (If the user had also set bp's on
1196      "main" from the old (parent) process, then they'll auto-
1197      matically get reset there in the new process.).  */
1198 }
1199
1200 /* Non-zero if we just simulating a single-step.  This is needed
1201    because we cannot remove the breakpoints in the inferior process
1202    until after the `wait' in `wait_for_inferior'.  */
1203 static int singlestep_breakpoints_inserted_p = 0;
1204
1205 /* The thread we inserted single-step breakpoints for.  */
1206 static ptid_t singlestep_ptid;
1207
1208 /* PC when we started this single-step.  */
1209 static CORE_ADDR singlestep_pc;
1210
1211 /* Info about an instruction that is being stepped over.  Invalid if
1212    ASPACE is NULL.  */
1213
1214 struct step_over_info
1215 {
1216   /* The instruction's address space.  */
1217   struct address_space *aspace;
1218
1219   /* The instruction's address.  */
1220   CORE_ADDR address;
1221 };
1222
1223 /* The step-over info of the location that is being stepped over.
1224
1225    Note that with async/breakpoint always-inserted mode, a user might
1226    set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1227    being stepped over.  As setting a new breakpoint inserts all
1228    breakpoints, we need to make sure the breakpoint being stepped over
1229    isn't inserted then.  We do that by only clearing the step-over
1230    info when the step-over is actually finished (or aborted).
1231
1232    Presently GDB can only step over one breakpoint at any given time.
1233    Given threads that can't run code in the same address space as the
1234    breakpoint's can't really miss the breakpoint, GDB could be taught
1235    to step-over at most one breakpoint per address space (so this info
1236    could move to the address space object if/when GDB is extended).
1237    The set of breakpoints being stepped over will normally be much
1238    smaller than the set of all breakpoints, so a flag in the
1239    breakpoint location structure would be wasteful.  A separate list
1240    also saves complexity and run-time, as otherwise we'd have to go
1241    through all breakpoint locations clearing their flag whenever we
1242    start a new sequence.  Similar considerations weigh against storing
1243    this info in the thread object.  Plus, not all step overs actually
1244    have breakpoint locations -- e.g., stepping past a single-step
1245    breakpoint, or stepping to complete a non-continuable
1246    watchpoint.  */
1247 static struct step_over_info step_over_info;
1248
1249 /* Record the address of the breakpoint/instruction we're currently
1250    stepping over.  */
1251
1252 static void
1253 set_step_over_info (struct address_space *aspace, CORE_ADDR address)
1254 {
1255   step_over_info.aspace = aspace;
1256   step_over_info.address = address;
1257 }
1258
1259 /* Called when we're not longer stepping over a breakpoint / an
1260    instruction, so all breakpoints are free to be (re)inserted.  */
1261
1262 static void
1263 clear_step_over_info (void)
1264 {
1265   step_over_info.aspace = NULL;
1266   step_over_info.address = 0;
1267 }
1268
1269 /* See infrun.h.  */
1270
1271 int
1272 stepping_past_instruction_at (struct address_space *aspace,
1273                               CORE_ADDR address)
1274 {
1275   return (step_over_info.aspace != NULL
1276           && breakpoint_address_match (aspace, address,
1277                                        step_over_info.aspace,
1278                                        step_over_info.address));
1279 }
1280
1281 \f
1282 /* Displaced stepping.  */
1283
1284 /* In non-stop debugging mode, we must take special care to manage
1285    breakpoints properly; in particular, the traditional strategy for
1286    stepping a thread past a breakpoint it has hit is unsuitable.
1287    'Displaced stepping' is a tactic for stepping one thread past a
1288    breakpoint it has hit while ensuring that other threads running
1289    concurrently will hit the breakpoint as they should.
1290
1291    The traditional way to step a thread T off a breakpoint in a
1292    multi-threaded program in all-stop mode is as follows:
1293
1294    a0) Initially, all threads are stopped, and breakpoints are not
1295        inserted.
1296    a1) We single-step T, leaving breakpoints uninserted.
1297    a2) We insert breakpoints, and resume all threads.
1298
1299    In non-stop debugging, however, this strategy is unsuitable: we
1300    don't want to have to stop all threads in the system in order to
1301    continue or step T past a breakpoint.  Instead, we use displaced
1302    stepping:
1303
1304    n0) Initially, T is stopped, other threads are running, and
1305        breakpoints are inserted.
1306    n1) We copy the instruction "under" the breakpoint to a separate
1307        location, outside the main code stream, making any adjustments
1308        to the instruction, register, and memory state as directed by
1309        T's architecture.
1310    n2) We single-step T over the instruction at its new location.
1311    n3) We adjust the resulting register and memory state as directed
1312        by T's architecture.  This includes resetting T's PC to point
1313        back into the main instruction stream.
1314    n4) We resume T.
1315
1316    This approach depends on the following gdbarch methods:
1317
1318    - gdbarch_max_insn_length and gdbarch_displaced_step_location
1319      indicate where to copy the instruction, and how much space must
1320      be reserved there.  We use these in step n1.
1321
1322    - gdbarch_displaced_step_copy_insn copies a instruction to a new
1323      address, and makes any necessary adjustments to the instruction,
1324      register contents, and memory.  We use this in step n1.
1325
1326    - gdbarch_displaced_step_fixup adjusts registers and memory after
1327      we have successfuly single-stepped the instruction, to yield the
1328      same effect the instruction would have had if we had executed it
1329      at its original address.  We use this in step n3.
1330
1331    - gdbarch_displaced_step_free_closure provides cleanup.
1332
1333    The gdbarch_displaced_step_copy_insn and
1334    gdbarch_displaced_step_fixup functions must be written so that
1335    copying an instruction with gdbarch_displaced_step_copy_insn,
1336    single-stepping across the copied instruction, and then applying
1337    gdbarch_displaced_insn_fixup should have the same effects on the
1338    thread's memory and registers as stepping the instruction in place
1339    would have.  Exactly which responsibilities fall to the copy and
1340    which fall to the fixup is up to the author of those functions.
1341
1342    See the comments in gdbarch.sh for details.
1343
1344    Note that displaced stepping and software single-step cannot
1345    currently be used in combination, although with some care I think
1346    they could be made to.  Software single-step works by placing
1347    breakpoints on all possible subsequent instructions; if the
1348    displaced instruction is a PC-relative jump, those breakpoints
1349    could fall in very strange places --- on pages that aren't
1350    executable, or at addresses that are not proper instruction
1351    boundaries.  (We do generally let other threads run while we wait
1352    to hit the software single-step breakpoint, and they might
1353    encounter such a corrupted instruction.)  One way to work around
1354    this would be to have gdbarch_displaced_step_copy_insn fully
1355    simulate the effect of PC-relative instructions (and return NULL)
1356    on architectures that use software single-stepping.
1357
1358    In non-stop mode, we can have independent and simultaneous step
1359    requests, so more than one thread may need to simultaneously step
1360    over a breakpoint.  The current implementation assumes there is
1361    only one scratch space per process.  In this case, we have to
1362    serialize access to the scratch space.  If thread A wants to step
1363    over a breakpoint, but we are currently waiting for some other
1364    thread to complete a displaced step, we leave thread A stopped and
1365    place it in the displaced_step_request_queue.  Whenever a displaced
1366    step finishes, we pick the next thread in the queue and start a new
1367    displaced step operation on it.  See displaced_step_prepare and
1368    displaced_step_fixup for details.  */
1369
1370 struct displaced_step_request
1371 {
1372   ptid_t ptid;
1373   struct displaced_step_request *next;
1374 };
1375
1376 /* Per-inferior displaced stepping state.  */
1377 struct displaced_step_inferior_state
1378 {
1379   /* Pointer to next in linked list.  */
1380   struct displaced_step_inferior_state *next;
1381
1382   /* The process this displaced step state refers to.  */
1383   int pid;
1384
1385   /* A queue of pending displaced stepping requests.  One entry per
1386      thread that needs to do a displaced step.  */
1387   struct displaced_step_request *step_request_queue;
1388
1389   /* If this is not null_ptid, this is the thread carrying out a
1390      displaced single-step in process PID.  This thread's state will
1391      require fixing up once it has completed its step.  */
1392   ptid_t step_ptid;
1393
1394   /* The architecture the thread had when we stepped it.  */
1395   struct gdbarch *step_gdbarch;
1396
1397   /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1398      for post-step cleanup.  */
1399   struct displaced_step_closure *step_closure;
1400
1401   /* The address of the original instruction, and the copy we
1402      made.  */
1403   CORE_ADDR step_original, step_copy;
1404
1405   /* Saved contents of copy area.  */
1406   gdb_byte *step_saved_copy;
1407 };
1408
1409 /* The list of states of processes involved in displaced stepping
1410    presently.  */
1411 static struct displaced_step_inferior_state *displaced_step_inferior_states;
1412
1413 /* Get the displaced stepping state of process PID.  */
1414
1415 static struct displaced_step_inferior_state *
1416 get_displaced_stepping_state (int pid)
1417 {
1418   struct displaced_step_inferior_state *state;
1419
1420   for (state = displaced_step_inferior_states;
1421        state != NULL;
1422        state = state->next)
1423     if (state->pid == pid)
1424       return state;
1425
1426   return NULL;
1427 }
1428
1429 /* Add a new displaced stepping state for process PID to the displaced
1430    stepping state list, or return a pointer to an already existing
1431    entry, if it already exists.  Never returns NULL.  */
1432
1433 static struct displaced_step_inferior_state *
1434 add_displaced_stepping_state (int pid)
1435 {
1436   struct displaced_step_inferior_state *state;
1437
1438   for (state = displaced_step_inferior_states;
1439        state != NULL;
1440        state = state->next)
1441     if (state->pid == pid)
1442       return state;
1443
1444   state = xcalloc (1, sizeof (*state));
1445   state->pid = pid;
1446   state->next = displaced_step_inferior_states;
1447   displaced_step_inferior_states = state;
1448
1449   return state;
1450 }
1451
1452 /* If inferior is in displaced stepping, and ADDR equals to starting address
1453    of copy area, return corresponding displaced_step_closure.  Otherwise,
1454    return NULL.  */
1455
1456 struct displaced_step_closure*
1457 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1458 {
1459   struct displaced_step_inferior_state *displaced
1460     = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1461
1462   /* If checking the mode of displaced instruction in copy area.  */
1463   if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1464      && (displaced->step_copy == addr))
1465     return displaced->step_closure;
1466
1467   return NULL;
1468 }
1469
1470 /* Remove the displaced stepping state of process PID.  */
1471
1472 static void
1473 remove_displaced_stepping_state (int pid)
1474 {
1475   struct displaced_step_inferior_state *it, **prev_next_p;
1476
1477   gdb_assert (pid != 0);
1478
1479   it = displaced_step_inferior_states;
1480   prev_next_p = &displaced_step_inferior_states;
1481   while (it)
1482     {
1483       if (it->pid == pid)
1484         {
1485           *prev_next_p = it->next;
1486           xfree (it);
1487           return;
1488         }
1489
1490       prev_next_p = &it->next;
1491       it = *prev_next_p;
1492     }
1493 }
1494
1495 static void
1496 infrun_inferior_exit (struct inferior *inf)
1497 {
1498   remove_displaced_stepping_state (inf->pid);
1499 }
1500
1501 /* If ON, and the architecture supports it, GDB will use displaced
1502    stepping to step over breakpoints.  If OFF, or if the architecture
1503    doesn't support it, GDB will instead use the traditional
1504    hold-and-step approach.  If AUTO (which is the default), GDB will
1505    decide which technique to use to step over breakpoints depending on
1506    which of all-stop or non-stop mode is active --- displaced stepping
1507    in non-stop mode; hold-and-step in all-stop mode.  */
1508
1509 static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
1510
1511 static void
1512 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1513                                  struct cmd_list_element *c,
1514                                  const char *value)
1515 {
1516   if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1517     fprintf_filtered (file,
1518                       _("Debugger's willingness to use displaced stepping "
1519                         "to step over breakpoints is %s (currently %s).\n"),
1520                       value, non_stop ? "on" : "off");
1521   else
1522     fprintf_filtered (file,
1523                       _("Debugger's willingness to use displaced stepping "
1524                         "to step over breakpoints is %s.\n"), value);
1525 }
1526
1527 /* Return non-zero if displaced stepping can/should be used to step
1528    over breakpoints.  */
1529
1530 static int
1531 use_displaced_stepping (struct gdbarch *gdbarch)
1532 {
1533   return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO && non_stop)
1534            || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1535           && gdbarch_displaced_step_copy_insn_p (gdbarch)
1536           && find_record_target () == NULL);
1537 }
1538
1539 /* Clean out any stray displaced stepping state.  */
1540 static void
1541 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1542 {
1543   /* Indicate that there is no cleanup pending.  */
1544   displaced->step_ptid = null_ptid;
1545
1546   if (displaced->step_closure)
1547     {
1548       gdbarch_displaced_step_free_closure (displaced->step_gdbarch,
1549                                            displaced->step_closure);
1550       displaced->step_closure = NULL;
1551     }
1552 }
1553
1554 static void
1555 displaced_step_clear_cleanup (void *arg)
1556 {
1557   struct displaced_step_inferior_state *state = arg;
1558
1559   displaced_step_clear (state);
1560 }
1561
1562 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline.  */
1563 void
1564 displaced_step_dump_bytes (struct ui_file *file,
1565                            const gdb_byte *buf,
1566                            size_t len)
1567 {
1568   int i;
1569
1570   for (i = 0; i < len; i++)
1571     fprintf_unfiltered (file, "%02x ", buf[i]);
1572   fputs_unfiltered ("\n", file);
1573 }
1574
1575 /* Prepare to single-step, using displaced stepping.
1576
1577    Note that we cannot use displaced stepping when we have a signal to
1578    deliver.  If we have a signal to deliver and an instruction to step
1579    over, then after the step, there will be no indication from the
1580    target whether the thread entered a signal handler or ignored the
1581    signal and stepped over the instruction successfully --- both cases
1582    result in a simple SIGTRAP.  In the first case we mustn't do a
1583    fixup, and in the second case we must --- but we can't tell which.
1584    Comments in the code for 'random signals' in handle_inferior_event
1585    explain how we handle this case instead.
1586
1587    Returns 1 if preparing was successful -- this thread is going to be
1588    stepped now; or 0 if displaced stepping this thread got queued.  */
1589 static int
1590 displaced_step_prepare (ptid_t ptid)
1591 {
1592   struct cleanup *old_cleanups, *ignore_cleanups;
1593   struct thread_info *tp = find_thread_ptid (ptid);
1594   struct regcache *regcache = get_thread_regcache (ptid);
1595   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1596   CORE_ADDR original, copy;
1597   ULONGEST len;
1598   struct displaced_step_closure *closure;
1599   struct displaced_step_inferior_state *displaced;
1600   int status;
1601
1602   /* We should never reach this function if the architecture does not
1603      support displaced stepping.  */
1604   gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1605
1606   /* Disable range stepping while executing in the scratch pad.  We
1607      want a single-step even if executing the displaced instruction in
1608      the scratch buffer lands within the stepping range (e.g., a
1609      jump/branch).  */
1610   tp->control.may_range_step = 0;
1611
1612   /* We have to displaced step one thread at a time, as we only have
1613      access to a single scratch space per inferior.  */
1614
1615   displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1616
1617   if (!ptid_equal (displaced->step_ptid, null_ptid))
1618     {
1619       /* Already waiting for a displaced step to finish.  Defer this
1620          request and place in queue.  */
1621       struct displaced_step_request *req, *new_req;
1622
1623       if (debug_displaced)
1624         fprintf_unfiltered (gdb_stdlog,
1625                             "displaced: defering step of %s\n",
1626                             target_pid_to_str (ptid));
1627
1628       new_req = xmalloc (sizeof (*new_req));
1629       new_req->ptid = ptid;
1630       new_req->next = NULL;
1631
1632       if (displaced->step_request_queue)
1633         {
1634           for (req = displaced->step_request_queue;
1635                req && req->next;
1636                req = req->next)
1637             ;
1638           req->next = new_req;
1639         }
1640       else
1641         displaced->step_request_queue = new_req;
1642
1643       return 0;
1644     }
1645   else
1646     {
1647       if (debug_displaced)
1648         fprintf_unfiltered (gdb_stdlog,
1649                             "displaced: stepping %s now\n",
1650                             target_pid_to_str (ptid));
1651     }
1652
1653   displaced_step_clear (displaced);
1654
1655   old_cleanups = save_inferior_ptid ();
1656   inferior_ptid = ptid;
1657
1658   original = regcache_read_pc (regcache);
1659
1660   copy = gdbarch_displaced_step_location (gdbarch);
1661   len = gdbarch_max_insn_length (gdbarch);
1662
1663   /* Save the original contents of the copy area.  */
1664   displaced->step_saved_copy = xmalloc (len);
1665   ignore_cleanups = make_cleanup (free_current_contents,
1666                                   &displaced->step_saved_copy);
1667   status = target_read_memory (copy, displaced->step_saved_copy, len);
1668   if (status != 0)
1669     throw_error (MEMORY_ERROR,
1670                  _("Error accessing memory address %s (%s) for "
1671                    "displaced-stepping scratch space."),
1672                  paddress (gdbarch, copy), safe_strerror (status));
1673   if (debug_displaced)
1674     {
1675       fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1676                           paddress (gdbarch, copy));
1677       displaced_step_dump_bytes (gdb_stdlog,
1678                                  displaced->step_saved_copy,
1679                                  len);
1680     };
1681
1682   closure = gdbarch_displaced_step_copy_insn (gdbarch,
1683                                               original, copy, regcache);
1684
1685   /* We don't support the fully-simulated case at present.  */
1686   gdb_assert (closure);
1687
1688   /* Save the information we need to fix things up if the step
1689      succeeds.  */
1690   displaced->step_ptid = ptid;
1691   displaced->step_gdbarch = gdbarch;
1692   displaced->step_closure = closure;
1693   displaced->step_original = original;
1694   displaced->step_copy = copy;
1695
1696   make_cleanup (displaced_step_clear_cleanup, displaced);
1697
1698   /* Resume execution at the copy.  */
1699   regcache_write_pc (regcache, copy);
1700
1701   discard_cleanups (ignore_cleanups);
1702
1703   do_cleanups (old_cleanups);
1704
1705   if (debug_displaced)
1706     fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1707                         paddress (gdbarch, copy));
1708
1709   return 1;
1710 }
1711
1712 static void
1713 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1714                    const gdb_byte *myaddr, int len)
1715 {
1716   struct cleanup *ptid_cleanup = save_inferior_ptid ();
1717
1718   inferior_ptid = ptid;
1719   write_memory (memaddr, myaddr, len);
1720   do_cleanups (ptid_cleanup);
1721 }
1722
1723 /* Restore the contents of the copy area for thread PTID.  */
1724
1725 static void
1726 displaced_step_restore (struct displaced_step_inferior_state *displaced,
1727                         ptid_t ptid)
1728 {
1729   ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1730
1731   write_memory_ptid (ptid, displaced->step_copy,
1732                      displaced->step_saved_copy, len);
1733   if (debug_displaced)
1734     fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1735                         target_pid_to_str (ptid),
1736                         paddress (displaced->step_gdbarch,
1737                                   displaced->step_copy));
1738 }
1739
1740 static void
1741 displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
1742 {
1743   struct cleanup *old_cleanups;
1744   struct displaced_step_inferior_state *displaced
1745     = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1746
1747   /* Was any thread of this process doing a displaced step?  */
1748   if (displaced == NULL)
1749     return;
1750
1751   /* Was this event for the pid we displaced?  */
1752   if (ptid_equal (displaced->step_ptid, null_ptid)
1753       || ! ptid_equal (displaced->step_ptid, event_ptid))
1754     return;
1755
1756   old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1757
1758   displaced_step_restore (displaced, displaced->step_ptid);
1759
1760   /* Did the instruction complete successfully?  */
1761   if (signal == GDB_SIGNAL_TRAP)
1762     {
1763       /* Fix up the resulting state.  */
1764       gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1765                                     displaced->step_closure,
1766                                     displaced->step_original,
1767                                     displaced->step_copy,
1768                                     get_thread_regcache (displaced->step_ptid));
1769     }
1770   else
1771     {
1772       /* Since the instruction didn't complete, all we can do is
1773          relocate the PC.  */
1774       struct regcache *regcache = get_thread_regcache (event_ptid);
1775       CORE_ADDR pc = regcache_read_pc (regcache);
1776
1777       pc = displaced->step_original + (pc - displaced->step_copy);
1778       regcache_write_pc (regcache, pc);
1779     }
1780
1781   do_cleanups (old_cleanups);
1782
1783   displaced->step_ptid = null_ptid;
1784
1785   /* Are there any pending displaced stepping requests?  If so, run
1786      one now.  Leave the state object around, since we're likely to
1787      need it again soon.  */
1788   while (displaced->step_request_queue)
1789     {
1790       struct displaced_step_request *head;
1791       ptid_t ptid;
1792       struct regcache *regcache;
1793       struct gdbarch *gdbarch;
1794       CORE_ADDR actual_pc;
1795       struct address_space *aspace;
1796
1797       head = displaced->step_request_queue;
1798       ptid = head->ptid;
1799       displaced->step_request_queue = head->next;
1800       xfree (head);
1801
1802       context_switch (ptid);
1803
1804       regcache = get_thread_regcache (ptid);
1805       actual_pc = regcache_read_pc (regcache);
1806       aspace = get_regcache_aspace (regcache);
1807
1808       if (breakpoint_here_p (aspace, actual_pc))
1809         {
1810           if (debug_displaced)
1811             fprintf_unfiltered (gdb_stdlog,
1812                                 "displaced: stepping queued %s now\n",
1813                                 target_pid_to_str (ptid));
1814
1815           displaced_step_prepare (ptid);
1816
1817           gdbarch = get_regcache_arch (regcache);
1818
1819           if (debug_displaced)
1820             {
1821               CORE_ADDR actual_pc = regcache_read_pc (regcache);
1822               gdb_byte buf[4];
1823
1824               fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1825                                   paddress (gdbarch, actual_pc));
1826               read_memory (actual_pc, buf, sizeof (buf));
1827               displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1828             }
1829
1830           if (gdbarch_displaced_step_hw_singlestep (gdbarch,
1831                                                     displaced->step_closure))
1832             target_resume (ptid, 1, GDB_SIGNAL_0);
1833           else
1834             target_resume (ptid, 0, GDB_SIGNAL_0);
1835
1836           /* Done, we're stepping a thread.  */
1837           break;
1838         }
1839       else
1840         {
1841           int step;
1842           struct thread_info *tp = inferior_thread ();
1843
1844           /* The breakpoint we were sitting under has since been
1845              removed.  */
1846           tp->control.trap_expected = 0;
1847
1848           /* Go back to what we were trying to do.  */
1849           step = currently_stepping (tp);
1850
1851           if (debug_displaced)
1852             fprintf_unfiltered (gdb_stdlog,
1853                                 "displaced: breakpoint is gone: %s, step(%d)\n",
1854                                 target_pid_to_str (tp->ptid), step);
1855
1856           target_resume (ptid, step, GDB_SIGNAL_0);
1857           tp->suspend.stop_signal = GDB_SIGNAL_0;
1858
1859           /* This request was discarded.  See if there's any other
1860              thread waiting for its turn.  */
1861         }
1862     }
1863 }
1864
1865 /* Update global variables holding ptids to hold NEW_PTID if they were
1866    holding OLD_PTID.  */
1867 static void
1868 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
1869 {
1870   struct displaced_step_request *it;
1871   struct displaced_step_inferior_state *displaced;
1872
1873   if (ptid_equal (inferior_ptid, old_ptid))
1874     inferior_ptid = new_ptid;
1875
1876   if (ptid_equal (singlestep_ptid, old_ptid))
1877     singlestep_ptid = new_ptid;
1878
1879   for (displaced = displaced_step_inferior_states;
1880        displaced;
1881        displaced = displaced->next)
1882     {
1883       if (ptid_equal (displaced->step_ptid, old_ptid))
1884         displaced->step_ptid = new_ptid;
1885
1886       for (it = displaced->step_request_queue; it; it = it->next)
1887         if (ptid_equal (it->ptid, old_ptid))
1888           it->ptid = new_ptid;
1889     }
1890 }
1891
1892 \f
1893 /* Resuming.  */
1894
1895 /* Things to clean up if we QUIT out of resume ().  */
1896 static void
1897 resume_cleanups (void *ignore)
1898 {
1899   normal_stop ();
1900 }
1901
1902 static const char schedlock_off[] = "off";
1903 static const char schedlock_on[] = "on";
1904 static const char schedlock_step[] = "step";
1905 static const char *const scheduler_enums[] = {
1906   schedlock_off,
1907   schedlock_on,
1908   schedlock_step,
1909   NULL
1910 };
1911 static const char *scheduler_mode = schedlock_off;
1912 static void
1913 show_scheduler_mode (struct ui_file *file, int from_tty,
1914                      struct cmd_list_element *c, const char *value)
1915 {
1916   fprintf_filtered (file,
1917                     _("Mode for locking scheduler "
1918                       "during execution is \"%s\".\n"),
1919                     value);
1920 }
1921
1922 static void
1923 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
1924 {
1925   if (!target_can_lock_scheduler)
1926     {
1927       scheduler_mode = schedlock_off;
1928       error (_("Target '%s' cannot support this command."), target_shortname);
1929     }
1930 }
1931
1932 /* True if execution commands resume all threads of all processes by
1933    default; otherwise, resume only threads of the current inferior
1934    process.  */
1935 int sched_multi = 0;
1936
1937 /* Try to setup for software single stepping over the specified location.
1938    Return 1 if target_resume() should use hardware single step.
1939
1940    GDBARCH the current gdbarch.
1941    PC the location to step over.  */
1942
1943 static int
1944 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
1945 {
1946   int hw_step = 1;
1947
1948   if (execution_direction == EXEC_FORWARD
1949       && gdbarch_software_single_step_p (gdbarch)
1950       && gdbarch_software_single_step (gdbarch, get_current_frame ()))
1951     {
1952       hw_step = 0;
1953       /* Do not pull these breakpoints until after a `wait' in
1954          `wait_for_inferior'.  */
1955       singlestep_breakpoints_inserted_p = 1;
1956       singlestep_ptid = inferior_ptid;
1957       singlestep_pc = pc;
1958     }
1959   return hw_step;
1960 }
1961
1962 ptid_t
1963 user_visible_resume_ptid (int step)
1964 {
1965   /* By default, resume all threads of all processes.  */
1966   ptid_t resume_ptid = RESUME_ALL;
1967
1968   /* Maybe resume only all threads of the current process.  */
1969   if (!sched_multi && target_supports_multi_process ())
1970     {
1971       resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1972     }
1973
1974   /* Maybe resume a single thread after all.  */
1975   if (non_stop)
1976     {
1977       /* With non-stop mode on, threads are always handled
1978          individually.  */
1979       resume_ptid = inferior_ptid;
1980     }
1981   else if ((scheduler_mode == schedlock_on)
1982            || (scheduler_mode == schedlock_step && step))
1983     {
1984       /* User-settable 'scheduler' mode requires solo thread resume.  */
1985       resume_ptid = inferior_ptid;
1986     }
1987
1988   /* We may actually resume fewer threads at first, e.g., if a thread
1989      is stopped at a breakpoint that needs stepping-off, but that
1990      should not be visible to the user/frontend, and neither should
1991      the frontend/user be allowed to proceed any of the threads that
1992      happen to be stopped for internal run control handling, if a
1993      previous command wanted them resumed.  */
1994   return resume_ptid;
1995 }
1996
1997 /* Resume the inferior, but allow a QUIT.  This is useful if the user
1998    wants to interrupt some lengthy single-stepping operation
1999    (for child processes, the SIGINT goes to the inferior, and so
2000    we get a SIGINT random_signal, but for remote debugging and perhaps
2001    other targets, that's not true).
2002
2003    STEP nonzero if we should step (zero to continue instead).
2004    SIG is the signal to give the inferior (zero for none).  */
2005 void
2006 resume (int step, enum gdb_signal sig)
2007 {
2008   struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
2009   struct regcache *regcache = get_current_regcache ();
2010   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2011   struct thread_info *tp = inferior_thread ();
2012   CORE_ADDR pc = regcache_read_pc (regcache);
2013   struct address_space *aspace = get_regcache_aspace (regcache);
2014   ptid_t resume_ptid;
2015   /* From here on, this represents the caller's step vs continue
2016      request, while STEP represents what we'll actually request the
2017      target to do.  STEP can decay from a step to a continue, if e.g.,
2018      we need to implement single-stepping with breakpoints (software
2019      single-step).  When deciding whether "set scheduler-locking step"
2020      applies, it's the callers intention that counts.  */
2021   const int entry_step = step;
2022
2023   QUIT;
2024
2025   if (current_inferior ()->waiting_for_vfork_done)
2026     {
2027       /* Don't try to single-step a vfork parent that is waiting for
2028          the child to get out of the shared memory region (by exec'ing
2029          or exiting).  This is particularly important on software
2030          single-step archs, as the child process would trip on the
2031          software single step breakpoint inserted for the parent
2032          process.  Since the parent will not actually execute any
2033          instruction until the child is out of the shared region (such
2034          are vfork's semantics), it is safe to simply continue it.
2035          Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2036          the parent, and tell it to `keep_going', which automatically
2037          re-sets it stepping.  */
2038       if (debug_infrun)
2039         fprintf_unfiltered (gdb_stdlog,
2040                             "infrun: resume : clear step\n");
2041       step = 0;
2042     }
2043
2044   if (debug_infrun)
2045     fprintf_unfiltered (gdb_stdlog,
2046                         "infrun: resume (step=%d, signal=%s), "
2047                         "trap_expected=%d, current thread [%s] at %s\n",
2048                         step, gdb_signal_to_symbol_string (sig),
2049                         tp->control.trap_expected,
2050                         target_pid_to_str (inferior_ptid),
2051                         paddress (gdbarch, pc));
2052
2053   /* Normally, by the time we reach `resume', the breakpoints are either
2054      removed or inserted, as appropriate.  The exception is if we're sitting
2055      at a permanent breakpoint; we need to step over it, but permanent
2056      breakpoints can't be removed.  So we have to test for it here.  */
2057   if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
2058     {
2059       if (gdbarch_skip_permanent_breakpoint_p (gdbarch))
2060         gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2061       else
2062         error (_("\
2063 The program is stopped at a permanent breakpoint, but GDB does not know\n\
2064 how to step past a permanent breakpoint on this architecture.  Try using\n\
2065 a command like `return' or `jump' to continue execution."));
2066     }
2067
2068   /* If we have a breakpoint to step over, make sure to do a single
2069      step only.  Same if we have software watchpoints.  */
2070   if (tp->control.trap_expected || bpstat_should_step ())
2071     tp->control.may_range_step = 0;
2072
2073   /* If enabled, step over breakpoints by executing a copy of the
2074      instruction at a different address.
2075
2076      We can't use displaced stepping when we have a signal to deliver;
2077      the comments for displaced_step_prepare explain why.  The
2078      comments in the handle_inferior event for dealing with 'random
2079      signals' explain what we do instead.
2080
2081      We can't use displaced stepping when we are waiting for vfork_done
2082      event, displaced stepping breaks the vfork child similarly as single
2083      step software breakpoint.  */
2084   if (use_displaced_stepping (gdbarch)
2085       && (tp->control.trap_expected
2086           || (step && gdbarch_software_single_step_p (gdbarch)))
2087       && sig == GDB_SIGNAL_0
2088       && !current_inferior ()->waiting_for_vfork_done)
2089     {
2090       struct displaced_step_inferior_state *displaced;
2091
2092       if (!displaced_step_prepare (inferior_ptid))
2093         {
2094           /* Got placed in displaced stepping queue.  Will be resumed
2095              later when all the currently queued displaced stepping
2096              requests finish.  The thread is not executing at this
2097              point, and the call to set_executing will be made later.
2098              But we need to call set_running here, since from the
2099              user/frontend's point of view, threads were set running.
2100              Unless we're calling an inferior function, as in that
2101              case we pretend the inferior doesn't run at all.  */
2102           if (!tp->control.in_infcall)
2103             set_running (user_visible_resume_ptid (entry_step), 1);
2104           discard_cleanups (old_cleanups);
2105           return;
2106         }
2107
2108       /* Update pc to reflect the new address from which we will execute
2109          instructions due to displaced stepping.  */
2110       pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
2111
2112       displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
2113       step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2114                                                    displaced->step_closure);
2115     }
2116
2117   /* Do we need to do it the hard way, w/temp breakpoints?  */
2118   else if (step)
2119     step = maybe_software_singlestep (gdbarch, pc);
2120
2121   /* Currently, our software single-step implementation leads to different
2122      results than hardware single-stepping in one situation: when stepping
2123      into delivering a signal which has an associated signal handler,
2124      hardware single-step will stop at the first instruction of the handler,
2125      while software single-step will simply skip execution of the handler.
2126
2127      For now, this difference in behavior is accepted since there is no
2128      easy way to actually implement single-stepping into a signal handler
2129      without kernel support.
2130
2131      However, there is one scenario where this difference leads to follow-on
2132      problems: if we're stepping off a breakpoint by removing all breakpoints
2133      and then single-stepping.  In this case, the software single-step
2134      behavior means that even if there is a *breakpoint* in the signal
2135      handler, GDB still would not stop.
2136
2137      Fortunately, we can at least fix this particular issue.  We detect
2138      here the case where we are about to deliver a signal while software
2139      single-stepping with breakpoints removed.  In this situation, we
2140      revert the decisions to remove all breakpoints and insert single-
2141      step breakpoints, and instead we install a step-resume breakpoint
2142      at the current address, deliver the signal without stepping, and
2143      once we arrive back at the step-resume breakpoint, actually step
2144      over the breakpoint we originally wanted to step over.  */
2145   if (singlestep_breakpoints_inserted_p
2146       && tp->control.trap_expected && sig != GDB_SIGNAL_0)
2147     {
2148       /* If we have nested signals or a pending signal is delivered
2149          immediately after a handler returns, might might already have
2150          a step-resume breakpoint set on the earlier handler.  We cannot
2151          set another step-resume breakpoint; just continue on until the
2152          original breakpoint is hit.  */
2153       if (tp->control.step_resume_breakpoint == NULL)
2154         {
2155           insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2156           tp->step_after_step_resume_breakpoint = 1;
2157         }
2158
2159       remove_single_step_breakpoints ();
2160       singlestep_breakpoints_inserted_p = 0;
2161
2162       clear_step_over_info ();
2163       tp->control.trap_expected = 0;
2164
2165       insert_breakpoints ();
2166     }
2167
2168   /* If STEP is set, it's a request to use hardware stepping
2169      facilities.  But in that case, we should never
2170      use singlestep breakpoint.  */
2171   gdb_assert (!(singlestep_breakpoints_inserted_p && step));
2172
2173   /* Decide the set of threads to ask the target to resume.  Start
2174      by assuming everything will be resumed, than narrow the set
2175      by applying increasingly restricting conditions.  */
2176   resume_ptid = user_visible_resume_ptid (entry_step);
2177
2178   /* Even if RESUME_PTID is a wildcard, and we end up resuming less
2179      (e.g., we might need to step over a breakpoint), from the
2180      user/frontend's point of view, all threads in RESUME_PTID are now
2181      running.  Unless we're calling an inferior function, as in that
2182      case pretend we inferior doesn't run at all.  */
2183   if (!tp->control.in_infcall)
2184     set_running (resume_ptid, 1);
2185
2186   /* Maybe resume a single thread after all.  */
2187   if ((step || singlestep_breakpoints_inserted_p)
2188       && tp->control.trap_expected)
2189     {
2190       /* We're allowing a thread to run past a breakpoint it has
2191          hit, by single-stepping the thread with the breakpoint
2192          removed.  In which case, we need to single-step only this
2193          thread, and keep others stopped, as they can miss this
2194          breakpoint if allowed to run.  */
2195       resume_ptid = inferior_ptid;
2196     }
2197
2198   if (gdbarch_cannot_step_breakpoint (gdbarch))
2199     {
2200       /* Most targets can step a breakpoint instruction, thus
2201          executing it normally.  But if this one cannot, just
2202          continue and we will hit it anyway.  */
2203       if (step && breakpoint_inserted_here_p (aspace, pc))
2204         step = 0;
2205     }
2206
2207   if (debug_displaced
2208       && use_displaced_stepping (gdbarch)
2209       && tp->control.trap_expected)
2210     {
2211       struct regcache *resume_regcache = get_thread_regcache (resume_ptid);
2212       struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
2213       CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2214       gdb_byte buf[4];
2215
2216       fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2217                           paddress (resume_gdbarch, actual_pc));
2218       read_memory (actual_pc, buf, sizeof (buf));
2219       displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2220     }
2221
2222   if (tp->control.may_range_step)
2223     {
2224       /* If we're resuming a thread with the PC out of the step
2225          range, then we're doing some nested/finer run control
2226          operation, like stepping the thread out of the dynamic
2227          linker or the displaced stepping scratch pad.  We
2228          shouldn't have allowed a range step then.  */
2229       gdb_assert (pc_in_thread_step_range (pc, tp));
2230     }
2231
2232   /* Install inferior's terminal modes.  */
2233   target_terminal_inferior ();
2234
2235   /* Avoid confusing the next resume, if the next stop/resume
2236      happens to apply to another thread.  */
2237   tp->suspend.stop_signal = GDB_SIGNAL_0;
2238
2239   /* Advise target which signals may be handled silently.  If we have
2240      removed breakpoints because we are stepping over one (which can
2241      happen only if we are not using displaced stepping), we need to
2242      receive all signals to avoid accidentally skipping a breakpoint
2243      during execution of a signal handler.  */
2244   if ((step || singlestep_breakpoints_inserted_p)
2245       && tp->control.trap_expected
2246       && !use_displaced_stepping (gdbarch))
2247     target_pass_signals (0, NULL);
2248   else
2249     target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2250
2251   target_resume (resume_ptid, step, sig);
2252
2253   discard_cleanups (old_cleanups);
2254 }
2255 \f
2256 /* Proceeding.  */
2257
2258 /* Clear out all variables saying what to do when inferior is continued.
2259    First do this, then set the ones you want, then call `proceed'.  */
2260
2261 static void
2262 clear_proceed_status_thread (struct thread_info *tp)
2263 {
2264   if (debug_infrun)
2265     fprintf_unfiltered (gdb_stdlog,
2266                         "infrun: clear_proceed_status_thread (%s)\n",
2267                         target_pid_to_str (tp->ptid));
2268
2269   /* If this signal should not be seen by program, give it zero.
2270      Used for debugging signals.  */
2271   if (!signal_pass_state (tp->suspend.stop_signal))
2272     tp->suspend.stop_signal = GDB_SIGNAL_0;
2273
2274   tp->control.trap_expected = 0;
2275   tp->control.step_range_start = 0;
2276   tp->control.step_range_end = 0;
2277   tp->control.may_range_step = 0;
2278   tp->control.step_frame_id = null_frame_id;
2279   tp->control.step_stack_frame_id = null_frame_id;
2280   tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
2281   tp->stop_requested = 0;
2282
2283   tp->control.stop_step = 0;
2284
2285   tp->control.proceed_to_finish = 0;
2286
2287   tp->control.command_interp = NULL;
2288
2289   /* Discard any remaining commands or status from previous stop.  */
2290   bpstat_clear (&tp->control.stop_bpstat);
2291 }
2292
2293 void
2294 clear_proceed_status (int step)
2295 {
2296   if (!non_stop)
2297     {
2298       struct thread_info *tp;
2299       ptid_t resume_ptid;
2300
2301       resume_ptid = user_visible_resume_ptid (step);
2302
2303       /* In all-stop mode, delete the per-thread status of all threads
2304          we're about to resume, implicitly and explicitly.  */
2305       ALL_NON_EXITED_THREADS (tp)
2306         {
2307           if (!ptid_match (tp->ptid, resume_ptid))
2308             continue;
2309           clear_proceed_status_thread (tp);
2310         }
2311     }
2312
2313   if (!ptid_equal (inferior_ptid, null_ptid))
2314     {
2315       struct inferior *inferior;
2316
2317       if (non_stop)
2318         {
2319           /* If in non-stop mode, only delete the per-thread status of
2320              the current thread.  */
2321           clear_proceed_status_thread (inferior_thread ());
2322         }
2323
2324       inferior = current_inferior ();
2325       inferior->control.stop_soon = NO_STOP_QUIETLY;
2326     }
2327
2328   stop_after_trap = 0;
2329
2330   clear_step_over_info ();
2331
2332   observer_notify_about_to_proceed ();
2333
2334   if (stop_registers)
2335     {
2336       regcache_xfree (stop_registers);
2337       stop_registers = NULL;
2338     }
2339 }
2340
2341 /* Returns true if TP is still stopped at a breakpoint that needs
2342    stepping-over in order to make progress.  If the breakpoint is gone
2343    meanwhile, we can skip the whole step-over dance.  */
2344
2345 static int
2346 thread_still_needs_step_over (struct thread_info *tp)
2347 {
2348   if (tp->stepping_over_breakpoint)
2349     {
2350       struct regcache *regcache = get_thread_regcache (tp->ptid);
2351
2352       if (breakpoint_here_p (get_regcache_aspace (regcache),
2353                              regcache_read_pc (regcache)))
2354         return 1;
2355
2356       tp->stepping_over_breakpoint = 0;
2357     }
2358
2359   return 0;
2360 }
2361
2362 /* Returns true if scheduler locking applies.  STEP indicates whether
2363    we're about to do a step/next-like command to a thread.  */
2364
2365 static int
2366 schedlock_applies (int step)
2367 {
2368   return (scheduler_mode == schedlock_on
2369           || (scheduler_mode == schedlock_step
2370               && step));
2371 }
2372
2373 /* Look a thread other than EXCEPT that has previously reported a
2374    breakpoint event, and thus needs a step-over in order to make
2375    progress.  Returns NULL is none is found.  STEP indicates whether
2376    we're about to step the current thread, in order to decide whether
2377    "set scheduler-locking step" applies.  */
2378
2379 static struct thread_info *
2380 find_thread_needs_step_over (int step, struct thread_info *except)
2381 {
2382   struct thread_info *tp, *current;
2383
2384   /* With non-stop mode on, threads are always handled individually.  */
2385   gdb_assert (! non_stop);
2386
2387   current = inferior_thread ();
2388
2389   /* If scheduler locking applies, we can avoid iterating over all
2390      threads.  */
2391   if (schedlock_applies (step))
2392     {
2393       if (except != current
2394           && thread_still_needs_step_over (current))
2395         return current;
2396
2397       return NULL;
2398     }
2399
2400   ALL_NON_EXITED_THREADS (tp)
2401     {
2402       /* Ignore the EXCEPT thread.  */
2403       if (tp == except)
2404         continue;
2405       /* Ignore threads of processes we're not resuming.  */
2406       if (!sched_multi
2407           && ptid_get_pid (tp->ptid) != ptid_get_pid (inferior_ptid))
2408         continue;
2409
2410       if (thread_still_needs_step_over (tp))
2411         return tp;
2412     }
2413
2414   return NULL;
2415 }
2416
2417 /* Basic routine for continuing the program in various fashions.
2418
2419    ADDR is the address to resume at, or -1 for resume where stopped.
2420    SIGGNAL is the signal to give it, or 0 for none,
2421    or -1 for act according to how it stopped.
2422    STEP is nonzero if should trap after one instruction.
2423    -1 means return after that and print nothing.
2424    You should probably set various step_... variables
2425    before calling here, if you are stepping.
2426
2427    You should call clear_proceed_status before calling proceed.  */
2428
2429 void
2430 proceed (CORE_ADDR addr, enum gdb_signal siggnal, int step)
2431 {
2432   struct regcache *regcache;
2433   struct gdbarch *gdbarch;
2434   struct thread_info *tp;
2435   CORE_ADDR pc;
2436   struct address_space *aspace;
2437
2438   /* If we're stopped at a fork/vfork, follow the branch set by the
2439      "set follow-fork-mode" command; otherwise, we'll just proceed
2440      resuming the current thread.  */
2441   if (!follow_fork ())
2442     {
2443       /* The target for some reason decided not to resume.  */
2444       normal_stop ();
2445       if (target_can_async_p ())
2446         inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2447       return;
2448     }
2449
2450   /* We'll update this if & when we switch to a new thread.  */
2451   previous_inferior_ptid = inferior_ptid;
2452
2453   regcache = get_current_regcache ();
2454   gdbarch = get_regcache_arch (regcache);
2455   aspace = get_regcache_aspace (regcache);
2456   pc = regcache_read_pc (regcache);
2457   tp = inferior_thread ();
2458
2459   if (step > 0)
2460     step_start_function = find_pc_function (pc);
2461   if (step < 0)
2462     stop_after_trap = 1;
2463
2464   /* Fill in with reasonable starting values.  */
2465   init_thread_stepping_state (tp);
2466
2467   if (addr == (CORE_ADDR) -1)
2468     {
2469       if (pc == stop_pc && breakpoint_here_p (aspace, pc)
2470           && execution_direction != EXEC_REVERSE)
2471         /* There is a breakpoint at the address we will resume at,
2472            step one instruction before inserting breakpoints so that
2473            we do not stop right away (and report a second hit at this
2474            breakpoint).
2475
2476            Note, we don't do this in reverse, because we won't
2477            actually be executing the breakpoint insn anyway.
2478            We'll be (un-)executing the previous instruction.  */
2479         tp->stepping_over_breakpoint = 1;
2480       else if (gdbarch_single_step_through_delay_p (gdbarch)
2481                && gdbarch_single_step_through_delay (gdbarch,
2482                                                      get_current_frame ()))
2483         /* We stepped onto an instruction that needs to be stepped
2484            again before re-inserting the breakpoint, do so.  */
2485         tp->stepping_over_breakpoint = 1;
2486     }
2487   else
2488     {
2489       regcache_write_pc (regcache, addr);
2490     }
2491
2492   if (siggnal != GDB_SIGNAL_DEFAULT)
2493     tp->suspend.stop_signal = siggnal;
2494
2495   /* Record the interpreter that issued the execution command that
2496      caused this thread to resume.  If the top level interpreter is
2497      MI/async, and the execution command was a CLI command
2498      (next/step/etc.), we'll want to print stop event output to the MI
2499      console channel (the stepped-to line, etc.), as if the user
2500      entered the execution command on a real GDB console.  */
2501   inferior_thread ()->control.command_interp = command_interp ();
2502
2503   if (debug_infrun)
2504     fprintf_unfiltered (gdb_stdlog,
2505                         "infrun: proceed (addr=%s, signal=%s, step=%d)\n",
2506                         paddress (gdbarch, addr),
2507                         gdb_signal_to_symbol_string (siggnal), step);
2508
2509   if (non_stop)
2510     /* In non-stop, each thread is handled individually.  The context
2511        must already be set to the right thread here.  */
2512     ;
2513   else
2514     {
2515       struct thread_info *step_over;
2516
2517       /* In a multi-threaded task we may select another thread and
2518          then continue or step.
2519
2520          But if the old thread was stopped at a breakpoint, it will
2521          immediately cause another breakpoint stop without any
2522          execution (i.e. it will report a breakpoint hit incorrectly).
2523          So we must step over it first.
2524
2525          Look for a thread other than the current (TP) that reported a
2526          breakpoint hit and hasn't been resumed yet since.  */
2527       step_over = find_thread_needs_step_over (step, tp);
2528       if (step_over != NULL)
2529         {
2530           if (debug_infrun)
2531             fprintf_unfiltered (gdb_stdlog,
2532                                 "infrun: need to step-over [%s] first\n",
2533                                 target_pid_to_str (step_over->ptid));
2534
2535           /* Store the prev_pc for the stepping thread too, needed by
2536              switch_back_to_stepping thread.  */
2537           tp->prev_pc = regcache_read_pc (get_current_regcache ());
2538           switch_to_thread (step_over->ptid);
2539           tp = step_over;
2540         }
2541     }
2542
2543   /* If we need to step over a breakpoint, and we're not using
2544      displaced stepping to do so, insert all breakpoints (watchpoints,
2545      etc.) but the one we're stepping over, step one instruction, and
2546      then re-insert the breakpoint when that step is finished.  */
2547   if (tp->stepping_over_breakpoint && !use_displaced_stepping (gdbarch))
2548     {
2549       struct regcache *regcache = get_current_regcache ();
2550
2551       set_step_over_info (get_regcache_aspace (regcache),
2552                           regcache_read_pc (regcache));
2553     }
2554   else
2555     clear_step_over_info ();
2556
2557   insert_breakpoints ();
2558
2559   tp->control.trap_expected = tp->stepping_over_breakpoint;
2560
2561   annotate_starting ();
2562
2563   /* Make sure that output from GDB appears before output from the
2564      inferior.  */
2565   gdb_flush (gdb_stdout);
2566
2567   /* Refresh prev_pc value just prior to resuming.  This used to be
2568      done in stop_waiting, however, setting prev_pc there did not handle
2569      scenarios such as inferior function calls or returning from
2570      a function via the return command.  In those cases, the prev_pc
2571      value was not set properly for subsequent commands.  The prev_pc value 
2572      is used to initialize the starting line number in the ecs.  With an 
2573      invalid value, the gdb next command ends up stopping at the position
2574      represented by the next line table entry past our start position.
2575      On platforms that generate one line table entry per line, this
2576      is not a problem.  However, on the ia64, the compiler generates
2577      extraneous line table entries that do not increase the line number.
2578      When we issue the gdb next command on the ia64 after an inferior call
2579      or a return command, we often end up a few instructions forward, still 
2580      within the original line we started.
2581
2582      An attempt was made to refresh the prev_pc at the same time the
2583      execution_control_state is initialized (for instance, just before
2584      waiting for an inferior event).  But this approach did not work
2585      because of platforms that use ptrace, where the pc register cannot
2586      be read unless the inferior is stopped.  At that point, we are not
2587      guaranteed the inferior is stopped and so the regcache_read_pc() call
2588      can fail.  Setting the prev_pc value here ensures the value is updated
2589      correctly when the inferior is stopped.  */
2590   tp->prev_pc = regcache_read_pc (get_current_regcache ());
2591
2592   /* Reset to normal state.  */
2593   init_infwait_state ();
2594
2595   /* Resume inferior.  */
2596   resume (tp->control.trap_expected || step || bpstat_should_step (),
2597           tp->suspend.stop_signal);
2598
2599   /* Wait for it to stop (if not standalone)
2600      and in any case decode why it stopped, and act accordingly.  */
2601   /* Do this only if we are not using the event loop, or if the target
2602      does not support asynchronous execution.  */
2603   if (!target_can_async_p ())
2604     {
2605       wait_for_inferior ();
2606       normal_stop ();
2607     }
2608 }
2609 \f
2610
2611 /* Start remote-debugging of a machine over a serial link.  */
2612
2613 void
2614 start_remote (int from_tty)
2615 {
2616   struct inferior *inferior;
2617
2618   inferior = current_inferior ();
2619   inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2620
2621   /* Always go on waiting for the target, regardless of the mode.  */
2622   /* FIXME: cagney/1999-09-23: At present it isn't possible to
2623      indicate to wait_for_inferior that a target should timeout if
2624      nothing is returned (instead of just blocking).  Because of this,
2625      targets expecting an immediate response need to, internally, set
2626      things up so that the target_wait() is forced to eventually
2627      timeout.  */
2628   /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
2629      differentiate to its caller what the state of the target is after
2630      the initial open has been performed.  Here we're assuming that
2631      the target has stopped.  It should be possible to eventually have
2632      target_open() return to the caller an indication that the target
2633      is currently running and GDB state should be set to the same as
2634      for an async run.  */
2635   wait_for_inferior ();
2636
2637   /* Now that the inferior has stopped, do any bookkeeping like
2638      loading shared libraries.  We want to do this before normal_stop,
2639      so that the displayed frame is up to date.  */
2640   post_create_inferior (&current_target, from_tty);
2641
2642   normal_stop ();
2643 }
2644
2645 /* Initialize static vars when a new inferior begins.  */
2646
2647 void
2648 init_wait_for_inferior (void)
2649 {
2650   /* These are meaningless until the first time through wait_for_inferior.  */
2651
2652   breakpoint_init_inferior (inf_starting);
2653
2654   clear_proceed_status (0);
2655
2656   target_last_wait_ptid = minus_one_ptid;
2657
2658   previous_inferior_ptid = inferior_ptid;
2659   init_infwait_state ();
2660
2661   /* Discard any skipped inlined frames.  */
2662   clear_inline_frame_state (minus_one_ptid);
2663
2664   singlestep_ptid = null_ptid;
2665   singlestep_pc = 0;
2666 }
2667
2668 \f
2669 /* This enum encodes possible reasons for doing a target_wait, so that
2670    wfi can call target_wait in one place.  (Ultimately the call will be
2671    moved out of the infinite loop entirely.) */
2672
2673 enum infwait_states
2674 {
2675   infwait_normal_state,
2676   infwait_step_watch_state,
2677   infwait_nonstep_watch_state
2678 };
2679
2680 /* The PTID we'll do a target_wait on.*/
2681 ptid_t waiton_ptid;
2682
2683 /* Current inferior wait state.  */
2684 static enum infwait_states infwait_state;
2685
2686 /* Data to be passed around while handling an event.  This data is
2687    discarded between events.  */
2688 struct execution_control_state
2689 {
2690   ptid_t ptid;
2691   /* The thread that got the event, if this was a thread event; NULL
2692      otherwise.  */
2693   struct thread_info *event_thread;
2694
2695   struct target_waitstatus ws;
2696   int stop_func_filled_in;
2697   CORE_ADDR stop_func_start;
2698   CORE_ADDR stop_func_end;
2699   const char *stop_func_name;
2700   int wait_some_more;
2701
2702   /* We were in infwait_step_watch_state or
2703      infwait_nonstep_watch_state state, and the thread reported an
2704      event.  */
2705   int stepped_after_stopped_by_watchpoint;
2706
2707   /* True if the event thread hit the single-step breakpoint of
2708      another thread.  Thus the event doesn't cause a stop, the thread
2709      needs to be single-stepped past the single-step breakpoint before
2710      we can switch back to the original stepping thread.  */
2711   int hit_singlestep_breakpoint;
2712 };
2713
2714 static void handle_inferior_event (struct execution_control_state *ecs);
2715
2716 static void handle_step_into_function (struct gdbarch *gdbarch,
2717                                        struct execution_control_state *ecs);
2718 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
2719                                                 struct execution_control_state *ecs);
2720 static void handle_signal_stop (struct execution_control_state *ecs);
2721 static void check_exception_resume (struct execution_control_state *,
2722                                     struct frame_info *);
2723
2724 static void end_stepping_range (struct execution_control_state *ecs);
2725 static void stop_waiting (struct execution_control_state *ecs);
2726 static void prepare_to_wait (struct execution_control_state *ecs);
2727 static void keep_going (struct execution_control_state *ecs);
2728 static void process_event_stop_test (struct execution_control_state *ecs);
2729 static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
2730
2731 /* Callback for iterate over threads.  If the thread is stopped, but
2732    the user/frontend doesn't know about that yet, go through
2733    normal_stop, as if the thread had just stopped now.  ARG points at
2734    a ptid.  If PTID is MINUS_ONE_PTID, applies to all threads.  If
2735    ptid_is_pid(PTID) is true, applies to all threads of the process
2736    pointed at by PTID.  Otherwise, apply only to the thread pointed by
2737    PTID.  */
2738
2739 static int
2740 infrun_thread_stop_requested_callback (struct thread_info *info, void *arg)
2741 {
2742   ptid_t ptid = * (ptid_t *) arg;
2743
2744   if ((ptid_equal (info->ptid, ptid)
2745        || ptid_equal (minus_one_ptid, ptid)
2746        || (ptid_is_pid (ptid)
2747            && ptid_get_pid (ptid) == ptid_get_pid (info->ptid)))
2748       && is_running (info->ptid)
2749       && !is_executing (info->ptid))
2750     {
2751       struct cleanup *old_chain;
2752       struct execution_control_state ecss;
2753       struct execution_control_state *ecs = &ecss;
2754
2755       memset (ecs, 0, sizeof (*ecs));
2756
2757       old_chain = make_cleanup_restore_current_thread ();
2758
2759       overlay_cache_invalid = 1;
2760       /* Flush target cache before starting to handle each event.
2761          Target was running and cache could be stale.  This is just a
2762          heuristic.  Running threads may modify target memory, but we
2763          don't get any event.  */
2764       target_dcache_invalidate ();
2765
2766       /* Go through handle_inferior_event/normal_stop, so we always
2767          have consistent output as if the stop event had been
2768          reported.  */
2769       ecs->ptid = info->ptid;
2770       ecs->event_thread = find_thread_ptid (info->ptid);
2771       ecs->ws.kind = TARGET_WAITKIND_STOPPED;
2772       ecs->ws.value.sig = GDB_SIGNAL_0;
2773
2774       handle_inferior_event (ecs);
2775
2776       if (!ecs->wait_some_more)
2777         {
2778           struct thread_info *tp;
2779
2780           normal_stop ();
2781
2782           /* Finish off the continuations.  */
2783           tp = inferior_thread ();
2784           do_all_intermediate_continuations_thread (tp, 1);
2785           do_all_continuations_thread (tp, 1);
2786         }
2787
2788       do_cleanups (old_chain);
2789     }
2790
2791   return 0;
2792 }
2793
2794 /* This function is attached as a "thread_stop_requested" observer.
2795    Cleanup local state that assumed the PTID was to be resumed, and
2796    report the stop to the frontend.  */
2797
2798 static void
2799 infrun_thread_stop_requested (ptid_t ptid)
2800 {
2801   struct displaced_step_inferior_state *displaced;
2802
2803   /* PTID was requested to stop.  Remove it from the displaced
2804      stepping queue, so we don't try to resume it automatically.  */
2805
2806   for (displaced = displaced_step_inferior_states;
2807        displaced;
2808        displaced = displaced->next)
2809     {
2810       struct displaced_step_request *it, **prev_next_p;
2811
2812       it = displaced->step_request_queue;
2813       prev_next_p = &displaced->step_request_queue;
2814       while (it)
2815         {
2816           if (ptid_match (it->ptid, ptid))
2817             {
2818               *prev_next_p = it->next;
2819               it->next = NULL;
2820               xfree (it);
2821             }
2822           else
2823             {
2824               prev_next_p = &it->next;
2825             }
2826
2827           it = *prev_next_p;
2828         }
2829     }
2830
2831   iterate_over_threads (infrun_thread_stop_requested_callback, &ptid);
2832 }
2833
2834 static void
2835 infrun_thread_thread_exit (struct thread_info *tp, int silent)
2836 {
2837   if (ptid_equal (target_last_wait_ptid, tp->ptid))
2838     nullify_last_target_wait_ptid ();
2839 }
2840
2841 /* Callback for iterate_over_threads.  */
2842
2843 static int
2844 delete_step_resume_breakpoint_callback (struct thread_info *info, void *data)
2845 {
2846   if (is_exited (info->ptid))
2847     return 0;
2848
2849   delete_step_resume_breakpoint (info);
2850   delete_exception_resume_breakpoint (info);
2851   return 0;
2852 }
2853
2854 /* In all-stop, delete the step resume breakpoint of any thread that
2855    had one.  In non-stop, delete the step resume breakpoint of the
2856    thread that just stopped.  */
2857
2858 static void
2859 delete_step_thread_step_resume_breakpoint (void)
2860 {
2861   if (!target_has_execution
2862       || ptid_equal (inferior_ptid, null_ptid))
2863     /* If the inferior has exited, we have already deleted the step
2864        resume breakpoints out of GDB's lists.  */
2865     return;
2866
2867   if (non_stop)
2868     {
2869       /* If in non-stop mode, only delete the step-resume or
2870          longjmp-resume breakpoint of the thread that just stopped
2871          stepping.  */
2872       struct thread_info *tp = inferior_thread ();
2873
2874       delete_step_resume_breakpoint (tp);
2875       delete_exception_resume_breakpoint (tp);
2876     }
2877   else
2878     /* In all-stop mode, delete all step-resume and longjmp-resume
2879        breakpoints of any thread that had them.  */
2880     iterate_over_threads (delete_step_resume_breakpoint_callback, NULL);
2881 }
2882
2883 /* A cleanup wrapper.  */
2884
2885 static void
2886 delete_step_thread_step_resume_breakpoint_cleanup (void *arg)
2887 {
2888   delete_step_thread_step_resume_breakpoint ();
2889 }
2890
2891 /* Pretty print the results of target_wait, for debugging purposes.  */
2892
2893 static void
2894 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
2895                            const struct target_waitstatus *ws)
2896 {
2897   char *status_string = target_waitstatus_to_string (ws);
2898   struct ui_file *tmp_stream = mem_fileopen ();
2899   char *text;
2900
2901   /* The text is split over several lines because it was getting too long.
2902      Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
2903      output as a unit; we want only one timestamp printed if debug_timestamp
2904      is set.  */
2905
2906   fprintf_unfiltered (tmp_stream,
2907                       "infrun: target_wait (%d", ptid_get_pid (waiton_ptid));
2908   if (ptid_get_pid (waiton_ptid) != -1)
2909     fprintf_unfiltered (tmp_stream,
2910                         " [%s]", target_pid_to_str (waiton_ptid));
2911   fprintf_unfiltered (tmp_stream, ", status) =\n");
2912   fprintf_unfiltered (tmp_stream,
2913                       "infrun:   %d [%s],\n",
2914                       ptid_get_pid (result_ptid),
2915                       target_pid_to_str (result_ptid));
2916   fprintf_unfiltered (tmp_stream,
2917                       "infrun:   %s\n",
2918                       status_string);
2919
2920   text = ui_file_xstrdup (tmp_stream, NULL);
2921
2922   /* This uses %s in part to handle %'s in the text, but also to avoid
2923      a gcc error: the format attribute requires a string literal.  */
2924   fprintf_unfiltered (gdb_stdlog, "%s", text);
2925
2926   xfree (status_string);
2927   xfree (text);
2928   ui_file_delete (tmp_stream);
2929 }
2930
2931 /* Prepare and stabilize the inferior for detaching it.  E.g.,
2932    detaching while a thread is displaced stepping is a recipe for
2933    crashing it, as nothing would readjust the PC out of the scratch
2934    pad.  */
2935
2936 void
2937 prepare_for_detach (void)
2938 {
2939   struct inferior *inf = current_inferior ();
2940   ptid_t pid_ptid = pid_to_ptid (inf->pid);
2941   struct cleanup *old_chain_1;
2942   struct displaced_step_inferior_state *displaced;
2943
2944   displaced = get_displaced_stepping_state (inf->pid);
2945
2946   /* Is any thread of this process displaced stepping?  If not,
2947      there's nothing else to do.  */
2948   if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
2949     return;
2950
2951   if (debug_infrun)
2952     fprintf_unfiltered (gdb_stdlog,
2953                         "displaced-stepping in-process while detaching");
2954
2955   old_chain_1 = make_cleanup_restore_integer (&inf->detaching);
2956   inf->detaching = 1;
2957
2958   while (!ptid_equal (displaced->step_ptid, null_ptid))
2959     {
2960       struct cleanup *old_chain_2;
2961       struct execution_control_state ecss;
2962       struct execution_control_state *ecs;
2963
2964       ecs = &ecss;
2965       memset (ecs, 0, sizeof (*ecs));
2966
2967       overlay_cache_invalid = 1;
2968       /* Flush target cache before starting to handle each event.
2969          Target was running and cache could be stale.  This is just a
2970          heuristic.  Running threads may modify target memory, but we
2971          don't get any event.  */
2972       target_dcache_invalidate ();
2973
2974       if (deprecated_target_wait_hook)
2975         ecs->ptid = deprecated_target_wait_hook (pid_ptid, &ecs->ws, 0);
2976       else
2977         ecs->ptid = target_wait (pid_ptid, &ecs->ws, 0);
2978
2979       if (debug_infrun)
2980         print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
2981
2982       /* If an error happens while handling the event, propagate GDB's
2983          knowledge of the executing state to the frontend/user running
2984          state.  */
2985       old_chain_2 = make_cleanup (finish_thread_state_cleanup,
2986                                   &minus_one_ptid);
2987
2988       /* Now figure out what to do with the result of the result.  */
2989       handle_inferior_event (ecs);
2990
2991       /* No error, don't finish the state yet.  */
2992       discard_cleanups (old_chain_2);
2993
2994       /* Breakpoints and watchpoints are not installed on the target
2995          at this point, and signals are passed directly to the
2996          inferior, so this must mean the process is gone.  */
2997       if (!ecs->wait_some_more)
2998         {
2999           discard_cleanups (old_chain_1);
3000           error (_("Program exited while detaching"));
3001         }
3002     }
3003
3004   discard_cleanups (old_chain_1);
3005 }
3006
3007 /* Wait for control to return from inferior to debugger.
3008
3009    If inferior gets a signal, we may decide to start it up again
3010    instead of returning.  That is why there is a loop in this function.
3011    When this function actually returns it means the inferior
3012    should be left stopped and GDB should read more commands.  */
3013
3014 void
3015 wait_for_inferior (void)
3016 {
3017   struct cleanup *old_cleanups;
3018
3019   if (debug_infrun)
3020     fprintf_unfiltered
3021       (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3022
3023   old_cleanups =
3024     make_cleanup (delete_step_thread_step_resume_breakpoint_cleanup, NULL);
3025
3026   while (1)
3027     {
3028       struct execution_control_state ecss;
3029       struct execution_control_state *ecs = &ecss;
3030       struct cleanup *old_chain;
3031
3032       memset (ecs, 0, sizeof (*ecs));
3033
3034       overlay_cache_invalid = 1;
3035
3036       /* Flush target cache before starting to handle each event.
3037          Target was running and cache could be stale.  This is just a
3038          heuristic.  Running threads may modify target memory, but we
3039          don't get any event.  */
3040       target_dcache_invalidate ();
3041
3042       if (deprecated_target_wait_hook)
3043         ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0);
3044       else
3045         ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0);
3046
3047       if (debug_infrun)
3048         print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3049
3050       /* If an error happens while handling the event, propagate GDB's
3051          knowledge of the executing state to the frontend/user running
3052          state.  */
3053       old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3054
3055       /* Now figure out what to do with the result of the result.  */
3056       handle_inferior_event (ecs);
3057
3058       /* No error, don't finish the state yet.  */
3059       discard_cleanups (old_chain);
3060
3061       if (!ecs->wait_some_more)
3062         break;
3063     }
3064
3065   do_cleanups (old_cleanups);
3066 }
3067
3068 /* Asynchronous version of wait_for_inferior.  It is called by the
3069    event loop whenever a change of state is detected on the file
3070    descriptor corresponding to the target.  It can be called more than
3071    once to complete a single execution command.  In such cases we need
3072    to keep the state in a global variable ECSS.  If it is the last time
3073    that this function is called for a single execution command, then
3074    report to the user that the inferior has stopped, and do the
3075    necessary cleanups.  */
3076
3077 void
3078 fetch_inferior_event (void *client_data)
3079 {
3080   struct execution_control_state ecss;
3081   struct execution_control_state *ecs = &ecss;
3082   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3083   struct cleanup *ts_old_chain;
3084   int was_sync = sync_execution;
3085   int cmd_done = 0;
3086
3087   memset (ecs, 0, sizeof (*ecs));
3088
3089   /* We're handling a live event, so make sure we're doing live
3090      debugging.  If we're looking at traceframes while the target is
3091      running, we're going to need to get back to that mode after
3092      handling the event.  */
3093   if (non_stop)
3094     {
3095       make_cleanup_restore_current_traceframe ();
3096       set_current_traceframe (-1);
3097     }
3098
3099   if (non_stop)
3100     /* In non-stop mode, the user/frontend should not notice a thread
3101        switch due to internal events.  Make sure we reverse to the
3102        user selected thread and frame after handling the event and
3103        running any breakpoint commands.  */
3104     make_cleanup_restore_current_thread ();
3105
3106   overlay_cache_invalid = 1;
3107   /* Flush target cache before starting to handle each event.  Target
3108      was running and cache could be stale.  This is just a heuristic.
3109      Running threads may modify target memory, but we don't get any
3110      event.  */
3111   target_dcache_invalidate ();
3112
3113   make_cleanup_restore_integer (&execution_direction);
3114   execution_direction = target_execution_direction ();
3115
3116   if (deprecated_target_wait_hook)
3117     ecs->ptid =
3118       deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
3119   else
3120     ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
3121
3122   if (debug_infrun)
3123     print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3124
3125   /* If an error happens while handling the event, propagate GDB's
3126      knowledge of the executing state to the frontend/user running
3127      state.  */
3128   if (!non_stop)
3129     ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3130   else
3131     ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
3132
3133   /* Get executed before make_cleanup_restore_current_thread above to apply
3134      still for the thread which has thrown the exception.  */
3135   make_bpstat_clear_actions_cleanup ();
3136
3137   /* Now figure out what to do with the result of the result.  */
3138   handle_inferior_event (ecs);
3139
3140   if (!ecs->wait_some_more)
3141     {
3142       struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
3143
3144       delete_step_thread_step_resume_breakpoint ();
3145
3146       /* We may not find an inferior if this was a process exit.  */
3147       if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3148         normal_stop ();
3149
3150       if (target_has_execution
3151           && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED
3152           && ecs->ws.kind != TARGET_WAITKIND_EXITED
3153           && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3154           && ecs->event_thread->step_multi
3155           && ecs->event_thread->control.stop_step)
3156         inferior_event_handler (INF_EXEC_CONTINUE, NULL);
3157       else
3158         {
3159           inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3160           cmd_done = 1;
3161         }
3162     }
3163
3164   /* No error, don't finish the thread states yet.  */
3165   discard_cleanups (ts_old_chain);
3166
3167   /* Revert thread and frame.  */
3168   do_cleanups (old_chain);
3169
3170   /* If the inferior was in sync execution mode, and now isn't,
3171      restore the prompt (a synchronous execution command has finished,
3172      and we're ready for input).  */
3173   if (interpreter_async && was_sync && !sync_execution)
3174     observer_notify_sync_execution_done ();
3175
3176   if (cmd_done
3177       && !was_sync
3178       && exec_done_display_p
3179       && (ptid_equal (inferior_ptid, null_ptid)
3180           || !is_running (inferior_ptid)))
3181     printf_unfiltered (_("completed.\n"));
3182 }
3183
3184 /* Record the frame and location we're currently stepping through.  */
3185 void
3186 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3187 {
3188   struct thread_info *tp = inferior_thread ();
3189
3190   tp->control.step_frame_id = get_frame_id (frame);
3191   tp->control.step_stack_frame_id = get_stack_frame_id (frame);
3192
3193   tp->current_symtab = sal.symtab;
3194   tp->current_line = sal.line;
3195 }
3196
3197 /* Clear context switchable stepping state.  */
3198
3199 void
3200 init_thread_stepping_state (struct thread_info *tss)
3201 {
3202   tss->stepping_over_breakpoint = 0;
3203   tss->step_after_step_resume_breakpoint = 0;
3204 }
3205
3206 /* Set the cached copy of the last ptid/waitstatus.  */
3207
3208 static void
3209 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
3210 {
3211   target_last_wait_ptid = ptid;
3212   target_last_waitstatus = status;
3213 }
3214
3215 /* Return the cached copy of the last pid/waitstatus returned by
3216    target_wait()/deprecated_target_wait_hook().  The data is actually
3217    cached by handle_inferior_event(), which gets called immediately
3218    after target_wait()/deprecated_target_wait_hook().  */
3219
3220 void
3221 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
3222 {
3223   *ptidp = target_last_wait_ptid;
3224   *status = target_last_waitstatus;
3225 }
3226
3227 void
3228 nullify_last_target_wait_ptid (void)
3229 {
3230   target_last_wait_ptid = minus_one_ptid;
3231 }
3232
3233 /* Switch thread contexts.  */
3234
3235 static void
3236 context_switch (ptid_t ptid)
3237 {
3238   if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
3239     {
3240       fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
3241                           target_pid_to_str (inferior_ptid));
3242       fprintf_unfiltered (gdb_stdlog, "to %s\n",
3243                           target_pid_to_str (ptid));
3244     }
3245
3246   switch_to_thread (ptid);
3247 }
3248
3249 static void
3250 adjust_pc_after_break (struct execution_control_state *ecs)
3251 {
3252   struct regcache *regcache;
3253   struct gdbarch *gdbarch;
3254   struct address_space *aspace;
3255   CORE_ADDR breakpoint_pc, decr_pc;
3256
3257   /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP.  If
3258      we aren't, just return.
3259
3260      We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3261      affected by gdbarch_decr_pc_after_break.  Other waitkinds which are
3262      implemented by software breakpoints should be handled through the normal
3263      breakpoint layer.
3264
3265      NOTE drow/2004-01-31: On some targets, breakpoints may generate
3266      different signals (SIGILL or SIGEMT for instance), but it is less
3267      clear where the PC is pointing afterwards.  It may not match
3268      gdbarch_decr_pc_after_break.  I don't know any specific target that
3269      generates these signals at breakpoints (the code has been in GDB since at
3270      least 1992) so I can not guess how to handle them here.
3271
3272      In earlier versions of GDB, a target with 
3273      gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3274      watchpoint affected by gdbarch_decr_pc_after_break.  I haven't found any
3275      target with both of these set in GDB history, and it seems unlikely to be
3276      correct, so gdbarch_have_nonsteppable_watchpoint is not checked here.  */
3277
3278   if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
3279     return;
3280
3281   if (ecs->ws.value.sig != GDB_SIGNAL_TRAP)
3282     return;
3283
3284   /* In reverse execution, when a breakpoint is hit, the instruction
3285      under it has already been de-executed.  The reported PC always
3286      points at the breakpoint address, so adjusting it further would
3287      be wrong.  E.g., consider this case on a decr_pc_after_break == 1
3288      architecture:
3289
3290        B1         0x08000000 :   INSN1
3291        B2         0x08000001 :   INSN2
3292                   0x08000002 :   INSN3
3293             PC -> 0x08000003 :   INSN4
3294
3295      Say you're stopped at 0x08000003 as above.  Reverse continuing
3296      from that point should hit B2 as below.  Reading the PC when the
3297      SIGTRAP is reported should read 0x08000001 and INSN2 should have
3298      been de-executed already.
3299
3300        B1         0x08000000 :   INSN1
3301        B2   PC -> 0x08000001 :   INSN2
3302                   0x08000002 :   INSN3
3303                   0x08000003 :   INSN4
3304
3305      We can't apply the same logic as for forward execution, because
3306      we would wrongly adjust the PC to 0x08000000, since there's a
3307      breakpoint at PC - 1.  We'd then report a hit on B1, although
3308      INSN1 hadn't been de-executed yet.  Doing nothing is the correct
3309      behaviour.  */
3310   if (execution_direction == EXEC_REVERSE)
3311     return;
3312
3313   /* If this target does not decrement the PC after breakpoints, then
3314      we have nothing to do.  */
3315   regcache = get_thread_regcache (ecs->ptid);
3316   gdbarch = get_regcache_arch (regcache);
3317
3318   decr_pc = target_decr_pc_after_break (gdbarch);
3319   if (decr_pc == 0)
3320     return;
3321
3322   aspace = get_regcache_aspace (regcache);
3323
3324   /* Find the location where (if we've hit a breakpoint) the
3325      breakpoint would be.  */
3326   breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
3327
3328   /* Check whether there actually is a software breakpoint inserted at
3329      that location.
3330
3331      If in non-stop mode, a race condition is possible where we've
3332      removed a breakpoint, but stop events for that breakpoint were
3333      already queued and arrive later.  To suppress those spurious
3334      SIGTRAPs, we keep a list of such breakpoint locations for a bit,
3335      and retire them after a number of stop events are reported.  */
3336   if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
3337       || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
3338     {
3339       struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
3340
3341       if (record_full_is_used ())
3342         record_full_gdb_operation_disable_set ();
3343
3344       /* When using hardware single-step, a SIGTRAP is reported for both
3345          a completed single-step and a software breakpoint.  Need to
3346          differentiate between the two, as the latter needs adjusting
3347          but the former does not.
3348
3349          The SIGTRAP can be due to a completed hardware single-step only if 
3350           - we didn't insert software single-step breakpoints
3351           - the thread to be examined is still the current thread
3352           - this thread is currently being stepped
3353
3354          If any of these events did not occur, we must have stopped due
3355          to hitting a software breakpoint, and have to back up to the
3356          breakpoint address.
3357
3358          As a special case, we could have hardware single-stepped a
3359          software breakpoint.  In this case (prev_pc == breakpoint_pc),
3360          we also need to back up to the breakpoint address.  */
3361
3362       if (singlestep_breakpoints_inserted_p
3363           || !ptid_equal (ecs->ptid, inferior_ptid)
3364           || !currently_stepping (ecs->event_thread)
3365           || ecs->event_thread->prev_pc == breakpoint_pc)
3366         regcache_write_pc (regcache, breakpoint_pc);
3367
3368       do_cleanups (old_cleanups);
3369     }
3370 }
3371
3372 static void
3373 init_infwait_state (void)
3374 {
3375   waiton_ptid = pid_to_ptid (-1);
3376   infwait_state = infwait_normal_state;
3377 }
3378
3379 static int
3380 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
3381 {
3382   for (frame = get_prev_frame (frame);
3383        frame != NULL;
3384        frame = get_prev_frame (frame))
3385     {
3386       if (frame_id_eq (get_frame_id (frame), step_frame_id))
3387         return 1;
3388       if (get_frame_type (frame) != INLINE_FRAME)
3389         break;
3390     }
3391
3392   return 0;
3393 }
3394
3395 /* Auxiliary function that handles syscall entry/return events.
3396    It returns 1 if the inferior should keep going (and GDB
3397    should ignore the event), or 0 if the event deserves to be
3398    processed.  */
3399
3400 static int
3401 handle_syscall_event (struct execution_control_state *ecs)
3402 {
3403   struct regcache *regcache;
3404   int syscall_number;
3405
3406   if (!ptid_equal (ecs->ptid, inferior_ptid))
3407     context_switch (ecs->ptid);
3408
3409   regcache = get_thread_regcache (ecs->ptid);
3410   syscall_number = ecs->ws.value.syscall_number;
3411   stop_pc = regcache_read_pc (regcache);
3412
3413   if (catch_syscall_enabled () > 0
3414       && catching_syscall_number (syscall_number) > 0)
3415     {
3416       if (debug_infrun)
3417         fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
3418                             syscall_number);
3419
3420       ecs->event_thread->control.stop_bpstat
3421         = bpstat_stop_status (get_regcache_aspace (regcache),
3422                               stop_pc, ecs->ptid, &ecs->ws);
3423
3424       if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3425         {
3426           /* Catchpoint hit.  */
3427           return 0;
3428         }
3429     }
3430
3431   /* If no catchpoint triggered for this, then keep going.  */
3432   keep_going (ecs);
3433   return 1;
3434 }
3435
3436 /* Lazily fill in the execution_control_state's stop_func_* fields.  */
3437
3438 static void
3439 fill_in_stop_func (struct gdbarch *gdbarch,
3440                    struct execution_control_state *ecs)
3441 {
3442   if (!ecs->stop_func_filled_in)
3443     {
3444       /* Don't care about return value; stop_func_start and stop_func_name
3445          will both be 0 if it doesn't work.  */
3446       find_pc_partial_function (stop_pc, &ecs->stop_func_name,
3447                                 &ecs->stop_func_start, &ecs->stop_func_end);
3448       ecs->stop_func_start
3449         += gdbarch_deprecated_function_start_offset (gdbarch);
3450
3451       if (gdbarch_skip_entrypoint_p (gdbarch))
3452         ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
3453                                                         ecs->stop_func_start);
3454
3455       ecs->stop_func_filled_in = 1;
3456     }
3457 }
3458
3459
3460 /* Return the STOP_SOON field of the inferior pointed at by PTID.  */
3461
3462 static enum stop_kind
3463 get_inferior_stop_soon (ptid_t ptid)
3464 {
3465   struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
3466
3467   gdb_assert (inf != NULL);
3468   return inf->control.stop_soon;
3469 }
3470
3471 /* Given an execution control state that has been freshly filled in by
3472    an event from the inferior, figure out what it means and take
3473    appropriate action.
3474
3475    The alternatives are:
3476
3477    1) stop_waiting and return; to really stop and return to the
3478    debugger.
3479
3480    2) keep_going and return; to wait for the next event (set
3481    ecs->event_thread->stepping_over_breakpoint to 1 to single step
3482    once).  */
3483
3484 static void
3485 handle_inferior_event (struct execution_control_state *ecs)
3486 {
3487   enum stop_kind stop_soon;
3488
3489   if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
3490     {
3491       /* We had an event in the inferior, but we are not interested in
3492          handling it at this level.  The lower layers have already
3493          done what needs to be done, if anything.
3494
3495          One of the possible circumstances for this is when the
3496          inferior produces output for the console.  The inferior has
3497          not stopped, and we are ignoring the event.  Another possible
3498          circumstance is any event which the lower level knows will be
3499          reported multiple times without an intervening resume.  */
3500       if (debug_infrun)
3501         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
3502       prepare_to_wait (ecs);
3503       return;
3504     }
3505
3506   if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
3507       && target_can_async_p () && !sync_execution)
3508     {
3509       /* There were no unwaited-for children left in the target, but,
3510          we're not synchronously waiting for events either.  Just
3511          ignore.  Otherwise, if we were running a synchronous
3512          execution command, we need to cancel it and give the user
3513          back the terminal.  */
3514       if (debug_infrun)
3515         fprintf_unfiltered (gdb_stdlog,
3516                             "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
3517       prepare_to_wait (ecs);
3518       return;
3519     }
3520
3521   /* Cache the last pid/waitstatus.  */
3522   set_last_target_status (ecs->ptid, ecs->ws);
3523
3524   /* Always clear state belonging to the previous time we stopped.  */
3525   stop_stack_dummy = STOP_NONE;
3526
3527   if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
3528     {
3529       /* No unwaited-for children left.  IOW, all resumed children
3530          have exited.  */
3531       if (debug_infrun)
3532         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
3533
3534       stop_print_frame = 0;
3535       stop_waiting (ecs);
3536       return;
3537     }
3538
3539   if (ecs->ws.kind != TARGET_WAITKIND_EXITED
3540       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
3541     {
3542       ecs->event_thread = find_thread_ptid (ecs->ptid);
3543       /* If it's a new thread, add it to the thread database.  */
3544       if (ecs->event_thread == NULL)
3545         ecs->event_thread = add_thread (ecs->ptid);
3546
3547       /* Disable range stepping.  If the next step request could use a
3548          range, this will be end up re-enabled then.  */
3549       ecs->event_thread->control.may_range_step = 0;
3550     }
3551
3552   /* Dependent on valid ECS->EVENT_THREAD.  */
3553   adjust_pc_after_break (ecs);
3554
3555   /* Dependent on the current PC value modified by adjust_pc_after_break.  */
3556   reinit_frame_cache ();
3557
3558   breakpoint_retire_moribund ();
3559
3560   /* First, distinguish signals caused by the debugger from signals
3561      that have to do with the program's own actions.  Note that
3562      breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
3563      on the operating system version.  Here we detect when a SIGILL or
3564      SIGEMT is really a breakpoint and change it to SIGTRAP.  We do
3565      something similar for SIGSEGV, since a SIGSEGV will be generated
3566      when we're trying to execute a breakpoint instruction on a
3567      non-executable stack.  This happens for call dummy breakpoints
3568      for architectures like SPARC that place call dummies on the
3569      stack.  */
3570   if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
3571       && (ecs->ws.value.sig == GDB_SIGNAL_ILL
3572           || ecs->ws.value.sig == GDB_SIGNAL_SEGV
3573           || ecs->ws.value.sig == GDB_SIGNAL_EMT))
3574     {
3575       struct regcache *regcache = get_thread_regcache (ecs->ptid);
3576
3577       if (breakpoint_inserted_here_p (get_regcache_aspace (regcache),
3578                                       regcache_read_pc (regcache)))
3579         {
3580           if (debug_infrun)
3581             fprintf_unfiltered (gdb_stdlog,
3582                                 "infrun: Treating signal as SIGTRAP\n");
3583           ecs->ws.value.sig = GDB_SIGNAL_TRAP;
3584         }
3585     }
3586
3587   /* Mark the non-executing threads accordingly.  In all-stop, all
3588      threads of all processes are stopped when we get any event
3589      reported.  In non-stop mode, only the event thread stops.  If
3590      we're handling a process exit in non-stop mode, there's nothing
3591      to do, as threads of the dead process are gone, and threads of
3592      any other process were left running.  */
3593   if (!non_stop)
3594     set_executing (minus_one_ptid, 0);
3595   else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3596            && ecs->ws.kind != TARGET_WAITKIND_EXITED)
3597     set_executing (ecs->ptid, 0);
3598
3599   switch (infwait_state)
3600     {
3601     case infwait_normal_state:
3602       if (debug_infrun)
3603         fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n");
3604       break;
3605
3606     case infwait_step_watch_state:
3607       if (debug_infrun)
3608         fprintf_unfiltered (gdb_stdlog,
3609                             "infrun: infwait_step_watch_state\n");
3610
3611       ecs->stepped_after_stopped_by_watchpoint = 1;
3612       break;
3613
3614     case infwait_nonstep_watch_state:
3615       if (debug_infrun)
3616         fprintf_unfiltered (gdb_stdlog,
3617                             "infrun: infwait_nonstep_watch_state\n");
3618       insert_breakpoints ();
3619
3620       /* FIXME-maybe: is this cleaner than setting a flag?  Does it
3621          handle things like signals arriving and other things happening
3622          in combination correctly?  */
3623       ecs->stepped_after_stopped_by_watchpoint = 1;
3624       break;
3625
3626     default:
3627       internal_error (__FILE__, __LINE__, _("bad switch"));
3628     }
3629
3630   infwait_state = infwait_normal_state;
3631   waiton_ptid = pid_to_ptid (-1);
3632
3633   switch (ecs->ws.kind)
3634     {
3635     case TARGET_WAITKIND_LOADED:
3636       if (debug_infrun)
3637         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
3638       if (!ptid_equal (ecs->ptid, inferior_ptid))
3639         context_switch (ecs->ptid);
3640       /* Ignore gracefully during startup of the inferior, as it might
3641          be the shell which has just loaded some objects, otherwise
3642          add the symbols for the newly loaded objects.  Also ignore at
3643          the beginning of an attach or remote session; we will query
3644          the full list of libraries once the connection is
3645          established.  */
3646
3647       stop_soon = get_inferior_stop_soon (ecs->ptid);
3648       if (stop_soon == NO_STOP_QUIETLY)
3649         {
3650           struct regcache *regcache;
3651
3652           regcache = get_thread_regcache (ecs->ptid);
3653
3654           handle_solib_event ();
3655
3656           ecs->event_thread->control.stop_bpstat
3657             = bpstat_stop_status (get_regcache_aspace (regcache),
3658                                   stop_pc, ecs->ptid, &ecs->ws);
3659
3660           if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3661             {
3662               /* A catchpoint triggered.  */
3663               process_event_stop_test (ecs);
3664               return;
3665             }
3666
3667           /* If requested, stop when the dynamic linker notifies
3668              gdb of events.  This allows the user to get control
3669              and place breakpoints in initializer routines for
3670              dynamically loaded objects (among other things).  */
3671           ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3672           if (stop_on_solib_events)
3673             {
3674               /* Make sure we print "Stopped due to solib-event" in
3675                  normal_stop.  */
3676               stop_print_frame = 1;
3677
3678               stop_waiting (ecs);
3679               return;
3680             }
3681         }
3682
3683       /* If we are skipping through a shell, or through shared library
3684          loading that we aren't interested in, resume the program.  If
3685          we're running the program normally, also resume.  */
3686       if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
3687         {
3688           /* Loading of shared libraries might have changed breakpoint
3689              addresses.  Make sure new breakpoints are inserted.  */
3690           if (stop_soon == NO_STOP_QUIETLY)
3691             insert_breakpoints ();
3692           resume (0, GDB_SIGNAL_0);
3693           prepare_to_wait (ecs);
3694           return;
3695         }
3696
3697       /* But stop if we're attaching or setting up a remote
3698          connection.  */
3699       if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
3700           || stop_soon == STOP_QUIETLY_REMOTE)
3701         {
3702           if (debug_infrun)
3703             fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
3704           stop_waiting (ecs);
3705           return;
3706         }
3707
3708       internal_error (__FILE__, __LINE__,
3709                       _("unhandled stop_soon: %d"), (int) stop_soon);
3710
3711     case TARGET_WAITKIND_SPURIOUS:
3712       if (debug_infrun)
3713         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
3714       if (!ptid_equal (ecs->ptid, inferior_ptid))
3715         context_switch (ecs->ptid);
3716       resume (0, GDB_SIGNAL_0);
3717       prepare_to_wait (ecs);
3718       return;
3719
3720     case TARGET_WAITKIND_EXITED:
3721     case TARGET_WAITKIND_SIGNALLED:
3722       if (debug_infrun)
3723         {
3724           if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3725             fprintf_unfiltered (gdb_stdlog,
3726                                 "infrun: TARGET_WAITKIND_EXITED\n");
3727           else
3728             fprintf_unfiltered (gdb_stdlog,
3729                                 "infrun: TARGET_WAITKIND_SIGNALLED\n");
3730         }
3731
3732       inferior_ptid = ecs->ptid;
3733       set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid)));
3734       set_current_program_space (current_inferior ()->pspace);
3735       handle_vfork_child_exec_or_exit (0);
3736       target_terminal_ours ();  /* Must do this before mourn anyway.  */
3737
3738       /* Clearing any previous state of convenience variables.  */
3739       clear_exit_convenience_vars ();
3740
3741       if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3742         {
3743           /* Record the exit code in the convenience variable $_exitcode, so
3744              that the user can inspect this again later.  */
3745           set_internalvar_integer (lookup_internalvar ("_exitcode"),
3746                                    (LONGEST) ecs->ws.value.integer);
3747
3748           /* Also record this in the inferior itself.  */
3749           current_inferior ()->has_exit_code = 1;
3750           current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
3751
3752           /* Support the --return-child-result option.  */
3753           return_child_result_value = ecs->ws.value.integer;
3754
3755           observer_notify_exited (ecs->ws.value.integer);
3756         }
3757       else
3758         {
3759           struct regcache *regcache = get_thread_regcache (ecs->ptid);
3760           struct gdbarch *gdbarch = get_regcache_arch (regcache);
3761
3762           if (gdbarch_gdb_signal_to_target_p (gdbarch))
3763             {
3764               /* Set the value of the internal variable $_exitsignal,
3765                  which holds the signal uncaught by the inferior.  */
3766               set_internalvar_integer (lookup_internalvar ("_exitsignal"),
3767                                        gdbarch_gdb_signal_to_target (gdbarch,
3768                                                           ecs->ws.value.sig));
3769             }
3770           else
3771             {
3772               /* We don't have access to the target's method used for
3773                  converting between signal numbers (GDB's internal
3774                  representation <-> target's representation).
3775                  Therefore, we cannot do a good job at displaying this
3776                  information to the user.  It's better to just warn
3777                  her about it (if infrun debugging is enabled), and
3778                  give up.  */
3779               if (debug_infrun)
3780                 fprintf_filtered (gdb_stdlog, _("\
3781 Cannot fill $_exitsignal with the correct signal number.\n"));
3782             }
3783
3784           observer_notify_signal_exited (ecs->ws.value.sig);
3785         }
3786
3787       gdb_flush (gdb_stdout);
3788       target_mourn_inferior ();
3789       singlestep_breakpoints_inserted_p = 0;
3790       cancel_single_step_breakpoints ();
3791       stop_print_frame = 0;
3792       stop_waiting (ecs);
3793       return;
3794
3795       /* The following are the only cases in which we keep going;
3796          the above cases end in a continue or goto.  */
3797     case TARGET_WAITKIND_FORKED:
3798     case TARGET_WAITKIND_VFORKED:
3799       if (debug_infrun)
3800         {
3801           if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3802             fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
3803           else
3804             fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
3805         }
3806
3807       /* Check whether the inferior is displaced stepping.  */
3808       {
3809         struct regcache *regcache = get_thread_regcache (ecs->ptid);
3810         struct gdbarch *gdbarch = get_regcache_arch (regcache);
3811         struct displaced_step_inferior_state *displaced
3812           = get_displaced_stepping_state (ptid_get_pid (ecs->ptid));
3813
3814         /* If checking displaced stepping is supported, and thread
3815            ecs->ptid is displaced stepping.  */
3816         if (displaced && ptid_equal (displaced->step_ptid, ecs->ptid))
3817           {
3818             struct inferior *parent_inf
3819               = find_inferior_pid (ptid_get_pid (ecs->ptid));
3820             struct regcache *child_regcache;
3821             CORE_ADDR parent_pc;
3822
3823             /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
3824                indicating that the displaced stepping of syscall instruction
3825                has been done.  Perform cleanup for parent process here.  Note
3826                that this operation also cleans up the child process for vfork,
3827                because their pages are shared.  */
3828             displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
3829
3830             if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3831               {
3832                 /* Restore scratch pad for child process.  */
3833                 displaced_step_restore (displaced, ecs->ws.value.related_pid);
3834               }
3835
3836             /* Since the vfork/fork syscall instruction was executed in the scratchpad,
3837                the child's PC is also within the scratchpad.  Set the child's PC
3838                to the parent's PC value, which has already been fixed up.
3839                FIXME: we use the parent's aspace here, although we're touching
3840                the child, because the child hasn't been added to the inferior
3841                list yet at this point.  */
3842
3843             child_regcache
3844               = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
3845                                                  gdbarch,
3846                                                  parent_inf->aspace);
3847             /* Read PC value of parent process.  */
3848             parent_pc = regcache_read_pc (regcache);
3849
3850             if (debug_displaced)
3851               fprintf_unfiltered (gdb_stdlog,
3852                                   "displaced: write child pc from %s to %s\n",
3853                                   paddress (gdbarch,
3854                                             regcache_read_pc (child_regcache)),
3855                                   paddress (gdbarch, parent_pc));
3856
3857             regcache_write_pc (child_regcache, parent_pc);
3858           }
3859       }
3860
3861       if (!ptid_equal (ecs->ptid, inferior_ptid))
3862         context_switch (ecs->ptid);
3863
3864       /* Immediately detach breakpoints from the child before there's
3865          any chance of letting the user delete breakpoints from the
3866          breakpoint lists.  If we don't do this early, it's easy to
3867          leave left over traps in the child, vis: "break foo; catch
3868          fork; c; <fork>; del; c; <child calls foo>".  We only follow
3869          the fork on the last `continue', and by that time the
3870          breakpoint at "foo" is long gone from the breakpoint table.
3871          If we vforked, then we don't need to unpatch here, since both
3872          parent and child are sharing the same memory pages; we'll
3873          need to unpatch at follow/detach time instead to be certain
3874          that new breakpoints added between catchpoint hit time and
3875          vfork follow are detached.  */
3876       if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
3877         {
3878           /* This won't actually modify the breakpoint list, but will
3879              physically remove the breakpoints from the child.  */
3880           detach_breakpoints (ecs->ws.value.related_pid);
3881         }
3882
3883       if (singlestep_breakpoints_inserted_p)
3884         {
3885           /* Pull the single step breakpoints out of the target.  */
3886           remove_single_step_breakpoints ();
3887           singlestep_breakpoints_inserted_p = 0;
3888         }
3889
3890       /* In case the event is caught by a catchpoint, remember that
3891          the event is to be followed at the next resume of the thread,
3892          and not immediately.  */
3893       ecs->event_thread->pending_follow = ecs->ws;
3894
3895       stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3896
3897       ecs->event_thread->control.stop_bpstat
3898         = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3899                               stop_pc, ecs->ptid, &ecs->ws);
3900
3901       /* If no catchpoint triggered for this, then keep going.  Note
3902          that we're interested in knowing the bpstat actually causes a
3903          stop, not just if it may explain the signal.  Software
3904          watchpoints, for example, always appear in the bpstat.  */
3905       if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3906         {
3907           ptid_t parent;
3908           ptid_t child;
3909           int should_resume;
3910           int follow_child
3911             = (follow_fork_mode_string == follow_fork_mode_child);
3912
3913           ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3914
3915           should_resume = follow_fork ();
3916
3917           parent = ecs->ptid;
3918           child = ecs->ws.value.related_pid;
3919
3920           /* In non-stop mode, also resume the other branch.  */
3921           if (non_stop && !detach_fork)
3922             {
3923               if (follow_child)
3924                 switch_to_thread (parent);
3925               else
3926                 switch_to_thread (child);
3927
3928               ecs->event_thread = inferior_thread ();
3929               ecs->ptid = inferior_ptid;
3930               keep_going (ecs);
3931             }
3932
3933           if (follow_child)
3934             switch_to_thread (child);
3935           else
3936             switch_to_thread (parent);
3937
3938           ecs->event_thread = inferior_thread ();
3939           ecs->ptid = inferior_ptid;
3940
3941           if (should_resume)
3942             keep_going (ecs);
3943           else
3944             stop_waiting (ecs);
3945           return;
3946         }
3947       process_event_stop_test (ecs);
3948       return;
3949
3950     case TARGET_WAITKIND_VFORK_DONE:
3951       /* Done with the shared memory region.  Re-insert breakpoints in
3952          the parent, and keep going.  */
3953
3954       if (debug_infrun)
3955         fprintf_unfiltered (gdb_stdlog,
3956                             "infrun: TARGET_WAITKIND_VFORK_DONE\n");
3957
3958       if (!ptid_equal (ecs->ptid, inferior_ptid))
3959         context_switch (ecs->ptid);
3960
3961       current_inferior ()->waiting_for_vfork_done = 0;
3962       current_inferior ()->pspace->breakpoints_not_allowed = 0;
3963       /* This also takes care of reinserting breakpoints in the
3964          previously locked inferior.  */
3965       keep_going (ecs);
3966       return;
3967
3968     case TARGET_WAITKIND_EXECD:
3969       if (debug_infrun)
3970         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
3971
3972       if (!ptid_equal (ecs->ptid, inferior_ptid))
3973         context_switch (ecs->ptid);
3974
3975       singlestep_breakpoints_inserted_p = 0;
3976       cancel_single_step_breakpoints ();
3977
3978       stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3979
3980       /* Do whatever is necessary to the parent branch of the vfork.  */
3981       handle_vfork_child_exec_or_exit (1);
3982
3983       /* This causes the eventpoints and symbol table to be reset.
3984          Must do this now, before trying to determine whether to
3985          stop.  */
3986       follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
3987
3988       ecs->event_thread->control.stop_bpstat
3989         = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3990                               stop_pc, ecs->ptid, &ecs->ws);
3991
3992       /* Note that this may be referenced from inside
3993          bpstat_stop_status above, through inferior_has_execd.  */
3994       xfree (ecs->ws.value.execd_pathname);
3995       ecs->ws.value.execd_pathname = NULL;
3996
3997       /* If no catchpoint triggered for this, then keep going.  */
3998       if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
3999         {
4000           ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4001           keep_going (ecs);
4002           return;
4003         }
4004       process_event_stop_test (ecs);
4005       return;
4006
4007       /* Be careful not to try to gather much state about a thread
4008          that's in a syscall.  It's frequently a losing proposition.  */
4009     case TARGET_WAITKIND_SYSCALL_ENTRY:
4010       if (debug_infrun)
4011         fprintf_unfiltered (gdb_stdlog,
4012                             "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
4013       /* Getting the current syscall number.  */
4014       if (handle_syscall_event (ecs) == 0)
4015         process_event_stop_test (ecs);
4016       return;
4017
4018       /* Before examining the threads further, step this thread to
4019          get it entirely out of the syscall.  (We get notice of the
4020          event when the thread is just on the verge of exiting a
4021          syscall.  Stepping one instruction seems to get it back
4022          into user code.)  */
4023     case TARGET_WAITKIND_SYSCALL_RETURN:
4024       if (debug_infrun)
4025         fprintf_unfiltered (gdb_stdlog,
4026                             "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
4027       if (handle_syscall_event (ecs) == 0)
4028         process_event_stop_test (ecs);
4029       return;
4030
4031     case TARGET_WAITKIND_STOPPED:
4032       if (debug_infrun)
4033         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
4034       ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
4035       handle_signal_stop (ecs);
4036       return;
4037
4038     case TARGET_WAITKIND_NO_HISTORY:
4039       if (debug_infrun)
4040         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
4041       /* Reverse execution: target ran out of history info.  */
4042
4043       /* Pull the single step breakpoints out of the target.  */
4044       if (singlestep_breakpoints_inserted_p)
4045         {
4046           if (!ptid_equal (ecs->ptid, inferior_ptid))
4047             context_switch (ecs->ptid);
4048           remove_single_step_breakpoints ();
4049           singlestep_breakpoints_inserted_p = 0;
4050         }
4051       stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
4052       observer_notify_no_history ();
4053       stop_waiting (ecs);
4054       return;
4055     }
4056 }
4057
4058 /* Come here when the program has stopped with a signal.  */
4059
4060 static void
4061 handle_signal_stop (struct execution_control_state *ecs)
4062 {
4063   struct frame_info *frame;
4064   struct gdbarch *gdbarch;
4065   int stopped_by_watchpoint;
4066   enum stop_kind stop_soon;
4067   int random_signal;
4068
4069   gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
4070
4071   /* Do we need to clean up the state of a thread that has
4072      completed a displaced single-step?  (Doing so usually affects
4073      the PC, so do it here, before we set stop_pc.)  */
4074   displaced_step_fixup (ecs->ptid,
4075                         ecs->event_thread->suspend.stop_signal);
4076
4077   /* If we either finished a single-step or hit a breakpoint, but
4078      the user wanted this thread to be stopped, pretend we got a
4079      SIG0 (generic unsignaled stop).  */
4080   if (ecs->event_thread->stop_requested
4081       && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
4082     ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4083
4084   stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
4085
4086   if (debug_infrun)
4087     {
4088       struct regcache *regcache = get_thread_regcache (ecs->ptid);
4089       struct gdbarch *gdbarch = get_regcache_arch (regcache);
4090       struct cleanup *old_chain = save_inferior_ptid ();
4091
4092       inferior_ptid = ecs->ptid;
4093
4094       fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
4095                           paddress (gdbarch, stop_pc));
4096       if (target_stopped_by_watchpoint ())
4097         {
4098           CORE_ADDR addr;
4099
4100           fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
4101
4102           if (target_stopped_data_address (&current_target, &addr))
4103             fprintf_unfiltered (gdb_stdlog,
4104                                 "infrun: stopped data address = %s\n",
4105                                 paddress (gdbarch, addr));
4106           else
4107             fprintf_unfiltered (gdb_stdlog,
4108                                 "infrun: (no data address available)\n");
4109         }
4110
4111       do_cleanups (old_chain);
4112     }
4113
4114   /* This is originated from start_remote(), start_inferior() and
4115      shared libraries hook functions.  */
4116   stop_soon = get_inferior_stop_soon (ecs->ptid);
4117   if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
4118     {
4119       if (!ptid_equal (ecs->ptid, inferior_ptid))
4120         context_switch (ecs->ptid);
4121       if (debug_infrun)
4122         fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
4123       stop_print_frame = 1;
4124       stop_waiting (ecs);
4125       return;
4126     }
4127
4128   if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4129       && stop_after_trap)
4130     {
4131       if (!ptid_equal (ecs->ptid, inferior_ptid))
4132         context_switch (ecs->ptid);
4133       if (debug_infrun)
4134         fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
4135       stop_print_frame = 0;
4136       stop_waiting (ecs);
4137       return;
4138     }
4139
4140   /* This originates from attach_command().  We need to overwrite
4141      the stop_signal here, because some kernels don't ignore a
4142      SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
4143      See more comments in inferior.h.  On the other hand, if we
4144      get a non-SIGSTOP, report it to the user - assume the backend
4145      will handle the SIGSTOP if it should show up later.
4146
4147      Also consider that the attach is complete when we see a
4148      SIGTRAP.  Some systems (e.g. Windows), and stubs supporting
4149      target extended-remote report it instead of a SIGSTOP
4150      (e.g. gdbserver).  We already rely on SIGTRAP being our
4151      signal, so this is no exception.
4152
4153      Also consider that the attach is complete when we see a
4154      GDB_SIGNAL_0.  In non-stop mode, GDB will explicitly tell
4155      the target to stop all threads of the inferior, in case the
4156      low level attach operation doesn't stop them implicitly.  If
4157      they weren't stopped implicitly, then the stub will report a
4158      GDB_SIGNAL_0, meaning: stopped for no particular reason
4159      other than GDB's request.  */
4160   if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
4161       && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
4162           || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4163           || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
4164     {
4165       stop_print_frame = 1;
4166       stop_waiting (ecs);
4167       ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4168       return;
4169     }
4170
4171   /* See if something interesting happened to the non-current thread.  If
4172      so, then switch to that thread.  */
4173   if (!ptid_equal (ecs->ptid, inferior_ptid))
4174     {
4175       if (debug_infrun)
4176         fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
4177
4178       context_switch (ecs->ptid);
4179
4180       if (deprecated_context_hook)
4181         deprecated_context_hook (pid_to_thread_id (ecs->ptid));
4182     }
4183
4184   /* At this point, get hold of the now-current thread's frame.  */
4185   frame = get_current_frame ();
4186   gdbarch = get_frame_arch (frame);
4187
4188   /* Pull the single step breakpoints out of the target.  */
4189   if (singlestep_breakpoints_inserted_p)
4190     {
4191       /* However, before doing so, if this single-step breakpoint was
4192          actually for another thread, set this thread up for moving
4193          past it.  */
4194       if (!ptid_equal (ecs->ptid, singlestep_ptid)
4195           && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
4196         {
4197           struct regcache *regcache;
4198           struct address_space *aspace;
4199           CORE_ADDR pc;
4200
4201           regcache = get_thread_regcache (ecs->ptid);
4202           aspace = get_regcache_aspace (regcache);
4203           pc = regcache_read_pc (regcache);
4204           if (single_step_breakpoint_inserted_here_p (aspace, pc))
4205             {
4206               if (debug_infrun)
4207                 {
4208                   fprintf_unfiltered (gdb_stdlog,
4209                                       "infrun: [%s] hit step over single-step"
4210                                       " breakpoint of [%s]\n",
4211                                       target_pid_to_str (ecs->ptid),
4212                                       target_pid_to_str (singlestep_ptid));
4213                 }
4214               ecs->hit_singlestep_breakpoint = 1;
4215             }
4216         }
4217
4218       remove_single_step_breakpoints ();
4219       singlestep_breakpoints_inserted_p = 0;
4220     }
4221
4222   if (ecs->stepped_after_stopped_by_watchpoint)
4223     stopped_by_watchpoint = 0;
4224   else
4225     stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
4226
4227   /* If necessary, step over this watchpoint.  We'll be back to display
4228      it in a moment.  */
4229   if (stopped_by_watchpoint
4230       && (target_have_steppable_watchpoint
4231           || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
4232     {
4233       /* At this point, we are stopped at an instruction which has
4234          attempted to write to a piece of memory under control of
4235          a watchpoint.  The instruction hasn't actually executed
4236          yet.  If we were to evaluate the watchpoint expression
4237          now, we would get the old value, and therefore no change
4238          would seem to have occurred.
4239
4240          In order to make watchpoints work `right', we really need
4241          to complete the memory write, and then evaluate the
4242          watchpoint expression.  We do this by single-stepping the
4243          target.
4244
4245          It may not be necessary to disable the watchpoint to step over
4246          it.  For example, the PA can (with some kernel cooperation)
4247          single step over a watchpoint without disabling the watchpoint.
4248
4249          It is far more common to need to disable a watchpoint to step
4250          the inferior over it.  If we have non-steppable watchpoints,
4251          we must disable the current watchpoint; it's simplest to
4252          disable all watchpoints and breakpoints.  */
4253       int hw_step = 1;
4254
4255       if (!target_have_steppable_watchpoint)
4256         {
4257           remove_breakpoints ();
4258           /* See comment in resume why we need to stop bypassing signals
4259              while breakpoints have been removed.  */
4260           target_pass_signals (0, NULL);
4261         }
4262         /* Single step */
4263       hw_step = maybe_software_singlestep (gdbarch, stop_pc);
4264       target_resume (ecs->ptid, hw_step, GDB_SIGNAL_0);
4265       waiton_ptid = ecs->ptid;
4266       if (target_have_steppable_watchpoint)
4267         infwait_state = infwait_step_watch_state;
4268       else
4269         infwait_state = infwait_nonstep_watch_state;
4270       prepare_to_wait (ecs);
4271       return;
4272     }
4273
4274   ecs->event_thread->stepping_over_breakpoint = 0;
4275   bpstat_clear (&ecs->event_thread->control.stop_bpstat);
4276   ecs->event_thread->control.stop_step = 0;
4277   stop_print_frame = 1;
4278   stopped_by_random_signal = 0;
4279
4280   /* Hide inlined functions starting here, unless we just performed stepi or
4281      nexti.  After stepi and nexti, always show the innermost frame (not any
4282      inline function call sites).  */
4283   if (ecs->event_thread->control.step_range_end != 1)
4284     {
4285       struct address_space *aspace = 
4286         get_regcache_aspace (get_thread_regcache (ecs->ptid));
4287
4288       /* skip_inline_frames is expensive, so we avoid it if we can
4289          determine that the address is one where functions cannot have
4290          been inlined.  This improves performance with inferiors that
4291          load a lot of shared libraries, because the solib event
4292          breakpoint is defined as the address of a function (i.e. not
4293          inline).  Note that we have to check the previous PC as well
4294          as the current one to catch cases when we have just
4295          single-stepped off a breakpoint prior to reinstating it.
4296          Note that we're assuming that the code we single-step to is
4297          not inline, but that's not definitive: there's nothing
4298          preventing the event breakpoint function from containing
4299          inlined code, and the single-step ending up there.  If the
4300          user had set a breakpoint on that inlined code, the missing
4301          skip_inline_frames call would break things.  Fortunately
4302          that's an extremely unlikely scenario.  */
4303       if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
4304           && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4305                && ecs->event_thread->control.trap_expected
4306                && pc_at_non_inline_function (aspace,
4307                                              ecs->event_thread->prev_pc,
4308                                              &ecs->ws)))
4309         {
4310           skip_inline_frames (ecs->ptid);
4311
4312           /* Re-fetch current thread's frame in case that invalidated
4313              the frame cache.  */
4314           frame = get_current_frame ();
4315           gdbarch = get_frame_arch (frame);
4316         }
4317     }
4318
4319   if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4320       && ecs->event_thread->control.trap_expected
4321       && gdbarch_single_step_through_delay_p (gdbarch)
4322       && currently_stepping (ecs->event_thread))
4323     {
4324       /* We're trying to step off a breakpoint.  Turns out that we're
4325          also on an instruction that needs to be stepped multiple
4326          times before it's been fully executing.  E.g., architectures
4327          with a delay slot.  It needs to be stepped twice, once for
4328          the instruction and once for the delay slot.  */
4329       int step_through_delay
4330         = gdbarch_single_step_through_delay (gdbarch, frame);
4331
4332       if (debug_infrun && step_through_delay)
4333         fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
4334       if (ecs->event_thread->control.step_range_end == 0
4335           && step_through_delay)
4336         {
4337           /* The user issued a continue when stopped at a breakpoint.
4338              Set up for another trap and get out of here.  */
4339          ecs->event_thread->stepping_over_breakpoint = 1;
4340          keep_going (ecs);
4341          return;
4342         }
4343       else if (step_through_delay)
4344         {
4345           /* The user issued a step when stopped at a breakpoint.
4346              Maybe we should stop, maybe we should not - the delay
4347              slot *might* correspond to a line of source.  In any
4348              case, don't decide that here, just set 
4349              ecs->stepping_over_breakpoint, making sure we 
4350              single-step again before breakpoints are re-inserted.  */
4351           ecs->event_thread->stepping_over_breakpoint = 1;
4352         }
4353     }
4354
4355   /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
4356      handles this event.  */
4357   ecs->event_thread->control.stop_bpstat
4358     = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
4359                           stop_pc, ecs->ptid, &ecs->ws);
4360
4361   /* Following in case break condition called a
4362      function.  */
4363   stop_print_frame = 1;
4364
4365   /* This is where we handle "moribund" watchpoints.  Unlike
4366      software breakpoints traps, hardware watchpoint traps are
4367      always distinguishable from random traps.  If no high-level
4368      watchpoint is associated with the reported stop data address
4369      anymore, then the bpstat does not explain the signal ---
4370      simply make sure to ignore it if `stopped_by_watchpoint' is
4371      set.  */
4372
4373   if (debug_infrun
4374       && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4375       && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
4376                                   GDB_SIGNAL_TRAP)
4377       && stopped_by_watchpoint)
4378     fprintf_unfiltered (gdb_stdlog,
4379                         "infrun: no user watchpoint explains "
4380                         "watchpoint SIGTRAP, ignoring\n");
4381
4382   /* NOTE: cagney/2003-03-29: These checks for a random signal
4383      at one stage in the past included checks for an inferior
4384      function call's call dummy's return breakpoint.  The original
4385      comment, that went with the test, read:
4386
4387      ``End of a stack dummy.  Some systems (e.g. Sony news) give
4388      another signal besides SIGTRAP, so check here as well as
4389      above.''
4390
4391      If someone ever tries to get call dummys on a
4392      non-executable stack to work (where the target would stop
4393      with something like a SIGSEGV), then those tests might need
4394      to be re-instated.  Given, however, that the tests were only
4395      enabled when momentary breakpoints were not being used, I
4396      suspect that it won't be the case.
4397
4398      NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
4399      be necessary for call dummies on a non-executable stack on
4400      SPARC.  */
4401
4402   /* See if the breakpoints module can explain the signal.  */
4403   random_signal
4404     = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
4405                                ecs->event_thread->suspend.stop_signal);
4406
4407   /* If not, perhaps stepping/nexting can.  */
4408   if (random_signal)
4409     random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4410                       && currently_stepping (ecs->event_thread));
4411
4412   /* Perhaps the thread hit a single-step breakpoint of _another_
4413      thread.  Single-step breakpoints are transparent to the
4414      breakpoints module.  */
4415   if (random_signal)
4416     random_signal = !ecs->hit_singlestep_breakpoint;
4417
4418   /* No?  Perhaps we got a moribund watchpoint.  */
4419   if (random_signal)
4420     random_signal = !stopped_by_watchpoint;
4421
4422   /* For the program's own signals, act according to
4423      the signal handling tables.  */
4424
4425   if (random_signal)
4426     {
4427       /* Signal not for debugging purposes.  */
4428       int printed = 0;
4429       struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
4430       enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
4431
4432       if (debug_infrun)
4433          fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
4434                              gdb_signal_to_symbol_string (stop_signal));
4435
4436       stopped_by_random_signal = 1;
4437
4438       /* Always stop on signals if we're either just gaining control
4439          of the program, or the user explicitly requested this thread
4440          to remain stopped.  */
4441       if (stop_soon != NO_STOP_QUIETLY
4442           || ecs->event_thread->stop_requested
4443           || (!inf->detaching
4444               && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
4445         {
4446           stop_waiting (ecs);
4447           return;
4448         }
4449
4450       /* Notify observers the signal has "handle print" set.  Note we
4451          returned early above if stopping; normal_stop handles the
4452          printing in that case.  */
4453       if (signal_print[ecs->event_thread->suspend.stop_signal])
4454         {
4455           /* The signal table tells us to print about this signal.  */
4456           target_terminal_ours_for_output ();
4457           observer_notify_signal_received (ecs->event_thread->suspend.stop_signal);
4458           target_terminal_inferior ();
4459         }
4460
4461       /* Clear the signal if it should not be passed.  */
4462       if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
4463         ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4464
4465       if (ecs->event_thread->prev_pc == stop_pc
4466           && ecs->event_thread->control.trap_expected
4467           && ecs->event_thread->control.step_resume_breakpoint == NULL)
4468         {
4469           /* We were just starting a new sequence, attempting to
4470              single-step off of a breakpoint and expecting a SIGTRAP.
4471              Instead this signal arrives.  This signal will take us out
4472              of the stepping range so GDB needs to remember to, when
4473              the signal handler returns, resume stepping off that
4474              breakpoint.  */
4475           /* To simplify things, "continue" is forced to use the same
4476              code paths as single-step - set a breakpoint at the
4477              signal return address and then, once hit, step off that
4478              breakpoint.  */
4479           if (debug_infrun)
4480             fprintf_unfiltered (gdb_stdlog,
4481                                 "infrun: signal arrived while stepping over "
4482                                 "breakpoint\n");
4483
4484           insert_hp_step_resume_breakpoint_at_frame (frame);
4485           ecs->event_thread->step_after_step_resume_breakpoint = 1;
4486           /* Reset trap_expected to ensure breakpoints are re-inserted.  */
4487           ecs->event_thread->control.trap_expected = 0;
4488
4489           /* If we were nexting/stepping some other thread, switch to
4490              it, so that we don't continue it, losing control.  */
4491           if (!switch_back_to_stepped_thread (ecs))
4492             keep_going (ecs);
4493           return;
4494         }
4495
4496       if (ecs->event_thread->control.step_range_end != 0
4497           && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
4498           && pc_in_thread_step_range (stop_pc, ecs->event_thread)
4499           && frame_id_eq (get_stack_frame_id (frame),
4500                           ecs->event_thread->control.step_stack_frame_id)
4501           && ecs->event_thread->control.step_resume_breakpoint == NULL)
4502         {
4503           /* The inferior is about to take a signal that will take it
4504              out of the single step range.  Set a breakpoint at the
4505              current PC (which is presumably where the signal handler
4506              will eventually return) and then allow the inferior to
4507              run free.
4508
4509              Note that this is only needed for a signal delivered
4510              while in the single-step range.  Nested signals aren't a
4511              problem as they eventually all return.  */
4512           if (debug_infrun)
4513             fprintf_unfiltered (gdb_stdlog,
4514                                 "infrun: signal may take us out of "
4515                                 "single-step range\n");
4516
4517           insert_hp_step_resume_breakpoint_at_frame (frame);
4518           /* Reset trap_expected to ensure breakpoints are re-inserted.  */
4519           ecs->event_thread->control.trap_expected = 0;
4520           keep_going (ecs);
4521           return;
4522         }
4523
4524       /* Note: step_resume_breakpoint may be non-NULL.  This occures
4525          when either there's a nested signal, or when there's a
4526          pending signal enabled just as the signal handler returns
4527          (leaving the inferior at the step-resume-breakpoint without
4528          actually executing it).  Either way continue until the
4529          breakpoint is really hit.  */
4530
4531       if (!switch_back_to_stepped_thread (ecs))
4532         {
4533           if (debug_infrun)
4534             fprintf_unfiltered (gdb_stdlog,
4535                                 "infrun: random signal, keep going\n");
4536
4537           keep_going (ecs);
4538         }
4539       return;
4540     }
4541
4542   process_event_stop_test (ecs);
4543 }
4544
4545 /* Come here when we've got some debug event / signal we can explain
4546    (IOW, not a random signal), and test whether it should cause a
4547    stop, or whether we should resume the inferior (transparently).
4548    E.g., could be a breakpoint whose condition evaluates false; we
4549    could be still stepping within the line; etc.  */
4550
4551 static void
4552 process_event_stop_test (struct execution_control_state *ecs)
4553 {
4554   struct symtab_and_line stop_pc_sal;
4555   struct frame_info *frame;
4556   struct gdbarch *gdbarch;
4557   CORE_ADDR jmp_buf_pc;
4558   struct bpstat_what what;
4559
4560   /* Handle cases caused by hitting a breakpoint.  */
4561
4562   frame = get_current_frame ();
4563   gdbarch = get_frame_arch (frame);
4564
4565   what = bpstat_what (ecs->event_thread->control.stop_bpstat);
4566
4567   if (what.call_dummy)
4568     {
4569       stop_stack_dummy = what.call_dummy;
4570     }
4571
4572   /* If we hit an internal event that triggers symbol changes, the
4573      current frame will be invalidated within bpstat_what (e.g., if we
4574      hit an internal solib event).  Re-fetch it.  */
4575   frame = get_current_frame ();
4576   gdbarch = get_frame_arch (frame);
4577
4578   switch (what.main_action)
4579     {
4580     case BPSTAT_WHAT_SET_LONGJMP_RESUME:
4581       /* If we hit the breakpoint at longjmp while stepping, we
4582          install a momentary breakpoint at the target of the
4583          jmp_buf.  */
4584
4585       if (debug_infrun)
4586         fprintf_unfiltered (gdb_stdlog,
4587                             "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4588
4589       ecs->event_thread->stepping_over_breakpoint = 1;
4590
4591       if (what.is_longjmp)
4592         {
4593           struct value *arg_value;
4594
4595           /* If we set the longjmp breakpoint via a SystemTap probe,
4596              then use it to extract the arguments.  The destination PC
4597              is the third argument to the probe.  */
4598           arg_value = probe_safe_evaluate_at_pc (frame, 2);
4599           if (arg_value)
4600             jmp_buf_pc = value_as_address (arg_value);
4601           else if (!gdbarch_get_longjmp_target_p (gdbarch)
4602                    || !gdbarch_get_longjmp_target (gdbarch,
4603                                                    frame, &jmp_buf_pc))
4604             {
4605               if (debug_infrun)
4606                 fprintf_unfiltered (gdb_stdlog,
4607                                     "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4608                                     "(!gdbarch_get_longjmp_target)\n");
4609               keep_going (ecs);
4610               return;
4611             }
4612
4613           /* Insert a breakpoint at resume address.  */
4614           insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
4615         }
4616       else
4617         check_exception_resume (ecs, frame);
4618       keep_going (ecs);
4619       return;
4620
4621     case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
4622       {
4623         struct frame_info *init_frame;
4624
4625         /* There are several cases to consider.
4626
4627            1. The initiating frame no longer exists.  In this case we
4628            must stop, because the exception or longjmp has gone too
4629            far.
4630
4631            2. The initiating frame exists, and is the same as the
4632            current frame.  We stop, because the exception or longjmp
4633            has been caught.
4634
4635            3. The initiating frame exists and is different from the
4636            current frame.  This means the exception or longjmp has
4637            been caught beneath the initiating frame, so keep going.
4638
4639            4. longjmp breakpoint has been placed just to protect
4640            against stale dummy frames and user is not interested in
4641            stopping around longjmps.  */
4642
4643         if (debug_infrun)
4644           fprintf_unfiltered (gdb_stdlog,
4645                               "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4646
4647         gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
4648                     != NULL);
4649         delete_exception_resume_breakpoint (ecs->event_thread);
4650
4651         if (what.is_longjmp)
4652           {
4653             check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
4654
4655             if (!frame_id_p (ecs->event_thread->initiating_frame))
4656               {
4657                 /* Case 4.  */
4658                 keep_going (ecs);
4659                 return;
4660               }
4661           }
4662
4663         init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
4664
4665         if (init_frame)
4666           {
4667             struct frame_id current_id
4668               = get_frame_id (get_current_frame ());
4669             if (frame_id_eq (current_id,
4670                              ecs->event_thread->initiating_frame))
4671               {
4672                 /* Case 2.  Fall through.  */
4673               }
4674             else
4675               {
4676                 /* Case 3.  */
4677                 keep_going (ecs);
4678                 return;
4679               }
4680           }
4681
4682         /* For Cases 1 and 2, remove the step-resume breakpoint, if it
4683            exists.  */
4684         delete_step_resume_breakpoint (ecs->event_thread);
4685
4686         end_stepping_range (ecs);
4687       }
4688       return;
4689
4690     case BPSTAT_WHAT_SINGLE:
4691       if (debug_infrun)
4692         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
4693       ecs->event_thread->stepping_over_breakpoint = 1;
4694       /* Still need to check other stuff, at least the case where we
4695          are stepping and step out of the right range.  */
4696       break;
4697
4698     case BPSTAT_WHAT_STEP_RESUME:
4699       if (debug_infrun)
4700         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
4701
4702       delete_step_resume_breakpoint (ecs->event_thread);
4703       if (ecs->event_thread->control.proceed_to_finish
4704           && execution_direction == EXEC_REVERSE)
4705         {
4706           struct thread_info *tp = ecs->event_thread;
4707
4708           /* We are finishing a function in reverse, and just hit the
4709              step-resume breakpoint at the start address of the
4710              function, and we're almost there -- just need to back up
4711              by one more single-step, which should take us back to the
4712              function call.  */
4713           tp->control.step_range_start = tp->control.step_range_end = 1;
4714           keep_going (ecs);
4715           return;
4716         }
4717       fill_in_stop_func (gdbarch, ecs);
4718       if (stop_pc == ecs->stop_func_start
4719           && execution_direction == EXEC_REVERSE)
4720         {
4721           /* We are stepping over a function call in reverse, and just
4722              hit the step-resume breakpoint at the start address of
4723              the function.  Go back to single-stepping, which should
4724              take us back to the function call.  */
4725           ecs->event_thread->stepping_over_breakpoint = 1;
4726           keep_going (ecs);
4727           return;
4728         }
4729       break;
4730
4731     case BPSTAT_WHAT_STOP_NOISY:
4732       if (debug_infrun)
4733         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
4734       stop_print_frame = 1;
4735
4736       /* Assume the thread stopped for a breapoint.  We'll still check
4737          whether a/the breakpoint is there when the thread is next
4738          resumed.  */
4739       ecs->event_thread->stepping_over_breakpoint = 1;
4740
4741       stop_waiting (ecs);
4742       return;
4743
4744     case BPSTAT_WHAT_STOP_SILENT:
4745       if (debug_infrun)
4746         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
4747       stop_print_frame = 0;
4748
4749       /* Assume the thread stopped for a breapoint.  We'll still check
4750          whether a/the breakpoint is there when the thread is next
4751          resumed.  */
4752       ecs->event_thread->stepping_over_breakpoint = 1;
4753       stop_waiting (ecs);
4754       return;
4755
4756     case BPSTAT_WHAT_HP_STEP_RESUME:
4757       if (debug_infrun)
4758         fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
4759
4760       delete_step_resume_breakpoint (ecs->event_thread);
4761       if (ecs->event_thread->step_after_step_resume_breakpoint)
4762         {
4763           /* Back when the step-resume breakpoint was inserted, we
4764              were trying to single-step off a breakpoint.  Go back to
4765              doing that.  */
4766           ecs->event_thread->step_after_step_resume_breakpoint = 0;
4767           ecs->event_thread->stepping_over_breakpoint = 1;
4768           keep_going (ecs);
4769           return;
4770         }
4771       break;
4772
4773     case BPSTAT_WHAT_KEEP_CHECKING:
4774       break;
4775     }
4776
4777   /* We come here if we hit a breakpoint but should not stop for it.
4778      Possibly we also were stepping and should stop for that.  So fall
4779      through and test for stepping.  But, if not stepping, do not
4780      stop.  */
4781
4782   /* In all-stop mode, if we're currently stepping but have stopped in
4783      some other thread, we need to switch back to the stepped thread.  */
4784   if (switch_back_to_stepped_thread (ecs))
4785     return;
4786
4787   if (ecs->event_thread->control.step_resume_breakpoint)
4788     {
4789       if (debug_infrun)
4790          fprintf_unfiltered (gdb_stdlog,
4791                              "infrun: step-resume breakpoint is inserted\n");
4792
4793       /* Having a step-resume breakpoint overrides anything
4794          else having to do with stepping commands until
4795          that breakpoint is reached.  */
4796       keep_going (ecs);
4797       return;
4798     }
4799
4800   if (ecs->event_thread->control.step_range_end == 0)
4801     {
4802       if (debug_infrun)
4803          fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
4804       /* Likewise if we aren't even stepping.  */
4805       keep_going (ecs);
4806       return;
4807     }
4808
4809   /* Re-fetch current thread's frame in case the code above caused
4810      the frame cache to be re-initialized, making our FRAME variable
4811      a dangling pointer.  */
4812   frame = get_current_frame ();
4813   gdbarch = get_frame_arch (frame);
4814   fill_in_stop_func (gdbarch, ecs);
4815
4816   /* If stepping through a line, keep going if still within it.
4817
4818      Note that step_range_end is the address of the first instruction
4819      beyond the step range, and NOT the address of the last instruction
4820      within it!
4821
4822      Note also that during reverse execution, we may be stepping
4823      through a function epilogue and therefore must detect when
4824      the current-frame changes in the middle of a line.  */
4825
4826   if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
4827       && (execution_direction != EXEC_REVERSE
4828           || frame_id_eq (get_frame_id (frame),
4829                           ecs->event_thread->control.step_frame_id)))
4830     {
4831       if (debug_infrun)
4832         fprintf_unfiltered
4833           (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
4834            paddress (gdbarch, ecs->event_thread->control.step_range_start),
4835            paddress (gdbarch, ecs->event_thread->control.step_range_end));
4836
4837       /* Tentatively re-enable range stepping; `resume' disables it if
4838          necessary (e.g., if we're stepping over a breakpoint or we
4839          have software watchpoints).  */
4840       ecs->event_thread->control.may_range_step = 1;
4841
4842       /* When stepping backward, stop at beginning of line range
4843          (unless it's the function entry point, in which case
4844          keep going back to the call point).  */
4845       if (stop_pc == ecs->event_thread->control.step_range_start
4846           && stop_pc != ecs->stop_func_start
4847           && execution_direction == EXEC_REVERSE)
4848         end_stepping_range (ecs);
4849       else
4850         keep_going (ecs);
4851
4852       return;
4853     }
4854
4855   /* We stepped out of the stepping range.  */
4856
4857   /* If we are stepping at the source level and entered the runtime
4858      loader dynamic symbol resolution code...
4859
4860      EXEC_FORWARD: we keep on single stepping until we exit the run
4861      time loader code and reach the callee's address.
4862
4863      EXEC_REVERSE: we've already executed the callee (backward), and
4864      the runtime loader code is handled just like any other
4865      undebuggable function call.  Now we need only keep stepping
4866      backward through the trampoline code, and that's handled further
4867      down, so there is nothing for us to do here.  */
4868
4869   if (execution_direction != EXEC_REVERSE
4870       && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4871       && in_solib_dynsym_resolve_code (stop_pc))
4872     {
4873       CORE_ADDR pc_after_resolver =
4874         gdbarch_skip_solib_resolver (gdbarch, stop_pc);
4875
4876       if (debug_infrun)
4877          fprintf_unfiltered (gdb_stdlog,
4878                              "infrun: stepped into dynsym resolve code\n");
4879
4880       if (pc_after_resolver)
4881         {
4882           /* Set up a step-resume breakpoint at the address
4883              indicated by SKIP_SOLIB_RESOLVER.  */
4884           struct symtab_and_line sr_sal;
4885
4886           init_sal (&sr_sal);
4887           sr_sal.pc = pc_after_resolver;
4888           sr_sal.pspace = get_frame_program_space (frame);
4889
4890           insert_step_resume_breakpoint_at_sal (gdbarch,
4891                                                 sr_sal, null_frame_id);
4892         }
4893
4894       keep_going (ecs);
4895       return;
4896     }
4897
4898   if (ecs->event_thread->control.step_range_end != 1
4899       && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
4900           || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
4901       && get_frame_type (frame) == SIGTRAMP_FRAME)
4902     {
4903       if (debug_infrun)
4904          fprintf_unfiltered (gdb_stdlog,
4905                              "infrun: stepped into signal trampoline\n");
4906       /* The inferior, while doing a "step" or "next", has ended up in
4907          a signal trampoline (either by a signal being delivered or by
4908          the signal handler returning).  Just single-step until the
4909          inferior leaves the trampoline (either by calling the handler
4910          or returning).  */
4911       keep_going (ecs);
4912       return;
4913     }
4914
4915   /* If we're in the return path from a shared library trampoline,
4916      we want to proceed through the trampoline when stepping.  */
4917   /* macro/2012-04-25: This needs to come before the subroutine
4918      call check below as on some targets return trampolines look
4919      like subroutine calls (MIPS16 return thunks).  */
4920   if (gdbarch_in_solib_return_trampoline (gdbarch,
4921                                           stop_pc, ecs->stop_func_name)
4922       && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
4923     {
4924       /* Determine where this trampoline returns.  */
4925       CORE_ADDR real_stop_pc;
4926
4927       real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
4928
4929       if (debug_infrun)
4930          fprintf_unfiltered (gdb_stdlog,
4931                              "infrun: stepped into solib return tramp\n");
4932
4933       /* Only proceed through if we know where it's going.  */
4934       if (real_stop_pc)
4935         {
4936           /* And put the step-breakpoint there and go until there.  */
4937           struct symtab_and_line sr_sal;
4938
4939           init_sal (&sr_sal);   /* initialize to zeroes */
4940           sr_sal.pc = real_stop_pc;
4941           sr_sal.section = find_pc_overlay (sr_sal.pc);
4942           sr_sal.pspace = get_frame_program_space (frame);
4943
4944           /* Do not specify what the fp should be when we stop since
4945              on some machines the prologue is where the new fp value
4946              is established.  */
4947           insert_step_resume_breakpoint_at_sal (gdbarch,
4948                                                 sr_sal, null_frame_id);
4949
4950           /* Restart without fiddling with the step ranges or
4951              other state.  */
4952           keep_going (ecs);
4953           return;
4954         }
4955     }
4956
4957   /* Check for subroutine calls.  The check for the current frame
4958      equalling the step ID is not necessary - the check of the
4959      previous frame's ID is sufficient - but it is a common case and
4960      cheaper than checking the previous frame's ID.
4961
4962      NOTE: frame_id_eq will never report two invalid frame IDs as
4963      being equal, so to get into this block, both the current and
4964      previous frame must have valid frame IDs.  */
4965   /* The outer_frame_id check is a heuristic to detect stepping
4966      through startup code.  If we step over an instruction which
4967      sets the stack pointer from an invalid value to a valid value,
4968      we may detect that as a subroutine call from the mythical
4969      "outermost" function.  This could be fixed by marking
4970      outermost frames as !stack_p,code_p,special_p.  Then the
4971      initial outermost frame, before sp was valid, would
4972      have code_addr == &_start.  See the comment in frame_id_eq
4973      for more.  */
4974   if (!frame_id_eq (get_stack_frame_id (frame),
4975                     ecs->event_thread->control.step_stack_frame_id)
4976       && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
4977                        ecs->event_thread->control.step_stack_frame_id)
4978           && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
4979                             outer_frame_id)
4980               || step_start_function != find_pc_function (stop_pc))))
4981     {
4982       CORE_ADDR real_stop_pc;
4983
4984       if (debug_infrun)
4985          fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
4986
4987       if ((ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
4988           || ((ecs->event_thread->control.step_range_end == 1)
4989               && in_prologue (gdbarch, ecs->event_thread->prev_pc,
4990                               ecs->stop_func_start)))
4991         {
4992           /* I presume that step_over_calls is only 0 when we're
4993              supposed to be stepping at the assembly language level
4994              ("stepi").  Just stop.  */
4995           /* Also, maybe we just did a "nexti" inside a prolog, so we
4996              thought it was a subroutine call but it was not.  Stop as
4997              well.  FENN */
4998           /* And this works the same backward as frontward.  MVS */
4999           end_stepping_range (ecs);
5000           return;
5001         }
5002
5003       /* Reverse stepping through solib trampolines.  */
5004
5005       if (execution_direction == EXEC_REVERSE
5006           && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
5007           && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5008               || (ecs->stop_func_start == 0
5009                   && in_solib_dynsym_resolve_code (stop_pc))))
5010         {
5011           /* Any solib trampoline code can be handled in reverse
5012              by simply continuing to single-step.  We have already
5013              executed the solib function (backwards), and a few 
5014              steps will take us back through the trampoline to the
5015              caller.  */
5016           keep_going (ecs);
5017           return;
5018         }
5019
5020       if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5021         {
5022           /* We're doing a "next".
5023
5024              Normal (forward) execution: set a breakpoint at the
5025              callee's return address (the address at which the caller
5026              will resume).
5027
5028              Reverse (backward) execution.  set the step-resume
5029              breakpoint at the start of the function that we just
5030              stepped into (backwards), and continue to there.  When we
5031              get there, we'll need to single-step back to the caller.  */
5032
5033           if (execution_direction == EXEC_REVERSE)
5034             {
5035               /* If we're already at the start of the function, we've either
5036                  just stepped backward into a single instruction function,
5037                  or stepped back out of a signal handler to the first instruction
5038                  of the function.  Just keep going, which will single-step back
5039                  to the caller.  */
5040               if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
5041                 {
5042                   struct symtab_and_line sr_sal;
5043
5044                   /* Normal function call return (static or dynamic).  */
5045                   init_sal (&sr_sal);
5046                   sr_sal.pc = ecs->stop_func_start;
5047                   sr_sal.pspace = get_frame_program_space (frame);
5048                   insert_step_resume_breakpoint_at_sal (gdbarch,
5049                                                         sr_sal, null_frame_id);
5050                 }
5051             }
5052           else
5053             insert_step_resume_breakpoint_at_caller (frame);
5054
5055           keep_going (ecs);
5056           return;
5057         }
5058
5059       /* If we are in a function call trampoline (a stub between the
5060          calling routine and the real function), locate the real
5061          function.  That's what tells us (a) whether we want to step
5062          into it at all, and (b) what prologue we want to run to the
5063          end of, if we do step into it.  */
5064       real_stop_pc = skip_language_trampoline (frame, stop_pc);
5065       if (real_stop_pc == 0)
5066         real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
5067       if (real_stop_pc != 0)
5068         ecs->stop_func_start = real_stop_pc;
5069
5070       if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
5071         {
5072           struct symtab_and_line sr_sal;
5073
5074           init_sal (&sr_sal);
5075           sr_sal.pc = ecs->stop_func_start;
5076           sr_sal.pspace = get_frame_program_space (frame);
5077
5078           insert_step_resume_breakpoint_at_sal (gdbarch,
5079                                                 sr_sal, null_frame_id);
5080           keep_going (ecs);
5081           return;
5082         }
5083
5084       /* If we have line number information for the function we are
5085          thinking of stepping into and the function isn't on the skip
5086          list, step into it.
5087
5088          If there are several symtabs at that PC (e.g. with include
5089          files), just want to know whether *any* of them have line
5090          numbers.  find_pc_line handles this.  */
5091       {
5092         struct symtab_and_line tmp_sal;
5093
5094         tmp_sal = find_pc_line (ecs->stop_func_start, 0);
5095         if (tmp_sal.line != 0
5096             && !function_name_is_marked_for_skip (ecs->stop_func_name,
5097                                                   &tmp_sal))
5098           {
5099             if (execution_direction == EXEC_REVERSE)
5100               handle_step_into_function_backward (gdbarch, ecs);
5101             else
5102               handle_step_into_function (gdbarch, ecs);
5103             return;
5104           }
5105       }
5106
5107       /* If we have no line number and the step-stop-if-no-debug is
5108          set, we stop the step so that the user has a chance to switch
5109          in assembly mode.  */
5110       if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5111           && step_stop_if_no_debug)
5112         {
5113           end_stepping_range (ecs);
5114           return;
5115         }
5116
5117       if (execution_direction == EXEC_REVERSE)
5118         {
5119           /* If we're already at the start of the function, we've either just
5120              stepped backward into a single instruction function without line
5121              number info, or stepped back out of a signal handler to the first
5122              instruction of the function without line number info.  Just keep
5123              going, which will single-step back to the caller.  */
5124           if (ecs->stop_func_start != stop_pc)
5125             {
5126               /* Set a breakpoint at callee's start address.
5127                  From there we can step once and be back in the caller.  */
5128               struct symtab_and_line sr_sal;
5129
5130               init_sal (&sr_sal);
5131               sr_sal.pc = ecs->stop_func_start;
5132               sr_sal.pspace = get_frame_program_space (frame);
5133               insert_step_resume_breakpoint_at_sal (gdbarch,
5134                                                     sr_sal, null_frame_id);
5135             }
5136         }
5137       else
5138         /* Set a breakpoint at callee's return address (the address
5139            at which the caller will resume).  */
5140         insert_step_resume_breakpoint_at_caller (frame);
5141
5142       keep_going (ecs);
5143       return;
5144     }
5145
5146   /* Reverse stepping through solib trampolines.  */
5147
5148   if (execution_direction == EXEC_REVERSE
5149       && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
5150     {
5151       if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5152           || (ecs->stop_func_start == 0
5153               && in_solib_dynsym_resolve_code (stop_pc)))
5154         {
5155           /* Any solib trampoline code can be handled in reverse
5156              by simply continuing to single-step.  We have already
5157              executed the solib function (backwards), and a few 
5158              steps will take us back through the trampoline to the
5159              caller.  */
5160           keep_going (ecs);
5161           return;
5162         }
5163       else if (in_solib_dynsym_resolve_code (stop_pc))
5164         {
5165           /* Stepped backward into the solib dynsym resolver.
5166              Set a breakpoint at its start and continue, then
5167              one more step will take us out.  */
5168           struct symtab_and_line sr_sal;
5169
5170           init_sal (&sr_sal);
5171           sr_sal.pc = ecs->stop_func_start;
5172           sr_sal.pspace = get_frame_program_space (frame);
5173           insert_step_resume_breakpoint_at_sal (gdbarch, 
5174                                                 sr_sal, null_frame_id);
5175           keep_going (ecs);
5176           return;
5177         }
5178     }
5179
5180   stop_pc_sal = find_pc_line (stop_pc, 0);
5181
5182   /* NOTE: tausq/2004-05-24: This if block used to be done before all
5183      the trampoline processing logic, however, there are some trampolines 
5184      that have no names, so we should do trampoline handling first.  */
5185   if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
5186       && ecs->stop_func_name == NULL
5187       && stop_pc_sal.line == 0)
5188     {
5189       if (debug_infrun)
5190          fprintf_unfiltered (gdb_stdlog,
5191                              "infrun: stepped into undebuggable function\n");
5192
5193       /* The inferior just stepped into, or returned to, an
5194          undebuggable function (where there is no debugging information
5195          and no line number corresponding to the address where the
5196          inferior stopped).  Since we want to skip this kind of code,
5197          we keep going until the inferior returns from this
5198          function - unless the user has asked us not to (via
5199          set step-mode) or we no longer know how to get back
5200          to the call site.  */
5201       if (step_stop_if_no_debug
5202           || !frame_id_p (frame_unwind_caller_id (frame)))
5203         {
5204           /* If we have no line number and the step-stop-if-no-debug
5205              is set, we stop the step so that the user has a chance to
5206              switch in assembly mode.  */
5207           end_stepping_range (ecs);
5208           return;
5209         }
5210       else
5211         {
5212           /* Set a breakpoint at callee's return address (the address
5213              at which the caller will resume).  */
5214           insert_step_resume_breakpoint_at_caller (frame);
5215           keep_going (ecs);
5216           return;
5217         }
5218     }
5219
5220   if (ecs->event_thread->control.step_range_end == 1)
5221     {
5222       /* It is stepi or nexti.  We always want to stop stepping after
5223          one instruction.  */
5224       if (debug_infrun)
5225          fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
5226       end_stepping_range (ecs);
5227       return;
5228     }
5229
5230   if (stop_pc_sal.line == 0)
5231     {
5232       /* We have no line number information.  That means to stop
5233          stepping (does this always happen right after one instruction,
5234          when we do "s" in a function with no line numbers,
5235          or can this happen as a result of a return or longjmp?).  */
5236       if (debug_infrun)
5237          fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
5238       end_stepping_range (ecs);
5239       return;
5240     }
5241
5242   /* Look for "calls" to inlined functions, part one.  If the inline
5243      frame machinery detected some skipped call sites, we have entered
5244      a new inline function.  */
5245
5246   if (frame_id_eq (get_frame_id (get_current_frame ()),
5247                    ecs->event_thread->control.step_frame_id)
5248       && inline_skipped_frames (ecs->ptid))
5249     {
5250       struct symtab_and_line call_sal;
5251
5252       if (debug_infrun)
5253         fprintf_unfiltered (gdb_stdlog,
5254                             "infrun: stepped into inlined function\n");
5255
5256       find_frame_sal (get_current_frame (), &call_sal);
5257
5258       if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
5259         {
5260           /* For "step", we're going to stop.  But if the call site
5261              for this inlined function is on the same source line as
5262              we were previously stepping, go down into the function
5263              first.  Otherwise stop at the call site.  */
5264
5265           if (call_sal.line == ecs->event_thread->current_line
5266               && call_sal.symtab == ecs->event_thread->current_symtab)
5267             step_into_inline_frame (ecs->ptid);
5268
5269           end_stepping_range (ecs);
5270           return;
5271         }
5272       else
5273         {
5274           /* For "next", we should stop at the call site if it is on a
5275              different source line.  Otherwise continue through the
5276              inlined function.  */
5277           if (call_sal.line == ecs->event_thread->current_line
5278               && call_sal.symtab == ecs->event_thread->current_symtab)
5279             keep_going (ecs);
5280           else
5281             end_stepping_range (ecs);
5282           return;
5283         }
5284     }
5285
5286   /* Look for "calls" to inlined functions, part two.  If we are still
5287      in the same real function we were stepping through, but we have
5288      to go further up to find the exact frame ID, we are stepping
5289      through a more inlined call beyond its call site.  */
5290
5291   if (get_frame_type (get_current_frame ()) == INLINE_FRAME
5292       && !frame_id_eq (get_frame_id (get_current_frame ()),
5293                        ecs->event_thread->control.step_frame_id)
5294       && stepped_in_from (get_current_frame (),
5295                           ecs->event_thread->control.step_frame_id))
5296     {
5297       if (debug_infrun)
5298         fprintf_unfiltered (gdb_stdlog,
5299                             "infrun: stepping through inlined function\n");
5300
5301       if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
5302         keep_going (ecs);
5303       else
5304         end_stepping_range (ecs);
5305       return;
5306     }
5307
5308   if ((stop_pc == stop_pc_sal.pc)
5309       && (ecs->event_thread->current_line != stop_pc_sal.line
5310           || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
5311     {
5312       /* We are at the start of a different line.  So stop.  Note that
5313          we don't stop if we step into the middle of a different line.
5314          That is said to make things like for (;;) statements work
5315          better.  */
5316       if (debug_infrun)
5317          fprintf_unfiltered (gdb_stdlog,
5318                              "infrun: stepped to a different line\n");
5319       end_stepping_range (ecs);
5320       return;
5321     }
5322
5323   /* We aren't done stepping.
5324
5325      Optimize by setting the stepping range to the line.
5326      (We might not be in the original line, but if we entered a
5327      new line in mid-statement, we continue stepping.  This makes
5328      things like for(;;) statements work better.)  */
5329
5330   ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
5331   ecs->event_thread->control.step_range_end = stop_pc_sal.end;
5332   ecs->event_thread->control.may_range_step = 1;
5333   set_step_info (frame, stop_pc_sal);
5334
5335   if (debug_infrun)
5336      fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
5337   keep_going (ecs);
5338 }
5339
5340 /* In all-stop mode, if we're currently stepping but have stopped in
5341    some other thread, we may need to switch back to the stepped
5342    thread.  Returns true we set the inferior running, false if we left
5343    it stopped (and the event needs further processing).  */
5344
5345 static int
5346 switch_back_to_stepped_thread (struct execution_control_state *ecs)
5347 {
5348   if (!non_stop)
5349     {
5350       struct thread_info *tp;
5351       struct thread_info *stepping_thread;
5352       struct thread_info *step_over;
5353
5354       /* If any thread is blocked on some internal breakpoint, and we
5355          simply need to step over that breakpoint to get it going
5356          again, do that first.  */
5357
5358       /* However, if we see an event for the stepping thread, then we
5359          know all other threads have been moved past their breakpoints
5360          already.  Let the caller check whether the step is finished,
5361          etc., before deciding to move it past a breakpoint.  */
5362       if (ecs->event_thread->control.step_range_end != 0)
5363         return 0;
5364
5365       /* Check if the current thread is blocked on an incomplete
5366          step-over, interrupted by a random signal.  */
5367       if (ecs->event_thread->control.trap_expected
5368           && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5369         {
5370           if (debug_infrun)
5371             {
5372               fprintf_unfiltered (gdb_stdlog,
5373                                   "infrun: need to finish step-over of [%s]\n",
5374                                   target_pid_to_str (ecs->event_thread->ptid));
5375             }
5376           keep_going (ecs);
5377           return 1;
5378         }
5379
5380       /* Check if the current thread is blocked by a single-step
5381          breakpoint of another thread.  */
5382       if (ecs->hit_singlestep_breakpoint)
5383        {
5384          if (debug_infrun)
5385            {
5386              fprintf_unfiltered (gdb_stdlog,
5387                                  "infrun: need to step [%s] over single-step "
5388                                  "breakpoint\n",
5389                                  target_pid_to_str (ecs->ptid));
5390            }
5391          keep_going (ecs);
5392          return 1;
5393        }
5394
5395       /* Otherwise, we no longer expect a trap in the current thread.
5396          Clear the trap_expected flag before switching back -- this is
5397          what keep_going does as well, if we call it.  */
5398       ecs->event_thread->control.trap_expected = 0;
5399
5400       /* Likewise, clear the signal if it should not be passed.  */
5401       if (!signal_program[ecs->event_thread->suspend.stop_signal])
5402         ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5403
5404       /* If scheduler locking applies even if not stepping, there's no
5405          need to walk over threads.  Above we've checked whether the
5406          current thread is stepping.  If some other thread not the
5407          event thread is stepping, then it must be that scheduler
5408          locking is not in effect.  */
5409       if (schedlock_applies (0))
5410         return 0;
5411
5412       /* Look for the stepping/nexting thread, and check if any other
5413          thread other than the stepping thread needs to start a
5414          step-over.  Do all step-overs before actually proceeding with
5415          step/next/etc.  */
5416       stepping_thread = NULL;
5417       step_over = NULL;
5418       ALL_NON_EXITED_THREADS (tp)
5419         {
5420           /* Ignore threads of processes we're not resuming.  */
5421           if (!sched_multi
5422               && ptid_get_pid (tp->ptid) != ptid_get_pid (inferior_ptid))
5423             continue;
5424
5425           /* When stepping over a breakpoint, we lock all threads
5426              except the one that needs to move past the breakpoint.
5427              If a non-event thread has this set, the "incomplete
5428              step-over" check above should have caught it earlier.  */
5429           gdb_assert (!tp->control.trap_expected);
5430
5431           /* Did we find the stepping thread?  */
5432           if (tp->control.step_range_end)
5433             {
5434               /* Yep.  There should only one though.  */
5435               gdb_assert (stepping_thread == NULL);
5436
5437               /* The event thread is handled at the top, before we
5438                  enter this loop.  */
5439               gdb_assert (tp != ecs->event_thread);
5440
5441               /* If some thread other than the event thread is
5442                  stepping, then scheduler locking can't be in effect,
5443                  otherwise we wouldn't have resumed the current event
5444                  thread in the first place.  */
5445               gdb_assert (!schedlock_applies (1));
5446
5447               stepping_thread = tp;
5448             }
5449           else if (thread_still_needs_step_over (tp))
5450             {
5451               step_over = tp;
5452
5453               /* At the top we've returned early if the event thread
5454                  is stepping.  If some other thread not the event
5455                  thread is stepping, then scheduler locking can't be
5456                  in effect, and we can resume this thread.  No need to
5457                  keep looking for the stepping thread then.  */
5458               break;
5459             }
5460         }
5461
5462       if (step_over != NULL)
5463         {
5464           tp = step_over;
5465           if (debug_infrun)
5466             {
5467               fprintf_unfiltered (gdb_stdlog,
5468                                   "infrun: need to step-over [%s]\n",
5469                                   target_pid_to_str (tp->ptid));
5470             }
5471
5472           /* Only the stepping thread should have this set.  */
5473           gdb_assert (tp->control.step_range_end == 0);
5474
5475           ecs->ptid = tp->ptid;
5476           ecs->event_thread = tp;
5477           switch_to_thread (ecs->ptid);
5478           keep_going (ecs);
5479           return 1;
5480         }
5481
5482       if (stepping_thread != NULL)
5483         {
5484           struct frame_info *frame;
5485           struct gdbarch *gdbarch;
5486
5487           tp = stepping_thread;
5488
5489           /* If the stepping thread exited, then don't try to switch
5490              back and resume it, which could fail in several different
5491              ways depending on the target.  Instead, just keep going.
5492
5493              We can find a stepping dead thread in the thread list in
5494              two cases:
5495
5496              - The target supports thread exit events, and when the
5497              target tries to delete the thread from the thread list,
5498              inferior_ptid pointed at the exiting thread.  In such
5499              case, calling delete_thread does not really remove the
5500              thread from the list; instead, the thread is left listed,
5501              with 'exited' state.
5502
5503              - The target's debug interface does not support thread
5504              exit events, and so we have no idea whatsoever if the
5505              previously stepping thread is still alive.  For that
5506              reason, we need to synchronously query the target
5507              now.  */
5508           if (is_exited (tp->ptid)
5509               || !target_thread_alive (tp->ptid))
5510             {
5511               if (debug_infrun)
5512                 fprintf_unfiltered (gdb_stdlog,
5513                                     "infrun: not switching back to "
5514                                     "stepped thread, it has vanished\n");
5515
5516               delete_thread (tp->ptid);
5517               keep_going (ecs);
5518               return 1;
5519             }
5520
5521           if (debug_infrun)
5522             fprintf_unfiltered (gdb_stdlog,
5523                                 "infrun: switching back to stepped thread\n");
5524
5525           ecs->event_thread = tp;
5526           ecs->ptid = tp->ptid;
5527           context_switch (ecs->ptid);
5528
5529           stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5530           frame = get_current_frame ();
5531           gdbarch = get_frame_arch (frame);
5532
5533           /* If the PC of the thread we were trying to single-step has
5534              changed, then that thread has trapped or been signaled,
5535              but the event has not been reported to GDB yet.  Re-poll
5536              the target looking for this particular thread's event
5537              (i.e. temporarily enable schedlock) by:
5538
5539                - setting a break at the current PC
5540                - resuming that particular thread, only (by setting
5541                  trap expected)
5542
5543              This prevents us continuously moving the single-step
5544              breakpoint forward, one instruction at a time,
5545              overstepping.  */
5546
5547           if (gdbarch_software_single_step_p (gdbarch)
5548               && stop_pc != tp->prev_pc)
5549             {
5550               if (debug_infrun)
5551                 fprintf_unfiltered (gdb_stdlog,
5552                                     "infrun: expected thread advanced also\n");
5553
5554               insert_single_step_breakpoint (get_frame_arch (frame),
5555                                              get_frame_address_space (frame),
5556                                              stop_pc);
5557               singlestep_breakpoints_inserted_p = 1;
5558               ecs->event_thread->control.trap_expected = 1;
5559               singlestep_ptid = inferior_ptid;
5560               singlestep_pc = stop_pc;
5561
5562               resume (0, GDB_SIGNAL_0);
5563               prepare_to_wait (ecs);
5564             }
5565           else
5566             {
5567               if (debug_infrun)
5568                 fprintf_unfiltered (gdb_stdlog,
5569                                     "infrun: expected thread still "
5570                                     "hasn't advanced\n");
5571               keep_going (ecs);
5572             }
5573
5574           return 1;
5575         }
5576     }
5577   return 0;
5578 }
5579
5580 /* Is thread TP in the middle of single-stepping?  */
5581
5582 static int
5583 currently_stepping (struct thread_info *tp)
5584 {
5585   return ((tp->control.step_range_end
5586            && tp->control.step_resume_breakpoint == NULL)
5587           || tp->control.trap_expected
5588           || bpstat_should_step ());
5589 }
5590
5591 /* Inferior has stepped into a subroutine call with source code that
5592    we should not step over.  Do step to the first line of code in
5593    it.  */
5594
5595 static void
5596 handle_step_into_function (struct gdbarch *gdbarch,
5597                            struct execution_control_state *ecs)
5598 {
5599   struct symtab *s;
5600   struct symtab_and_line stop_func_sal, sr_sal;
5601
5602   fill_in_stop_func (gdbarch, ecs);
5603
5604   s = find_pc_symtab (stop_pc);
5605   if (s && s->language != language_asm)
5606     ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5607                                                   ecs->stop_func_start);
5608
5609   stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
5610   /* Use the step_resume_break to step until the end of the prologue,
5611      even if that involves jumps (as it seems to on the vax under
5612      4.2).  */
5613   /* If the prologue ends in the middle of a source line, continue to
5614      the end of that source line (if it is still within the function).
5615      Otherwise, just go to end of prologue.  */
5616   if (stop_func_sal.end
5617       && stop_func_sal.pc != ecs->stop_func_start
5618       && stop_func_sal.end < ecs->stop_func_end)
5619     ecs->stop_func_start = stop_func_sal.end;
5620
5621   /* Architectures which require breakpoint adjustment might not be able
5622      to place a breakpoint at the computed address.  If so, the test
5623      ``ecs->stop_func_start == stop_pc'' will never succeed.  Adjust
5624      ecs->stop_func_start to an address at which a breakpoint may be
5625      legitimately placed.
5626
5627      Note:  kevinb/2004-01-19:  On FR-V, if this adjustment is not
5628      made, GDB will enter an infinite loop when stepping through
5629      optimized code consisting of VLIW instructions which contain
5630      subinstructions corresponding to different source lines.  On
5631      FR-V, it's not permitted to place a breakpoint on any but the
5632      first subinstruction of a VLIW instruction.  When a breakpoint is
5633      set, GDB will adjust the breakpoint address to the beginning of
5634      the VLIW instruction.  Thus, we need to make the corresponding
5635      adjustment here when computing the stop address.  */
5636
5637   if (gdbarch_adjust_breakpoint_address_p (gdbarch))
5638     {
5639       ecs->stop_func_start
5640         = gdbarch_adjust_breakpoint_address (gdbarch,
5641                                              ecs->stop_func_start);
5642     }
5643
5644   if (ecs->stop_func_start == stop_pc)
5645     {
5646       /* We are already there: stop now.  */
5647       end_stepping_range (ecs);
5648       return;
5649     }
5650   else
5651     {
5652       /* Put the step-breakpoint there and go until there.  */
5653       init_sal (&sr_sal);       /* initialize to zeroes */
5654       sr_sal.pc = ecs->stop_func_start;
5655       sr_sal.section = find_pc_overlay (ecs->stop_func_start);
5656       sr_sal.pspace = get_frame_program_space (get_current_frame ());
5657
5658       /* Do not specify what the fp should be when we stop since on
5659          some machines the prologue is where the new fp value is
5660          established.  */
5661       insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
5662
5663       /* And make sure stepping stops right away then.  */
5664       ecs->event_thread->control.step_range_end
5665         = ecs->event_thread->control.step_range_start;
5666     }
5667   keep_going (ecs);
5668 }
5669
5670 /* Inferior has stepped backward into a subroutine call with source
5671    code that we should not step over.  Do step to the beginning of the
5672    last line of code in it.  */
5673
5674 static void
5675 handle_step_into_function_backward (struct gdbarch *gdbarch,
5676                                     struct execution_control_state *ecs)
5677 {
5678   struct symtab *s;
5679   struct symtab_and_line stop_func_sal;
5680
5681   fill_in_stop_func (gdbarch, ecs);
5682
5683   s = find_pc_symtab (stop_pc);
5684   if (s && s->language != language_asm)
5685     ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5686                                                   ecs->stop_func_start);
5687
5688   stop_func_sal = find_pc_line (stop_pc, 0);
5689
5690   /* OK, we're just going to keep stepping here.  */
5691   if (stop_func_sal.pc == stop_pc)
5692     {
5693       /* We're there already.  Just stop stepping now.  */
5694       end_stepping_range (ecs);
5695     }
5696   else
5697     {
5698       /* Else just reset the step range and keep going.
5699          No step-resume breakpoint, they don't work for
5700          epilogues, which can have multiple entry paths.  */
5701       ecs->event_thread->control.step_range_start = stop_func_sal.pc;
5702       ecs->event_thread->control.step_range_end = stop_func_sal.end;
5703       keep_going (ecs);
5704     }
5705   return;
5706 }
5707
5708 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
5709    This is used to both functions and to skip over code.  */
5710
5711 static void
5712 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
5713                                         struct symtab_and_line sr_sal,
5714                                         struct frame_id sr_id,
5715                                         enum bptype sr_type)
5716 {
5717   /* There should never be more than one step-resume or longjmp-resume
5718      breakpoint per thread, so we should never be setting a new
5719      step_resume_breakpoint when one is already active.  */
5720   gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
5721   gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
5722
5723   if (debug_infrun)
5724     fprintf_unfiltered (gdb_stdlog,
5725                         "infrun: inserting step-resume breakpoint at %s\n",
5726                         paddress (gdbarch, sr_sal.pc));
5727
5728   inferior_thread ()->control.step_resume_breakpoint
5729     = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
5730 }
5731
5732 void
5733 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
5734                                       struct symtab_and_line sr_sal,
5735                                       struct frame_id sr_id)
5736 {
5737   insert_step_resume_breakpoint_at_sal_1 (gdbarch,
5738                                           sr_sal, sr_id,
5739                                           bp_step_resume);
5740 }
5741
5742 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
5743    This is used to skip a potential signal handler.
5744
5745    This is called with the interrupted function's frame.  The signal
5746    handler, when it returns, will resume the interrupted function at
5747    RETURN_FRAME.pc.  */
5748
5749 static void
5750 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
5751 {
5752   struct symtab_and_line sr_sal;
5753   struct gdbarch *gdbarch;
5754
5755   gdb_assert (return_frame != NULL);
5756   init_sal (&sr_sal);           /* initialize to zeros */
5757
5758   gdbarch = get_frame_arch (return_frame);
5759   sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
5760   sr_sal.section = find_pc_overlay (sr_sal.pc);
5761   sr_sal.pspace = get_frame_program_space (return_frame);
5762
5763   insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
5764                                           get_stack_frame_id (return_frame),
5765                                           bp_hp_step_resume);
5766 }
5767
5768 /* Insert a "step-resume breakpoint" at the previous frame's PC.  This
5769    is used to skip a function after stepping into it (for "next" or if
5770    the called function has no debugging information).
5771
5772    The current function has almost always been reached by single
5773    stepping a call or return instruction.  NEXT_FRAME belongs to the
5774    current function, and the breakpoint will be set at the caller's
5775    resume address.
5776
5777    This is a separate function rather than reusing
5778    insert_hp_step_resume_breakpoint_at_frame in order to avoid
5779    get_prev_frame, which may stop prematurely (see the implementation
5780    of frame_unwind_caller_id for an example).  */
5781
5782 static void
5783 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
5784 {
5785   struct symtab_and_line sr_sal;
5786   struct gdbarch *gdbarch;
5787
5788   /* We shouldn't have gotten here if we don't know where the call site
5789      is.  */
5790   gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
5791
5792   init_sal (&sr_sal);           /* initialize to zeros */
5793
5794   gdbarch = frame_unwind_caller_arch (next_frame);
5795   sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
5796                                         frame_unwind_caller_pc (next_frame));
5797   sr_sal.section = find_pc_overlay (sr_sal.pc);
5798   sr_sal.pspace = frame_unwind_program_space (next_frame);
5799
5800   insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
5801                                         frame_unwind_caller_id (next_frame));
5802 }
5803
5804 /* Insert a "longjmp-resume" breakpoint at PC.  This is used to set a
5805    new breakpoint at the target of a jmp_buf.  The handling of
5806    longjmp-resume uses the same mechanisms used for handling
5807    "step-resume" breakpoints.  */
5808
5809 static void
5810 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
5811 {
5812   /* There should never be more than one longjmp-resume breakpoint per
5813      thread, so we should never be setting a new
5814      longjmp_resume_breakpoint when one is already active.  */
5815   gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
5816
5817   if (debug_infrun)
5818     fprintf_unfiltered (gdb_stdlog,
5819                         "infrun: inserting longjmp-resume breakpoint at %s\n",
5820                         paddress (gdbarch, pc));
5821
5822   inferior_thread ()->control.exception_resume_breakpoint =
5823     set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
5824 }
5825
5826 /* Insert an exception resume breakpoint.  TP is the thread throwing
5827    the exception.  The block B is the block of the unwinder debug hook
5828    function.  FRAME is the frame corresponding to the call to this
5829    function.  SYM is the symbol of the function argument holding the
5830    target PC of the exception.  */
5831
5832 static void
5833 insert_exception_resume_breakpoint (struct thread_info *tp,
5834                                     const struct block *b,
5835                                     struct frame_info *frame,
5836                                     struct symbol *sym)
5837 {
5838   volatile struct gdb_exception e;
5839
5840   /* We want to ignore errors here.  */
5841   TRY_CATCH (e, RETURN_MASK_ERROR)
5842     {
5843       struct symbol *vsym;
5844       struct value *value;
5845       CORE_ADDR handler;
5846       struct breakpoint *bp;
5847
5848       vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
5849       value = read_var_value (vsym, frame);
5850       /* If the value was optimized out, revert to the old behavior.  */
5851       if (! value_optimized_out (value))
5852         {
5853           handler = value_as_address (value);
5854
5855           if (debug_infrun)
5856             fprintf_unfiltered (gdb_stdlog,
5857                                 "infrun: exception resume at %lx\n",
5858                                 (unsigned long) handler);
5859
5860           bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5861                                                handler, bp_exception_resume);
5862
5863           /* set_momentary_breakpoint_at_pc invalidates FRAME.  */
5864           frame = NULL;
5865
5866           bp->thread = tp->num;
5867           inferior_thread ()->control.exception_resume_breakpoint = bp;
5868         }
5869     }
5870 }
5871
5872 /* A helper for check_exception_resume that sets an
5873    exception-breakpoint based on a SystemTap probe.  */
5874
5875 static void
5876 insert_exception_resume_from_probe (struct thread_info *tp,
5877                                     const struct bound_probe *probe,
5878                                     struct frame_info *frame)
5879 {
5880   struct value *arg_value;
5881   CORE_ADDR handler;
5882   struct breakpoint *bp;
5883
5884   arg_value = probe_safe_evaluate_at_pc (frame, 1);
5885   if (!arg_value)
5886     return;
5887
5888   handler = value_as_address (arg_value);
5889
5890   if (debug_infrun)
5891     fprintf_unfiltered (gdb_stdlog,
5892                         "infrun: exception resume at %s\n",
5893                         paddress (get_objfile_arch (probe->objfile),
5894                                   handler));
5895
5896   bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
5897                                        handler, bp_exception_resume);
5898   bp->thread = tp->num;
5899   inferior_thread ()->control.exception_resume_breakpoint = bp;
5900 }
5901
5902 /* This is called when an exception has been intercepted.  Check to
5903    see whether the exception's destination is of interest, and if so,
5904    set an exception resume breakpoint there.  */
5905
5906 static void
5907 check_exception_resume (struct execution_control_state *ecs,
5908                         struct frame_info *frame)
5909 {
5910   volatile struct gdb_exception e;
5911   struct bound_probe probe;
5912   struct symbol *func;
5913
5914   /* First see if this exception unwinding breakpoint was set via a
5915      SystemTap probe point.  If so, the probe has two arguments: the
5916      CFA and the HANDLER.  We ignore the CFA, extract the handler, and
5917      set a breakpoint there.  */
5918   probe = find_probe_by_pc (get_frame_pc (frame));
5919   if (probe.probe)
5920     {
5921       insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
5922       return;
5923     }
5924
5925   func = get_frame_function (frame);
5926   if (!func)
5927     return;
5928
5929   TRY_CATCH (e, RETURN_MASK_ERROR)
5930     {
5931       const struct block *b;
5932       struct block_iterator iter;
5933       struct symbol *sym;
5934       int argno = 0;
5935
5936       /* The exception breakpoint is a thread-specific breakpoint on
5937          the unwinder's debug hook, declared as:
5938          
5939          void _Unwind_DebugHook (void *cfa, void *handler);
5940          
5941          The CFA argument indicates the frame to which control is
5942          about to be transferred.  HANDLER is the destination PC.
5943          
5944          We ignore the CFA and set a temporary breakpoint at HANDLER.
5945          This is not extremely efficient but it avoids issues in gdb
5946          with computing the DWARF CFA, and it also works even in weird
5947          cases such as throwing an exception from inside a signal
5948          handler.  */
5949
5950       b = SYMBOL_BLOCK_VALUE (func);
5951       ALL_BLOCK_SYMBOLS (b, iter, sym)
5952         {
5953           if (!SYMBOL_IS_ARGUMENT (sym))
5954             continue;
5955
5956           if (argno == 0)
5957             ++argno;
5958           else
5959             {
5960               insert_exception_resume_breakpoint (ecs->event_thread,
5961                                                   b, frame, sym);
5962               break;
5963             }
5964         }
5965     }
5966 }
5967
5968 static void
5969 stop_waiting (struct execution_control_state *ecs)
5970 {
5971   if (debug_infrun)
5972     fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
5973
5974   clear_step_over_info ();
5975
5976   /* Let callers know we don't want to wait for the inferior anymore.  */
5977   ecs->wait_some_more = 0;
5978 }
5979
5980 /* Called when we should continue running the inferior, because the
5981    current event doesn't cause a user visible stop.  This does the
5982    resuming part; waiting for the next event is done elsewhere.  */
5983
5984 static void
5985 keep_going (struct execution_control_state *ecs)
5986 {
5987   /* Make sure normal_stop is called if we get a QUIT handled before
5988      reaching resume.  */
5989   struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
5990
5991   /* Save the pc before execution, to compare with pc after stop.  */
5992   ecs->event_thread->prev_pc
5993     = regcache_read_pc (get_thread_regcache (ecs->ptid));
5994
5995   if (ecs->event_thread->control.trap_expected
5996       && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5997     {
5998       /* We haven't yet gotten our trap, and either: intercepted a
5999          non-signal event (e.g., a fork); or took a signal which we
6000          are supposed to pass through to the inferior.  Simply
6001          continue.  */
6002       discard_cleanups (old_cleanups);
6003       resume (currently_stepping (ecs->event_thread),
6004               ecs->event_thread->suspend.stop_signal);
6005     }
6006   else
6007     {
6008       volatile struct gdb_exception e;
6009       struct regcache *regcache = get_current_regcache ();
6010
6011       /* Either the trap was not expected, but we are continuing
6012          anyway (if we got a signal, the user asked it be passed to
6013          the child)
6014          -- or --
6015          We got our expected trap, but decided we should resume from
6016          it.
6017
6018          We're going to run this baby now!
6019
6020          Note that insert_breakpoints won't try to re-insert
6021          already inserted breakpoints.  Therefore, we don't
6022          care if breakpoints were already inserted, or not.  */
6023
6024       /* If we need to step over a breakpoint, and we're not using
6025          displaced stepping to do so, insert all breakpoints
6026          (watchpoints, etc.) but the one we're stepping over, step one
6027          instruction, and then re-insert the breakpoint when that step
6028          is finished.  */
6029       if ((ecs->hit_singlestep_breakpoint
6030            || thread_still_needs_step_over (ecs->event_thread))
6031           && !use_displaced_stepping (get_regcache_arch (regcache)))
6032         {
6033           set_step_over_info (get_regcache_aspace (regcache),
6034                               regcache_read_pc (regcache));
6035         }
6036       else
6037         clear_step_over_info ();
6038
6039       /* Stop stepping if inserting breakpoints fails.  */
6040       TRY_CATCH (e, RETURN_MASK_ERROR)
6041         {
6042           insert_breakpoints ();
6043         }
6044       if (e.reason < 0)
6045         {
6046           exception_print (gdb_stderr, e);
6047           stop_waiting (ecs);
6048           return;
6049         }
6050
6051       ecs->event_thread->control.trap_expected
6052         = (ecs->event_thread->stepping_over_breakpoint
6053            || ecs->hit_singlestep_breakpoint);
6054
6055       /* Do not deliver GDB_SIGNAL_TRAP (except when the user
6056          explicitly specifies that such a signal should be delivered
6057          to the target program).  Typically, that would occur when a
6058          user is debugging a target monitor on a simulator: the target
6059          monitor sets a breakpoint; the simulator encounters this
6060          breakpoint and halts the simulation handing control to GDB;
6061          GDB, noting that the stop address doesn't map to any known
6062          breakpoint, returns control back to the simulator; the
6063          simulator then delivers the hardware equivalent of a
6064          GDB_SIGNAL_TRAP to the program being debugged.  */
6065       if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6066           && !signal_program[ecs->event_thread->suspend.stop_signal])
6067         ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6068
6069       discard_cleanups (old_cleanups);
6070       resume (currently_stepping (ecs->event_thread),
6071               ecs->event_thread->suspend.stop_signal);
6072     }
6073
6074   prepare_to_wait (ecs);
6075 }
6076
6077 /* This function normally comes after a resume, before
6078    handle_inferior_event exits.  It takes care of any last bits of
6079    housekeeping, and sets the all-important wait_some_more flag.  */
6080
6081 static void
6082 prepare_to_wait (struct execution_control_state *ecs)
6083 {
6084   if (debug_infrun)
6085     fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
6086
6087   /* This is the old end of the while loop.  Let everybody know we
6088      want to wait for the inferior some more and get called again
6089      soon.  */
6090   ecs->wait_some_more = 1;
6091 }
6092
6093 /* We are done with the step range of a step/next/si/ni command.
6094    Called once for each n of a "step n" operation.  */
6095
6096 static void
6097 end_stepping_range (struct execution_control_state *ecs)
6098 {
6099   ecs->event_thread->control.stop_step = 1;
6100   stop_waiting (ecs);
6101 }
6102
6103 /* Several print_*_reason functions to print why the inferior has stopped.
6104    We always print something when the inferior exits, or receives a signal.
6105    The rest of the cases are dealt with later on in normal_stop and
6106    print_it_typical.  Ideally there should be a call to one of these
6107    print_*_reason functions functions from handle_inferior_event each time
6108    stop_waiting is called.
6109
6110    Note that we don't call these directly, instead we delegate that to
6111    the interpreters, through observers.  Interpreters then call these
6112    with whatever uiout is right.  */
6113
6114 void
6115 print_end_stepping_range_reason (struct ui_out *uiout)
6116 {
6117   /* For CLI-like interpreters, print nothing.  */
6118
6119   if (ui_out_is_mi_like_p (uiout))
6120     {
6121       ui_out_field_string (uiout, "reason",
6122                            async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
6123     }
6124 }
6125
6126 void
6127 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6128 {
6129   annotate_signalled ();
6130   if (ui_out_is_mi_like_p (uiout))
6131     ui_out_field_string
6132       (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
6133   ui_out_text (uiout, "\nProgram terminated with signal ");
6134   annotate_signal_name ();
6135   ui_out_field_string (uiout, "signal-name",
6136                        gdb_signal_to_name (siggnal));
6137   annotate_signal_name_end ();
6138   ui_out_text (uiout, ", ");
6139   annotate_signal_string ();
6140   ui_out_field_string (uiout, "signal-meaning",
6141                        gdb_signal_to_string (siggnal));
6142   annotate_signal_string_end ();
6143   ui_out_text (uiout, ".\n");
6144   ui_out_text (uiout, "The program no longer exists.\n");
6145 }
6146
6147 void
6148 print_exited_reason (struct ui_out *uiout, int exitstatus)
6149 {
6150   struct inferior *inf = current_inferior ();
6151   const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
6152
6153   annotate_exited (exitstatus);
6154   if (exitstatus)
6155     {
6156       if (ui_out_is_mi_like_p (uiout))
6157         ui_out_field_string (uiout, "reason", 
6158                              async_reason_lookup (EXEC_ASYNC_EXITED));
6159       ui_out_text (uiout, "[Inferior ");
6160       ui_out_text (uiout, plongest (inf->num));
6161       ui_out_text (uiout, " (");
6162       ui_out_text (uiout, pidstr);
6163       ui_out_text (uiout, ") exited with code ");
6164       ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
6165       ui_out_text (uiout, "]\n");
6166     }
6167   else
6168     {
6169       if (ui_out_is_mi_like_p (uiout))
6170         ui_out_field_string
6171           (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
6172       ui_out_text (uiout, "[Inferior ");
6173       ui_out_text (uiout, plongest (inf->num));
6174       ui_out_text (uiout, " (");
6175       ui_out_text (uiout, pidstr);
6176       ui_out_text (uiout, ") exited normally]\n");
6177     }
6178 }
6179
6180 void
6181 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6182 {
6183   annotate_signal ();
6184
6185   if (siggnal == GDB_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
6186     {
6187       struct thread_info *t = inferior_thread ();
6188
6189       ui_out_text (uiout, "\n[");
6190       ui_out_field_string (uiout, "thread-name",
6191                            target_pid_to_str (t->ptid));
6192       ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
6193       ui_out_text (uiout, " stopped");
6194     }
6195   else
6196     {
6197       ui_out_text (uiout, "\nProgram received signal ");
6198       annotate_signal_name ();
6199       if (ui_out_is_mi_like_p (uiout))
6200         ui_out_field_string
6201           (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
6202       ui_out_field_string (uiout, "signal-name",
6203                            gdb_signal_to_name (siggnal));
6204       annotate_signal_name_end ();
6205       ui_out_text (uiout, ", ");
6206       annotate_signal_string ();
6207       ui_out_field_string (uiout, "signal-meaning",
6208                            gdb_signal_to_string (siggnal));
6209       annotate_signal_string_end ();
6210     }
6211   ui_out_text (uiout, ".\n");
6212 }
6213
6214 void
6215 print_no_history_reason (struct ui_out *uiout)
6216 {
6217   ui_out_text (uiout, "\nNo more reverse-execution history.\n");
6218 }
6219
6220 /* Print current location without a level number, if we have changed
6221    functions or hit a breakpoint.  Print source line if we have one.
6222    bpstat_print contains the logic deciding in detail what to print,
6223    based on the event(s) that just occurred.  */
6224
6225 void
6226 print_stop_event (struct target_waitstatus *ws)
6227 {
6228   int bpstat_ret;
6229   int source_flag;
6230   int do_frame_printing = 1;
6231   struct thread_info *tp = inferior_thread ();
6232
6233   bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
6234   switch (bpstat_ret)
6235     {
6236     case PRINT_UNKNOWN:
6237       /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
6238          should) carry around the function and does (or should) use
6239          that when doing a frame comparison.  */
6240       if (tp->control.stop_step
6241           && frame_id_eq (tp->control.step_frame_id,
6242                           get_frame_id (get_current_frame ()))
6243           && step_start_function == find_pc_function (stop_pc))
6244         {
6245           /* Finished step, just print source line.  */
6246           source_flag = SRC_LINE;
6247         }
6248       else
6249         {
6250           /* Print location and source line.  */
6251           source_flag = SRC_AND_LOC;
6252         }
6253       break;
6254     case PRINT_SRC_AND_LOC:
6255       /* Print location and source line.  */
6256       source_flag = SRC_AND_LOC;
6257       break;
6258     case PRINT_SRC_ONLY:
6259       source_flag = SRC_LINE;
6260       break;
6261     case PRINT_NOTHING:
6262       /* Something bogus.  */
6263       source_flag = SRC_LINE;
6264       do_frame_printing = 0;
6265       break;
6266     default:
6267       internal_error (__FILE__, __LINE__, _("Unknown value."));
6268     }
6269
6270   /* The behavior of this routine with respect to the source
6271      flag is:
6272      SRC_LINE: Print only source line
6273      LOCATION: Print only location
6274      SRC_AND_LOC: Print location and source line.  */
6275   if (do_frame_printing)
6276     print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
6277
6278   /* Display the auto-display expressions.  */
6279   do_displays ();
6280 }
6281
6282 /* Here to return control to GDB when the inferior stops for real.
6283    Print appropriate messages, remove breakpoints, give terminal our modes.
6284
6285    STOP_PRINT_FRAME nonzero means print the executing frame
6286    (pc, function, args, file, line number and line text).
6287    BREAKPOINTS_FAILED nonzero means stop was due to error
6288    attempting to insert breakpoints.  */
6289
6290 void
6291 normal_stop (void)
6292 {
6293   struct target_waitstatus last;
6294   ptid_t last_ptid;
6295   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
6296
6297   get_last_target_status (&last_ptid, &last);
6298
6299   /* If an exception is thrown from this point on, make sure to
6300      propagate GDB's knowledge of the executing state to the
6301      frontend/user running state.  A QUIT is an easy exception to see
6302      here, so do this before any filtered output.  */
6303   if (!non_stop)
6304     make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
6305   else if (last.kind != TARGET_WAITKIND_SIGNALLED
6306            && last.kind != TARGET_WAITKIND_EXITED
6307            && last.kind != TARGET_WAITKIND_NO_RESUMED)
6308     make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
6309
6310   /* As we're presenting a stop, and potentially removing breakpoints,
6311      update the thread list so we can tell whether there are threads
6312      running on the target.  With target remote, for example, we can
6313      only learn about new threads when we explicitly update the thread
6314      list.  Do this before notifying the interpreters about signal
6315      stops, end of stepping ranges, etc., so that the "new thread"
6316      output is emitted before e.g., "Program received signal FOO",
6317      instead of after.  */
6318   update_thread_list ();
6319
6320   if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
6321     observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
6322
6323   /* As with the notification of thread events, we want to delay
6324      notifying the user that we've switched thread context until
6325      the inferior actually stops.
6326
6327      There's no point in saying anything if the inferior has exited.
6328      Note that SIGNALLED here means "exited with a signal", not
6329      "received a signal".
6330
6331      Also skip saying anything in non-stop mode.  In that mode, as we
6332      don't want GDB to switch threads behind the user's back, to avoid
6333      races where the user is typing a command to apply to thread x,
6334      but GDB switches to thread y before the user finishes entering
6335      the command, fetch_inferior_event installs a cleanup to restore
6336      the current thread back to the thread the user had selected right
6337      after this event is handled, so we're not really switching, only
6338      informing of a stop.  */
6339   if (!non_stop
6340       && !ptid_equal (previous_inferior_ptid, inferior_ptid)
6341       && target_has_execution
6342       && last.kind != TARGET_WAITKIND_SIGNALLED
6343       && last.kind != TARGET_WAITKIND_EXITED
6344       && last.kind != TARGET_WAITKIND_NO_RESUMED)
6345     {
6346       target_terminal_ours_for_output ();
6347       printf_filtered (_("[Switching to %s]\n"),
6348                        target_pid_to_str (inferior_ptid));
6349       annotate_thread_changed ();
6350       previous_inferior_ptid = inferior_ptid;
6351     }
6352
6353   if (last.kind == TARGET_WAITKIND_NO_RESUMED)
6354     {
6355       gdb_assert (sync_execution || !target_can_async_p ());
6356
6357       target_terminal_ours_for_output ();
6358       printf_filtered (_("No unwaited-for children left.\n"));
6359     }
6360
6361   /* Note: this depends on the update_thread_list call above.  */
6362   if (!breakpoints_should_be_inserted_now () && target_has_execution)
6363     {
6364       if (remove_breakpoints ())
6365         {
6366           target_terminal_ours_for_output ();
6367           printf_filtered (_("Cannot remove breakpoints because "
6368                              "program is no longer writable.\nFurther "
6369                              "execution is probably impossible.\n"));
6370         }
6371     }
6372
6373   /* If an auto-display called a function and that got a signal,
6374      delete that auto-display to avoid an infinite recursion.  */
6375
6376   if (stopped_by_random_signal)
6377     disable_current_display ();
6378
6379   /* Notify observers if we finished a "step"-like command, etc.  */
6380   if (target_has_execution
6381       && last.kind != TARGET_WAITKIND_SIGNALLED
6382       && last.kind != TARGET_WAITKIND_EXITED
6383       && inferior_thread ()->control.stop_step)
6384     {
6385       /* But not if if in the middle of doing a "step n" operation for
6386          n > 1 */
6387       if (inferior_thread ()->step_multi)
6388         goto done;
6389
6390       observer_notify_end_stepping_range ();
6391     }
6392
6393   target_terminal_ours ();
6394   async_enable_stdin ();
6395
6396   /* Set the current source location.  This will also happen if we
6397      display the frame below, but the current SAL will be incorrect
6398      during a user hook-stop function.  */
6399   if (has_stack_frames () && !stop_stack_dummy)
6400     set_current_sal_from_frame (get_current_frame ());
6401
6402   /* Let the user/frontend see the threads as stopped, but do nothing
6403      if the thread was running an infcall.  We may be e.g., evaluating
6404      a breakpoint condition.  In that case, the thread had state
6405      THREAD_RUNNING before the infcall, and shall remain set to
6406      running, all without informing the user/frontend about state
6407      transition changes.  If this is actually a call command, then the
6408      thread was originally already stopped, so there's no state to
6409      finish either.  */
6410   if (target_has_execution && inferior_thread ()->control.in_infcall)
6411     discard_cleanups (old_chain);
6412   else
6413     do_cleanups (old_chain);
6414
6415   /* Look up the hook_stop and run it (CLI internally handles problem
6416      of stop_command's pre-hook not existing).  */
6417   if (stop_command)
6418     catch_errors (hook_stop_stub, stop_command,
6419                   "Error while running hook_stop:\n", RETURN_MASK_ALL);
6420
6421   if (!has_stack_frames ())
6422     goto done;
6423
6424   if (last.kind == TARGET_WAITKIND_SIGNALLED
6425       || last.kind == TARGET_WAITKIND_EXITED)
6426     goto done;
6427
6428   /* Select innermost stack frame - i.e., current frame is frame 0,
6429      and current location is based on that.
6430      Don't do this on return from a stack dummy routine,
6431      or if the program has exited.  */
6432
6433   if (!stop_stack_dummy)
6434     {
6435       select_frame (get_current_frame ());
6436
6437       /* If --batch-silent is enabled then there's no need to print the current
6438          source location, and to try risks causing an error message about
6439          missing source files.  */
6440       if (stop_print_frame && !batch_silent)
6441         print_stop_event (&last);
6442     }
6443
6444   /* Save the function value return registers, if we care.
6445      We might be about to restore their previous contents.  */
6446   if (inferior_thread ()->control.proceed_to_finish
6447       && execution_direction != EXEC_REVERSE)
6448     {
6449       /* This should not be necessary.  */
6450       if (stop_registers)
6451         regcache_xfree (stop_registers);
6452
6453       /* NB: The copy goes through to the target picking up the value of
6454          all the registers.  */
6455       stop_registers = regcache_dup (get_current_regcache ());
6456     }
6457
6458   if (stop_stack_dummy == STOP_STACK_DUMMY)
6459     {
6460       /* Pop the empty frame that contains the stack dummy.
6461          This also restores inferior state prior to the call
6462          (struct infcall_suspend_state).  */
6463       struct frame_info *frame = get_current_frame ();
6464
6465       gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
6466       frame_pop (frame);
6467       /* frame_pop() calls reinit_frame_cache as the last thing it
6468          does which means there's currently no selected frame.  We
6469          don't need to re-establish a selected frame if the dummy call
6470          returns normally, that will be done by
6471          restore_infcall_control_state.  However, we do have to handle
6472          the case where the dummy call is returning after being
6473          stopped (e.g. the dummy call previously hit a breakpoint).
6474          We can't know which case we have so just always re-establish
6475          a selected frame here.  */
6476       select_frame (get_current_frame ());
6477     }
6478
6479 done:
6480   annotate_stopped ();
6481
6482   /* Suppress the stop observer if we're in the middle of:
6483
6484      - a step n (n > 1), as there still more steps to be done.
6485
6486      - a "finish" command, as the observer will be called in
6487        finish_command_continuation, so it can include the inferior
6488        function's return value.
6489
6490      - calling an inferior function, as we pretend we inferior didn't
6491        run at all.  The return value of the call is handled by the
6492        expression evaluator, through call_function_by_hand.  */
6493
6494   if (!target_has_execution
6495       || last.kind == TARGET_WAITKIND_SIGNALLED
6496       || last.kind == TARGET_WAITKIND_EXITED
6497       || last.kind == TARGET_WAITKIND_NO_RESUMED
6498       || (!(inferior_thread ()->step_multi
6499             && inferior_thread ()->control.stop_step)
6500           && !(inferior_thread ()->control.stop_bpstat
6501                && inferior_thread ()->control.proceed_to_finish)
6502           && !inferior_thread ()->control.in_infcall))
6503     {
6504       if (!ptid_equal (inferior_ptid, null_ptid))
6505         observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
6506                                      stop_print_frame);
6507       else
6508         observer_notify_normal_stop (NULL, stop_print_frame);
6509     }
6510
6511   if (target_has_execution)
6512     {
6513       if (last.kind != TARGET_WAITKIND_SIGNALLED
6514           && last.kind != TARGET_WAITKIND_EXITED)
6515         /* Delete the breakpoint we stopped at, if it wants to be deleted.
6516            Delete any breakpoint that is to be deleted at the next stop.  */
6517         breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
6518     }
6519
6520   /* Try to get rid of automatically added inferiors that are no
6521      longer needed.  Keeping those around slows down things linearly.
6522      Note that this never removes the current inferior.  */
6523   prune_inferiors ();
6524 }
6525
6526 static int
6527 hook_stop_stub (void *cmd)
6528 {
6529   execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
6530   return (0);
6531 }
6532 \f
6533 int
6534 signal_stop_state (int signo)
6535 {
6536   return signal_stop[signo];
6537 }
6538
6539 int
6540 signal_print_state (int signo)
6541 {
6542   return signal_print[signo];
6543 }
6544
6545 int
6546 signal_pass_state (int signo)
6547 {
6548   return signal_program[signo];
6549 }
6550
6551 static void
6552 signal_cache_update (int signo)
6553 {
6554   if (signo == -1)
6555     {
6556       for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
6557         signal_cache_update (signo);
6558
6559       return;
6560     }
6561
6562   signal_pass[signo] = (signal_stop[signo] == 0
6563                         && signal_print[signo] == 0
6564                         && signal_program[signo] == 1
6565                         && signal_catch[signo] == 0);
6566 }
6567
6568 int
6569 signal_stop_update (int signo, int state)
6570 {
6571   int ret = signal_stop[signo];
6572
6573   signal_stop[signo] = state;
6574   signal_cache_update (signo);
6575   return ret;
6576 }
6577
6578 int
6579 signal_print_update (int signo, int state)
6580 {
6581   int ret = signal_print[signo];
6582
6583   signal_print[signo] = state;
6584   signal_cache_update (signo);
6585   return ret;
6586 }
6587
6588 int
6589 signal_pass_update (int signo, int state)
6590 {
6591   int ret = signal_program[signo];
6592
6593   signal_program[signo] = state;
6594   signal_cache_update (signo);
6595   return ret;
6596 }
6597
6598 /* Update the global 'signal_catch' from INFO and notify the
6599    target.  */
6600
6601 void
6602 signal_catch_update (const unsigned int *info)
6603 {
6604   int i;
6605
6606   for (i = 0; i < GDB_SIGNAL_LAST; ++i)
6607     signal_catch[i] = info[i] > 0;
6608   signal_cache_update (-1);
6609   target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6610 }
6611
6612 static void
6613 sig_print_header (void)
6614 {
6615   printf_filtered (_("Signal        Stop\tPrint\tPass "
6616                      "to program\tDescription\n"));
6617 }
6618
6619 static void
6620 sig_print_info (enum gdb_signal oursig)
6621 {
6622   const char *name = gdb_signal_to_name (oursig);
6623   int name_padding = 13 - strlen (name);
6624
6625   if (name_padding <= 0)
6626     name_padding = 0;
6627
6628   printf_filtered ("%s", name);
6629   printf_filtered ("%*.*s ", name_padding, name_padding, "                 ");
6630   printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
6631   printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
6632   printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
6633   printf_filtered ("%s\n", gdb_signal_to_string (oursig));
6634 }
6635
6636 /* Specify how various signals in the inferior should be handled.  */
6637
6638 static void
6639 handle_command (char *args, int from_tty)
6640 {
6641   char **argv;
6642   int digits, wordlen;
6643   int sigfirst, signum, siglast;
6644   enum gdb_signal oursig;
6645   int allsigs;
6646   int nsigs;
6647   unsigned char *sigs;
6648   struct cleanup *old_chain;
6649
6650   if (args == NULL)
6651     {
6652       error_no_arg (_("signal to handle"));
6653     }
6654
6655   /* Allocate and zero an array of flags for which signals to handle.  */
6656
6657   nsigs = (int) GDB_SIGNAL_LAST;
6658   sigs = (unsigned char *) alloca (nsigs);
6659   memset (sigs, 0, nsigs);
6660
6661   /* Break the command line up into args.  */
6662
6663   argv = gdb_buildargv (args);
6664   old_chain = make_cleanup_freeargv (argv);
6665
6666   /* Walk through the args, looking for signal oursigs, signal names, and
6667      actions.  Signal numbers and signal names may be interspersed with
6668      actions, with the actions being performed for all signals cumulatively
6669      specified.  Signal ranges can be specified as <LOW>-<HIGH>.  */
6670
6671   while (*argv != NULL)
6672     {
6673       wordlen = strlen (*argv);
6674       for (digits = 0; isdigit ((*argv)[digits]); digits++)
6675         {;
6676         }
6677       allsigs = 0;
6678       sigfirst = siglast = -1;
6679
6680       if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
6681         {
6682           /* Apply action to all signals except those used by the
6683              debugger.  Silently skip those.  */
6684           allsigs = 1;
6685           sigfirst = 0;
6686           siglast = nsigs - 1;
6687         }
6688       else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
6689         {
6690           SET_SIGS (nsigs, sigs, signal_stop);
6691           SET_SIGS (nsigs, sigs, signal_print);
6692         }
6693       else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
6694         {
6695           UNSET_SIGS (nsigs, sigs, signal_program);
6696         }
6697       else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
6698         {
6699           SET_SIGS (nsigs, sigs, signal_print);
6700         }
6701       else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
6702         {
6703           SET_SIGS (nsigs, sigs, signal_program);
6704         }
6705       else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
6706         {
6707           UNSET_SIGS (nsigs, sigs, signal_stop);
6708         }
6709       else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
6710         {
6711           SET_SIGS (nsigs, sigs, signal_program);
6712         }
6713       else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
6714         {
6715           UNSET_SIGS (nsigs, sigs, signal_print);
6716           UNSET_SIGS (nsigs, sigs, signal_stop);
6717         }
6718       else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
6719         {
6720           UNSET_SIGS (nsigs, sigs, signal_program);
6721         }
6722       else if (digits > 0)
6723         {
6724           /* It is numeric.  The numeric signal refers to our own
6725              internal signal numbering from target.h, not to host/target
6726              signal  number.  This is a feature; users really should be
6727              using symbolic names anyway, and the common ones like
6728              SIGHUP, SIGINT, SIGALRM, etc. will work right anyway.  */
6729
6730           sigfirst = siglast = (int)
6731             gdb_signal_from_command (atoi (*argv));
6732           if ((*argv)[digits] == '-')
6733             {
6734               siglast = (int)
6735                 gdb_signal_from_command (atoi ((*argv) + digits + 1));
6736             }
6737           if (sigfirst > siglast)
6738             {
6739               /* Bet he didn't figure we'd think of this case...  */
6740               signum = sigfirst;
6741               sigfirst = siglast;
6742               siglast = signum;
6743             }
6744         }
6745       else
6746         {
6747           oursig = gdb_signal_from_name (*argv);
6748           if (oursig != GDB_SIGNAL_UNKNOWN)
6749             {
6750               sigfirst = siglast = (int) oursig;
6751             }
6752           else
6753             {
6754               /* Not a number and not a recognized flag word => complain.  */
6755               error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv);
6756             }
6757         }
6758
6759       /* If any signal numbers or symbol names were found, set flags for
6760          which signals to apply actions to.  */
6761
6762       for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
6763         {
6764           switch ((enum gdb_signal) signum)
6765             {
6766             case GDB_SIGNAL_TRAP:
6767             case GDB_SIGNAL_INT:
6768               if (!allsigs && !sigs[signum])
6769                 {
6770                   if (query (_("%s is used by the debugger.\n\
6771 Are you sure you want to change it? "),
6772                              gdb_signal_to_name ((enum gdb_signal) signum)))
6773                     {
6774                       sigs[signum] = 1;
6775                     }
6776                   else
6777                     {
6778                       printf_unfiltered (_("Not confirmed, unchanged.\n"));
6779                       gdb_flush (gdb_stdout);
6780                     }
6781                 }
6782               break;
6783             case GDB_SIGNAL_0:
6784             case GDB_SIGNAL_DEFAULT:
6785             case GDB_SIGNAL_UNKNOWN:
6786               /* Make sure that "all" doesn't print these.  */
6787               break;
6788             default:
6789               sigs[signum] = 1;
6790               break;
6791             }
6792         }
6793
6794       argv++;
6795     }
6796
6797   for (signum = 0; signum < nsigs; signum++)
6798     if (sigs[signum])
6799       {
6800         signal_cache_update (-1);
6801         target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6802         target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
6803
6804         if (from_tty)
6805           {
6806             /* Show the results.  */
6807             sig_print_header ();
6808             for (; signum < nsigs; signum++)
6809               if (sigs[signum])
6810                 sig_print_info (signum);
6811           }
6812
6813         break;
6814       }
6815
6816   do_cleanups (old_chain);
6817 }
6818
6819 /* Complete the "handle" command.  */
6820
6821 static VEC (char_ptr) *
6822 handle_completer (struct cmd_list_element *ignore,
6823                   const char *text, const char *word)
6824 {
6825   VEC (char_ptr) *vec_signals, *vec_keywords, *return_val;
6826   static const char * const keywords[] =
6827     {
6828       "all",
6829       "stop",
6830       "ignore",
6831       "print",
6832       "pass",
6833       "nostop",
6834       "noignore",
6835       "noprint",
6836       "nopass",
6837       NULL,
6838     };
6839
6840   vec_signals = signal_completer (ignore, text, word);
6841   vec_keywords = complete_on_enum (keywords, word, word);
6842
6843   return_val = VEC_merge (char_ptr, vec_signals, vec_keywords);
6844   VEC_free (char_ptr, vec_signals);
6845   VEC_free (char_ptr, vec_keywords);
6846   return return_val;
6847 }
6848
6849 static void
6850 xdb_handle_command (char *args, int from_tty)
6851 {
6852   char **argv;
6853   struct cleanup *old_chain;
6854
6855   if (args == NULL)
6856     error_no_arg (_("xdb command"));
6857
6858   /* Break the command line up into args.  */
6859
6860   argv = gdb_buildargv (args);
6861   old_chain = make_cleanup_freeargv (argv);
6862   if (argv[1] != (char *) NULL)
6863     {
6864       char *argBuf;
6865       int bufLen;
6866
6867       bufLen = strlen (argv[0]) + 20;
6868       argBuf = (char *) xmalloc (bufLen);
6869       if (argBuf)
6870         {
6871           int validFlag = 1;
6872           enum gdb_signal oursig;
6873
6874           oursig = gdb_signal_from_name (argv[0]);
6875           memset (argBuf, 0, bufLen);
6876           if (strcmp (argv[1], "Q") == 0)
6877             sprintf (argBuf, "%s %s", argv[0], "noprint");
6878           else
6879             {
6880               if (strcmp (argv[1], "s") == 0)
6881                 {
6882                   if (!signal_stop[oursig])
6883                     sprintf (argBuf, "%s %s", argv[0], "stop");
6884                   else
6885                     sprintf (argBuf, "%s %s", argv[0], "nostop");
6886                 }
6887               else if (strcmp (argv[1], "i") == 0)
6888                 {
6889                   if (!signal_program[oursig])
6890                     sprintf (argBuf, "%s %s", argv[0], "pass");
6891                   else
6892                     sprintf (argBuf, "%s %s", argv[0], "nopass");
6893                 }
6894               else if (strcmp (argv[1], "r") == 0)
6895                 {
6896                   if (!signal_print[oursig])
6897                     sprintf (argBuf, "%s %s", argv[0], "print");
6898                   else
6899                     sprintf (argBuf, "%s %s", argv[0], "noprint");
6900                 }
6901               else
6902                 validFlag = 0;
6903             }
6904           if (validFlag)
6905             handle_command (argBuf, from_tty);
6906           else
6907             printf_filtered (_("Invalid signal handling flag.\n"));
6908           if (argBuf)
6909             xfree (argBuf);
6910         }
6911     }
6912   do_cleanups (old_chain);
6913 }
6914
6915 enum gdb_signal
6916 gdb_signal_from_command (int num)
6917 {
6918   if (num >= 1 && num <= 15)
6919     return (enum gdb_signal) num;
6920   error (_("Only signals 1-15 are valid as numeric signals.\n\
6921 Use \"info signals\" for a list of symbolic signals."));
6922 }
6923
6924 /* Print current contents of the tables set by the handle command.
6925    It is possible we should just be printing signals actually used
6926    by the current target (but for things to work right when switching
6927    targets, all signals should be in the signal tables).  */
6928
6929 static void
6930 signals_info (char *signum_exp, int from_tty)
6931 {
6932   enum gdb_signal oursig;
6933
6934   sig_print_header ();
6935
6936   if (signum_exp)
6937     {
6938       /* First see if this is a symbol name.  */
6939       oursig = gdb_signal_from_name (signum_exp);
6940       if (oursig == GDB_SIGNAL_UNKNOWN)
6941         {
6942           /* No, try numeric.  */
6943           oursig =
6944             gdb_signal_from_command (parse_and_eval_long (signum_exp));
6945         }
6946       sig_print_info (oursig);
6947       return;
6948     }
6949
6950   printf_filtered ("\n");
6951   /* These ugly casts brought to you by the native VAX compiler.  */
6952   for (oursig = GDB_SIGNAL_FIRST;
6953        (int) oursig < (int) GDB_SIGNAL_LAST;
6954        oursig = (enum gdb_signal) ((int) oursig + 1))
6955     {
6956       QUIT;
6957
6958       if (oursig != GDB_SIGNAL_UNKNOWN
6959           && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
6960         sig_print_info (oursig);
6961     }
6962
6963   printf_filtered (_("\nUse the \"handle\" command "
6964                      "to change these tables.\n"));
6965 }
6966
6967 /* Check if it makes sense to read $_siginfo from the current thread
6968    at this point.  If not, throw an error.  */
6969
6970 static void
6971 validate_siginfo_access (void)
6972 {
6973   /* No current inferior, no siginfo.  */
6974   if (ptid_equal (inferior_ptid, null_ptid))
6975     error (_("No thread selected."));
6976
6977   /* Don't try to read from a dead thread.  */
6978   if (is_exited (inferior_ptid))
6979     error (_("The current thread has terminated"));
6980
6981   /* ... or from a spinning thread.  */
6982   if (is_running (inferior_ptid))
6983     error (_("Selected thread is running."));
6984 }
6985
6986 /* The $_siginfo convenience variable is a bit special.  We don't know
6987    for sure the type of the value until we actually have a chance to
6988    fetch the data.  The type can change depending on gdbarch, so it is
6989    also dependent on which thread you have selected.
6990
6991      1. making $_siginfo be an internalvar that creates a new value on
6992      access.
6993
6994      2. making the value of $_siginfo be an lval_computed value.  */
6995
6996 /* This function implements the lval_computed support for reading a
6997    $_siginfo value.  */
6998
6999 static void
7000 siginfo_value_read (struct value *v)
7001 {
7002   LONGEST transferred;
7003
7004   validate_siginfo_access ();
7005
7006   transferred =
7007     target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO,
7008                  NULL,
7009                  value_contents_all_raw (v),
7010                  value_offset (v),
7011                  TYPE_LENGTH (value_type (v)));
7012
7013   if (transferred != TYPE_LENGTH (value_type (v)))
7014     error (_("Unable to read siginfo"));
7015 }
7016
7017 /* This function implements the lval_computed support for writing a
7018    $_siginfo value.  */
7019
7020 static void
7021 siginfo_value_write (struct value *v, struct value *fromval)
7022 {
7023   LONGEST transferred;
7024
7025   validate_siginfo_access ();
7026
7027   transferred = target_write (&current_target,
7028                               TARGET_OBJECT_SIGNAL_INFO,
7029                               NULL,
7030                               value_contents_all_raw (fromval),
7031                               value_offset (v),
7032                               TYPE_LENGTH (value_type (fromval)));
7033
7034   if (transferred != TYPE_LENGTH (value_type (fromval)))
7035     error (_("Unable to write siginfo"));
7036 }
7037
7038 static const struct lval_funcs siginfo_value_funcs =
7039   {
7040     siginfo_value_read,
7041     siginfo_value_write
7042   };
7043
7044 /* Return a new value with the correct type for the siginfo object of
7045    the current thread using architecture GDBARCH.  Return a void value
7046    if there's no object available.  */
7047
7048 static struct value *
7049 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
7050                     void *ignore)
7051 {
7052   if (target_has_stack
7053       && !ptid_equal (inferior_ptid, null_ptid)
7054       && gdbarch_get_siginfo_type_p (gdbarch))
7055     {
7056       struct type *type = gdbarch_get_siginfo_type (gdbarch);
7057
7058       return allocate_computed_value (type, &siginfo_value_funcs, NULL);
7059     }
7060
7061   return allocate_value (builtin_type (gdbarch)->builtin_void);
7062 }
7063
7064 \f
7065 /* infcall_suspend_state contains state about the program itself like its
7066    registers and any signal it received when it last stopped.
7067    This state must be restored regardless of how the inferior function call
7068    ends (either successfully, or after it hits a breakpoint or signal)
7069    if the program is to properly continue where it left off.  */
7070
7071 struct infcall_suspend_state
7072 {
7073   struct thread_suspend_state thread_suspend;
7074 #if 0 /* Currently unused and empty structures are not valid C.  */
7075   struct inferior_suspend_state inferior_suspend;
7076 #endif
7077
7078   /* Other fields:  */
7079   CORE_ADDR stop_pc;
7080   struct regcache *registers;
7081
7082   /* Format of SIGINFO_DATA or NULL if it is not present.  */
7083   struct gdbarch *siginfo_gdbarch;
7084
7085   /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
7086      TYPE_LENGTH (gdbarch_get_siginfo_type ()).  For different gdbarch the
7087      content would be invalid.  */
7088   gdb_byte *siginfo_data;
7089 };
7090
7091 struct infcall_suspend_state *
7092 save_infcall_suspend_state (void)
7093 {
7094   struct infcall_suspend_state *inf_state;
7095   struct thread_info *tp = inferior_thread ();
7096 #if 0
7097   struct inferior *inf = current_inferior ();
7098 #endif
7099   struct regcache *regcache = get_current_regcache ();
7100   struct gdbarch *gdbarch = get_regcache_arch (regcache);
7101   gdb_byte *siginfo_data = NULL;
7102
7103   if (gdbarch_get_siginfo_type_p (gdbarch))
7104     {
7105       struct type *type = gdbarch_get_siginfo_type (gdbarch);
7106       size_t len = TYPE_LENGTH (type);
7107       struct cleanup *back_to;
7108
7109       siginfo_data = xmalloc (len);
7110       back_to = make_cleanup (xfree, siginfo_data);
7111
7112       if (target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
7113                        siginfo_data, 0, len) == len)
7114         discard_cleanups (back_to);
7115       else
7116         {
7117           /* Errors ignored.  */
7118           do_cleanups (back_to);
7119           siginfo_data = NULL;
7120         }
7121     }
7122
7123   inf_state = XCNEW (struct infcall_suspend_state);
7124
7125   if (siginfo_data)
7126     {
7127       inf_state->siginfo_gdbarch = gdbarch;
7128       inf_state->siginfo_data = siginfo_data;
7129     }
7130
7131   inf_state->thread_suspend = tp->suspend;
7132 #if 0 /* Currently unused and empty structures are not valid C.  */
7133   inf_state->inferior_suspend = inf->suspend;
7134 #endif
7135
7136   /* run_inferior_call will not use the signal due to its `proceed' call with
7137      GDB_SIGNAL_0 anyway.  */
7138   tp->suspend.stop_signal = GDB_SIGNAL_0;
7139
7140   inf_state->stop_pc = stop_pc;
7141
7142   inf_state->registers = regcache_dup (regcache);
7143
7144   return inf_state;
7145 }
7146
7147 /* Restore inferior session state to INF_STATE.  */
7148
7149 void
7150 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
7151 {
7152   struct thread_info *tp = inferior_thread ();
7153 #if 0
7154   struct inferior *inf = current_inferior ();
7155 #endif
7156   struct regcache *regcache = get_current_regcache ();
7157   struct gdbarch *gdbarch = get_regcache_arch (regcache);
7158
7159   tp->suspend = inf_state->thread_suspend;
7160 #if 0 /* Currently unused and empty structures are not valid C.  */
7161   inf->suspend = inf_state->inferior_suspend;
7162 #endif
7163
7164   stop_pc = inf_state->stop_pc;
7165
7166   if (inf_state->siginfo_gdbarch == gdbarch)
7167     {
7168       struct type *type = gdbarch_get_siginfo_type (gdbarch);
7169
7170       /* Errors ignored.  */
7171       target_write (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
7172                     inf_state->siginfo_data, 0, TYPE_LENGTH (type));
7173     }
7174
7175   /* The inferior can be gone if the user types "print exit(0)"
7176      (and perhaps other times).  */
7177   if (target_has_execution)
7178     /* NB: The register write goes through to the target.  */
7179     regcache_cpy (regcache, inf_state->registers);
7180
7181   discard_infcall_suspend_state (inf_state);
7182 }
7183
7184 static void
7185 do_restore_infcall_suspend_state_cleanup (void *state)
7186 {
7187   restore_infcall_suspend_state (state);
7188 }
7189
7190 struct cleanup *
7191 make_cleanup_restore_infcall_suspend_state
7192   (struct infcall_suspend_state *inf_state)
7193 {
7194   return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
7195 }
7196
7197 void
7198 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
7199 {
7200   regcache_xfree (inf_state->registers);
7201   xfree (inf_state->siginfo_data);
7202   xfree (inf_state);
7203 }
7204
7205 struct regcache *
7206 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
7207 {
7208   return inf_state->registers;
7209 }
7210
7211 /* infcall_control_state contains state regarding gdb's control of the
7212    inferior itself like stepping control.  It also contains session state like
7213    the user's currently selected frame.  */
7214
7215 struct infcall_control_state
7216 {
7217   struct thread_control_state thread_control;
7218   struct inferior_control_state inferior_control;
7219
7220   /* Other fields:  */
7221   enum stop_stack_kind stop_stack_dummy;
7222   int stopped_by_random_signal;
7223   int stop_after_trap;
7224
7225   /* ID if the selected frame when the inferior function call was made.  */
7226   struct frame_id selected_frame_id;
7227 };
7228
7229 /* Save all of the information associated with the inferior<==>gdb
7230    connection.  */
7231
7232 struct infcall_control_state *
7233 save_infcall_control_state (void)
7234 {
7235   struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status));
7236   struct thread_info *tp = inferior_thread ();
7237   struct inferior *inf = current_inferior ();
7238
7239   inf_status->thread_control = tp->control;
7240   inf_status->inferior_control = inf->control;
7241
7242   tp->control.step_resume_breakpoint = NULL;
7243   tp->control.exception_resume_breakpoint = NULL;
7244
7245   /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
7246      chain.  If caller's caller is walking the chain, they'll be happier if we
7247      hand them back the original chain when restore_infcall_control_state is
7248      called.  */
7249   tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
7250
7251   /* Other fields:  */
7252   inf_status->stop_stack_dummy = stop_stack_dummy;
7253   inf_status->stopped_by_random_signal = stopped_by_random_signal;
7254   inf_status->stop_after_trap = stop_after_trap;
7255
7256   inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
7257
7258   return inf_status;
7259 }
7260
7261 static int
7262 restore_selected_frame (void *args)
7263 {
7264   struct frame_id *fid = (struct frame_id *) args;
7265   struct frame_info *frame;
7266
7267   frame = frame_find_by_id (*fid);
7268
7269   /* If inf_status->selected_frame_id is NULL, there was no previously
7270      selected frame.  */
7271   if (frame == NULL)
7272     {
7273       warning (_("Unable to restore previously selected frame."));
7274       return 0;
7275     }
7276
7277   select_frame (frame);
7278
7279   return (1);
7280 }
7281
7282 /* Restore inferior session state to INF_STATUS.  */
7283
7284 void
7285 restore_infcall_control_state (struct infcall_control_state *inf_status)
7286 {
7287   struct thread_info *tp = inferior_thread ();
7288   struct inferior *inf = current_inferior ();
7289
7290   if (tp->control.step_resume_breakpoint)
7291     tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
7292
7293   if (tp->control.exception_resume_breakpoint)
7294     tp->control.exception_resume_breakpoint->disposition
7295       = disp_del_at_next_stop;
7296
7297   /* Handle the bpstat_copy of the chain.  */
7298   bpstat_clear (&tp->control.stop_bpstat);
7299
7300   tp->control = inf_status->thread_control;
7301   inf->control = inf_status->inferior_control;
7302
7303   /* Other fields:  */
7304   stop_stack_dummy = inf_status->stop_stack_dummy;
7305   stopped_by_random_signal = inf_status->stopped_by_random_signal;
7306   stop_after_trap = inf_status->stop_after_trap;
7307
7308   if (target_has_stack)
7309     {
7310       /* The point of catch_errors is that if the stack is clobbered,
7311          walking the stack might encounter a garbage pointer and
7312          error() trying to dereference it.  */
7313       if (catch_errors
7314           (restore_selected_frame, &inf_status->selected_frame_id,
7315            "Unable to restore previously selected frame:\n",
7316            RETURN_MASK_ERROR) == 0)
7317         /* Error in restoring the selected frame.  Select the innermost
7318            frame.  */
7319         select_frame (get_current_frame ());
7320     }
7321
7322   xfree (inf_status);
7323 }
7324
7325 static void
7326 do_restore_infcall_control_state_cleanup (void *sts)
7327 {
7328   restore_infcall_control_state (sts);
7329 }
7330
7331 struct cleanup *
7332 make_cleanup_restore_infcall_control_state
7333   (struct infcall_control_state *inf_status)
7334 {
7335   return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
7336 }
7337
7338 void
7339 discard_infcall_control_state (struct infcall_control_state *inf_status)
7340 {
7341   if (inf_status->thread_control.step_resume_breakpoint)
7342     inf_status->thread_control.step_resume_breakpoint->disposition
7343       = disp_del_at_next_stop;
7344
7345   if (inf_status->thread_control.exception_resume_breakpoint)
7346     inf_status->thread_control.exception_resume_breakpoint->disposition
7347       = disp_del_at_next_stop;
7348
7349   /* See save_infcall_control_state for info on stop_bpstat.  */
7350   bpstat_clear (&inf_status->thread_control.stop_bpstat);
7351
7352   xfree (inf_status);
7353 }
7354 \f
7355 /* restore_inferior_ptid() will be used by the cleanup machinery
7356    to restore the inferior_ptid value saved in a call to
7357    save_inferior_ptid().  */
7358
7359 static void
7360 restore_inferior_ptid (void *arg)
7361 {
7362   ptid_t *saved_ptid_ptr = arg;
7363
7364   inferior_ptid = *saved_ptid_ptr;
7365   xfree (arg);
7366 }
7367
7368 /* Save the value of inferior_ptid so that it may be restored by a
7369    later call to do_cleanups().  Returns the struct cleanup pointer
7370    needed for later doing the cleanup.  */
7371
7372 struct cleanup *
7373 save_inferior_ptid (void)
7374 {
7375   ptid_t *saved_ptid_ptr;
7376
7377   saved_ptid_ptr = xmalloc (sizeof (ptid_t));
7378   *saved_ptid_ptr = inferior_ptid;
7379   return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
7380 }
7381
7382 /* See infrun.h.  */
7383
7384 void
7385 clear_exit_convenience_vars (void)
7386 {
7387   clear_internalvar (lookup_internalvar ("_exitsignal"));
7388   clear_internalvar (lookup_internalvar ("_exitcode"));
7389 }
7390 \f
7391
7392 /* User interface for reverse debugging:
7393    Set exec-direction / show exec-direction commands
7394    (returns error unless target implements to_set_exec_direction method).  */
7395
7396 int execution_direction = EXEC_FORWARD;
7397 static const char exec_forward[] = "forward";
7398 static const char exec_reverse[] = "reverse";
7399 static const char *exec_direction = exec_forward;
7400 static const char *const exec_direction_names[] = {
7401   exec_forward,
7402   exec_reverse,
7403   NULL
7404 };
7405
7406 static void
7407 set_exec_direction_func (char *args, int from_tty,
7408                          struct cmd_list_element *cmd)
7409 {
7410   if (target_can_execute_reverse)
7411     {
7412       if (!strcmp (exec_direction, exec_forward))
7413         execution_direction = EXEC_FORWARD;
7414       else if (!strcmp (exec_direction, exec_reverse))
7415         execution_direction = EXEC_REVERSE;
7416     }
7417   else
7418     {
7419       exec_direction = exec_forward;
7420       error (_("Target does not support this operation."));
7421     }
7422 }
7423
7424 static void
7425 show_exec_direction_func (struct ui_file *out, int from_tty,
7426                           struct cmd_list_element *cmd, const char *value)
7427 {
7428   switch (execution_direction) {
7429   case EXEC_FORWARD:
7430     fprintf_filtered (out, _("Forward.\n"));
7431     break;
7432   case EXEC_REVERSE:
7433     fprintf_filtered (out, _("Reverse.\n"));
7434     break;
7435   default:
7436     internal_error (__FILE__, __LINE__,
7437                     _("bogus execution_direction value: %d"),
7438                     (int) execution_direction);
7439   }
7440 }
7441
7442 static void
7443 show_schedule_multiple (struct ui_file *file, int from_tty,
7444                         struct cmd_list_element *c, const char *value)
7445 {
7446   fprintf_filtered (file, _("Resuming the execution of threads "
7447                             "of all processes is %s.\n"), value);
7448 }
7449
7450 /* Implementation of `siginfo' variable.  */
7451
7452 static const struct internalvar_funcs siginfo_funcs =
7453 {
7454   siginfo_make_value,
7455   NULL,
7456   NULL
7457 };
7458
7459 void
7460 _initialize_infrun (void)
7461 {
7462   int i;
7463   int numsigs;
7464   struct cmd_list_element *c;
7465
7466   add_info ("signals", signals_info, _("\
7467 What debugger does when program gets various signals.\n\
7468 Specify a signal as argument to print info on that signal only."));
7469   add_info_alias ("handle", "signals", 0);
7470
7471   c = add_com ("handle", class_run, handle_command, _("\
7472 Specify how to handle signals.\n\
7473 Usage: handle SIGNAL [ACTIONS]\n\
7474 Args are signals and actions to apply to those signals.\n\
7475 If no actions are specified, the current settings for the specified signals\n\
7476 will be displayed instead.\n\
7477 \n\
7478 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7479 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7480 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7481 The special arg \"all\" is recognized to mean all signals except those\n\
7482 used by the debugger, typically SIGTRAP and SIGINT.\n\
7483 \n\
7484 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7485 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7486 Stop means reenter debugger if this signal happens (implies print).\n\
7487 Print means print a message if this signal happens.\n\
7488 Pass means let program see this signal; otherwise program doesn't know.\n\
7489 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7490 Pass and Stop may be combined.\n\
7491 \n\
7492 Multiple signals may be specified.  Signal numbers and signal names\n\
7493 may be interspersed with actions, with the actions being performed for\n\
7494 all signals cumulatively specified."));
7495   set_cmd_completer (c, handle_completer);
7496
7497   if (xdb_commands)
7498     {
7499       add_com ("lz", class_info, signals_info, _("\
7500 What debugger does when program gets various signals.\n\
7501 Specify a signal as argument to print info on that signal only."));
7502       add_com ("z", class_run, xdb_handle_command, _("\
7503 Specify how to handle a signal.\n\
7504 Args are signals and actions to apply to those signals.\n\
7505 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7506 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7507 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7508 The special arg \"all\" is recognized to mean all signals except those\n\
7509 used by the debugger, typically SIGTRAP and SIGINT.\n\
7510 Recognized actions include \"s\" (toggles between stop and nostop),\n\
7511 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
7512 nopass), \"Q\" (noprint)\n\
7513 Stop means reenter debugger if this signal happens (implies print).\n\
7514 Print means print a message if this signal happens.\n\
7515 Pass means let program see this signal; otherwise program doesn't know.\n\
7516 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7517 Pass and Stop may be combined."));
7518     }
7519
7520   if (!dbx_commands)
7521     stop_command = add_cmd ("stop", class_obscure,
7522                             not_just_help_class_command, _("\
7523 There is no `stop' command, but you can set a hook on `stop'.\n\
7524 This allows you to set a list of commands to be run each time execution\n\
7525 of the program stops."), &cmdlist);
7526
7527   add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
7528 Set inferior debugging."), _("\
7529 Show inferior debugging."), _("\
7530 When non-zero, inferior specific debugging is enabled."),
7531                              NULL,
7532                              show_debug_infrun,
7533                              &setdebuglist, &showdebuglist);
7534
7535   add_setshow_boolean_cmd ("displaced", class_maintenance,
7536                            &debug_displaced, _("\
7537 Set displaced stepping debugging."), _("\
7538 Show displaced stepping debugging."), _("\
7539 When non-zero, displaced stepping specific debugging is enabled."),
7540                             NULL,
7541                             show_debug_displaced,
7542                             &setdebuglist, &showdebuglist);
7543
7544   add_setshow_boolean_cmd ("non-stop", no_class,
7545                            &non_stop_1, _("\
7546 Set whether gdb controls the inferior in non-stop mode."), _("\
7547 Show whether gdb controls the inferior in non-stop mode."), _("\
7548 When debugging a multi-threaded program and this setting is\n\
7549 off (the default, also called all-stop mode), when one thread stops\n\
7550 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7551 all other threads in the program while you interact with the thread of\n\
7552 interest.  When you continue or step a thread, you can allow the other\n\
7553 threads to run, or have them remain stopped, but while you inspect any\n\
7554 thread's state, all threads stop.\n\
7555 \n\
7556 In non-stop mode, when one thread stops, other threads can continue\n\
7557 to run freely.  You'll be able to step each thread independently,\n\
7558 leave it stopped or free to run as needed."),
7559                            set_non_stop,
7560                            show_non_stop,
7561                            &setlist,
7562                            &showlist);
7563
7564   numsigs = (int) GDB_SIGNAL_LAST;
7565   signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
7566   signal_print = (unsigned char *)
7567     xmalloc (sizeof (signal_print[0]) * numsigs);
7568   signal_program = (unsigned char *)
7569     xmalloc (sizeof (signal_program[0]) * numsigs);
7570   signal_catch = (unsigned char *)
7571     xmalloc (sizeof (signal_catch[0]) * numsigs);
7572   signal_pass = (unsigned char *)
7573     xmalloc (sizeof (signal_pass[0]) * numsigs);
7574   for (i = 0; i < numsigs; i++)
7575     {
7576       signal_stop[i] = 1;
7577       signal_print[i] = 1;
7578       signal_program[i] = 1;
7579       signal_catch[i] = 0;
7580     }
7581
7582   /* Signals caused by debugger's own actions
7583      should not be given to the program afterwards.  */
7584   signal_program[GDB_SIGNAL_TRAP] = 0;
7585   signal_program[GDB_SIGNAL_INT] = 0;
7586
7587   /* Signals that are not errors should not normally enter the debugger.  */
7588   signal_stop[GDB_SIGNAL_ALRM] = 0;
7589   signal_print[GDB_SIGNAL_ALRM] = 0;
7590   signal_stop[GDB_SIGNAL_VTALRM] = 0;
7591   signal_print[GDB_SIGNAL_VTALRM] = 0;
7592   signal_stop[GDB_SIGNAL_PROF] = 0;
7593   signal_print[GDB_SIGNAL_PROF] = 0;
7594   signal_stop[GDB_SIGNAL_CHLD] = 0;
7595   signal_print[GDB_SIGNAL_CHLD] = 0;
7596   signal_stop[GDB_SIGNAL_IO] = 0;
7597   signal_print[GDB_SIGNAL_IO] = 0;
7598   signal_stop[GDB_SIGNAL_POLL] = 0;
7599   signal_print[GDB_SIGNAL_POLL] = 0;
7600   signal_stop[GDB_SIGNAL_URG] = 0;
7601   signal_print[GDB_SIGNAL_URG] = 0;
7602   signal_stop[GDB_SIGNAL_WINCH] = 0;
7603   signal_print[GDB_SIGNAL_WINCH] = 0;
7604   signal_stop[GDB_SIGNAL_PRIO] = 0;
7605   signal_print[GDB_SIGNAL_PRIO] = 0;
7606
7607   /* These signals are used internally by user-level thread
7608      implementations.  (See signal(5) on Solaris.)  Like the above
7609      signals, a healthy program receives and handles them as part of
7610      its normal operation.  */
7611   signal_stop[GDB_SIGNAL_LWP] = 0;
7612   signal_print[GDB_SIGNAL_LWP] = 0;
7613   signal_stop[GDB_SIGNAL_WAITING] = 0;
7614   signal_print[GDB_SIGNAL_WAITING] = 0;
7615   signal_stop[GDB_SIGNAL_CANCEL] = 0;
7616   signal_print[GDB_SIGNAL_CANCEL] = 0;
7617
7618   /* Update cached state.  */
7619   signal_cache_update (-1);
7620
7621   add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
7622                             &stop_on_solib_events, _("\
7623 Set stopping for shared library events."), _("\
7624 Show stopping for shared library events."), _("\
7625 If nonzero, gdb will give control to the user when the dynamic linker\n\
7626 notifies gdb of shared library events.  The most common event of interest\n\
7627 to the user would be loading/unloading of a new library."),
7628                             set_stop_on_solib_events,
7629                             show_stop_on_solib_events,
7630                             &setlist, &showlist);
7631
7632   add_setshow_enum_cmd ("follow-fork-mode", class_run,
7633                         follow_fork_mode_kind_names,
7634                         &follow_fork_mode_string, _("\
7635 Set debugger response to a program call of fork or vfork."), _("\
7636 Show debugger response to a program call of fork or vfork."), _("\
7637 A fork or vfork creates a new process.  follow-fork-mode can be:\n\
7638   parent  - the original process is debugged after a fork\n\
7639   child   - the new process is debugged after a fork\n\
7640 The unfollowed process will continue to run.\n\
7641 By default, the debugger will follow the parent process."),
7642                         NULL,
7643                         show_follow_fork_mode_string,
7644                         &setlist, &showlist);
7645
7646   add_setshow_enum_cmd ("follow-exec-mode", class_run,
7647                         follow_exec_mode_names,
7648                         &follow_exec_mode_string, _("\
7649 Set debugger response to a program call of exec."), _("\
7650 Show debugger response to a program call of exec."), _("\
7651 An exec call replaces the program image of a process.\n\
7652 \n\
7653 follow-exec-mode can be:\n\
7654 \n\
7655   new - the debugger creates a new inferior and rebinds the process\n\
7656 to this new inferior.  The program the process was running before\n\
7657 the exec call can be restarted afterwards by restarting the original\n\
7658 inferior.\n\
7659 \n\
7660   same - the debugger keeps the process bound to the same inferior.\n\
7661 The new executable image replaces the previous executable loaded in\n\
7662 the inferior.  Restarting the inferior after the exec call restarts\n\
7663 the executable the process was running after the exec call.\n\
7664 \n\
7665 By default, the debugger will use the same inferior."),
7666                         NULL,
7667                         show_follow_exec_mode_string,
7668                         &setlist, &showlist);
7669
7670   add_setshow_enum_cmd ("scheduler-locking", class_run, 
7671                         scheduler_enums, &scheduler_mode, _("\
7672 Set mode for locking scheduler during execution."), _("\
7673 Show mode for locking scheduler during execution."), _("\
7674 off  == no locking (threads may preempt at any time)\n\
7675 on   == full locking (no thread except the current thread may run)\n\
7676 step == scheduler locked during every single-step operation.\n\
7677         In this mode, no other thread may run during a step command.\n\
7678         Other threads may run while stepping over a function call ('next')."), 
7679                         set_schedlock_func,     /* traps on target vector */
7680                         show_scheduler_mode,
7681                         &setlist, &showlist);
7682
7683   add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
7684 Set mode for resuming threads of all processes."), _("\
7685 Show mode for resuming threads of all processes."), _("\
7686 When on, execution commands (such as 'continue' or 'next') resume all\n\
7687 threads of all processes.  When off (which is the default), execution\n\
7688 commands only resume the threads of the current process.  The set of\n\
7689 threads that are resumed is further refined by the scheduler-locking\n\
7690 mode (see help set scheduler-locking)."),
7691                            NULL,
7692                            show_schedule_multiple,
7693                            &setlist, &showlist);
7694
7695   add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
7696 Set mode of the step operation."), _("\
7697 Show mode of the step operation."), _("\
7698 When set, doing a step over a function without debug line information\n\
7699 will stop at the first instruction of that function. Otherwise, the\n\
7700 function is skipped and the step command stops at a different source line."),
7701                            NULL,
7702                            show_step_stop_if_no_debug,
7703                            &setlist, &showlist);
7704
7705   add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
7706                                 &can_use_displaced_stepping, _("\
7707 Set debugger's willingness to use displaced stepping."), _("\
7708 Show debugger's willingness to use displaced stepping."), _("\
7709 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7710 supported by the target architecture.  If off, gdb will not use displaced\n\
7711 stepping to step over breakpoints, even if such is supported by the target\n\
7712 architecture.  If auto (which is the default), gdb will use displaced stepping\n\
7713 if the target architecture supports it and non-stop mode is active, but will not\n\
7714 use it in all-stop mode (see help set non-stop)."),
7715                                 NULL,
7716                                 show_can_use_displaced_stepping,
7717                                 &setlist, &showlist);
7718
7719   add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
7720                         &exec_direction, _("Set direction of execution.\n\
7721 Options are 'forward' or 'reverse'."),
7722                         _("Show direction of execution (forward/reverse)."),
7723                         _("Tells gdb whether to execute forward or backward."),
7724                         set_exec_direction_func, show_exec_direction_func,
7725                         &setlist, &showlist);
7726
7727   /* Set/show detach-on-fork: user-settable mode.  */
7728
7729   add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
7730 Set whether gdb will detach the child of a fork."), _("\
7731 Show whether gdb will detach the child of a fork."), _("\
7732 Tells gdb whether to detach the child of a fork."),
7733                            NULL, NULL, &setlist, &showlist);
7734
7735   /* Set/show disable address space randomization mode.  */
7736
7737   add_setshow_boolean_cmd ("disable-randomization", class_support,
7738                            &disable_randomization, _("\
7739 Set disabling of debuggee's virtual address space randomization."), _("\
7740 Show disabling of debuggee's virtual address space randomization."), _("\
7741 When this mode is on (which is the default), randomization of the virtual\n\
7742 address space is disabled.  Standalone programs run with the randomization\n\
7743 enabled by default on some platforms."),
7744                            &set_disable_randomization,
7745                            &show_disable_randomization,
7746                            &setlist, &showlist);
7747
7748   /* ptid initializations */
7749   inferior_ptid = null_ptid;
7750   target_last_wait_ptid = minus_one_ptid;
7751
7752   observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
7753   observer_attach_thread_stop_requested (infrun_thread_stop_requested);
7754   observer_attach_thread_exit (infrun_thread_thread_exit);
7755   observer_attach_inferior_exit (infrun_inferior_exit);
7756
7757   /* Explicitly create without lookup, since that tries to create a
7758      value with a void typed value, and when we get here, gdbarch
7759      isn't initialized yet.  At this point, we're quite sure there
7760      isn't another convenience variable of the same name.  */
7761   create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
7762
7763   add_setshow_boolean_cmd ("observer", no_class,
7764                            &observer_mode_1, _("\
7765 Set whether gdb controls the inferior in observer mode."), _("\
7766 Show whether gdb controls the inferior in observer mode."), _("\
7767 In observer mode, GDB can get data from the inferior, but not\n\
7768 affect its execution.  Registers and memory may not be changed,\n\
7769 breakpoints may not be set, and the program cannot be interrupted\n\
7770 or signalled."),
7771                            set_observer_mode,
7772                            show_observer_mode,
7773                            &setlist,
7774                            &showlist);
7775 }