Merge branch 'vendor/GDB'
[dragonfly.git] / contrib / gdb-7 / gdb / infrun.c
1 /* Target-struct-independent code to start (run) and stop an inferior
2    process.
3
4    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
5    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
6    2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #include "defs.h"
24 #include "gdb_string.h"
25 #include <ctype.h>
26 #include "symtab.h"
27 #include "frame.h"
28 #include "inferior.h"
29 #include "exceptions.h"
30 #include "breakpoint.h"
31 #include "gdb_wait.h"
32 #include "gdbcore.h"
33 #include "gdbcmd.h"
34 #include "cli/cli-script.h"
35 #include "target.h"
36 #include "gdbthread.h"
37 #include "annotate.h"
38 #include "symfile.h"
39 #include "top.h"
40 #include <signal.h>
41 #include "inf-loop.h"
42 #include "regcache.h"
43 #include "value.h"
44 #include "observer.h"
45 #include "language.h"
46 #include "solib.h"
47 #include "main.h"
48 #include "dictionary.h"
49 #include "block.h"
50 #include "gdb_assert.h"
51 #include "mi/mi-common.h"
52 #include "event-top.h"
53 #include "record.h"
54 #include "inline-frame.h"
55 #include "jit.h"
56 #include "tracepoint.h"
57
58 /* Prototypes for local functions */
59
60 static void signals_info (char *, int);
61
62 static void handle_command (char *, int);
63
64 static void sig_print_info (enum target_signal);
65
66 static void sig_print_header (void);
67
68 static void resume_cleanups (void *);
69
70 static int hook_stop_stub (void *);
71
72 static int restore_selected_frame (void *);
73
74 static int follow_fork (void);
75
76 static void set_schedlock_func (char *args, int from_tty,
77                                 struct cmd_list_element *c);
78
79 static int currently_stepping (struct thread_info *tp);
80
81 static int currently_stepping_or_nexting_callback (struct thread_info *tp,
82                                                    void *data);
83
84 static void xdb_handle_command (char *args, int from_tty);
85
86 static int prepare_to_proceed (int);
87
88 static void print_exited_reason (int exitstatus);
89
90 static void print_signal_exited_reason (enum target_signal siggnal);
91
92 static void print_no_history_reason (void);
93
94 static void print_signal_received_reason (enum target_signal siggnal);
95
96 static void print_end_stepping_range_reason (void);
97
98 void _initialize_infrun (void);
99
100 void nullify_last_target_wait_ptid (void);
101
102 /* When set, stop the 'step' command if we enter a function which has
103    no line number information.  The normal behavior is that we step
104    over such function.  */
105 int step_stop_if_no_debug = 0;
106 static void
107 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
108                             struct cmd_list_element *c, const char *value)
109 {
110   fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
111 }
112
113 /* In asynchronous mode, but simulating synchronous execution.  */
114
115 int sync_execution = 0;
116
117 /* wait_for_inferior and normal_stop use this to notify the user
118    when the inferior stopped in a different thread than it had been
119    running in.  */
120
121 static ptid_t previous_inferior_ptid;
122
123 /* Default behavior is to detach newly forked processes (legacy).  */
124 int detach_fork = 1;
125
126 int debug_displaced = 0;
127 static void
128 show_debug_displaced (struct ui_file *file, int from_tty,
129                       struct cmd_list_element *c, const char *value)
130 {
131   fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
132 }
133
134 int debug_infrun = 0;
135 static void
136 show_debug_infrun (struct ui_file *file, int from_tty,
137                    struct cmd_list_element *c, const char *value)
138 {
139   fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
140 }
141
142 /* If the program uses ELF-style shared libraries, then calls to
143    functions in shared libraries go through stubs, which live in a
144    table called the PLT (Procedure Linkage Table).  The first time the
145    function is called, the stub sends control to the dynamic linker,
146    which looks up the function's real address, patches the stub so
147    that future calls will go directly to the function, and then passes
148    control to the function.
149
150    If we are stepping at the source level, we don't want to see any of
151    this --- we just want to skip over the stub and the dynamic linker.
152    The simple approach is to single-step until control leaves the
153    dynamic linker.
154
155    However, on some systems (e.g., Red Hat's 5.2 distribution) the
156    dynamic linker calls functions in the shared C library, so you
157    can't tell from the PC alone whether the dynamic linker is still
158    running.  In this case, we use a step-resume breakpoint to get us
159    past the dynamic linker, as if we were using "next" to step over a
160    function call.
161
162    in_solib_dynsym_resolve_code() says whether we're in the dynamic
163    linker code or not.  Normally, this means we single-step.  However,
164    if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an
165    address where we can place a step-resume breakpoint to get past the
166    linker's symbol resolution function.
167
168    in_solib_dynsym_resolve_code() can generally be implemented in a
169    pretty portable way, by comparing the PC against the address ranges
170    of the dynamic linker's sections.
171
172    SKIP_SOLIB_RESOLVER is generally going to be system-specific, since
173    it depends on internal details of the dynamic linker.  It's usually
174    not too hard to figure out where to put a breakpoint, but it
175    certainly isn't portable.  SKIP_SOLIB_RESOLVER should do plenty of
176    sanity checking.  If it can't figure things out, returning zero and
177    getting the (possibly confusing) stepping behavior is better than
178    signalling an error, which will obscure the change in the
179    inferior's state.  */
180
181 /* This function returns TRUE if pc is the address of an instruction
182    that lies within the dynamic linker (such as the event hook, or the
183    dld itself).
184
185    This function must be used only when a dynamic linker event has
186    been caught, and the inferior is being stepped out of the hook, or
187    undefined results are guaranteed.  */
188
189 #ifndef SOLIB_IN_DYNAMIC_LINKER
190 #define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0
191 #endif
192
193 /* "Observer mode" is somewhat like a more extreme version of
194    non-stop, in which all GDB operations that might affect the
195    target's execution have been disabled.  */
196
197 static int non_stop_1 = 0;
198
199 int observer_mode = 0;
200 static int observer_mode_1 = 0;
201
202 static void
203 set_observer_mode (char *args, int from_tty,
204                    struct cmd_list_element *c)
205 {
206   extern int pagination_enabled;
207
208   if (target_has_execution)
209     {
210       observer_mode_1 = observer_mode;
211       error (_("Cannot change this setting while the inferior is running."));
212     }
213
214   observer_mode = observer_mode_1;
215
216   may_write_registers = !observer_mode;
217   may_write_memory = !observer_mode;
218   may_insert_breakpoints = !observer_mode;
219   may_insert_tracepoints = !observer_mode;
220   /* We can insert fast tracepoints in or out of observer mode,
221      but enable them if we're going into this mode.  */
222   if (observer_mode)
223     may_insert_fast_tracepoints = 1;
224   may_stop = !observer_mode;
225   update_target_permissions ();
226
227   /* Going *into* observer mode we must force non-stop, then
228      going out we leave it that way.  */
229   if (observer_mode)
230     {
231       target_async_permitted = 1;
232       pagination_enabled = 0;
233       non_stop = non_stop_1 = 1;
234     }
235
236   if (from_tty)
237     printf_filtered (_("Observer mode is now %s.\n"),
238                      (observer_mode ? "on" : "off"));
239 }
240
241 static void
242 show_observer_mode (struct ui_file *file, int from_tty,
243                     struct cmd_list_element *c, const char *value)
244 {
245   fprintf_filtered (file, _("Observer mode is %s.\n"), value);
246 }
247
248 /* This updates the value of observer mode based on changes in
249    permissions.  Note that we are deliberately ignoring the values of
250    may-write-registers and may-write-memory, since the user may have
251    reason to enable these during a session, for instance to turn on a
252    debugging-related global.  */
253
254 void
255 update_observer_mode (void)
256 {
257   int newval;
258
259   newval = (!may_insert_breakpoints
260             && !may_insert_tracepoints
261             && may_insert_fast_tracepoints
262             && !may_stop
263             && non_stop);
264
265   /* Let the user know if things change.  */
266   if (newval != observer_mode)
267     printf_filtered (_("Observer mode is now %s.\n"),
268                      (newval ? "on" : "off"));
269
270   observer_mode = observer_mode_1 = newval;
271 }
272
273 /* Tables of how to react to signals; the user sets them.  */
274
275 static unsigned char *signal_stop;
276 static unsigned char *signal_print;
277 static unsigned char *signal_program;
278
279 #define SET_SIGS(nsigs,sigs,flags) \
280   do { \
281     int signum = (nsigs); \
282     while (signum-- > 0) \
283       if ((sigs)[signum]) \
284         (flags)[signum] = 1; \
285   } while (0)
286
287 #define UNSET_SIGS(nsigs,sigs,flags) \
288   do { \
289     int signum = (nsigs); \
290     while (signum-- > 0) \
291       if ((sigs)[signum]) \
292         (flags)[signum] = 0; \
293   } while (0)
294
295 /* Value to pass to target_resume() to cause all threads to resume.  */
296
297 #define RESUME_ALL minus_one_ptid
298
299 /* Command list pointer for the "stop" placeholder.  */
300
301 static struct cmd_list_element *stop_command;
302
303 /* Function inferior was in as of last step command.  */
304
305 static struct symbol *step_start_function;
306
307 /* Nonzero if we want to give control to the user when we're notified
308    of shared library events by the dynamic linker.  */
309 int stop_on_solib_events;
310 static void
311 show_stop_on_solib_events (struct ui_file *file, int from_tty,
312                            struct cmd_list_element *c, const char *value)
313 {
314   fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
315                     value);
316 }
317
318 /* Nonzero means expecting a trace trap
319    and should stop the inferior and return silently when it happens.  */
320
321 int stop_after_trap;
322
323 /* Save register contents here when executing a "finish" command or are
324    about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set.
325    Thus this contains the return value from the called function (assuming
326    values are returned in a register).  */
327
328 struct regcache *stop_registers;
329
330 /* Nonzero after stop if current stack frame should be printed.  */
331
332 static int stop_print_frame;
333
334 /* This is a cached copy of the pid/waitstatus of the last event
335    returned by target_wait()/deprecated_target_wait_hook().  This
336    information is returned by get_last_target_status().  */
337 static ptid_t target_last_wait_ptid;
338 static struct target_waitstatus target_last_waitstatus;
339
340 static void context_switch (ptid_t ptid);
341
342 void init_thread_stepping_state (struct thread_info *tss);
343
344 void init_infwait_state (void);
345
346 static const char follow_fork_mode_child[] = "child";
347 static const char follow_fork_mode_parent[] = "parent";
348
349 static const char *follow_fork_mode_kind_names[] = {
350   follow_fork_mode_child,
351   follow_fork_mode_parent,
352   NULL
353 };
354
355 static const char *follow_fork_mode_string = follow_fork_mode_parent;
356 static void
357 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
358                               struct cmd_list_element *c, const char *value)
359 {
360   fprintf_filtered (file,
361                     _("Debugger response to a program "
362                       "call of fork or vfork is \"%s\".\n"),
363                     value);
364 }
365 \f
366
367 /* Tell the target to follow the fork we're stopped at.  Returns true
368    if the inferior should be resumed; false, if the target for some
369    reason decided it's best not to resume.  */
370
371 static int
372 follow_fork (void)
373 {
374   int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
375   int should_resume = 1;
376   struct thread_info *tp;
377
378   /* Copy user stepping state to the new inferior thread.  FIXME: the
379      followed fork child thread should have a copy of most of the
380      parent thread structure's run control related fields, not just these.
381      Initialized to avoid "may be used uninitialized" warnings from gcc.  */
382   struct breakpoint *step_resume_breakpoint = NULL;
383   struct breakpoint *exception_resume_breakpoint = NULL;
384   CORE_ADDR step_range_start = 0;
385   CORE_ADDR step_range_end = 0;
386   struct frame_id step_frame_id = { 0 };
387
388   if (!non_stop)
389     {
390       ptid_t wait_ptid;
391       struct target_waitstatus wait_status;
392
393       /* Get the last target status returned by target_wait().  */
394       get_last_target_status (&wait_ptid, &wait_status);
395
396       /* If not stopped at a fork event, then there's nothing else to
397          do.  */
398       if (wait_status.kind != TARGET_WAITKIND_FORKED
399           && wait_status.kind != TARGET_WAITKIND_VFORKED)
400         return 1;
401
402       /* Check if we switched over from WAIT_PTID, since the event was
403          reported.  */
404       if (!ptid_equal (wait_ptid, minus_one_ptid)
405           && !ptid_equal (inferior_ptid, wait_ptid))
406         {
407           /* We did.  Switch back to WAIT_PTID thread, to tell the
408              target to follow it (in either direction).  We'll
409              afterwards refuse to resume, and inform the user what
410              happened.  */
411           switch_to_thread (wait_ptid);
412           should_resume = 0;
413         }
414     }
415
416   tp = inferior_thread ();
417
418   /* If there were any forks/vforks that were caught and are now to be
419      followed, then do so now.  */
420   switch (tp->pending_follow.kind)
421     {
422     case TARGET_WAITKIND_FORKED:
423     case TARGET_WAITKIND_VFORKED:
424       {
425         ptid_t parent, child;
426
427         /* If the user did a next/step, etc, over a fork call,
428            preserve the stepping state in the fork child.  */
429         if (follow_child && should_resume)
430           {
431             step_resume_breakpoint = clone_momentary_breakpoint
432                                          (tp->control.step_resume_breakpoint);
433             step_range_start = tp->control.step_range_start;
434             step_range_end = tp->control.step_range_end;
435             step_frame_id = tp->control.step_frame_id;
436             exception_resume_breakpoint
437               = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
438
439             /* For now, delete the parent's sr breakpoint, otherwise,
440                parent/child sr breakpoints are considered duplicates,
441                and the child version will not be installed.  Remove
442                this when the breakpoints module becomes aware of
443                inferiors and address spaces.  */
444             delete_step_resume_breakpoint (tp);
445             tp->control.step_range_start = 0;
446             tp->control.step_range_end = 0;
447             tp->control.step_frame_id = null_frame_id;
448             delete_exception_resume_breakpoint (tp);
449           }
450
451         parent = inferior_ptid;
452         child = tp->pending_follow.value.related_pid;
453
454         /* Tell the target to do whatever is necessary to follow
455            either parent or child.  */
456         if (target_follow_fork (follow_child))
457           {
458             /* Target refused to follow, or there's some other reason
459                we shouldn't resume.  */
460             should_resume = 0;
461           }
462         else
463           {
464             /* This pending follow fork event is now handled, one way
465                or another.  The previous selected thread may be gone
466                from the lists by now, but if it is still around, need
467                to clear the pending follow request.  */
468             tp = find_thread_ptid (parent);
469             if (tp)
470               tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
471
472             /* This makes sure we don't try to apply the "Switched
473                over from WAIT_PID" logic above.  */
474             nullify_last_target_wait_ptid ();
475
476             /* If we followed the child, switch to it...  */
477             if (follow_child)
478               {
479                 switch_to_thread (child);
480
481                 /* ... and preserve the stepping state, in case the
482                    user was stepping over the fork call.  */
483                 if (should_resume)
484                   {
485                     tp = inferior_thread ();
486                     tp->control.step_resume_breakpoint
487                       = step_resume_breakpoint;
488                     tp->control.step_range_start = step_range_start;
489                     tp->control.step_range_end = step_range_end;
490                     tp->control.step_frame_id = step_frame_id;
491                     tp->control.exception_resume_breakpoint
492                       = exception_resume_breakpoint;
493                   }
494                 else
495                   {
496                     /* If we get here, it was because we're trying to
497                        resume from a fork catchpoint, but, the user
498                        has switched threads away from the thread that
499                        forked.  In that case, the resume command
500                        issued is most likely not applicable to the
501                        child, so just warn, and refuse to resume.  */
502                     warning (_("Not resuming: switched threads "
503                                "before following fork child.\n"));
504                   }
505
506                 /* Reset breakpoints in the child as appropriate.  */
507                 follow_inferior_reset_breakpoints ();
508               }
509             else
510               switch_to_thread (parent);
511           }
512       }
513       break;
514     case TARGET_WAITKIND_SPURIOUS:
515       /* Nothing to follow.  */
516       break;
517     default:
518       internal_error (__FILE__, __LINE__,
519                       "Unexpected pending_follow.kind %d\n",
520                       tp->pending_follow.kind);
521       break;
522     }
523
524   return should_resume;
525 }
526
527 void
528 follow_inferior_reset_breakpoints (void)
529 {
530   struct thread_info *tp = inferior_thread ();
531
532   /* Was there a step_resume breakpoint?  (There was if the user
533      did a "next" at the fork() call.)  If so, explicitly reset its
534      thread number.
535
536      step_resumes are a form of bp that are made to be per-thread.
537      Since we created the step_resume bp when the parent process
538      was being debugged, and now are switching to the child process,
539      from the breakpoint package's viewpoint, that's a switch of
540      "threads".  We must update the bp's notion of which thread
541      it is for, or it'll be ignored when it triggers.  */
542
543   if (tp->control.step_resume_breakpoint)
544     breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
545
546   if (tp->control.exception_resume_breakpoint)
547     breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
548
549   /* Reinsert all breakpoints in the child.  The user may have set
550      breakpoints after catching the fork, in which case those
551      were never set in the child, but only in the parent.  This makes
552      sure the inserted breakpoints match the breakpoint list.  */
553
554   breakpoint_re_set ();
555   insert_breakpoints ();
556 }
557
558 /* The child has exited or execed: resume threads of the parent the
559    user wanted to be executing.  */
560
561 static int
562 proceed_after_vfork_done (struct thread_info *thread,
563                           void *arg)
564 {
565   int pid = * (int *) arg;
566
567   if (ptid_get_pid (thread->ptid) == pid
568       && is_running (thread->ptid)
569       && !is_executing (thread->ptid)
570       && !thread->stop_requested
571       && thread->suspend.stop_signal == TARGET_SIGNAL_0)
572     {
573       if (debug_infrun)
574         fprintf_unfiltered (gdb_stdlog,
575                             "infrun: resuming vfork parent thread %s\n",
576                             target_pid_to_str (thread->ptid));
577
578       switch_to_thread (thread->ptid);
579       clear_proceed_status ();
580       proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
581     }
582
583   return 0;
584 }
585
586 /* Called whenever we notice an exec or exit event, to handle
587    detaching or resuming a vfork parent.  */
588
589 static void
590 handle_vfork_child_exec_or_exit (int exec)
591 {
592   struct inferior *inf = current_inferior ();
593
594   if (inf->vfork_parent)
595     {
596       int resume_parent = -1;
597
598       /* This exec or exit marks the end of the shared memory region
599          between the parent and the child.  If the user wanted to
600          detach from the parent, now is the time.  */
601
602       if (inf->vfork_parent->pending_detach)
603         {
604           struct thread_info *tp;
605           struct cleanup *old_chain;
606           struct program_space *pspace;
607           struct address_space *aspace;
608
609           /* follow-fork child, detach-on-fork on.  */
610
611           old_chain = make_cleanup_restore_current_thread ();
612
613           /* We're letting loose of the parent.  */
614           tp = any_live_thread_of_process (inf->vfork_parent->pid);
615           switch_to_thread (tp->ptid);
616
617           /* We're about to detach from the parent, which implicitly
618              removes breakpoints from its address space.  There's a
619              catch here: we want to reuse the spaces for the child,
620              but, parent/child are still sharing the pspace at this
621              point, although the exec in reality makes the kernel give
622              the child a fresh set of new pages.  The problem here is
623              that the breakpoints module being unaware of this, would
624              likely chose the child process to write to the parent
625              address space.  Swapping the child temporarily away from
626              the spaces has the desired effect.  Yes, this is "sort
627              of" a hack.  */
628
629           pspace = inf->pspace;
630           aspace = inf->aspace;
631           inf->aspace = NULL;
632           inf->pspace = NULL;
633
634           if (debug_infrun || info_verbose)
635             {
636               target_terminal_ours ();
637
638               if (exec)
639                 fprintf_filtered (gdb_stdlog,
640                                   "Detaching vfork parent process "
641                                   "%d after child exec.\n",
642                                   inf->vfork_parent->pid);
643               else
644                 fprintf_filtered (gdb_stdlog,
645                                   "Detaching vfork parent process "
646                                   "%d after child exit.\n",
647                                   inf->vfork_parent->pid);
648             }
649
650           target_detach (NULL, 0);
651
652           /* Put it back.  */
653           inf->pspace = pspace;
654           inf->aspace = aspace;
655
656           do_cleanups (old_chain);
657         }
658       else if (exec)
659         {
660           /* We're staying attached to the parent, so, really give the
661              child a new address space.  */
662           inf->pspace = add_program_space (maybe_new_address_space ());
663           inf->aspace = inf->pspace->aspace;
664           inf->removable = 1;
665           set_current_program_space (inf->pspace);
666
667           resume_parent = inf->vfork_parent->pid;
668
669           /* Break the bonds.  */
670           inf->vfork_parent->vfork_child = NULL;
671         }
672       else
673         {
674           struct cleanup *old_chain;
675           struct program_space *pspace;
676
677           /* If this is a vfork child exiting, then the pspace and
678              aspaces were shared with the parent.  Since we're
679              reporting the process exit, we'll be mourning all that is
680              found in the address space, and switching to null_ptid,
681              preparing to start a new inferior.  But, since we don't
682              want to clobber the parent's address/program spaces, we
683              go ahead and create a new one for this exiting
684              inferior.  */
685
686           /* Switch to null_ptid, so that clone_program_space doesn't want
687              to read the selected frame of a dead process.  */
688           old_chain = save_inferior_ptid ();
689           inferior_ptid = null_ptid;
690
691           /* This inferior is dead, so avoid giving the breakpoints
692              module the option to write through to it (cloning a
693              program space resets breakpoints).  */
694           inf->aspace = NULL;
695           inf->pspace = NULL;
696           pspace = add_program_space (maybe_new_address_space ());
697           set_current_program_space (pspace);
698           inf->removable = 1;
699           clone_program_space (pspace, inf->vfork_parent->pspace);
700           inf->pspace = pspace;
701           inf->aspace = pspace->aspace;
702
703           /* Put back inferior_ptid.  We'll continue mourning this
704              inferior.  */
705           do_cleanups (old_chain);
706
707           resume_parent = inf->vfork_parent->pid;
708           /* Break the bonds.  */
709           inf->vfork_parent->vfork_child = NULL;
710         }
711
712       inf->vfork_parent = NULL;
713
714       gdb_assert (current_program_space == inf->pspace);
715
716       if (non_stop && resume_parent != -1)
717         {
718           /* If the user wanted the parent to be running, let it go
719              free now.  */
720           struct cleanup *old_chain = make_cleanup_restore_current_thread ();
721
722           if (debug_infrun)
723             fprintf_unfiltered (gdb_stdlog,
724                                 "infrun: resuming vfork parent process %d\n",
725                                 resume_parent);
726
727           iterate_over_threads (proceed_after_vfork_done, &resume_parent);
728
729           do_cleanups (old_chain);
730         }
731     }
732 }
733
734 /* Enum strings for "set|show displaced-stepping".  */
735
736 static const char follow_exec_mode_new[] = "new";
737 static const char follow_exec_mode_same[] = "same";
738 static const char *follow_exec_mode_names[] =
739 {
740   follow_exec_mode_new,
741   follow_exec_mode_same,
742   NULL,
743 };
744
745 static const char *follow_exec_mode_string = follow_exec_mode_same;
746 static void
747 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
748                               struct cmd_list_element *c, const char *value)
749 {
750   fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"),  value);
751 }
752
753 /* EXECD_PATHNAME is assumed to be non-NULL.  */
754
755 static void
756 follow_exec (ptid_t pid, char *execd_pathname)
757 {
758   struct thread_info *th = inferior_thread ();
759   struct inferior *inf = current_inferior ();
760
761   /* This is an exec event that we actually wish to pay attention to.
762      Refresh our symbol table to the newly exec'd program, remove any
763      momentary bp's, etc.
764
765      If there are breakpoints, they aren't really inserted now,
766      since the exec() transformed our inferior into a fresh set
767      of instructions.
768
769      We want to preserve symbolic breakpoints on the list, since
770      we have hopes that they can be reset after the new a.out's
771      symbol table is read.
772
773      However, any "raw" breakpoints must be removed from the list
774      (e.g., the solib bp's), since their address is probably invalid
775      now.
776
777      And, we DON'T want to call delete_breakpoints() here, since
778      that may write the bp's "shadow contents" (the instruction
779      value that was overwritten witha TRAP instruction).  Since
780      we now have a new a.out, those shadow contents aren't valid.  */
781
782   mark_breakpoints_out ();
783
784   update_breakpoints_after_exec ();
785
786   /* If there was one, it's gone now.  We cannot truly step-to-next
787      statement through an exec().  */
788   th->control.step_resume_breakpoint = NULL;
789   th->control.exception_resume_breakpoint = NULL;
790   th->control.step_range_start = 0;
791   th->control.step_range_end = 0;
792
793   /* The target reports the exec event to the main thread, even if
794      some other thread does the exec, and even if the main thread was
795      already stopped --- if debugging in non-stop mode, it's possible
796      the user had the main thread held stopped in the previous image
797      --- release it now.  This is the same behavior as step-over-exec
798      with scheduler-locking on in all-stop mode.  */
799   th->stop_requested = 0;
800
801   /* What is this a.out's name?  */
802   printf_unfiltered (_("%s is executing new program: %s\n"),
803                      target_pid_to_str (inferior_ptid),
804                      execd_pathname);
805
806   /* We've followed the inferior through an exec.  Therefore, the
807      inferior has essentially been killed & reborn.  */
808
809   gdb_flush (gdb_stdout);
810
811   breakpoint_init_inferior (inf_execd);
812
813   if (gdb_sysroot && *gdb_sysroot)
814     {
815       char *name = alloca (strlen (gdb_sysroot)
816                             + strlen (execd_pathname)
817                             + 1);
818
819       strcpy (name, gdb_sysroot);
820       strcat (name, execd_pathname);
821       execd_pathname = name;
822     }
823
824   /* Reset the shared library package.  This ensures that we get a
825      shlib event when the child reaches "_start", at which point the
826      dld will have had a chance to initialize the child.  */
827   /* Also, loading a symbol file below may trigger symbol lookups, and
828      we don't want those to be satisfied by the libraries of the
829      previous incarnation of this process.  */
830   no_shared_libraries (NULL, 0);
831
832   if (follow_exec_mode_string == follow_exec_mode_new)
833     {
834       struct program_space *pspace;
835
836       /* The user wants to keep the old inferior and program spaces
837          around.  Create a new fresh one, and switch to it.  */
838
839       inf = add_inferior (current_inferior ()->pid);
840       pspace = add_program_space (maybe_new_address_space ());
841       inf->pspace = pspace;
842       inf->aspace = pspace->aspace;
843
844       exit_inferior_num_silent (current_inferior ()->num);
845
846       set_current_inferior (inf);
847       set_current_program_space (pspace);
848     }
849
850   gdb_assert (current_program_space == inf->pspace);
851
852   /* That a.out is now the one to use.  */
853   exec_file_attach (execd_pathname, 0);
854
855   /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
856      (Position Independent Executable) main symbol file will get applied by
857      solib_create_inferior_hook below.  breakpoint_re_set would fail to insert
858      the breakpoints with the zero displacement.  */
859
860   symbol_file_add (execd_pathname, SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET,
861                    NULL, 0);
862
863   set_initial_language ();
864
865 #ifdef SOLIB_CREATE_INFERIOR_HOOK
866   SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
867 #else
868   solib_create_inferior_hook (0);
869 #endif
870
871   jit_inferior_created_hook ();
872
873   breakpoint_re_set ();
874
875   /* Reinsert all breakpoints.  (Those which were symbolic have
876      been reset to the proper address in the new a.out, thanks
877      to symbol_file_command...).  */
878   insert_breakpoints ();
879
880   /* The next resume of this inferior should bring it to the shlib
881      startup breakpoints.  (If the user had also set bp's on
882      "main" from the old (parent) process, then they'll auto-
883      matically get reset there in the new process.).  */
884 }
885
886 /* Non-zero if we just simulating a single-step.  This is needed
887    because we cannot remove the breakpoints in the inferior process
888    until after the `wait' in `wait_for_inferior'.  */
889 static int singlestep_breakpoints_inserted_p = 0;
890
891 /* The thread we inserted single-step breakpoints for.  */
892 static ptid_t singlestep_ptid;
893
894 /* PC when we started this single-step.  */
895 static CORE_ADDR singlestep_pc;
896
897 /* If another thread hit the singlestep breakpoint, we save the original
898    thread here so that we can resume single-stepping it later.  */
899 static ptid_t saved_singlestep_ptid;
900 static int stepping_past_singlestep_breakpoint;
901
902 /* If not equal to null_ptid, this means that after stepping over breakpoint
903    is finished, we need to switch to deferred_step_ptid, and step it.
904
905    The use case is when one thread has hit a breakpoint, and then the user 
906    has switched to another thread and issued 'step'.  We need to step over
907    breakpoint in the thread which hit the breakpoint, but then continue
908    stepping the thread user has selected.  */
909 static ptid_t deferred_step_ptid;
910 \f
911 /* Displaced stepping.  */
912
913 /* In non-stop debugging mode, we must take special care to manage
914    breakpoints properly; in particular, the traditional strategy for
915    stepping a thread past a breakpoint it has hit is unsuitable.
916    'Displaced stepping' is a tactic for stepping one thread past a
917    breakpoint it has hit while ensuring that other threads running
918    concurrently will hit the breakpoint as they should.
919
920    The traditional way to step a thread T off a breakpoint in a
921    multi-threaded program in all-stop mode is as follows:
922
923    a0) Initially, all threads are stopped, and breakpoints are not
924        inserted.
925    a1) We single-step T, leaving breakpoints uninserted.
926    a2) We insert breakpoints, and resume all threads.
927
928    In non-stop debugging, however, this strategy is unsuitable: we
929    don't want to have to stop all threads in the system in order to
930    continue or step T past a breakpoint.  Instead, we use displaced
931    stepping:
932
933    n0) Initially, T is stopped, other threads are running, and
934        breakpoints are inserted.
935    n1) We copy the instruction "under" the breakpoint to a separate
936        location, outside the main code stream, making any adjustments
937        to the instruction, register, and memory state as directed by
938        T's architecture.
939    n2) We single-step T over the instruction at its new location.
940    n3) We adjust the resulting register and memory state as directed
941        by T's architecture.  This includes resetting T's PC to point
942        back into the main instruction stream.
943    n4) We resume T.
944
945    This approach depends on the following gdbarch methods:
946
947    - gdbarch_max_insn_length and gdbarch_displaced_step_location
948      indicate where to copy the instruction, and how much space must
949      be reserved there.  We use these in step n1.
950
951    - gdbarch_displaced_step_copy_insn copies a instruction to a new
952      address, and makes any necessary adjustments to the instruction,
953      register contents, and memory.  We use this in step n1.
954
955    - gdbarch_displaced_step_fixup adjusts registers and memory after
956      we have successfuly single-stepped the instruction, to yield the
957      same effect the instruction would have had if we had executed it
958      at its original address.  We use this in step n3.
959
960    - gdbarch_displaced_step_free_closure provides cleanup.
961
962    The gdbarch_displaced_step_copy_insn and
963    gdbarch_displaced_step_fixup functions must be written so that
964    copying an instruction with gdbarch_displaced_step_copy_insn,
965    single-stepping across the copied instruction, and then applying
966    gdbarch_displaced_insn_fixup should have the same effects on the
967    thread's memory and registers as stepping the instruction in place
968    would have.  Exactly which responsibilities fall to the copy and
969    which fall to the fixup is up to the author of those functions.
970
971    See the comments in gdbarch.sh for details.
972
973    Note that displaced stepping and software single-step cannot
974    currently be used in combination, although with some care I think
975    they could be made to.  Software single-step works by placing
976    breakpoints on all possible subsequent instructions; if the
977    displaced instruction is a PC-relative jump, those breakpoints
978    could fall in very strange places --- on pages that aren't
979    executable, or at addresses that are not proper instruction
980    boundaries.  (We do generally let other threads run while we wait
981    to hit the software single-step breakpoint, and they might
982    encounter such a corrupted instruction.)  One way to work around
983    this would be to have gdbarch_displaced_step_copy_insn fully
984    simulate the effect of PC-relative instructions (and return NULL)
985    on architectures that use software single-stepping.
986
987    In non-stop mode, we can have independent and simultaneous step
988    requests, so more than one thread may need to simultaneously step
989    over a breakpoint.  The current implementation assumes there is
990    only one scratch space per process.  In this case, we have to
991    serialize access to the scratch space.  If thread A wants to step
992    over a breakpoint, but we are currently waiting for some other
993    thread to complete a displaced step, we leave thread A stopped and
994    place it in the displaced_step_request_queue.  Whenever a displaced
995    step finishes, we pick the next thread in the queue and start a new
996    displaced step operation on it.  See displaced_step_prepare and
997    displaced_step_fixup for details.  */
998
999 struct displaced_step_request
1000 {
1001   ptid_t ptid;
1002   struct displaced_step_request *next;
1003 };
1004
1005 /* Per-inferior displaced stepping state.  */
1006 struct displaced_step_inferior_state
1007 {
1008   /* Pointer to next in linked list.  */
1009   struct displaced_step_inferior_state *next;
1010
1011   /* The process this displaced step state refers to.  */
1012   int pid;
1013
1014   /* A queue of pending displaced stepping requests.  One entry per
1015      thread that needs to do a displaced step.  */
1016   struct displaced_step_request *step_request_queue;
1017
1018   /* If this is not null_ptid, this is the thread carrying out a
1019      displaced single-step in process PID.  This thread's state will
1020      require fixing up once it has completed its step.  */
1021   ptid_t step_ptid;
1022
1023   /* The architecture the thread had when we stepped it.  */
1024   struct gdbarch *step_gdbarch;
1025
1026   /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1027      for post-step cleanup.  */
1028   struct displaced_step_closure *step_closure;
1029
1030   /* The address of the original instruction, and the copy we
1031      made.  */
1032   CORE_ADDR step_original, step_copy;
1033
1034   /* Saved contents of copy area.  */
1035   gdb_byte *step_saved_copy;
1036 };
1037
1038 /* The list of states of processes involved in displaced stepping
1039    presently.  */
1040 static struct displaced_step_inferior_state *displaced_step_inferior_states;
1041
1042 /* Get the displaced stepping state of process PID.  */
1043
1044 static struct displaced_step_inferior_state *
1045 get_displaced_stepping_state (int pid)
1046 {
1047   struct displaced_step_inferior_state *state;
1048
1049   for (state = displaced_step_inferior_states;
1050        state != NULL;
1051        state = state->next)
1052     if (state->pid == pid)
1053       return state;
1054
1055   return NULL;
1056 }
1057
1058 /* Add a new displaced stepping state for process PID to the displaced
1059    stepping state list, or return a pointer to an already existing
1060    entry, if it already exists.  Never returns NULL.  */
1061
1062 static struct displaced_step_inferior_state *
1063 add_displaced_stepping_state (int pid)
1064 {
1065   struct displaced_step_inferior_state *state;
1066
1067   for (state = displaced_step_inferior_states;
1068        state != NULL;
1069        state = state->next)
1070     if (state->pid == pid)
1071       return state;
1072
1073   state = xcalloc (1, sizeof (*state));
1074   state->pid = pid;
1075   state->next = displaced_step_inferior_states;
1076   displaced_step_inferior_states = state;
1077
1078   return state;
1079 }
1080
1081 /* If inferior is in displaced stepping, and ADDR equals to starting address
1082    of copy area, return corresponding displaced_step_closure.  Otherwise,
1083    return NULL.  */
1084
1085 struct displaced_step_closure*
1086 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1087 {
1088   struct displaced_step_inferior_state *displaced
1089     = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1090
1091   /* If checking the mode of displaced instruction in copy area.  */
1092   if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1093      && (displaced->step_copy == addr))
1094     return displaced->step_closure;
1095
1096   return NULL;
1097 }
1098
1099 /* Remove the displaced stepping state of process PID.  */
1100
1101 static void
1102 remove_displaced_stepping_state (int pid)
1103 {
1104   struct displaced_step_inferior_state *it, **prev_next_p;
1105
1106   gdb_assert (kernel_debugger || (pid != 0));
1107
1108   it = displaced_step_inferior_states;
1109   prev_next_p = &displaced_step_inferior_states;
1110   while (it)
1111     {
1112       if (it->pid == pid)
1113         {
1114           *prev_next_p = it->next;
1115           xfree (it);
1116           return;
1117         }
1118
1119       prev_next_p = &it->next;
1120       it = *prev_next_p;
1121     }
1122 }
1123
1124 static void
1125 infrun_inferior_exit (struct inferior *inf)
1126 {
1127   remove_displaced_stepping_state (inf->pid);
1128 }
1129
1130 /* Enum strings for "set|show displaced-stepping".  */
1131
1132 static const char can_use_displaced_stepping_auto[] = "auto";
1133 static const char can_use_displaced_stepping_on[] = "on";
1134 static const char can_use_displaced_stepping_off[] = "off";
1135 static const char *can_use_displaced_stepping_enum[] =
1136 {
1137   can_use_displaced_stepping_auto,
1138   can_use_displaced_stepping_on,
1139   can_use_displaced_stepping_off,
1140   NULL,
1141 };
1142
1143 /* If ON, and the architecture supports it, GDB will use displaced
1144    stepping to step over breakpoints.  If OFF, or if the architecture
1145    doesn't support it, GDB will instead use the traditional
1146    hold-and-step approach.  If AUTO (which is the default), GDB will
1147    decide which technique to use to step over breakpoints depending on
1148    which of all-stop or non-stop mode is active --- displaced stepping
1149    in non-stop mode; hold-and-step in all-stop mode.  */
1150
1151 static const char *can_use_displaced_stepping =
1152   can_use_displaced_stepping_auto;
1153
1154 static void
1155 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1156                                  struct cmd_list_element *c,
1157                                  const char *value)
1158 {
1159   if (can_use_displaced_stepping == can_use_displaced_stepping_auto)
1160     fprintf_filtered (file,
1161                       _("Debugger's willingness to use displaced stepping "
1162                         "to step over breakpoints is %s (currently %s).\n"),
1163                       value, non_stop ? "on" : "off");
1164   else
1165     fprintf_filtered (file,
1166                       _("Debugger's willingness to use displaced stepping "
1167                         "to step over breakpoints is %s.\n"), value);
1168 }
1169
1170 /* Return non-zero if displaced stepping can/should be used to step
1171    over breakpoints.  */
1172
1173 static int
1174 use_displaced_stepping (struct gdbarch *gdbarch)
1175 {
1176   return (((can_use_displaced_stepping == can_use_displaced_stepping_auto
1177             && non_stop)
1178            || can_use_displaced_stepping == can_use_displaced_stepping_on)
1179           && gdbarch_displaced_step_copy_insn_p (gdbarch)
1180           && !RECORD_IS_USED);
1181 }
1182
1183 /* Clean out any stray displaced stepping state.  */
1184 static void
1185 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1186 {
1187   /* Indicate that there is no cleanup pending.  */
1188   displaced->step_ptid = null_ptid;
1189
1190   if (displaced->step_closure)
1191     {
1192       gdbarch_displaced_step_free_closure (displaced->step_gdbarch,
1193                                            displaced->step_closure);
1194       displaced->step_closure = NULL;
1195     }
1196 }
1197
1198 static void
1199 displaced_step_clear_cleanup (void *arg)
1200 {
1201   struct displaced_step_inferior_state *state = arg;
1202
1203   displaced_step_clear (state);
1204 }
1205
1206 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline.  */
1207 void
1208 displaced_step_dump_bytes (struct ui_file *file,
1209                            const gdb_byte *buf,
1210                            size_t len)
1211 {
1212   int i;
1213
1214   for (i = 0; i < len; i++)
1215     fprintf_unfiltered (file, "%02x ", buf[i]);
1216   fputs_unfiltered ("\n", file);
1217 }
1218
1219 /* Prepare to single-step, using displaced stepping.
1220
1221    Note that we cannot use displaced stepping when we have a signal to
1222    deliver.  If we have a signal to deliver and an instruction to step
1223    over, then after the step, there will be no indication from the
1224    target whether the thread entered a signal handler or ignored the
1225    signal and stepped over the instruction successfully --- both cases
1226    result in a simple SIGTRAP.  In the first case we mustn't do a
1227    fixup, and in the second case we must --- but we can't tell which.
1228    Comments in the code for 'random signals' in handle_inferior_event
1229    explain how we handle this case instead.
1230
1231    Returns 1 if preparing was successful -- this thread is going to be
1232    stepped now; or 0 if displaced stepping this thread got queued.  */
1233 static int
1234 displaced_step_prepare (ptid_t ptid)
1235 {
1236   struct cleanup *old_cleanups, *ignore_cleanups;
1237   struct regcache *regcache = get_thread_regcache (ptid);
1238   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1239   CORE_ADDR original, copy;
1240   ULONGEST len;
1241   struct displaced_step_closure *closure;
1242   struct displaced_step_inferior_state *displaced;
1243
1244   /* We should never reach this function if the architecture does not
1245      support displaced stepping.  */
1246   gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1247
1248   /* We have to displaced step one thread at a time, as we only have
1249      access to a single scratch space per inferior.  */
1250
1251   displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1252
1253   if (!ptid_equal (displaced->step_ptid, null_ptid))
1254     {
1255       /* Already waiting for a displaced step to finish.  Defer this
1256          request and place in queue.  */
1257       struct displaced_step_request *req, *new_req;
1258
1259       if (debug_displaced)
1260         fprintf_unfiltered (gdb_stdlog,
1261                             "displaced: defering step of %s\n",
1262                             target_pid_to_str (ptid));
1263
1264       new_req = xmalloc (sizeof (*new_req));
1265       new_req->ptid = ptid;
1266       new_req->next = NULL;
1267
1268       if (displaced->step_request_queue)
1269         {
1270           for (req = displaced->step_request_queue;
1271                req && req->next;
1272                req = req->next)
1273             ;
1274           req->next = new_req;
1275         }
1276       else
1277         displaced->step_request_queue = new_req;
1278
1279       return 0;
1280     }
1281   else
1282     {
1283       if (debug_displaced)
1284         fprintf_unfiltered (gdb_stdlog,
1285                             "displaced: stepping %s now\n",
1286                             target_pid_to_str (ptid));
1287     }
1288
1289   displaced_step_clear (displaced);
1290
1291   old_cleanups = save_inferior_ptid ();
1292   inferior_ptid = ptid;
1293
1294   original = regcache_read_pc (regcache);
1295
1296   copy = gdbarch_displaced_step_location (gdbarch);
1297   len = gdbarch_max_insn_length (gdbarch);
1298
1299   /* Save the original contents of the copy area.  */
1300   displaced->step_saved_copy = xmalloc (len);
1301   ignore_cleanups = make_cleanup (free_current_contents,
1302                                   &displaced->step_saved_copy);
1303   read_memory (copy, displaced->step_saved_copy, len);
1304   if (debug_displaced)
1305     {
1306       fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1307                           paddress (gdbarch, copy));
1308       displaced_step_dump_bytes (gdb_stdlog,
1309                                  displaced->step_saved_copy,
1310                                  len);
1311     };
1312
1313   closure = gdbarch_displaced_step_copy_insn (gdbarch,
1314                                               original, copy, regcache);
1315
1316   /* We don't support the fully-simulated case at present.  */
1317   gdb_assert (closure);
1318
1319   /* Save the information we need to fix things up if the step
1320      succeeds.  */
1321   displaced->step_ptid = ptid;
1322   displaced->step_gdbarch = gdbarch;
1323   displaced->step_closure = closure;
1324   displaced->step_original = original;
1325   displaced->step_copy = copy;
1326
1327   make_cleanup (displaced_step_clear_cleanup, displaced);
1328
1329   /* Resume execution at the copy.  */
1330   regcache_write_pc (regcache, copy);
1331
1332   discard_cleanups (ignore_cleanups);
1333
1334   do_cleanups (old_cleanups);
1335
1336   if (debug_displaced)
1337     fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1338                         paddress (gdbarch, copy));
1339
1340   return 1;
1341 }
1342
1343 static void
1344 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1345                    const gdb_byte *myaddr, int len)
1346 {
1347   struct cleanup *ptid_cleanup = save_inferior_ptid ();
1348
1349   inferior_ptid = ptid;
1350   write_memory (memaddr, myaddr, len);
1351   do_cleanups (ptid_cleanup);
1352 }
1353
1354 static void
1355 displaced_step_fixup (ptid_t event_ptid, enum target_signal signal)
1356 {
1357   struct cleanup *old_cleanups;
1358   struct displaced_step_inferior_state *displaced
1359     = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1360
1361   /* Was any thread of this process doing a displaced step?  */
1362   if (displaced == NULL)
1363     return;
1364
1365   /* Was this event for the pid we displaced?  */
1366   if (ptid_equal (displaced->step_ptid, null_ptid)
1367       || ! ptid_equal (displaced->step_ptid, event_ptid))
1368     return;
1369
1370   old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1371
1372   /* Restore the contents of the copy area.  */
1373   {
1374     ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1375
1376     write_memory_ptid (displaced->step_ptid, displaced->step_copy,
1377                        displaced->step_saved_copy, len);
1378     if (debug_displaced)
1379       fprintf_unfiltered (gdb_stdlog, "displaced: restored %s\n",
1380                           paddress (displaced->step_gdbarch,
1381                                     displaced->step_copy));
1382   }
1383
1384   /* Did the instruction complete successfully?  */
1385   if (signal == TARGET_SIGNAL_TRAP)
1386     {
1387       /* Fix up the resulting state.  */
1388       gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1389                                     displaced->step_closure,
1390                                     displaced->step_original,
1391                                     displaced->step_copy,
1392                                     get_thread_regcache (displaced->step_ptid));
1393     }
1394   else
1395     {
1396       /* Since the instruction didn't complete, all we can do is
1397          relocate the PC.  */
1398       struct regcache *regcache = get_thread_regcache (event_ptid);
1399       CORE_ADDR pc = regcache_read_pc (regcache);
1400
1401       pc = displaced->step_original + (pc - displaced->step_copy);
1402       regcache_write_pc (regcache, pc);
1403     }
1404
1405   do_cleanups (old_cleanups);
1406
1407   displaced->step_ptid = null_ptid;
1408
1409   /* Are there any pending displaced stepping requests?  If so, run
1410      one now.  Leave the state object around, since we're likely to
1411      need it again soon.  */
1412   while (displaced->step_request_queue)
1413     {
1414       struct displaced_step_request *head;
1415       ptid_t ptid;
1416       struct regcache *regcache;
1417       struct gdbarch *gdbarch;
1418       CORE_ADDR actual_pc;
1419       struct address_space *aspace;
1420
1421       head = displaced->step_request_queue;
1422       ptid = head->ptid;
1423       displaced->step_request_queue = head->next;
1424       xfree (head);
1425
1426       context_switch (ptid);
1427
1428       regcache = get_thread_regcache (ptid);
1429       actual_pc = regcache_read_pc (regcache);
1430       aspace = get_regcache_aspace (regcache);
1431
1432       if (breakpoint_here_p (aspace, actual_pc))
1433         {
1434           if (debug_displaced)
1435             fprintf_unfiltered (gdb_stdlog,
1436                                 "displaced: stepping queued %s now\n",
1437                                 target_pid_to_str (ptid));
1438
1439           displaced_step_prepare (ptid);
1440
1441           gdbarch = get_regcache_arch (regcache);
1442
1443           if (debug_displaced)
1444             {
1445               CORE_ADDR actual_pc = regcache_read_pc (regcache);
1446               gdb_byte buf[4];
1447
1448               fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1449                                   paddress (gdbarch, actual_pc));
1450               read_memory (actual_pc, buf, sizeof (buf));
1451               displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1452             }
1453
1454           if (gdbarch_displaced_step_hw_singlestep (gdbarch,
1455                                                     displaced->step_closure))
1456             target_resume (ptid, 1, TARGET_SIGNAL_0);
1457           else
1458             target_resume (ptid, 0, TARGET_SIGNAL_0);
1459
1460           /* Done, we're stepping a thread.  */
1461           break;
1462         }
1463       else
1464         {
1465           int step;
1466           struct thread_info *tp = inferior_thread ();
1467
1468           /* The breakpoint we were sitting under has since been
1469              removed.  */
1470           tp->control.trap_expected = 0;
1471
1472           /* Go back to what we were trying to do.  */
1473           step = currently_stepping (tp);
1474
1475           if (debug_displaced)
1476             fprintf_unfiltered (gdb_stdlog,
1477                                 "breakpoint is gone %s: step(%d)\n",
1478                                 target_pid_to_str (tp->ptid), step);
1479
1480           target_resume (ptid, step, TARGET_SIGNAL_0);
1481           tp->suspend.stop_signal = TARGET_SIGNAL_0;
1482
1483           /* This request was discarded.  See if there's any other
1484              thread waiting for its turn.  */
1485         }
1486     }
1487 }
1488
1489 /* Update global variables holding ptids to hold NEW_PTID if they were
1490    holding OLD_PTID.  */
1491 static void
1492 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
1493 {
1494   struct displaced_step_request *it;
1495   struct displaced_step_inferior_state *displaced;
1496
1497   if (ptid_equal (inferior_ptid, old_ptid))
1498     inferior_ptid = new_ptid;
1499
1500   if (ptid_equal (singlestep_ptid, old_ptid))
1501     singlestep_ptid = new_ptid;
1502
1503   if (ptid_equal (deferred_step_ptid, old_ptid))
1504     deferred_step_ptid = new_ptid;
1505
1506   for (displaced = displaced_step_inferior_states;
1507        displaced;
1508        displaced = displaced->next)
1509     {
1510       if (ptid_equal (displaced->step_ptid, old_ptid))
1511         displaced->step_ptid = new_ptid;
1512
1513       for (it = displaced->step_request_queue; it; it = it->next)
1514         if (ptid_equal (it->ptid, old_ptid))
1515           it->ptid = new_ptid;
1516     }
1517 }
1518
1519 \f
1520 /* Resuming.  */
1521
1522 /* Things to clean up if we QUIT out of resume ().  */
1523 static void
1524 resume_cleanups (void *ignore)
1525 {
1526   normal_stop ();
1527 }
1528
1529 static const char schedlock_off[] = "off";
1530 static const char schedlock_on[] = "on";
1531 static const char schedlock_step[] = "step";
1532 static const char *scheduler_enums[] = {
1533   schedlock_off,
1534   schedlock_on,
1535   schedlock_step,
1536   NULL
1537 };
1538 static const char *scheduler_mode = schedlock_off;
1539 static void
1540 show_scheduler_mode (struct ui_file *file, int from_tty,
1541                      struct cmd_list_element *c, const char *value)
1542 {
1543   fprintf_filtered (file,
1544                     _("Mode for locking scheduler "
1545                       "during execution is \"%s\".\n"),
1546                     value);
1547 }
1548
1549 static void
1550 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
1551 {
1552   if (!target_can_lock_scheduler)
1553     {
1554       scheduler_mode = schedlock_off;
1555       error (_("Target '%s' cannot support this command."), target_shortname);
1556     }
1557 }
1558
1559 /* True if execution commands resume all threads of all processes by
1560    default; otherwise, resume only threads of the current inferior
1561    process.  */
1562 int sched_multi = 0;
1563
1564 /* Try to setup for software single stepping over the specified location.
1565    Return 1 if target_resume() should use hardware single step.
1566
1567    GDBARCH the current gdbarch.
1568    PC the location to step over.  */
1569
1570 static int
1571 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
1572 {
1573   int hw_step = 1;
1574
1575   if (execution_direction == EXEC_FORWARD
1576       && gdbarch_software_single_step_p (gdbarch)
1577       && gdbarch_software_single_step (gdbarch, get_current_frame ()))
1578     {
1579       hw_step = 0;
1580       /* Do not pull these breakpoints until after a `wait' in
1581          `wait_for_inferior'.  */
1582       singlestep_breakpoints_inserted_p = 1;
1583       singlestep_ptid = inferior_ptid;
1584       singlestep_pc = pc;
1585     }
1586   return hw_step;
1587 }
1588
1589 /* Resume the inferior, but allow a QUIT.  This is useful if the user
1590    wants to interrupt some lengthy single-stepping operation
1591    (for child processes, the SIGINT goes to the inferior, and so
1592    we get a SIGINT random_signal, but for remote debugging and perhaps
1593    other targets, that's not true).
1594
1595    STEP nonzero if we should step (zero to continue instead).
1596    SIG is the signal to give the inferior (zero for none).  */
1597 void
1598 resume (int step, enum target_signal sig)
1599 {
1600   int should_resume = 1;
1601   struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
1602   struct regcache *regcache = get_current_regcache ();
1603   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1604   struct thread_info *tp = inferior_thread ();
1605   CORE_ADDR pc = regcache_read_pc (regcache);
1606   struct address_space *aspace = get_regcache_aspace (regcache);
1607
1608   QUIT;
1609
1610   if (current_inferior ()->waiting_for_vfork_done)
1611     {
1612       /* Don't try to single-step a vfork parent that is waiting for
1613          the child to get out of the shared memory region (by exec'ing
1614          or exiting).  This is particularly important on software
1615          single-step archs, as the child process would trip on the
1616          software single step breakpoint inserted for the parent
1617          process.  Since the parent will not actually execute any
1618          instruction until the child is out of the shared region (such
1619          are vfork's semantics), it is safe to simply continue it.
1620          Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
1621          the parent, and tell it to `keep_going', which automatically
1622          re-sets it stepping.  */
1623       if (debug_infrun)
1624         fprintf_unfiltered (gdb_stdlog,
1625                             "infrun: resume : clear step\n");
1626       step = 0;
1627     }
1628
1629   if (debug_infrun)
1630     fprintf_unfiltered (gdb_stdlog,
1631                         "infrun: resume (step=%d, signal=%d), "
1632                         "trap_expected=%d\n",
1633                         step, sig, tp->control.trap_expected);
1634
1635   /* Normally, by the time we reach `resume', the breakpoints are either
1636      removed or inserted, as appropriate.  The exception is if we're sitting
1637      at a permanent breakpoint; we need to step over it, but permanent
1638      breakpoints can't be removed.  So we have to test for it here.  */
1639   if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
1640     {
1641       if (gdbarch_skip_permanent_breakpoint_p (gdbarch))
1642         gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
1643       else
1644         error (_("\
1645 The program is stopped at a permanent breakpoint, but GDB does not know\n\
1646 how to step past a permanent breakpoint on this architecture.  Try using\n\
1647 a command like `return' or `jump' to continue execution."));
1648     }
1649
1650   /* If enabled, step over breakpoints by executing a copy of the
1651      instruction at a different address.
1652
1653      We can't use displaced stepping when we have a signal to deliver;
1654      the comments for displaced_step_prepare explain why.  The
1655      comments in the handle_inferior event for dealing with 'random
1656      signals' explain what we do instead.
1657
1658      We can't use displaced stepping when we are waiting for vfork_done
1659      event, displaced stepping breaks the vfork child similarly as single
1660      step software breakpoint.  */
1661   if (use_displaced_stepping (gdbarch)
1662       && (tp->control.trap_expected
1663           || (step && gdbarch_software_single_step_p (gdbarch)))
1664       && sig == TARGET_SIGNAL_0
1665       && !current_inferior ()->waiting_for_vfork_done)
1666     {
1667       struct displaced_step_inferior_state *displaced;
1668
1669       if (!displaced_step_prepare (inferior_ptid))
1670         {
1671           /* Got placed in displaced stepping queue.  Will be resumed
1672              later when all the currently queued displaced stepping
1673              requests finish.  The thread is not executing at this point,
1674              and the call to set_executing will be made later.  But we
1675              need to call set_running here, since from frontend point of view,
1676              the thread is running.  */
1677           set_running (inferior_ptid, 1);
1678           discard_cleanups (old_cleanups);
1679           return;
1680         }
1681
1682       displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1683       step = gdbarch_displaced_step_hw_singlestep (gdbarch,
1684                                                    displaced->step_closure);
1685     }
1686
1687   /* Do we need to do it the hard way, w/temp breakpoints?  */
1688   else if (step)
1689     step = maybe_software_singlestep (gdbarch, pc);
1690
1691   if (should_resume)
1692     {
1693       ptid_t resume_ptid;
1694
1695       /* If STEP is set, it's a request to use hardware stepping
1696          facilities.  But in that case, we should never
1697          use singlestep breakpoint.  */
1698       gdb_assert (!(singlestep_breakpoints_inserted_p && step));
1699
1700       /* Decide the set of threads to ask the target to resume.  Start
1701          by assuming everything will be resumed, than narrow the set
1702          by applying increasingly restricting conditions.  */
1703
1704       /* By default, resume all threads of all processes.  */
1705       resume_ptid = RESUME_ALL;
1706
1707       /* Maybe resume only all threads of the current process.  */
1708       if (!sched_multi && target_supports_multi_process ())
1709         {
1710           resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1711         }
1712
1713       /* Maybe resume a single thread after all.  */
1714       if (singlestep_breakpoints_inserted_p
1715           && stepping_past_singlestep_breakpoint)
1716         {
1717           /* The situation here is as follows.  In thread T1 we wanted to
1718              single-step.  Lacking hardware single-stepping we've
1719              set breakpoint at the PC of the next instruction -- call it
1720              P.  After resuming, we've hit that breakpoint in thread T2.
1721              Now we've removed original breakpoint, inserted breakpoint
1722              at P+1, and try to step to advance T2 past breakpoint.
1723              We need to step only T2, as if T1 is allowed to freely run,
1724              it can run past P, and if other threads are allowed to run,
1725              they can hit breakpoint at P+1, and nested hits of single-step
1726              breakpoints is not something we'd want -- that's complicated
1727              to support, and has no value.  */
1728           resume_ptid = inferior_ptid;
1729         }
1730       else if ((step || singlestep_breakpoints_inserted_p)
1731                && tp->control.trap_expected)
1732         {
1733           /* We're allowing a thread to run past a breakpoint it has
1734              hit, by single-stepping the thread with the breakpoint
1735              removed.  In which case, we need to single-step only this
1736              thread, and keep others stopped, as they can miss this
1737              breakpoint if allowed to run.
1738
1739              The current code actually removes all breakpoints when
1740              doing this, not just the one being stepped over, so if we
1741              let other threads run, we can actually miss any
1742              breakpoint, not just the one at PC.  */
1743           resume_ptid = inferior_ptid;
1744         }
1745       else if (non_stop)
1746         {
1747           /* With non-stop mode on, threads are always handled
1748              individually.  */
1749           resume_ptid = inferior_ptid;
1750         }
1751       else if ((scheduler_mode == schedlock_on)
1752                || (scheduler_mode == schedlock_step
1753                    && (step || singlestep_breakpoints_inserted_p)))
1754         {
1755           /* User-settable 'scheduler' mode requires solo thread resume.  */
1756           resume_ptid = inferior_ptid;
1757         }
1758
1759       if (gdbarch_cannot_step_breakpoint (gdbarch))
1760         {
1761           /* Most targets can step a breakpoint instruction, thus
1762              executing it normally.  But if this one cannot, just
1763              continue and we will hit it anyway.  */
1764           if (step && breakpoint_inserted_here_p (aspace, pc))
1765             step = 0;
1766         }
1767
1768       if (debug_displaced
1769           && use_displaced_stepping (gdbarch)
1770           && tp->control.trap_expected)
1771         {
1772           struct regcache *resume_regcache = get_thread_regcache (resume_ptid);
1773           struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
1774           CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
1775           gdb_byte buf[4];
1776
1777           fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1778                               paddress (resume_gdbarch, actual_pc));
1779           read_memory (actual_pc, buf, sizeof (buf));
1780           displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1781         }
1782
1783       /* Install inferior's terminal modes.  */
1784       target_terminal_inferior ();
1785
1786       /* Avoid confusing the next resume, if the next stop/resume
1787          happens to apply to another thread.  */
1788       tp->suspend.stop_signal = TARGET_SIGNAL_0;
1789
1790       target_resume (resume_ptid, step, sig);
1791     }
1792
1793   discard_cleanups (old_cleanups);
1794 }
1795 \f
1796 /* Proceeding.  */
1797
1798 /* Clear out all variables saying what to do when inferior is continued.
1799    First do this, then set the ones you want, then call `proceed'.  */
1800
1801 static void
1802 clear_proceed_status_thread (struct thread_info *tp)
1803 {
1804   if (debug_infrun)
1805     fprintf_unfiltered (gdb_stdlog,
1806                         "infrun: clear_proceed_status_thread (%s)\n",
1807                         target_pid_to_str (tp->ptid));
1808
1809   tp->control.trap_expected = 0;
1810   tp->control.step_range_start = 0;
1811   tp->control.step_range_end = 0;
1812   tp->control.step_frame_id = null_frame_id;
1813   tp->control.step_stack_frame_id = null_frame_id;
1814   tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
1815   tp->stop_requested = 0;
1816
1817   tp->control.stop_step = 0;
1818
1819   tp->control.proceed_to_finish = 0;
1820
1821   /* Discard any remaining commands or status from previous stop.  */
1822   bpstat_clear (&tp->control.stop_bpstat);
1823 }
1824
1825 static int
1826 clear_proceed_status_callback (struct thread_info *tp, void *data)
1827 {
1828   if (is_exited (tp->ptid))
1829     return 0;
1830
1831   clear_proceed_status_thread (tp);
1832   return 0;
1833 }
1834
1835 void
1836 clear_proceed_status (void)
1837 {
1838   if (!non_stop)
1839     {
1840       /* In all-stop mode, delete the per-thread status of all
1841          threads, even if inferior_ptid is null_ptid, there may be
1842          threads on the list.  E.g., we may be launching a new
1843          process, while selecting the executable.  */
1844       iterate_over_threads (clear_proceed_status_callback, NULL);
1845     }
1846
1847   if (!ptid_equal (inferior_ptid, null_ptid))
1848     {
1849       struct inferior *inferior;
1850
1851       if (non_stop)
1852         {
1853           /* If in non-stop mode, only delete the per-thread status of
1854              the current thread.  */
1855           clear_proceed_status_thread (inferior_thread ());
1856         }
1857
1858       inferior = current_inferior ();
1859       inferior->control.stop_soon = NO_STOP_QUIETLY;
1860     }
1861
1862   stop_after_trap = 0;
1863
1864   observer_notify_about_to_proceed ();
1865
1866   if (stop_registers)
1867     {
1868       regcache_xfree (stop_registers);
1869       stop_registers = NULL;
1870     }
1871 }
1872
1873 /* Check the current thread against the thread that reported the most recent
1874    event.  If a step-over is required return TRUE and set the current thread
1875    to the old thread.  Otherwise return FALSE.
1876
1877    This should be suitable for any targets that support threads.  */
1878
1879 static int
1880 prepare_to_proceed (int step)
1881 {
1882   ptid_t wait_ptid;
1883   struct target_waitstatus wait_status;
1884   int schedlock_enabled;
1885
1886   /* With non-stop mode on, threads are always handled individually.  */
1887   gdb_assert (! non_stop);
1888
1889   /* Get the last target status returned by target_wait().  */
1890   get_last_target_status (&wait_ptid, &wait_status);
1891
1892   /* Make sure we were stopped at a breakpoint.  */
1893   if (wait_status.kind != TARGET_WAITKIND_STOPPED
1894       || (wait_status.value.sig != TARGET_SIGNAL_TRAP
1895           && wait_status.value.sig != TARGET_SIGNAL_ILL
1896           && wait_status.value.sig != TARGET_SIGNAL_SEGV
1897           && wait_status.value.sig != TARGET_SIGNAL_EMT))
1898     {
1899       return 0;
1900     }
1901
1902   schedlock_enabled = (scheduler_mode == schedlock_on
1903                        || (scheduler_mode == schedlock_step
1904                            && step));
1905
1906   /* Don't switch over to WAIT_PTID if scheduler locking is on.  */
1907   if (schedlock_enabled)
1908     return 0;
1909
1910   /* Don't switch over if we're about to resume some other process
1911      other than WAIT_PTID's, and schedule-multiple is off.  */
1912   if (!sched_multi
1913       && ptid_get_pid (wait_ptid) != ptid_get_pid (inferior_ptid))
1914     return 0;
1915
1916   /* Switched over from WAIT_PID.  */
1917   if (!ptid_equal (wait_ptid, minus_one_ptid)
1918       && !ptid_equal (inferior_ptid, wait_ptid))
1919     {
1920       struct regcache *regcache = get_thread_regcache (wait_ptid);
1921
1922       if (breakpoint_here_p (get_regcache_aspace (regcache),
1923                              regcache_read_pc (regcache)))
1924         {
1925           /* If stepping, remember current thread to switch back to.  */
1926           if (step)
1927             deferred_step_ptid = inferior_ptid;
1928
1929           /* Switch back to WAIT_PID thread.  */
1930           switch_to_thread (wait_ptid);
1931
1932           /* We return 1 to indicate that there is a breakpoint here,
1933              so we need to step over it before continuing to avoid
1934              hitting it straight away.  */
1935           return 1;
1936         }
1937     }
1938
1939   return 0;
1940 }
1941
1942 /* Basic routine for continuing the program in various fashions.
1943
1944    ADDR is the address to resume at, or -1 for resume where stopped.
1945    SIGGNAL is the signal to give it, or 0 for none,
1946    or -1 for act according to how it stopped.
1947    STEP is nonzero if should trap after one instruction.
1948    -1 means return after that and print nothing.
1949    You should probably set various step_... variables
1950    before calling here, if you are stepping.
1951
1952    You should call clear_proceed_status before calling proceed.  */
1953
1954 void
1955 proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
1956 {
1957   struct regcache *regcache;
1958   struct gdbarch *gdbarch;
1959   struct thread_info *tp;
1960   CORE_ADDR pc;
1961   struct address_space *aspace;
1962   int oneproc = 0;
1963
1964   /* If we're stopped at a fork/vfork, follow the branch set by the
1965      "set follow-fork-mode" command; otherwise, we'll just proceed
1966      resuming the current thread.  */
1967   if (!follow_fork ())
1968     {
1969       /* The target for some reason decided not to resume.  */
1970       normal_stop ();
1971       return;
1972     }
1973
1974   regcache = get_current_regcache ();
1975   gdbarch = get_regcache_arch (regcache);
1976   aspace = get_regcache_aspace (regcache);
1977   pc = regcache_read_pc (regcache);
1978
1979   if (step > 0)
1980     step_start_function = find_pc_function (pc);
1981   if (step < 0)
1982     stop_after_trap = 1;
1983
1984   if (addr == (CORE_ADDR) -1)
1985     {
1986       if (pc == stop_pc && breakpoint_here_p (aspace, pc)
1987           && execution_direction != EXEC_REVERSE)
1988         /* There is a breakpoint at the address we will resume at,
1989            step one instruction before inserting breakpoints so that
1990            we do not stop right away (and report a second hit at this
1991            breakpoint).
1992
1993            Note, we don't do this in reverse, because we won't
1994            actually be executing the breakpoint insn anyway.
1995            We'll be (un-)executing the previous instruction.  */
1996
1997         oneproc = 1;
1998       else if (gdbarch_single_step_through_delay_p (gdbarch)
1999                && gdbarch_single_step_through_delay (gdbarch,
2000                                                      get_current_frame ()))
2001         /* We stepped onto an instruction that needs to be stepped
2002            again before re-inserting the breakpoint, do so.  */
2003         oneproc = 1;
2004     }
2005   else
2006     {
2007       regcache_write_pc (regcache, addr);
2008     }
2009
2010   if (debug_infrun)
2011     fprintf_unfiltered (gdb_stdlog,
2012                         "infrun: proceed (addr=%s, signal=%d, step=%d)\n",
2013                         paddress (gdbarch, addr), siggnal, step);
2014
2015   if (non_stop)
2016     /* In non-stop, each thread is handled individually.  The context
2017        must already be set to the right thread here.  */
2018     ;
2019   else
2020     {
2021       /* In a multi-threaded task we may select another thread and
2022          then continue or step.
2023
2024          But if the old thread was stopped at a breakpoint, it will
2025          immediately cause another breakpoint stop without any
2026          execution (i.e. it will report a breakpoint hit incorrectly).
2027          So we must step over it first.
2028
2029          prepare_to_proceed checks the current thread against the
2030          thread that reported the most recent event.  If a step-over
2031          is required it returns TRUE and sets the current thread to
2032          the old thread.  */
2033       if (prepare_to_proceed (step))
2034         oneproc = 1;
2035     }
2036
2037   /* prepare_to_proceed may change the current thread.  */
2038   tp = inferior_thread ();
2039
2040   if (oneproc)
2041     {
2042       tp->control.trap_expected = 1;
2043       /* If displaced stepping is enabled, we can step over the
2044          breakpoint without hitting it, so leave all breakpoints
2045          inserted.  Otherwise we need to disable all breakpoints, step
2046          one instruction, and then re-add them when that step is
2047          finished.  */
2048       if (!use_displaced_stepping (gdbarch))
2049         remove_breakpoints ();
2050     }
2051
2052   /* We can insert breakpoints if we're not trying to step over one,
2053      or if we are stepping over one but we're using displaced stepping
2054      to do so.  */
2055   if (! tp->control.trap_expected || use_displaced_stepping (gdbarch))
2056     insert_breakpoints ();
2057
2058   if (!non_stop)
2059     {
2060       /* Pass the last stop signal to the thread we're resuming,
2061          irrespective of whether the current thread is the thread that
2062          got the last event or not.  This was historically GDB's
2063          behaviour before keeping a stop_signal per thread.  */
2064
2065       struct thread_info *last_thread;
2066       ptid_t last_ptid;
2067       struct target_waitstatus last_status;
2068
2069       get_last_target_status (&last_ptid, &last_status);
2070       if (!ptid_equal (inferior_ptid, last_ptid)
2071           && !ptid_equal (last_ptid, null_ptid)
2072           && !ptid_equal (last_ptid, minus_one_ptid))
2073         {
2074           last_thread = find_thread_ptid (last_ptid);
2075           if (last_thread)
2076             {
2077               tp->suspend.stop_signal = last_thread->suspend.stop_signal;
2078               last_thread->suspend.stop_signal = TARGET_SIGNAL_0;
2079             }
2080         }
2081     }
2082
2083   if (siggnal != TARGET_SIGNAL_DEFAULT)
2084     tp->suspend.stop_signal = siggnal;
2085   /* If this signal should not be seen by program,
2086      give it zero.  Used for debugging signals.  */
2087   else if (!signal_program[tp->suspend.stop_signal])
2088     tp->suspend.stop_signal = TARGET_SIGNAL_0;
2089
2090   annotate_starting ();
2091
2092   /* Make sure that output from GDB appears before output from the
2093      inferior.  */
2094   gdb_flush (gdb_stdout);
2095
2096   /* Refresh prev_pc value just prior to resuming.  This used to be
2097      done in stop_stepping, however, setting prev_pc there did not handle
2098      scenarios such as inferior function calls or returning from
2099      a function via the return command.  In those cases, the prev_pc
2100      value was not set properly for subsequent commands.  The prev_pc value 
2101      is used to initialize the starting line number in the ecs.  With an 
2102      invalid value, the gdb next command ends up stopping at the position
2103      represented by the next line table entry past our start position.
2104      On platforms that generate one line table entry per line, this
2105      is not a problem.  However, on the ia64, the compiler generates
2106      extraneous line table entries that do not increase the line number.
2107      When we issue the gdb next command on the ia64 after an inferior call
2108      or a return command, we often end up a few instructions forward, still 
2109      within the original line we started.
2110
2111      An attempt was made to refresh the prev_pc at the same time the
2112      execution_control_state is initialized (for instance, just before
2113      waiting for an inferior event).  But this approach did not work
2114      because of platforms that use ptrace, where the pc register cannot
2115      be read unless the inferior is stopped.  At that point, we are not
2116      guaranteed the inferior is stopped and so the regcache_read_pc() call
2117      can fail.  Setting the prev_pc value here ensures the value is updated
2118      correctly when the inferior is stopped.  */
2119   tp->prev_pc = regcache_read_pc (get_current_regcache ());
2120
2121   /* Fill in with reasonable starting values.  */
2122   init_thread_stepping_state (tp);
2123
2124   /* Reset to normal state.  */
2125   init_infwait_state ();
2126
2127   /* Resume inferior.  */
2128   resume (oneproc || step || bpstat_should_step (), tp->suspend.stop_signal);
2129
2130   /* Wait for it to stop (if not standalone)
2131      and in any case decode why it stopped, and act accordingly.  */
2132   /* Do this only if we are not using the event loop, or if the target
2133      does not support asynchronous execution.  */
2134   if (!target_can_async_p ())
2135     {
2136       wait_for_inferior (0);
2137       normal_stop ();
2138     }
2139 }
2140 \f
2141
2142 /* Start remote-debugging of a machine over a serial link.  */
2143
2144 void
2145 start_remote (int from_tty)
2146 {
2147   struct inferior *inferior;
2148
2149   init_wait_for_inferior ();
2150   inferior = current_inferior ();
2151   inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2152
2153   /* Always go on waiting for the target, regardless of the mode.  */
2154   /* FIXME: cagney/1999-09-23: At present it isn't possible to
2155      indicate to wait_for_inferior that a target should timeout if
2156      nothing is returned (instead of just blocking).  Because of this,
2157      targets expecting an immediate response need to, internally, set
2158      things up so that the target_wait() is forced to eventually
2159      timeout.  */
2160   /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
2161      differentiate to its caller what the state of the target is after
2162      the initial open has been performed.  Here we're assuming that
2163      the target has stopped.  It should be possible to eventually have
2164      target_open() return to the caller an indication that the target
2165      is currently running and GDB state should be set to the same as
2166      for an async run.  */
2167   wait_for_inferior (0);
2168
2169   /* Now that the inferior has stopped, do any bookkeeping like
2170      loading shared libraries.  We want to do this before normal_stop,
2171      so that the displayed frame is up to date.  */
2172   post_create_inferior (&current_target, from_tty);
2173
2174   normal_stop ();
2175 }
2176
2177 /* Initialize static vars when a new inferior begins.  */
2178
2179 void
2180 init_wait_for_inferior (void)
2181 {
2182   /* These are meaningless until the first time through wait_for_inferior.  */
2183
2184   breakpoint_init_inferior (inf_starting);
2185
2186   clear_proceed_status ();
2187
2188   stepping_past_singlestep_breakpoint = 0;
2189   deferred_step_ptid = null_ptid;
2190
2191   target_last_wait_ptid = minus_one_ptid;
2192
2193   previous_inferior_ptid = null_ptid;
2194   init_infwait_state ();
2195
2196   /* Discard any skipped inlined frames.  */
2197   clear_inline_frame_state (minus_one_ptid);
2198 }
2199
2200 \f
2201 /* This enum encodes possible reasons for doing a target_wait, so that
2202    wfi can call target_wait in one place.  (Ultimately the call will be
2203    moved out of the infinite loop entirely.) */
2204
2205 enum infwait_states
2206 {
2207   infwait_normal_state,
2208   infwait_thread_hop_state,
2209   infwait_step_watch_state,
2210   infwait_nonstep_watch_state
2211 };
2212
2213 /* The PTID we'll do a target_wait on.*/
2214 ptid_t waiton_ptid;
2215
2216 /* Current inferior wait state.  */
2217 enum infwait_states infwait_state;
2218
2219 /* Data to be passed around while handling an event.  This data is
2220    discarded between events.  */
2221 struct execution_control_state
2222 {
2223   ptid_t ptid;
2224   /* The thread that got the event, if this was a thread event; NULL
2225      otherwise.  */
2226   struct thread_info *event_thread;
2227
2228   struct target_waitstatus ws;
2229   int random_signal;
2230   CORE_ADDR stop_func_start;
2231   CORE_ADDR stop_func_end;
2232   char *stop_func_name;
2233   int new_thread_event;
2234   int wait_some_more;
2235 };
2236
2237 static void handle_inferior_event (struct execution_control_state *ecs);
2238
2239 static void handle_step_into_function (struct gdbarch *gdbarch,
2240                                        struct execution_control_state *ecs);
2241 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
2242                                                 struct execution_control_state *ecs);
2243 static void insert_step_resume_breakpoint_at_frame (struct frame_info *);
2244 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
2245 static void insert_step_resume_breakpoint_at_sal (struct gdbarch *,
2246                                                   struct symtab_and_line ,
2247                                                   struct frame_id);
2248 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
2249 static void check_exception_resume (struct execution_control_state *,
2250                                     struct frame_info *, struct symbol *);
2251
2252 static void stop_stepping (struct execution_control_state *ecs);
2253 static void prepare_to_wait (struct execution_control_state *ecs);
2254 static void keep_going (struct execution_control_state *ecs);
2255
2256 /* Callback for iterate over threads.  If the thread is stopped, but
2257    the user/frontend doesn't know about that yet, go through
2258    normal_stop, as if the thread had just stopped now.  ARG points at
2259    a ptid.  If PTID is MINUS_ONE_PTID, applies to all threads.  If
2260    ptid_is_pid(PTID) is true, applies to all threads of the process
2261    pointed at by PTID.  Otherwise, apply only to the thread pointed by
2262    PTID.  */
2263
2264 static int
2265 infrun_thread_stop_requested_callback (struct thread_info *info, void *arg)
2266 {
2267   ptid_t ptid = * (ptid_t *) arg;
2268
2269   if ((ptid_equal (info->ptid, ptid)
2270        || ptid_equal (minus_one_ptid, ptid)
2271        || (ptid_is_pid (ptid)
2272            && ptid_get_pid (ptid) == ptid_get_pid (info->ptid)))
2273       && is_running (info->ptid)
2274       && !is_executing (info->ptid))
2275     {
2276       struct cleanup *old_chain;
2277       struct execution_control_state ecss;
2278       struct execution_control_state *ecs = &ecss;
2279
2280       memset (ecs, 0, sizeof (*ecs));
2281
2282       old_chain = make_cleanup_restore_current_thread ();
2283
2284       switch_to_thread (info->ptid);
2285
2286       /* Go through handle_inferior_event/normal_stop, so we always
2287          have consistent output as if the stop event had been
2288          reported.  */
2289       ecs->ptid = info->ptid;
2290       ecs->event_thread = find_thread_ptid (info->ptid);
2291       ecs->ws.kind = TARGET_WAITKIND_STOPPED;
2292       ecs->ws.value.sig = TARGET_SIGNAL_0;
2293
2294       handle_inferior_event (ecs);
2295
2296       if (!ecs->wait_some_more)
2297         {
2298           struct thread_info *tp;
2299
2300           normal_stop ();
2301
2302           /* Finish off the continuations.  The continations
2303              themselves are responsible for realising the thread
2304              didn't finish what it was supposed to do.  */
2305           tp = inferior_thread ();
2306           do_all_intermediate_continuations_thread (tp);
2307           do_all_continuations_thread (tp);
2308         }
2309
2310       do_cleanups (old_chain);
2311     }
2312
2313   return 0;
2314 }
2315
2316 /* This function is attached as a "thread_stop_requested" observer.
2317    Cleanup local state that assumed the PTID was to be resumed, and
2318    report the stop to the frontend.  */
2319
2320 static void
2321 infrun_thread_stop_requested (ptid_t ptid)
2322 {
2323   struct displaced_step_inferior_state *displaced;
2324
2325   /* PTID was requested to stop.  Remove it from the displaced
2326      stepping queue, so we don't try to resume it automatically.  */
2327
2328   for (displaced = displaced_step_inferior_states;
2329        displaced;
2330        displaced = displaced->next)
2331     {
2332       struct displaced_step_request *it, **prev_next_p;
2333
2334       it = displaced->step_request_queue;
2335       prev_next_p = &displaced->step_request_queue;
2336       while (it)
2337         {
2338           if (ptid_match (it->ptid, ptid))
2339             {
2340               *prev_next_p = it->next;
2341               it->next = NULL;
2342               xfree (it);
2343             }
2344           else
2345             {
2346               prev_next_p = &it->next;
2347             }
2348
2349           it = *prev_next_p;
2350         }
2351     }
2352
2353   iterate_over_threads (infrun_thread_stop_requested_callback, &ptid);
2354 }
2355
2356 static void
2357 infrun_thread_thread_exit (struct thread_info *tp, int silent)
2358 {
2359   if (ptid_equal (target_last_wait_ptid, tp->ptid))
2360     nullify_last_target_wait_ptid ();
2361 }
2362
2363 /* Callback for iterate_over_threads.  */
2364
2365 static int
2366 delete_step_resume_breakpoint_callback (struct thread_info *info, void *data)
2367 {
2368   if (is_exited (info->ptid))
2369     return 0;
2370
2371   delete_step_resume_breakpoint (info);
2372   delete_exception_resume_breakpoint (info);
2373   return 0;
2374 }
2375
2376 /* In all-stop, delete the step resume breakpoint of any thread that
2377    had one.  In non-stop, delete the step resume breakpoint of the
2378    thread that just stopped.  */
2379
2380 static void
2381 delete_step_thread_step_resume_breakpoint (void)
2382 {
2383   if (!target_has_execution
2384       || ptid_equal (inferior_ptid, null_ptid))
2385     /* If the inferior has exited, we have already deleted the step
2386        resume breakpoints out of GDB's lists.  */
2387     return;
2388
2389   if (non_stop)
2390     {
2391       /* If in non-stop mode, only delete the step-resume or
2392          longjmp-resume breakpoint of the thread that just stopped
2393          stepping.  */
2394       struct thread_info *tp = inferior_thread ();
2395
2396       delete_step_resume_breakpoint (tp);
2397       delete_exception_resume_breakpoint (tp);
2398     }
2399   else
2400     /* In all-stop mode, delete all step-resume and longjmp-resume
2401        breakpoints of any thread that had them.  */
2402     iterate_over_threads (delete_step_resume_breakpoint_callback, NULL);
2403 }
2404
2405 /* A cleanup wrapper.  */
2406
2407 static void
2408 delete_step_thread_step_resume_breakpoint_cleanup (void *arg)
2409 {
2410   delete_step_thread_step_resume_breakpoint ();
2411 }
2412
2413 /* Pretty print the results of target_wait, for debugging purposes.  */
2414
2415 static void
2416 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
2417                            const struct target_waitstatus *ws)
2418 {
2419   char *status_string = target_waitstatus_to_string (ws);
2420   struct ui_file *tmp_stream = mem_fileopen ();
2421   char *text;
2422
2423   /* The text is split over several lines because it was getting too long.
2424      Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
2425      output as a unit; we want only one timestamp printed if debug_timestamp
2426      is set.  */
2427
2428   fprintf_unfiltered (tmp_stream,
2429                       "infrun: target_wait (%d", PIDGET (waiton_ptid));
2430   if (PIDGET (waiton_ptid) != -1)
2431     fprintf_unfiltered (tmp_stream,
2432                         " [%s]", target_pid_to_str (waiton_ptid));
2433   fprintf_unfiltered (tmp_stream, ", status) =\n");
2434   fprintf_unfiltered (tmp_stream,
2435                       "infrun:   %d [%s],\n",
2436                       PIDGET (result_ptid), target_pid_to_str (result_ptid));
2437   fprintf_unfiltered (tmp_stream,
2438                       "infrun:   %s\n",
2439                       status_string);
2440
2441   text = ui_file_xstrdup (tmp_stream, NULL);
2442
2443   /* This uses %s in part to handle %'s in the text, but also to avoid
2444      a gcc error: the format attribute requires a string literal.  */
2445   fprintf_unfiltered (gdb_stdlog, "%s", text);
2446
2447   xfree (status_string);
2448   xfree (text);
2449   ui_file_delete (tmp_stream);
2450 }
2451
2452 /* Prepare and stabilize the inferior for detaching it.  E.g.,
2453    detaching while a thread is displaced stepping is a recipe for
2454    crashing it, as nothing would readjust the PC out of the scratch
2455    pad.  */
2456
2457 void
2458 prepare_for_detach (void)
2459 {
2460   struct inferior *inf = current_inferior ();
2461   ptid_t pid_ptid = pid_to_ptid (inf->pid);
2462   struct cleanup *old_chain_1;
2463   struct displaced_step_inferior_state *displaced;
2464
2465   displaced = get_displaced_stepping_state (inf->pid);
2466
2467   /* Is any thread of this process displaced stepping?  If not,
2468      there's nothing else to do.  */
2469   if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
2470     return;
2471
2472   if (debug_infrun)
2473     fprintf_unfiltered (gdb_stdlog,
2474                         "displaced-stepping in-process while detaching");
2475
2476   old_chain_1 = make_cleanup_restore_integer (&inf->detaching);
2477   inf->detaching = 1;
2478
2479   while (!ptid_equal (displaced->step_ptid, null_ptid))
2480     {
2481       struct cleanup *old_chain_2;
2482       struct execution_control_state ecss;
2483       struct execution_control_state *ecs;
2484
2485       ecs = &ecss;
2486       memset (ecs, 0, sizeof (*ecs));
2487
2488       overlay_cache_invalid = 1;
2489
2490       /* We have to invalidate the registers BEFORE calling
2491          target_wait because they can be loaded from the target while
2492          in target_wait.  This makes remote debugging a bit more
2493          efficient for those targets that provide critical registers
2494          as part of their normal status mechanism.  */
2495
2496       registers_changed ();
2497
2498       if (deprecated_target_wait_hook)
2499         ecs->ptid = deprecated_target_wait_hook (pid_ptid, &ecs->ws, 0);
2500       else
2501         ecs->ptid = target_wait (pid_ptid, &ecs->ws, 0);
2502
2503       if (debug_infrun)
2504         print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
2505
2506       /* If an error happens while handling the event, propagate GDB's
2507          knowledge of the executing state to the frontend/user running
2508          state.  */
2509       old_chain_2 = make_cleanup (finish_thread_state_cleanup,
2510                                   &minus_one_ptid);
2511
2512       /* In non-stop mode, each thread is handled individually.
2513          Switch early, so the global state is set correctly for this
2514          thread.  */
2515       if (non_stop
2516           && ecs->ws.kind != TARGET_WAITKIND_EXITED
2517           && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
2518         context_switch (ecs->ptid);
2519
2520       /* Now figure out what to do with the result of the result.  */
2521       handle_inferior_event (ecs);
2522
2523       /* No error, don't finish the state yet.  */
2524       discard_cleanups (old_chain_2);
2525
2526       /* Breakpoints and watchpoints are not installed on the target
2527          at this point, and signals are passed directly to the
2528          inferior, so this must mean the process is gone.  */
2529       if (!ecs->wait_some_more)
2530         {
2531           discard_cleanups (old_chain_1);
2532           error (_("Program exited while detaching"));
2533         }
2534     }
2535
2536   discard_cleanups (old_chain_1);
2537 }
2538
2539 /* Wait for control to return from inferior to debugger.
2540
2541    If TREAT_EXEC_AS_SIGTRAP is non-zero, then handle EXEC signals
2542    as if they were SIGTRAP signals.  This can be useful during
2543    the startup sequence on some targets such as HP/UX, where
2544    we receive an EXEC event instead of the expected SIGTRAP.
2545
2546    If inferior gets a signal, we may decide to start it up again
2547    instead of returning.  That is why there is a loop in this function.
2548    When this function actually returns it means the inferior
2549    should be left stopped and GDB should read more commands.  */
2550
2551 void
2552 wait_for_inferior (int treat_exec_as_sigtrap)
2553 {
2554   struct cleanup *old_cleanups;
2555   struct execution_control_state ecss;
2556   struct execution_control_state *ecs;
2557
2558   if (debug_infrun)
2559     fprintf_unfiltered
2560       (gdb_stdlog, "infrun: wait_for_inferior (treat_exec_as_sigtrap=%d)\n",
2561        treat_exec_as_sigtrap);
2562
2563   old_cleanups =
2564     make_cleanup (delete_step_thread_step_resume_breakpoint_cleanup, NULL);
2565
2566   ecs = &ecss;
2567   memset (ecs, 0, sizeof (*ecs));
2568
2569   /* We'll update this if & when we switch to a new thread.  */
2570   previous_inferior_ptid = inferior_ptid;
2571
2572   while (1)
2573     {
2574       struct cleanup *old_chain;
2575
2576       /* We have to invalidate the registers BEFORE calling target_wait
2577          because they can be loaded from the target while in target_wait.
2578          This makes remote debugging a bit more efficient for those
2579          targets that provide critical registers as part of their normal
2580          status mechanism.  */
2581
2582       overlay_cache_invalid = 1;
2583       registers_changed ();
2584
2585       if (deprecated_target_wait_hook)
2586         ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0);
2587       else
2588         ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0);
2589
2590       if (debug_infrun)
2591         print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
2592
2593       if (treat_exec_as_sigtrap && ecs->ws.kind == TARGET_WAITKIND_EXECD)
2594         {
2595           xfree (ecs->ws.value.execd_pathname);
2596           ecs->ws.kind = TARGET_WAITKIND_STOPPED;
2597           ecs->ws.value.sig = TARGET_SIGNAL_TRAP;
2598         }
2599
2600       /* If an error happens while handling the event, propagate GDB's
2601          knowledge of the executing state to the frontend/user running
2602          state.  */
2603       old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
2604
2605       if (ecs->ws.kind == TARGET_WAITKIND_SYSCALL_ENTRY
2606           || ecs->ws.kind == TARGET_WAITKIND_SYSCALL_RETURN)
2607         ecs->ws.value.syscall_number = UNKNOWN_SYSCALL;
2608
2609       /* Now figure out what to do with the result of the result.  */
2610       handle_inferior_event (ecs);
2611
2612       /* No error, don't finish the state yet.  */
2613       discard_cleanups (old_chain);
2614
2615       if (!ecs->wait_some_more)
2616         break;
2617     }
2618
2619   do_cleanups (old_cleanups);
2620 }
2621
2622 /* Asynchronous version of wait_for_inferior.  It is called by the
2623    event loop whenever a change of state is detected on the file
2624    descriptor corresponding to the target.  It can be called more than
2625    once to complete a single execution command.  In such cases we need
2626    to keep the state in a global variable ECSS.  If it is the last time
2627    that this function is called for a single execution command, then
2628    report to the user that the inferior has stopped, and do the
2629    necessary cleanups.  */
2630
2631 void
2632 fetch_inferior_event (void *client_data)
2633 {
2634   struct execution_control_state ecss;
2635   struct execution_control_state *ecs = &ecss;
2636   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
2637   struct cleanup *ts_old_chain;
2638   int was_sync = sync_execution;
2639
2640   memset (ecs, 0, sizeof (*ecs));
2641
2642   /* We'll update this if & when we switch to a new thread.  */
2643   previous_inferior_ptid = inferior_ptid;
2644
2645   /* We're handling a live event, so make sure we're doing live
2646      debugging.  If we're looking at traceframes while the target is
2647      running, we're going to need to get back to that mode after
2648      handling the event.  */
2649   if (non_stop)
2650     {
2651       make_cleanup_restore_current_traceframe ();
2652       set_current_traceframe (-1);
2653     }
2654
2655   if (non_stop)
2656     /* In non-stop mode, the user/frontend should not notice a thread
2657        switch due to internal events.  Make sure we reverse to the
2658        user selected thread and frame after handling the event and
2659        running any breakpoint commands.  */
2660     make_cleanup_restore_current_thread ();
2661
2662   /* We have to invalidate the registers BEFORE calling target_wait
2663      because they can be loaded from the target while in target_wait.
2664      This makes remote debugging a bit more efficient for those
2665      targets that provide critical registers as part of their normal
2666      status mechanism.  */
2667
2668   overlay_cache_invalid = 1;
2669   registers_changed ();
2670
2671   if (deprecated_target_wait_hook)
2672     ecs->ptid =
2673       deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
2674   else
2675     ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
2676
2677   if (debug_infrun)
2678     print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
2679
2680   if (non_stop
2681       && ecs->ws.kind != TARGET_WAITKIND_IGNORE
2682       && ecs->ws.kind != TARGET_WAITKIND_EXITED
2683       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
2684     /* In non-stop mode, each thread is handled individually.  Switch
2685        early, so the global state is set correctly for this
2686        thread.  */
2687     context_switch (ecs->ptid);
2688
2689   /* If an error happens while handling the event, propagate GDB's
2690      knowledge of the executing state to the frontend/user running
2691      state.  */
2692   if (!non_stop)
2693     ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
2694   else
2695     ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
2696
2697   /* Now figure out what to do with the result of the result.  */
2698   handle_inferior_event (ecs);
2699
2700   if (!ecs->wait_some_more)
2701     {
2702       struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
2703
2704       delete_step_thread_step_resume_breakpoint ();
2705
2706       /* We may not find an inferior if this was a process exit.  */
2707       if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
2708         normal_stop ();
2709
2710       if (target_has_execution
2711           && ecs->ws.kind != TARGET_WAITKIND_EXITED
2712           && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
2713           && ecs->event_thread->step_multi
2714           && ecs->event_thread->control.stop_step)
2715         inferior_event_handler (INF_EXEC_CONTINUE, NULL);
2716       else
2717         inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2718     }
2719
2720   /* No error, don't finish the thread states yet.  */
2721   discard_cleanups (ts_old_chain);
2722
2723   /* Revert thread and frame.  */
2724   do_cleanups (old_chain);
2725
2726   /* If the inferior was in sync execution mode, and now isn't,
2727      restore the prompt.  */
2728   if (was_sync && !sync_execution)
2729     display_gdb_prompt (0);
2730 }
2731
2732 /* Record the frame and location we're currently stepping through.  */
2733 void
2734 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
2735 {
2736   struct thread_info *tp = inferior_thread ();
2737
2738   tp->control.step_frame_id = get_frame_id (frame);
2739   tp->control.step_stack_frame_id = get_stack_frame_id (frame);
2740
2741   tp->current_symtab = sal.symtab;
2742   tp->current_line = sal.line;
2743 }
2744
2745 /* Clear context switchable stepping state.  */
2746
2747 void
2748 init_thread_stepping_state (struct thread_info *tss)
2749 {
2750   tss->stepping_over_breakpoint = 0;
2751   tss->step_after_step_resume_breakpoint = 0;
2752   tss->stepping_through_solib_after_catch = 0;
2753   tss->stepping_through_solib_catchpoints = NULL;
2754 }
2755
2756 /* Return the cached copy of the last pid/waitstatus returned by
2757    target_wait()/deprecated_target_wait_hook().  The data is actually
2758    cached by handle_inferior_event(), which gets called immediately
2759    after target_wait()/deprecated_target_wait_hook().  */
2760
2761 void
2762 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
2763 {
2764   *ptidp = target_last_wait_ptid;
2765   *status = target_last_waitstatus;
2766 }
2767
2768 void
2769 nullify_last_target_wait_ptid (void)
2770 {
2771   target_last_wait_ptid = minus_one_ptid;
2772 }
2773
2774 /* Switch thread contexts.  */
2775
2776 static void
2777 context_switch (ptid_t ptid)
2778 {
2779   if (debug_infrun)
2780     {
2781       fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
2782                           target_pid_to_str (inferior_ptid));
2783       fprintf_unfiltered (gdb_stdlog, "to %s\n",
2784                           target_pid_to_str (ptid));
2785     }
2786
2787   switch_to_thread (ptid);
2788 }
2789
2790 static void
2791 adjust_pc_after_break (struct execution_control_state *ecs)
2792 {
2793   struct regcache *regcache;
2794   struct gdbarch *gdbarch;
2795   struct address_space *aspace;
2796   CORE_ADDR breakpoint_pc;
2797
2798   /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP.  If
2799      we aren't, just return.
2800
2801      We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
2802      affected by gdbarch_decr_pc_after_break.  Other waitkinds which are
2803      implemented by software breakpoints should be handled through the normal
2804      breakpoint layer.
2805
2806      NOTE drow/2004-01-31: On some targets, breakpoints may generate
2807      different signals (SIGILL or SIGEMT for instance), but it is less
2808      clear where the PC is pointing afterwards.  It may not match
2809      gdbarch_decr_pc_after_break.  I don't know any specific target that
2810      generates these signals at breakpoints (the code has been in GDB since at
2811      least 1992) so I can not guess how to handle them here.
2812
2813      In earlier versions of GDB, a target with 
2814      gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
2815      watchpoint affected by gdbarch_decr_pc_after_break.  I haven't found any
2816      target with both of these set in GDB history, and it seems unlikely to be
2817      correct, so gdbarch_have_nonsteppable_watchpoint is not checked here.  */
2818
2819   if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
2820     return;
2821
2822   if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP)
2823     return;
2824
2825   /* In reverse execution, when a breakpoint is hit, the instruction
2826      under it has already been de-executed.  The reported PC always
2827      points at the breakpoint address, so adjusting it further would
2828      be wrong.  E.g., consider this case on a decr_pc_after_break == 1
2829      architecture:
2830
2831        B1         0x08000000 :   INSN1
2832        B2         0x08000001 :   INSN2
2833                   0x08000002 :   INSN3
2834             PC -> 0x08000003 :   INSN4
2835
2836      Say you're stopped at 0x08000003 as above.  Reverse continuing
2837      from that point should hit B2 as below.  Reading the PC when the
2838      SIGTRAP is reported should read 0x08000001 and INSN2 should have
2839      been de-executed already.
2840
2841        B1         0x08000000 :   INSN1
2842        B2   PC -> 0x08000001 :   INSN2
2843                   0x08000002 :   INSN3
2844                   0x08000003 :   INSN4
2845
2846      We can't apply the same logic as for forward execution, because
2847      we would wrongly adjust the PC to 0x08000000, since there's a
2848      breakpoint at PC - 1.  We'd then report a hit on B1, although
2849      INSN1 hadn't been de-executed yet.  Doing nothing is the correct
2850      behaviour.  */
2851   if (execution_direction == EXEC_REVERSE)
2852     return;
2853
2854   /* If this target does not decrement the PC after breakpoints, then
2855      we have nothing to do.  */
2856   regcache = get_thread_regcache (ecs->ptid);
2857   gdbarch = get_regcache_arch (regcache);
2858   if (gdbarch_decr_pc_after_break (gdbarch) == 0)
2859     return;
2860
2861   aspace = get_regcache_aspace (regcache);
2862
2863   /* Find the location where (if we've hit a breakpoint) the
2864      breakpoint would be.  */
2865   breakpoint_pc = regcache_read_pc (regcache)
2866                   - gdbarch_decr_pc_after_break (gdbarch);
2867
2868   /* Check whether there actually is a software breakpoint inserted at
2869      that location.
2870
2871      If in non-stop mode, a race condition is possible where we've
2872      removed a breakpoint, but stop events for that breakpoint were
2873      already queued and arrive later.  To suppress those spurious
2874      SIGTRAPs, we keep a list of such breakpoint locations for a bit,
2875      and retire them after a number of stop events are reported.  */
2876   if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
2877       || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
2878     {
2879       struct cleanup *old_cleanups = NULL;
2880
2881       if (RECORD_IS_USED)
2882         old_cleanups = record_gdb_operation_disable_set ();
2883
2884       /* When using hardware single-step, a SIGTRAP is reported for both
2885          a completed single-step and a software breakpoint.  Need to
2886          differentiate between the two, as the latter needs adjusting
2887          but the former does not.
2888
2889          The SIGTRAP can be due to a completed hardware single-step only if 
2890           - we didn't insert software single-step breakpoints
2891           - the thread to be examined is still the current thread
2892           - this thread is currently being stepped
2893
2894          If any of these events did not occur, we must have stopped due
2895          to hitting a software breakpoint, and have to back up to the
2896          breakpoint address.
2897
2898          As a special case, we could have hardware single-stepped a
2899          software breakpoint.  In this case (prev_pc == breakpoint_pc),
2900          we also need to back up to the breakpoint address.  */
2901
2902       if (singlestep_breakpoints_inserted_p
2903           || !ptid_equal (ecs->ptid, inferior_ptid)
2904           || !currently_stepping (ecs->event_thread)
2905           || ecs->event_thread->prev_pc == breakpoint_pc)
2906         regcache_write_pc (regcache, breakpoint_pc);
2907
2908       if (RECORD_IS_USED)
2909         do_cleanups (old_cleanups);
2910     }
2911 }
2912
2913 void
2914 init_infwait_state (void)
2915 {
2916   waiton_ptid = pid_to_ptid (-1);
2917   infwait_state = infwait_normal_state;
2918 }
2919
2920 void
2921 error_is_running (void)
2922 {
2923   error (_("Cannot execute this command while "
2924            "the selected thread is running."));
2925 }
2926
2927 void
2928 ensure_not_running (void)
2929 {
2930   if (is_running (inferior_ptid))
2931     error_is_running ();
2932 }
2933
2934 static int
2935 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
2936 {
2937   for (frame = get_prev_frame (frame);
2938        frame != NULL;
2939        frame = get_prev_frame (frame))
2940     {
2941       if (frame_id_eq (get_frame_id (frame), step_frame_id))
2942         return 1;
2943       if (get_frame_type (frame) != INLINE_FRAME)
2944         break;
2945     }
2946
2947   return 0;
2948 }
2949
2950 /* Auxiliary function that handles syscall entry/return events.
2951    It returns 1 if the inferior should keep going (and GDB
2952    should ignore the event), or 0 if the event deserves to be
2953    processed.  */
2954
2955 static int
2956 handle_syscall_event (struct execution_control_state *ecs)
2957 {
2958   struct regcache *regcache;
2959   struct gdbarch *gdbarch;
2960   int syscall_number;
2961
2962   if (!ptid_equal (ecs->ptid, inferior_ptid))
2963     context_switch (ecs->ptid);
2964
2965   regcache = get_thread_regcache (ecs->ptid);
2966   gdbarch = get_regcache_arch (regcache);
2967   syscall_number = gdbarch_get_syscall_number (gdbarch, ecs->ptid);
2968   stop_pc = regcache_read_pc (regcache);
2969
2970   target_last_waitstatus.value.syscall_number = syscall_number;
2971
2972   if (catch_syscall_enabled () > 0
2973       && catching_syscall_number (syscall_number) > 0)
2974     {
2975       if (debug_infrun)
2976         fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
2977                             syscall_number);
2978
2979       ecs->event_thread->control.stop_bpstat
2980         = bpstat_stop_status (get_regcache_aspace (regcache),
2981                               stop_pc, ecs->ptid);
2982       ecs->random_signal
2983         = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat);
2984
2985       if (!ecs->random_signal)
2986         {
2987           /* Catchpoint hit.  */
2988           ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP;
2989           return 0;
2990         }
2991     }
2992
2993   /* If no catchpoint triggered for this, then keep going.  */
2994   ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
2995   keep_going (ecs);
2996   return 1;
2997 }
2998
2999 /* Given an execution control state that has been freshly filled in
3000    by an event from the inferior, figure out what it means and take
3001    appropriate action.  */
3002
3003 static void
3004 handle_inferior_event (struct execution_control_state *ecs)
3005 {
3006   struct frame_info *frame;
3007   struct gdbarch *gdbarch;
3008   int sw_single_step_trap_p = 0;
3009   int stopped_by_watchpoint;
3010   int stepped_after_stopped_by_watchpoint = 0;
3011   struct symtab_and_line stop_pc_sal;
3012   enum stop_kind stop_soon;
3013
3014   if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
3015     {
3016       /* We had an event in the inferior, but we are not interested in
3017          handling it at this level.  The lower layers have already
3018          done what needs to be done, if anything.
3019
3020          One of the possible circumstances for this is when the
3021          inferior produces output for the console.  The inferior has
3022          not stopped, and we are ignoring the event.  Another possible
3023          circumstance is any event which the lower level knows will be
3024          reported multiple times without an intervening resume.  */
3025       if (debug_infrun)
3026         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
3027       prepare_to_wait (ecs);
3028       return;
3029     }
3030
3031   if (ecs->ws.kind != TARGET_WAITKIND_EXITED
3032       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
3033     {
3034       struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
3035
3036       gdb_assert (inf);
3037       stop_soon = inf->control.stop_soon;
3038     }
3039   else
3040     stop_soon = NO_STOP_QUIETLY;
3041
3042   /* Cache the last pid/waitstatus.  */
3043   target_last_wait_ptid = ecs->ptid;
3044   target_last_waitstatus = ecs->ws;
3045
3046   /* Always clear state belonging to the previous time we stopped.  */
3047   stop_stack_dummy = STOP_NONE;
3048
3049   /* If it's a new process, add it to the thread database.  */
3050
3051   ecs->new_thread_event = (!ptid_equal (ecs->ptid, inferior_ptid)
3052                            && !ptid_equal (ecs->ptid, minus_one_ptid)
3053                            && !in_thread_list (ecs->ptid));
3054
3055   if (ecs->ws.kind != TARGET_WAITKIND_EXITED
3056       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event)
3057     add_thread (ecs->ptid);
3058
3059   ecs->event_thread = find_thread_ptid (ecs->ptid);
3060
3061   /* Dependent on valid ECS->EVENT_THREAD.  */
3062   adjust_pc_after_break (ecs);
3063
3064   /* Dependent on the current PC value modified by adjust_pc_after_break.  */
3065   reinit_frame_cache ();
3066
3067   breakpoint_retire_moribund ();
3068
3069   /* First, distinguish signals caused by the debugger from signals
3070      that have to do with the program's own actions.  Note that
3071      breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
3072      on the operating system version.  Here we detect when a SIGILL or
3073      SIGEMT is really a breakpoint and change it to SIGTRAP.  We do
3074      something similar for SIGSEGV, since a SIGSEGV will be generated
3075      when we're trying to execute a breakpoint instruction on a
3076      non-executable stack.  This happens for call dummy breakpoints
3077      for architectures like SPARC that place call dummies on the
3078      stack.  */
3079   if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
3080       && (ecs->ws.value.sig == TARGET_SIGNAL_ILL
3081           || ecs->ws.value.sig == TARGET_SIGNAL_SEGV
3082           || ecs->ws.value.sig == TARGET_SIGNAL_EMT))
3083     {
3084       struct regcache *regcache = get_thread_regcache (ecs->ptid);
3085
3086       if (breakpoint_inserted_here_p (get_regcache_aspace (regcache),
3087                                       regcache_read_pc (regcache)))
3088         {
3089           if (debug_infrun)
3090             fprintf_unfiltered (gdb_stdlog,
3091                                 "infrun: Treating signal as SIGTRAP\n");
3092           ecs->ws.value.sig = TARGET_SIGNAL_TRAP;
3093         }
3094     }
3095
3096   /* Mark the non-executing threads accordingly.  In all-stop, all
3097      threads of all processes are stopped when we get any event
3098      reported.  In non-stop mode, only the event thread stops.  If
3099      we're handling a process exit in non-stop mode, there's nothing
3100      to do, as threads of the dead process are gone, and threads of
3101      any other process were left running.  */
3102   if (!non_stop)
3103     set_executing (minus_one_ptid, 0);
3104   else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3105            && ecs->ws.kind != TARGET_WAITKIND_EXITED)
3106     set_executing (inferior_ptid, 0);
3107
3108   switch (infwait_state)
3109     {
3110     case infwait_thread_hop_state:
3111       if (debug_infrun)
3112         fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n");
3113       break;
3114
3115     case infwait_normal_state:
3116       if (debug_infrun)
3117         fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n");
3118       break;
3119
3120     case infwait_step_watch_state:
3121       if (debug_infrun)
3122         fprintf_unfiltered (gdb_stdlog,
3123                             "infrun: infwait_step_watch_state\n");
3124
3125       stepped_after_stopped_by_watchpoint = 1;
3126       break;
3127
3128     case infwait_nonstep_watch_state:
3129       if (debug_infrun)
3130         fprintf_unfiltered (gdb_stdlog,
3131                             "infrun: infwait_nonstep_watch_state\n");
3132       insert_breakpoints ();
3133
3134       /* FIXME-maybe: is this cleaner than setting a flag?  Does it
3135          handle things like signals arriving and other things happening
3136          in combination correctly?  */
3137       stepped_after_stopped_by_watchpoint = 1;
3138       break;
3139
3140     default:
3141       internal_error (__FILE__, __LINE__, _("bad switch"));
3142     }
3143
3144   infwait_state = infwait_normal_state;
3145   waiton_ptid = pid_to_ptid (-1);
3146
3147   switch (ecs->ws.kind)
3148     {
3149     case TARGET_WAITKIND_LOADED:
3150       if (debug_infrun)
3151         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
3152       /* Ignore gracefully during startup of the inferior, as it might
3153          be the shell which has just loaded some objects, otherwise
3154          add the symbols for the newly loaded objects.  Also ignore at
3155          the beginning of an attach or remote session; we will query
3156          the full list of libraries once the connection is
3157          established.  */
3158       if (stop_soon == NO_STOP_QUIETLY)
3159         {
3160           /* Check for any newly added shared libraries if we're
3161              supposed to be adding them automatically.  Switch
3162              terminal for any messages produced by
3163              breakpoint_re_set.  */
3164           target_terminal_ours_for_output ();
3165           /* NOTE: cagney/2003-11-25: Make certain that the target
3166              stack's section table is kept up-to-date.  Architectures,
3167              (e.g., PPC64), use the section table to perform
3168              operations such as address => section name and hence
3169              require the table to contain all sections (including
3170              those found in shared libraries).  */
3171 #ifdef SOLIB_ADD
3172           SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
3173 #else
3174           solib_add (NULL, 0, &current_target, auto_solib_add);
3175 #endif
3176           target_terminal_inferior ();
3177
3178           /* If requested, stop when the dynamic linker notifies
3179              gdb of events.  This allows the user to get control
3180              and place breakpoints in initializer routines for
3181              dynamically loaded objects (among other things).  */
3182           if (stop_on_solib_events)
3183             {
3184               /* Make sure we print "Stopped due to solib-event" in
3185                  normal_stop.  */
3186               stop_print_frame = 1;
3187
3188               stop_stepping (ecs);
3189               return;
3190             }
3191
3192           /* NOTE drow/2007-05-11: This might be a good place to check
3193              for "catch load".  */
3194         }
3195
3196       /* If we are skipping through a shell, or through shared library
3197          loading that we aren't interested in, resume the program.  If
3198          we're running the program normally, also resume.  But stop if
3199          we're attaching or setting up a remote connection.  */
3200       if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
3201         {
3202           /* Loading of shared libraries might have changed breakpoint
3203              addresses.  Make sure new breakpoints are inserted.  */
3204           if (stop_soon == NO_STOP_QUIETLY
3205               && !breakpoints_always_inserted_mode ())
3206             insert_breakpoints ();
3207           resume (0, TARGET_SIGNAL_0);
3208           prepare_to_wait (ecs);
3209           return;
3210         }
3211
3212       break;
3213
3214     case TARGET_WAITKIND_SPURIOUS:
3215       if (debug_infrun)
3216         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
3217       resume (0, TARGET_SIGNAL_0);
3218       prepare_to_wait (ecs);
3219       return;
3220
3221     case TARGET_WAITKIND_EXITED:
3222       if (debug_infrun)
3223         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXITED\n");
3224       inferior_ptid = ecs->ptid;
3225       set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid)));
3226       set_current_program_space (current_inferior ()->pspace);
3227       handle_vfork_child_exec_or_exit (0);
3228       target_terminal_ours ();  /* Must do this before mourn anyway.  */
3229       print_exited_reason (ecs->ws.value.integer);
3230
3231       /* Record the exit code in the convenience variable $_exitcode, so
3232          that the user can inspect this again later.  */
3233       set_internalvar_integer (lookup_internalvar ("_exitcode"),
3234                                (LONGEST) ecs->ws.value.integer);
3235
3236       /* Also record this in the inferior itself.  */
3237       current_inferior ()->has_exit_code = 1;
3238       current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
3239
3240       gdb_flush (gdb_stdout);
3241       target_mourn_inferior ();
3242       singlestep_breakpoints_inserted_p = 0;
3243       cancel_single_step_breakpoints ();
3244       stop_print_frame = 0;
3245       stop_stepping (ecs);
3246       return;
3247
3248     case TARGET_WAITKIND_SIGNALLED:
3249       if (debug_infrun)
3250         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SIGNALLED\n");
3251       inferior_ptid = ecs->ptid;
3252       set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid)));
3253       set_current_program_space (current_inferior ()->pspace);
3254       handle_vfork_child_exec_or_exit (0);
3255       stop_print_frame = 0;
3256       target_terminal_ours ();  /* Must do this before mourn anyway.  */
3257
3258       /* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't
3259          reach here unless the inferior is dead.  However, for years
3260          target_kill() was called here, which hints that fatal signals aren't
3261          really fatal on some systems.  If that's true, then some changes
3262          may be needed.  */
3263       target_mourn_inferior ();
3264
3265       print_signal_exited_reason (ecs->ws.value.sig);
3266       singlestep_breakpoints_inserted_p = 0;
3267       cancel_single_step_breakpoints ();
3268       stop_stepping (ecs);
3269       return;
3270
3271       /* The following are the only cases in which we keep going;
3272          the above cases end in a continue or goto.  */
3273     case TARGET_WAITKIND_FORKED:
3274     case TARGET_WAITKIND_VFORKED:
3275       if (debug_infrun)
3276         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
3277
3278       if (!ptid_equal (ecs->ptid, inferior_ptid))
3279         {
3280           context_switch (ecs->ptid);
3281           reinit_frame_cache ();
3282         }
3283
3284       /* Immediately detach breakpoints from the child before there's
3285          any chance of letting the user delete breakpoints from the
3286          breakpoint lists.  If we don't do this early, it's easy to
3287          leave left over traps in the child, vis: "break foo; catch
3288          fork; c; <fork>; del; c; <child calls foo>".  We only follow
3289          the fork on the last `continue', and by that time the
3290          breakpoint at "foo" is long gone from the breakpoint table.
3291          If we vforked, then we don't need to unpatch here, since both
3292          parent and child are sharing the same memory pages; we'll
3293          need to unpatch at follow/detach time instead to be certain
3294          that new breakpoints added between catchpoint hit time and
3295          vfork follow are detached.  */
3296       if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
3297         {
3298           int child_pid = ptid_get_pid (ecs->ws.value.related_pid);
3299
3300           /* This won't actually modify the breakpoint list, but will
3301              physically remove the breakpoints from the child.  */
3302           detach_breakpoints (child_pid);
3303         }
3304
3305       if (singlestep_breakpoints_inserted_p)
3306         {
3307           /* Pull the single step breakpoints out of the target.  */
3308           remove_single_step_breakpoints ();
3309           singlestep_breakpoints_inserted_p = 0;
3310         }
3311
3312       /* In case the event is caught by a catchpoint, remember that
3313          the event is to be followed at the next resume of the thread,
3314          and not immediately.  */
3315       ecs->event_thread->pending_follow = ecs->ws;
3316
3317       stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3318
3319       ecs->event_thread->control.stop_bpstat
3320         = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3321                               stop_pc, ecs->ptid);
3322
3323       /* Note that we're interested in knowing the bpstat actually
3324          causes a stop, not just if it may explain the signal.
3325          Software watchpoints, for example, always appear in the
3326          bpstat.  */
3327       ecs->random_signal
3328         = !bpstat_causes_stop (ecs->event_thread->control.stop_bpstat);
3329
3330       /* If no catchpoint triggered for this, then keep going.  */
3331       if (ecs->random_signal)
3332         {
3333           ptid_t parent;
3334           ptid_t child;
3335           int should_resume;
3336           int follow_child
3337             = (follow_fork_mode_string == follow_fork_mode_child);
3338
3339           ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
3340
3341           should_resume = follow_fork ();
3342
3343           parent = ecs->ptid;
3344           child = ecs->ws.value.related_pid;
3345
3346           /* In non-stop mode, also resume the other branch.  */
3347           if (non_stop && !detach_fork)
3348             {
3349               if (follow_child)
3350                 switch_to_thread (parent);
3351               else
3352                 switch_to_thread (child);
3353
3354               ecs->event_thread = inferior_thread ();
3355               ecs->ptid = inferior_ptid;
3356               keep_going (ecs);
3357             }
3358
3359           if (follow_child)
3360             switch_to_thread (child);
3361           else
3362             switch_to_thread (parent);
3363
3364           ecs->event_thread = inferior_thread ();
3365           ecs->ptid = inferior_ptid;
3366
3367           if (should_resume)
3368             keep_going (ecs);
3369           else
3370             stop_stepping (ecs);
3371           return;
3372         }
3373       ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP;
3374       goto process_event_stop_test;
3375
3376     case TARGET_WAITKIND_VFORK_DONE:
3377       /* Done with the shared memory region.  Re-insert breakpoints in
3378          the parent, and keep going.  */
3379
3380       if (debug_infrun)
3381         fprintf_unfiltered (gdb_stdlog,
3382                             "infrun: TARGET_WAITKIND_VFORK_DONE\n");
3383
3384       if (!ptid_equal (ecs->ptid, inferior_ptid))
3385         context_switch (ecs->ptid);
3386
3387       current_inferior ()->waiting_for_vfork_done = 0;
3388       current_inferior ()->pspace->breakpoints_not_allowed = 0;
3389       /* This also takes care of reinserting breakpoints in the
3390          previously locked inferior.  */
3391       keep_going (ecs);
3392       return;
3393
3394     case TARGET_WAITKIND_EXECD:
3395       if (debug_infrun)
3396         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
3397
3398       if (!ptid_equal (ecs->ptid, inferior_ptid))
3399         {
3400           context_switch (ecs->ptid);
3401           reinit_frame_cache ();
3402         }
3403
3404       singlestep_breakpoints_inserted_p = 0;
3405       cancel_single_step_breakpoints ();
3406
3407       stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3408
3409       /* Do whatever is necessary to the parent branch of the vfork.  */
3410       handle_vfork_child_exec_or_exit (1);
3411
3412       /* This causes the eventpoints and symbol table to be reset.
3413          Must do this now, before trying to determine whether to
3414          stop.  */
3415       follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
3416
3417       ecs->event_thread->control.stop_bpstat
3418         = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3419                               stop_pc, ecs->ptid);
3420       ecs->random_signal
3421         = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat);
3422
3423       /* Note that this may be referenced from inside
3424          bpstat_stop_status above, through inferior_has_execd.  */
3425       xfree (ecs->ws.value.execd_pathname);
3426       ecs->ws.value.execd_pathname = NULL;
3427
3428       /* If no catchpoint triggered for this, then keep going.  */
3429       if (ecs->random_signal)
3430         {
3431           ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
3432           keep_going (ecs);
3433           return;
3434         }
3435       ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP;
3436       goto process_event_stop_test;
3437
3438       /* Be careful not to try to gather much state about a thread
3439          that's in a syscall.  It's frequently a losing proposition.  */
3440     case TARGET_WAITKIND_SYSCALL_ENTRY:
3441       if (debug_infrun)
3442         fprintf_unfiltered (gdb_stdlog,
3443                             "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
3444       /* Getting the current syscall number.  */
3445       if (handle_syscall_event (ecs) != 0)
3446         return;
3447       goto process_event_stop_test;
3448
3449       /* Before examining the threads further, step this thread to
3450          get it entirely out of the syscall.  (We get notice of the
3451          event when the thread is just on the verge of exiting a
3452          syscall.  Stepping one instruction seems to get it back
3453          into user code.)  */
3454     case TARGET_WAITKIND_SYSCALL_RETURN:
3455       if (debug_infrun)
3456         fprintf_unfiltered (gdb_stdlog,
3457                             "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
3458       if (handle_syscall_event (ecs) != 0)
3459         return;
3460       goto process_event_stop_test;
3461
3462     case TARGET_WAITKIND_STOPPED:
3463       if (debug_infrun)
3464         fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
3465       ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
3466       break;
3467
3468     case TARGET_WAITKIND_NO_HISTORY:
3469       /* Reverse execution: target ran out of history info.  */
3470       stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3471       print_no_history_reason ();
3472       stop_stepping (ecs);
3473       return;
3474     }
3475
3476   if (ecs->new_thread_event)
3477     {
3478       if (non_stop)
3479         /* Non-stop assumes that the target handles adding new threads
3480            to the thread list.  */
3481         internal_error (__FILE__, __LINE__,
3482                         "targets should add new threads to the thread "
3483                         "list themselves in non-stop mode.");
3484
3485       /* We may want to consider not doing a resume here in order to
3486          give the user a chance to play with the new thread.  It might
3487          be good to make that a user-settable option.  */
3488
3489       /* At this point, all threads are stopped (happens automatically
3490          in either the OS or the native code).  Therefore we need to
3491          continue all threads in order to make progress.  */
3492
3493       if (!ptid_equal (ecs->ptid, inferior_ptid))
3494         context_switch (ecs->ptid);
3495       target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0);
3496       prepare_to_wait (ecs);
3497       return;
3498     }
3499
3500   if (ecs->ws.kind == TARGET_WAITKIND_STOPPED)
3501     {
3502       /* Do we need to clean up the state of a thread that has
3503          completed a displaced single-step?  (Doing so usually affects
3504          the PC, so do it here, before we set stop_pc.)  */
3505       displaced_step_fixup (ecs->ptid,
3506                             ecs->event_thread->suspend.stop_signal);
3507
3508       /* If we either finished a single-step or hit a breakpoint, but
3509          the user wanted this thread to be stopped, pretend we got a
3510          SIG0 (generic unsignaled stop).  */
3511
3512       if (ecs->event_thread->stop_requested
3513           && ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP)
3514         ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
3515     }
3516
3517   stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
3518
3519   if (debug_infrun)
3520     {
3521       struct regcache *regcache = get_thread_regcache (ecs->ptid);
3522       struct gdbarch *gdbarch = get_regcache_arch (regcache);
3523       struct cleanup *old_chain = save_inferior_ptid ();
3524
3525       inferior_ptid = ecs->ptid;
3526
3527       fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
3528                           paddress (gdbarch, stop_pc));
3529       if (target_stopped_by_watchpoint ())
3530         {
3531           CORE_ADDR addr;
3532
3533           fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
3534
3535           if (target_stopped_data_address (&current_target, &addr))
3536             fprintf_unfiltered (gdb_stdlog,
3537                                 "infrun: stopped data address = %s\n",
3538                                 paddress (gdbarch, addr));
3539           else
3540             fprintf_unfiltered (gdb_stdlog,
3541                                 "infrun: (no data address available)\n");
3542         }
3543
3544       do_cleanups (old_chain);
3545     }
3546
3547   if (stepping_past_singlestep_breakpoint)
3548     {
3549       gdb_assert (singlestep_breakpoints_inserted_p);
3550       gdb_assert (ptid_equal (singlestep_ptid, ecs->ptid));
3551       gdb_assert (!ptid_equal (singlestep_ptid, saved_singlestep_ptid));
3552
3553       stepping_past_singlestep_breakpoint = 0;
3554
3555       /* We've either finished single-stepping past the single-step
3556          breakpoint, or stopped for some other reason.  It would be nice if
3557          we could tell, but we can't reliably.  */
3558       if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP)
3559         {
3560           if (debug_infrun)
3561             fprintf_unfiltered (gdb_stdlog,
3562                                 "infrun: stepping_past_"
3563                                 "singlestep_breakpoint\n");
3564           /* Pull the single step breakpoints out of the target.  */
3565           remove_single_step_breakpoints ();
3566           singlestep_breakpoints_inserted_p = 0;
3567
3568           ecs->random_signal = 0;
3569           ecs->event_thread->control.trap_expected = 0;
3570
3571           context_switch (saved_singlestep_ptid);
3572           if (deprecated_context_hook)
3573             deprecated_context_hook (pid_to_thread_id (ecs->ptid));
3574
3575           resume (1, TARGET_SIGNAL_0);
3576           prepare_to_wait (ecs);
3577           return;
3578         }
3579     }
3580
3581   if (!ptid_equal (deferred_step_ptid, null_ptid))
3582     {
3583       /* In non-stop mode, there's never a deferred_step_ptid set.  */
3584       gdb_assert (!non_stop);
3585
3586       /* If we stopped for some other reason than single-stepping, ignore
3587          the fact that we were supposed to switch back.  */
3588       if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP)
3589         {
3590           if (debug_infrun)
3591             fprintf_unfiltered (gdb_stdlog,
3592                                 "infrun: handling deferred step\n");
3593
3594           /* Pull the single step breakpoints out of the target.  */
3595           if (singlestep_breakpoints_inserted_p)
3596             {
3597               remove_single_step_breakpoints ();
3598               singlestep_breakpoints_inserted_p = 0;
3599             }
3600
3601           /* Note: We do not call context_switch at this point, as the
3602              context is already set up for stepping the original thread.  */
3603           switch_to_thread (deferred_step_ptid);
3604           deferred_step_ptid = null_ptid;
3605           /* Suppress spurious "Switching to ..." message.  */
3606           previous_inferior_ptid = inferior_ptid;
3607
3608           resume (1, TARGET_SIGNAL_0);
3609           prepare_to_wait (ecs);
3610           return;
3611         }
3612
3613       deferred_step_ptid = null_ptid;
3614     }
3615
3616   /* See if a thread hit a thread-specific breakpoint that was meant for
3617      another thread.  If so, then step that thread past the breakpoint,
3618      and continue it.  */
3619
3620   if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP)
3621     {
3622       int thread_hop_needed = 0;
3623       struct address_space *aspace = 
3624         get_regcache_aspace (get_thread_regcache (ecs->ptid));
3625
3626       /* Check if a regular breakpoint has been hit before checking
3627          for a potential single step breakpoint.  Otherwise, GDB will
3628          not see this breakpoint hit when stepping onto breakpoints.  */
3629       if (regular_breakpoint_inserted_here_p (aspace, stop_pc))
3630         {
3631           ecs->random_signal = 0;
3632           if (!breakpoint_thread_match (aspace, stop_pc, ecs->ptid))
3633             thread_hop_needed = 1;
3634         }
3635       else if (singlestep_breakpoints_inserted_p)
3636         {
3637           /* We have not context switched yet, so this should be true
3638              no matter which thread hit the singlestep breakpoint.  */
3639           gdb_assert (ptid_equal (inferior_ptid, singlestep_ptid));
3640           if (debug_infrun)
3641             fprintf_unfiltered (gdb_stdlog, "infrun: software single step "
3642                                 "trap for %s\n",
3643                                 target_pid_to_str (ecs->ptid));
3644
3645           ecs->random_signal = 0;
3646           /* The call to in_thread_list is necessary because PTIDs sometimes
3647              change when we go from single-threaded to multi-threaded.  If
3648              the singlestep_ptid is still in the list, assume that it is
3649              really different from ecs->ptid.  */
3650           if (!ptid_equal (singlestep_ptid, ecs->ptid)
3651               && in_thread_list (singlestep_ptid))
3652             {
3653               /* If the PC of the thread we were trying to single-step
3654                  has changed, discard this event (which we were going
3655                  to ignore anyway), and pretend we saw that thread
3656                  trap.  This prevents us continuously moving the
3657                  single-step breakpoint forward, one instruction at a
3658                  time.  If the PC has changed, then the thread we were
3659                  trying to single-step has trapped or been signalled,
3660                  but the event has not been reported to GDB yet.
3661
3662                  There might be some cases where this loses signal
3663                  information, if a signal has arrived at exactly the
3664                  same time that the PC changed, but this is the best
3665                  we can do with the information available.  Perhaps we
3666                  should arrange to report all events for all threads
3667                  when they stop, or to re-poll the remote looking for
3668                  this particular thread (i.e. temporarily enable
3669                  schedlock).  */
3670
3671              CORE_ADDR new_singlestep_pc
3672                = regcache_read_pc (get_thread_regcache (singlestep_ptid));
3673
3674              if (new_singlestep_pc != singlestep_pc)
3675                {
3676                  enum target_signal stop_signal;
3677
3678                  if (debug_infrun)
3679                    fprintf_unfiltered (gdb_stdlog, "infrun: unexpected thread,"
3680                                        " but expected thread advanced also\n");
3681
3682                  /* The current context still belongs to
3683                     singlestep_ptid.  Don't swap here, since that's
3684                     the context we want to use.  Just fudge our
3685                     state and continue.  */
3686                  stop_signal = ecs->event_thread->suspend.stop_signal;
3687                  ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
3688                  ecs->ptid = singlestep_ptid;
3689                  ecs->event_thread = find_thread_ptid (ecs->ptid);
3690                  ecs->event_thread->suspend.stop_signal = stop_signal;
3691                  stop_pc = new_singlestep_pc;
3692                }
3693              else
3694                {
3695                  if (debug_infrun)
3696                    fprintf_unfiltered (gdb_stdlog,
3697                                        "infrun: unexpected thread\n");
3698
3699                  thread_hop_needed = 1;
3700                  stepping_past_singlestep_breakpoint = 1;
3701                  saved_singlestep_ptid = singlestep_ptid;
3702                }
3703             }
3704         }
3705
3706       if (thread_hop_needed)
3707         {
3708           struct regcache *thread_regcache;
3709           int remove_status = 0;
3710
3711           if (debug_infrun)
3712             fprintf_unfiltered (gdb_stdlog, "infrun: thread_hop_needed\n");
3713
3714           /* Switch context before touching inferior memory, the
3715              previous thread may have exited.  */
3716           if (!ptid_equal (inferior_ptid, ecs->ptid))
3717             context_switch (ecs->ptid);
3718
3719           /* Saw a breakpoint, but it was hit by the wrong thread.
3720              Just continue.  */
3721
3722           if (singlestep_breakpoints_inserted_p)
3723             {
3724               /* Pull the single step breakpoints out of the target.  */
3725               remove_single_step_breakpoints ();
3726               singlestep_breakpoints_inserted_p = 0;
3727             }
3728
3729           /* If the arch can displace step, don't remove the
3730              breakpoints.  */
3731           thread_regcache = get_thread_regcache (ecs->ptid);
3732           if (!use_displaced_stepping (get_regcache_arch (thread_regcache)))
3733             remove_status = remove_breakpoints ();
3734
3735           /* Did we fail to remove breakpoints?  If so, try
3736              to set the PC past the bp.  (There's at least
3737              one situation in which we can fail to remove
3738              the bp's: On HP-UX's that use ttrace, we can't
3739              change the address space of a vforking child
3740              process until the child exits (well, okay, not
3741              then either :-) or execs.  */
3742           if (remove_status != 0)
3743             error (_("Cannot step over breakpoint hit in wrong thread"));
3744           else
3745             {                   /* Single step */
3746               if (!non_stop)
3747                 {
3748                   /* Only need to require the next event from this
3749                      thread in all-stop mode.  */
3750                   waiton_ptid = ecs->ptid;
3751                   infwait_state = infwait_thread_hop_state;
3752                 }
3753
3754               ecs->event_thread->stepping_over_breakpoint = 1;
3755               keep_going (ecs);
3756               return;
3757             }
3758         }
3759       else if (singlestep_breakpoints_inserted_p)
3760         {
3761           sw_single_step_trap_p = 1;
3762           ecs->random_signal = 0;
3763         }
3764     }
3765   else
3766     ecs->random_signal = 1;
3767
3768   /* See if something interesting happened to the non-current thread.  If
3769      so, then switch to that thread.  */
3770   if (!ptid_equal (ecs->ptid, inferior_ptid))
3771     {
3772       if (debug_infrun)
3773         fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
3774
3775       context_switch (ecs->ptid);
3776
3777       if (deprecated_context_hook)
3778         deprecated_context_hook (pid_to_thread_id (ecs->ptid));
3779     }
3780
3781   /* At this point, get hold of the now-current thread's frame.  */
3782   frame = get_current_frame ();
3783   gdbarch = get_frame_arch (frame);
3784
3785   if (singlestep_breakpoints_inserted_p)
3786     {
3787       /* Pull the single step breakpoints out of the target.  */
3788       remove_single_step_breakpoints ();
3789       singlestep_breakpoints_inserted_p = 0;
3790     }
3791
3792   if (stepped_after_stopped_by_watchpoint)
3793     stopped_by_watchpoint = 0;
3794   else
3795     stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
3796
3797   /* If necessary, step over this watchpoint.  We'll be back to display
3798      it in a moment.  */
3799   if (stopped_by_watchpoint
3800       && (target_have_steppable_watchpoint
3801           || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
3802     {
3803       /* At this point, we are stopped at an instruction which has
3804          attempted to write to a piece of memory under control of
3805          a watchpoint.  The instruction hasn't actually executed
3806          yet.  If we were to evaluate the watchpoint expression
3807          now, we would get the old value, and therefore no change
3808          would seem to have occurred.
3809
3810          In order to make watchpoints work `right', we really need
3811          to complete the memory write, and then evaluate the
3812          watchpoint expression.  We do this by single-stepping the
3813          target.
3814
3815          It may not be necessary to disable the watchpoint to stop over
3816          it.  For example, the PA can (with some kernel cooperation)
3817          single step over a watchpoint without disabling the watchpoint.
3818
3819          It is far more common to need to disable a watchpoint to step
3820          the inferior over it.  If we have non-steppable watchpoints,
3821          we must disable the current watchpoint; it's simplest to
3822          disable all watchpoints and breakpoints.  */
3823       int hw_step = 1;
3824
3825       if (!target_have_steppable_watchpoint)
3826         remove_breakpoints ();
3827         /* Single step */
3828       hw_step = maybe_software_singlestep (gdbarch, stop_pc);
3829       target_resume (ecs->ptid, hw_step, TARGET_SIGNAL_0);
3830       waiton_ptid = ecs->ptid;
3831       if (target_have_steppable_watchpoint)
3832         infwait_state = infwait_step_watch_state;
3833       else
3834         infwait_state = infwait_nonstep_watch_state;
3835       prepare_to_wait (ecs);
3836       return;
3837     }
3838
3839   ecs->stop_func_start = 0;
3840   ecs->stop_func_end = 0;
3841   ecs->stop_func_name = 0;
3842   /* Don't care about return value; stop_func_start and stop_func_name
3843      will both be 0 if it doesn't work.  */
3844   find_pc_partial_function (stop_pc, &ecs->stop_func_name,
3845                             &ecs->stop_func_start, &ecs->stop_func_end);
3846   ecs->stop_func_start
3847     += gdbarch_deprecated_function_start_offset (gdbarch);
3848   ecs->event_thread->stepping_over_breakpoint = 0;
3849   bpstat_clear (&ecs->event_thread->control.stop_bpstat);
3850   ecs->event_thread->control.stop_step = 0;
3851   stop_print_frame = 1;
3852   ecs->random_signal = 0;
3853   stopped_by_random_signal = 0;
3854
3855   /* Hide inlined functions starting here, unless we just performed stepi or
3856      nexti.  After stepi and nexti, always show the innermost frame (not any
3857      inline function call sites).  */
3858   if (ecs->event_thread->control.step_range_end != 1)
3859     skip_inline_frames (ecs->ptid);
3860
3861   if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP
3862       && ecs->event_thread->control.trap_expected
3863       && gdbarch_single_step_through_delay_p (gdbarch)
3864       && currently_stepping (ecs->event_thread))
3865     {
3866       /* We're trying to step off a breakpoint.  Turns out that we're
3867          also on an instruction that needs to be stepped multiple
3868          times before it's been fully executing.  E.g., architectures
3869          with a delay slot.  It needs to be stepped twice, once for
3870          the instruction and once for the delay slot.  */
3871       int step_through_delay
3872         = gdbarch_single_step_through_delay (gdbarch, frame);
3873
3874       if (debug_infrun && step_through_delay)
3875         fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
3876       if (ecs->event_thread->control.step_range_end == 0
3877           && step_through_delay)
3878         {
3879           /* The user issued a continue when stopped at a breakpoint.
3880              Set up for another trap and get out of here.  */
3881          ecs->event_thread->stepping_over_breakpoint = 1;
3882          keep_going (ecs);
3883          return;
3884         }
3885       else if (step_through_delay)
3886         {
3887           /* The user issued a step when stopped at a breakpoint.
3888              Maybe we should stop, maybe we should not - the delay
3889              slot *might* correspond to a line of source.  In any
3890              case, don't decide that here, just set 
3891              ecs->stepping_over_breakpoint, making sure we 
3892              single-step again before breakpoints are re-inserted.  */
3893           ecs->event_thread->stepping_over_breakpoint = 1;
3894         }
3895     }
3896
3897   /* Look at the cause of the stop, and decide what to do.
3898      The alternatives are:
3899      1) stop_stepping and return; to really stop and return to the debugger,
3900      2) keep_going and return to start up again
3901      (set ecs->event_thread->stepping_over_breakpoint to 1 to single step once)
3902      3) set ecs->random_signal to 1, and the decision between 1 and 2
3903      will be made according to the signal handling tables.  */
3904
3905   if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP
3906       || stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_NO_SIGSTOP
3907       || stop_soon == STOP_QUIETLY_REMOTE)
3908     {
3909       if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP
3910           && stop_after_trap)
3911         {
3912           if (debug_infrun)
3913             fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
3914           stop_print_frame = 0;
3915           stop_stepping (ecs);
3916           return;
3917         }
3918
3919       /* This is originated from start_remote(), start_inferior() and
3920          shared libraries hook functions.  */
3921       if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
3922         {
3923           if (debug_infrun)
3924             fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
3925           stop_stepping (ecs);
3926           return;
3927         }
3928
3929       /* This originates from attach_command().  We need to overwrite
3930          the stop_signal here, because some kernels don't ignore a
3931          SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
3932          See more comments in inferior.h.  On the other hand, if we
3933          get a non-SIGSTOP, report it to the user - assume the backend
3934          will handle the SIGSTOP if it should show up later.
3935
3936          Also consider that the attach is complete when we see a
3937          SIGTRAP.  Some systems (e.g. Windows), and stubs supporting
3938          target extended-remote report it instead of a SIGSTOP
3939          (e.g. gdbserver).  We already rely on SIGTRAP being our
3940          signal, so this is no exception.
3941
3942          Also consider that the attach is complete when we see a
3943          TARGET_SIGNAL_0.  In non-stop mode, GDB will explicitly tell
3944          the target to stop all threads of the inferior, in case the
3945          low level attach operation doesn't stop them implicitly.  If
3946          they weren't stopped implicitly, then the stub will report a
3947          TARGET_SIGNAL_0, meaning: stopped for no particular reason
3948          other than GDB's request.  */
3949       if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
3950           && (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_STOP
3951               || ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP
3952               || ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_0))
3953         {
3954           stop_stepping (ecs);
3955           ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
3956           return;
3957         }
3958
3959       /* See if there is a breakpoint at the current PC.  */
3960       ecs->event_thread->control.stop_bpstat
3961         = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()),
3962                               stop_pc, ecs->ptid);
3963
3964       /* Following in case break condition called a
3965          function.  */
3966       stop_print_frame = 1;
3967
3968       /* This is where we handle "moribund" watchpoints.  Unlike
3969          software breakpoints traps, hardware watchpoint traps are
3970          always distinguishable from random traps.  If no high-level
3971          watchpoint is associated with the reported stop data address
3972          anymore, then the bpstat does not explain the signal ---
3973          simply make sure to ignore it if `stopped_by_watchpoint' is
3974          set.  */
3975
3976       if (debug_infrun
3977           && ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP
3978           && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat)
3979           && stopped_by_watchpoint)
3980         fprintf_unfiltered (gdb_stdlog,
3981                             "infrun: no user watchpoint explains "
3982                             "watchpoint SIGTRAP, ignoring\n");
3983
3984       /* NOTE: cagney/2003-03-29: These two checks for a random signal
3985          at one stage in the past included checks for an inferior
3986          function call's call dummy's return breakpoint.  The original
3987          comment, that went with the test, read:
3988
3989          ``End of a stack dummy.  Some systems (e.g. Sony news) give
3990          another signal besides SIGTRAP, so check here as well as
3991          above.''
3992
3993          If someone ever tries to get call dummys on a
3994          non-executable stack to work (where the target would stop
3995          with something like a SIGSEGV), then those tests might need
3996          to be re-instated.  Given, however, that the tests were only
3997          enabled when momentary breakpoints were not being used, I
3998          suspect that it won't be the case.
3999
4000          NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
4001          be necessary for call dummies on a non-executable stack on
4002          SPARC.  */
4003
4004       if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP)
4005         ecs->random_signal
4006           = !(bpstat_explains_signal (ecs->event_thread->control.stop_bpstat)
4007               || stopped_by_watchpoint
4008               || ecs->event_thread->control.trap_expected
4009               || (ecs->event_thread->control.step_range_end
4010                   && (ecs->event_thread->control.step_resume_breakpoint
4011                       == NULL)));
4012       else
4013         {
4014           ecs->random_signal = !bpstat_explains_signal
4015                                      (ecs->event_thread->control.stop_bpstat);
4016           if (!ecs->random_signal)
4017             ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP;
4018         }
4019     }
4020
4021   /* When we reach this point, we've pretty much decided
4022      that the reason for stopping must've been a random
4023      (unexpected) signal.  */
4024
4025   else
4026     ecs->random_signal = 1;
4027
4028 process_event_stop_test:
4029
4030   /* Re-fetch current thread's frame in case we did a
4031      "goto process_event_stop_test" above.  */
4032   frame = get_current_frame ();
4033   gdbarch = get_frame_arch (frame);
4034
4035   /* For the program's own signals, act according to
4036      the signal handling tables.  */
4037
4038   if (ecs->random_signal)
4039     {
4040       /* Signal not for debugging purposes.  */
4041       int printed = 0;
4042       struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
4043
4044       if (debug_infrun)
4045          fprintf_unfiltered (gdb_stdlog, "infrun: random signal %d\n",
4046                              ecs->event_thread->suspend.stop_signal);
4047
4048       stopped_by_random_signal = 1;
4049
4050       if (signal_print[ecs->event_thread->suspend.stop_signal])
4051         {
4052           printed = 1;
4053           target_terminal_ours_for_output ();
4054           print_signal_received_reason
4055                                      (ecs->event_thread->suspend.stop_signal);
4056         }
4057       /* Always stop on signals if we're either just gaining control
4058          of the program, or the user explicitly requested this thread
4059          to remain stopped.  */
4060       if (stop_soon != NO_STOP_QUIETLY
4061           || ecs->event_thread->stop_requested
4062           || (!inf->detaching
4063               && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
4064         {
4065           stop_stepping (ecs);
4066           return;
4067         }
4068       /* If not going to stop, give terminal back
4069          if we took it away.  */
4070       else if (printed)
4071         target_terminal_inferior ();
4072
4073       /* Clear the signal if it should not be passed.  */
4074       if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
4075         ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0;
4076
4077       if (ecs->event_thread->prev_pc == stop_pc
4078           && ecs->event_thread->control.trap_expected
4079           && ecs->event_thread->control.step_resume_breakpoint == NULL)
4080         {
4081           /* We were just starting a new sequence, attempting to
4082              single-step off of a breakpoint and expecting a SIGTRAP.
4083              Instead this signal arrives.  This signal will take us out
4084              of the stepping range so GDB needs to remember to, when
4085              the signal handler returns, resume stepping off that
4086              breakpoint.  */
4087           /* To simplify things, "continue" is forced to use the same
4088              code paths as single-step - set a breakpoint at the
4089              signal return address and then, once hit, step off that
4090              breakpoint.  */
4091           if (debug_infrun)
4092             fprintf_unfiltered (gdb_stdlog,
4093                                 "infrun: signal arrived while stepping over "
4094                                 "breakpoint\n");
4095
4096           insert_step_resume_breakpoint_at_frame (frame);
4097           ecs->event_thread->step_after_step_resume_breakpoint = 1;
4098           keep_going (ecs);
4099           return;
4100         }
4101
4102       if (ecs->event_thread->control.step_range_end != 0
4103           && ecs->event_thread->suspend.stop_signal != TARGET_SIGNAL_0
4104           && (ecs->event_thread->control.step_range_start <= stop_pc
4105               && stop_pc < ecs->event_thread->control.step_range_end)
4106           && frame_id_eq (get_stack_frame_id (frame),
4107                           ecs->event_thread->control.step_stack_frame_id)
4108           && ecs->event_thread->control.step_resume_breakpoint == NULL)
4109         {
4110           /* The inferior is about to take a signal that will take it
4111              out of the single step range.  Set a breakpoint at the
4112              current PC (which is presumably where the signal handler
4113              will eventually return) and then allow the inferior to
4114              run free.
4115
4116              Note that this is only needed for a signal delivered
4117              while in the single-step range.  Nested signals aren't a
4118              problem as they eventually all return.  */
4119           if (debug_infrun)
4120             fprintf_unfiltered (gdb_stdlog,
4121                                 "infrun: signal may take us out of "
4122                                 "single-step range\n");
4123
4124           insert_step_resume_breakpoint_at_frame (frame);
4125           keep_going (ecs);
4126           return;
4127         }
4128
4129       /* Note: step_resume_breakpoint may be non-NULL.  This occures
4130          when either there's a nested signal, or when there's a
4131          pending signal enabled just as the signal handler returns
4132          (leaving the inferior at the step-resume-breakpoint without
4133          actually executing it).  Either way continue until the
4134          breakpoint is really hit.  */
4135       keep_going (ecs);
4136       return;
4137     }
4138
4139   /* Handle cases caused by hitting a breakpoint.  */
4140   {
4141     CORE_ADDR jmp_buf_pc;
4142     struct bpstat_what what;
4143
4144     what = bpstat_what (ecs->event_thread->control.stop_bpstat);
4145
4146     if (what.call_dummy)
4147       {
4148         stop_stack_dummy = what.call_dummy;
4149       }
4150
4151     /* If we hit an internal event that triggers symbol changes, the
4152        current frame will be invalidated within bpstat_what (e.g., if
4153        we hit an internal solib event).  Re-fetch it.  */
4154     frame = get_current_frame ();
4155     gdbarch = get_frame_arch (frame);
4156
4157     switch (what.main_action)
4158       {
4159       case BPSTAT_WHAT_SET_LONGJMP_RESUME:
4160         /* If we hit the breakpoint at longjmp while stepping, we
4161            install a momentary breakpoint at the target of the
4162            jmp_buf.  */
4163
4164         if (debug_infrun)
4165           fprintf_unfiltered (gdb_stdlog,
4166                               "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4167
4168         ecs->event_thread->stepping_over_breakpoint = 1;
4169
4170         if (what.is_longjmp)
4171           {
4172             if (!gdbarch_get_longjmp_target_p (gdbarch)
4173                 || !gdbarch_get_longjmp_target (gdbarch,
4174                                                 frame, &jmp_buf_pc))
4175               {
4176                 if (debug_infrun)
4177                   fprintf_unfiltered (gdb_stdlog,
4178                                       "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4179                                       "(!gdbarch_get_longjmp_target)\n");
4180                 keep_going (ecs);
4181                 return;
4182               }