2004-07-16 Andrew Cagney <cagney@gnu.org>
[external/binutils.git] / gdb / infrun.c
1 /* Target-struct-independent code to start (run) and stop an inferior
2    process.
3
4    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
5    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
6    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 2 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, write to the Free Software
22    Foundation, Inc., 59 Temple Place - Suite 330,
23    Boston, MA 02111-1307, USA.  */
24
25 #include "defs.h"
26 #include "gdb_string.h"
27 #include <ctype.h>
28 #include "symtab.h"
29 #include "frame.h"
30 #include "inferior.h"
31 #include "breakpoint.h"
32 #include "gdb_wait.h"
33 #include "gdbcore.h"
34 #include "gdbcmd.h"
35 #include "cli/cli-script.h"
36 #include "target.h"
37 #include "gdbthread.h"
38 #include "annotate.h"
39 #include "symfile.h"
40 #include "top.h"
41 #include <signal.h>
42 #include "inf-loop.h"
43 #include "regcache.h"
44 #include "value.h"
45 #include "observer.h"
46 #include "language.h"
47 #include "gdb_assert.h"
48
49 /* Prototypes for local functions */
50
51 static void signals_info (char *, int);
52
53 static void handle_command (char *, int);
54
55 static void sig_print_info (enum target_signal);
56
57 static void sig_print_header (void);
58
59 static void resume_cleanups (void *);
60
61 static int hook_stop_stub (void *);
62
63 static int restore_selected_frame (void *);
64
65 static void build_infrun (void);
66
67 static int follow_fork (void);
68
69 static void set_schedlock_func (char *args, int from_tty,
70                                 struct cmd_list_element *c);
71
72 struct execution_control_state;
73
74 static int currently_stepping (struct execution_control_state *ecs);
75
76 static void xdb_handle_command (char *args, int from_tty);
77
78 static int prepare_to_proceed (void);
79
80 void _initialize_infrun (void);
81
82 int inferior_ignoring_startup_exec_events = 0;
83 int inferior_ignoring_leading_exec_events = 0;
84
85 /* When set, stop the 'step' command if we enter a function which has
86    no line number information.  The normal behavior is that we step
87    over such function.  */
88 int step_stop_if_no_debug = 0;
89
90 /* In asynchronous mode, but simulating synchronous execution. */
91
92 int sync_execution = 0;
93
94 /* wait_for_inferior and normal_stop use this to notify the user
95    when the inferior stopped in a different thread than it had been
96    running in.  */
97
98 static ptid_t previous_inferior_ptid;
99
100 /* This is true for configurations that may follow through execl() and
101    similar functions.  At present this is only true for HP-UX native.  */
102
103 #ifndef MAY_FOLLOW_EXEC
104 #define MAY_FOLLOW_EXEC (0)
105 #endif
106
107 static int may_follow_exec = MAY_FOLLOW_EXEC;
108
109 /* If the program uses ELF-style shared libraries, then calls to
110    functions in shared libraries go through stubs, which live in a
111    table called the PLT (Procedure Linkage Table).  The first time the
112    function is called, the stub sends control to the dynamic linker,
113    which looks up the function's real address, patches the stub so
114    that future calls will go directly to the function, and then passes
115    control to the function.
116
117    If we are stepping at the source level, we don't want to see any of
118    this --- we just want to skip over the stub and the dynamic linker.
119    The simple approach is to single-step until control leaves the
120    dynamic linker.
121
122    However, on some systems (e.g., Red Hat's 5.2 distribution) the
123    dynamic linker calls functions in the shared C library, so you
124    can't tell from the PC alone whether the dynamic linker is still
125    running.  In this case, we use a step-resume breakpoint to get us
126    past the dynamic linker, as if we were using "next" to step over a
127    function call.
128
129    IN_SOLIB_DYNSYM_RESOLVE_CODE says whether we're in the dynamic
130    linker code or not.  Normally, this means we single-step.  However,
131    if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an
132    address where we can place a step-resume breakpoint to get past the
133    linker's symbol resolution function.
134
135    IN_SOLIB_DYNSYM_RESOLVE_CODE can generally be implemented in a
136    pretty portable way, by comparing the PC against the address ranges
137    of the dynamic linker's sections.
138
139    SKIP_SOLIB_RESOLVER is generally going to be system-specific, since
140    it depends on internal details of the dynamic linker.  It's usually
141    not too hard to figure out where to put a breakpoint, but it
142    certainly isn't portable.  SKIP_SOLIB_RESOLVER should do plenty of
143    sanity checking.  If it can't figure things out, returning zero and
144    getting the (possibly confusing) stepping behavior is better than
145    signalling an error, which will obscure the change in the
146    inferior's state.  */
147
148 #ifndef IN_SOLIB_DYNSYM_RESOLVE_CODE
149 #define IN_SOLIB_DYNSYM_RESOLVE_CODE(pc) 0
150 #endif
151
152 /* This function returns TRUE if pc is the address of an instruction
153    that lies within the dynamic linker (such as the event hook, or the
154    dld itself).
155
156    This function must be used only when a dynamic linker event has
157    been caught, and the inferior is being stepped out of the hook, or
158    undefined results are guaranteed.  */
159
160 #ifndef SOLIB_IN_DYNAMIC_LINKER
161 #define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0
162 #endif
163
164 /* On MIPS16, a function that returns a floating point value may call
165    a library helper function to copy the return value to a floating point
166    register.  The IGNORE_HELPER_CALL macro returns non-zero if we
167    should ignore (i.e. step over) this function call.  */
168 #ifndef IGNORE_HELPER_CALL
169 #define IGNORE_HELPER_CALL(pc)  0
170 #endif
171
172 /* On some systems, the PC may be left pointing at an instruction that  won't
173    actually be executed.  This is usually indicated by a bit in the PSW.  If
174    we find ourselves in such a state, then we step the target beyond the
175    nullified instruction before returning control to the user so as to avoid
176    confusion. */
177
178 #ifndef INSTRUCTION_NULLIFIED
179 #define INSTRUCTION_NULLIFIED 0
180 #endif
181
182 /* We can't step off a permanent breakpoint in the ordinary way, because we
183    can't remove it.  Instead, we have to advance the PC to the next
184    instruction.  This macro should expand to a pointer to a function that
185    does that, or zero if we have no such function.  If we don't have a
186    definition for it, we have to report an error.  */
187 #ifndef SKIP_PERMANENT_BREAKPOINT
188 #define SKIP_PERMANENT_BREAKPOINT (default_skip_permanent_breakpoint)
189 static void
190 default_skip_permanent_breakpoint (void)
191 {
192   error ("\
193 The program is stopped at a permanent breakpoint, but GDB does not know\n\
194 how to step past a permanent breakpoint on this architecture.  Try using\n\
195 a command like `return' or `jump' to continue execution.");
196 }
197 #endif
198
199
200 /* Convert the #defines into values.  This is temporary until wfi control
201    flow is completely sorted out.  */
202
203 #ifndef HAVE_STEPPABLE_WATCHPOINT
204 #define HAVE_STEPPABLE_WATCHPOINT 0
205 #else
206 #undef  HAVE_STEPPABLE_WATCHPOINT
207 #define HAVE_STEPPABLE_WATCHPOINT 1
208 #endif
209
210 #ifndef CANNOT_STEP_HW_WATCHPOINTS
211 #define CANNOT_STEP_HW_WATCHPOINTS 0
212 #else
213 #undef  CANNOT_STEP_HW_WATCHPOINTS
214 #define CANNOT_STEP_HW_WATCHPOINTS 1
215 #endif
216
217 /* Tables of how to react to signals; the user sets them.  */
218
219 static unsigned char *signal_stop;
220 static unsigned char *signal_print;
221 static unsigned char *signal_program;
222
223 #define SET_SIGS(nsigs,sigs,flags) \
224   do { \
225     int signum = (nsigs); \
226     while (signum-- > 0) \
227       if ((sigs)[signum]) \
228         (flags)[signum] = 1; \
229   } while (0)
230
231 #define UNSET_SIGS(nsigs,sigs,flags) \
232   do { \
233     int signum = (nsigs); \
234     while (signum-- > 0) \
235       if ((sigs)[signum]) \
236         (flags)[signum] = 0; \
237   } while (0)
238
239 /* Value to pass to target_resume() to cause all threads to resume */
240
241 #define RESUME_ALL (pid_to_ptid (-1))
242
243 /* Command list pointer for the "stop" placeholder.  */
244
245 static struct cmd_list_element *stop_command;
246
247 /* Nonzero if breakpoints are now inserted in the inferior.  */
248
249 static int breakpoints_inserted;
250
251 /* Function inferior was in as of last step command.  */
252
253 static struct symbol *step_start_function;
254
255 /* Nonzero if we are expecting a trace trap and should proceed from it.  */
256
257 static int trap_expected;
258
259 #ifdef SOLIB_ADD
260 /* Nonzero if we want to give control to the user when we're notified
261    of shared library events by the dynamic linker.  */
262 static int stop_on_solib_events;
263 #endif
264
265 /* Nonzero means expecting a trace trap
266    and should stop the inferior and return silently when it happens.  */
267
268 int stop_after_trap;
269
270 /* Nonzero means expecting a trap and caller will handle it themselves.
271    It is used after attach, due to attaching to a process;
272    when running in the shell before the child program has been exec'd;
273    and when running some kinds of remote stuff (FIXME?).  */
274
275 enum stop_kind stop_soon;
276
277 /* Nonzero if proceed is being used for a "finish" command or a similar
278    situation when stop_registers should be saved.  */
279
280 int proceed_to_finish;
281
282 /* Save register contents here when about to pop a stack dummy frame,
283    if-and-only-if proceed_to_finish is set.
284    Thus this contains the return value from the called function (assuming
285    values are returned in a register).  */
286
287 struct regcache *stop_registers;
288
289 /* Nonzero if program stopped due to error trying to insert breakpoints.  */
290
291 static int breakpoints_failed;
292
293 /* Nonzero after stop if current stack frame should be printed.  */
294
295 static int stop_print_frame;
296
297 static struct breakpoint *step_resume_breakpoint = NULL;
298
299 /* On some platforms (e.g., HP-UX), hardware watchpoints have bad
300    interactions with an inferior that is running a kernel function
301    (aka, a system call or "syscall").  wait_for_inferior therefore
302    may have a need to know when the inferior is in a syscall.  This
303    is a count of the number of inferior threads which are known to
304    currently be running in a syscall. */
305 static int number_of_threads_in_syscalls;
306
307 /* This is a cached copy of the pid/waitstatus of the last event
308    returned by target_wait()/deprecated_target_wait_hook().  This
309    information is returned by get_last_target_status().  */
310 static ptid_t target_last_wait_ptid;
311 static struct target_waitstatus target_last_waitstatus;
312
313 /* This is used to remember when a fork, vfork or exec event
314    was caught by a catchpoint, and thus the event is to be
315    followed at the next resume of the inferior, and not
316    immediately. */
317 static struct
318 {
319   enum target_waitkind kind;
320   struct
321   {
322     int parent_pid;
323     int child_pid;
324   }
325   fork_event;
326   char *execd_pathname;
327 }
328 pending_follow;
329
330 static const char follow_fork_mode_child[] = "child";
331 static const char follow_fork_mode_parent[] = "parent";
332
333 static const char *follow_fork_mode_kind_names[] = {
334   follow_fork_mode_child,
335   follow_fork_mode_parent,
336   NULL
337 };
338
339 static const char *follow_fork_mode_string = follow_fork_mode_parent;
340 \f
341
342 static int
343 follow_fork (void)
344 {
345   int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
346
347   return target_follow_fork (follow_child);
348 }
349
350 void
351 follow_inferior_reset_breakpoints (void)
352 {
353   /* Was there a step_resume breakpoint?  (There was if the user
354      did a "next" at the fork() call.)  If so, explicitly reset its
355      thread number.
356
357      step_resumes are a form of bp that are made to be per-thread.
358      Since we created the step_resume bp when the parent process
359      was being debugged, and now are switching to the child process,
360      from the breakpoint package's viewpoint, that's a switch of
361      "threads".  We must update the bp's notion of which thread
362      it is for, or it'll be ignored when it triggers.  */
363
364   if (step_resume_breakpoint)
365     breakpoint_re_set_thread (step_resume_breakpoint);
366
367   /* Reinsert all breakpoints in the child.  The user may have set
368      breakpoints after catching the fork, in which case those
369      were never set in the child, but only in the parent.  This makes
370      sure the inserted breakpoints match the breakpoint list.  */
371
372   breakpoint_re_set ();
373   insert_breakpoints ();
374 }
375
376 /* EXECD_PATHNAME is assumed to be non-NULL. */
377
378 static void
379 follow_exec (int pid, char *execd_pathname)
380 {
381   int saved_pid = pid;
382   struct target_ops *tgt;
383
384   if (!may_follow_exec)
385     return;
386
387   /* This is an exec event that we actually wish to pay attention to.
388      Refresh our symbol table to the newly exec'd program, remove any
389      momentary bp's, etc.
390
391      If there are breakpoints, they aren't really inserted now,
392      since the exec() transformed our inferior into a fresh set
393      of instructions.
394
395      We want to preserve symbolic breakpoints on the list, since
396      we have hopes that they can be reset after the new a.out's
397      symbol table is read.
398
399      However, any "raw" breakpoints must be removed from the list
400      (e.g., the solib bp's), since their address is probably invalid
401      now.
402
403      And, we DON'T want to call delete_breakpoints() here, since
404      that may write the bp's "shadow contents" (the instruction
405      value that was overwritten witha TRAP instruction).  Since
406      we now have a new a.out, those shadow contents aren't valid. */
407   update_breakpoints_after_exec ();
408
409   /* If there was one, it's gone now.  We cannot truly step-to-next
410      statement through an exec(). */
411   step_resume_breakpoint = NULL;
412   step_range_start = 0;
413   step_range_end = 0;
414
415   /* What is this a.out's name? */
416   printf_unfiltered ("Executing new program: %s\n", execd_pathname);
417
418   /* We've followed the inferior through an exec.  Therefore, the
419      inferior has essentially been killed & reborn. */
420
421   /* First collect the run target in effect.  */
422   tgt = find_run_target ();
423   /* If we can't find one, things are in a very strange state...  */
424   if (tgt == NULL)
425     error ("Could find run target to save before following exec");
426
427   gdb_flush (gdb_stdout);
428   target_mourn_inferior ();
429   inferior_ptid = pid_to_ptid (saved_pid);
430   /* Because mourn_inferior resets inferior_ptid. */
431   push_target (tgt);
432
433   /* That a.out is now the one to use. */
434   exec_file_attach (execd_pathname, 0);
435
436   /* And also is where symbols can be found. */
437   symbol_file_add_main (execd_pathname, 0);
438
439   /* Reset the shared library package.  This ensures that we get
440      a shlib event when the child reaches "_start", at which point
441      the dld will have had a chance to initialize the child. */
442 #if defined(SOLIB_RESTART)
443   SOLIB_RESTART ();
444 #endif
445 #ifdef SOLIB_CREATE_INFERIOR_HOOK
446   SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
447 #endif
448
449   /* Reinsert all breakpoints.  (Those which were symbolic have
450      been reset to the proper address in the new a.out, thanks
451      to symbol_file_command...) */
452   insert_breakpoints ();
453
454   /* The next resume of this inferior should bring it to the shlib
455      startup breakpoints.  (If the user had also set bp's on
456      "main" from the old (parent) process, then they'll auto-
457      matically get reset there in the new process.) */
458 }
459
460 /* Non-zero if we just simulating a single-step.  This is needed
461    because we cannot remove the breakpoints in the inferior process
462    until after the `wait' in `wait_for_inferior'.  */
463 static int singlestep_breakpoints_inserted_p = 0;
464
465 /* The thread we inserted single-step breakpoints for.  */
466 static ptid_t singlestep_ptid;
467
468 /* If another thread hit the singlestep breakpoint, we save the original
469    thread here so that we can resume single-stepping it later.  */
470 static ptid_t saved_singlestep_ptid;
471 static int stepping_past_singlestep_breakpoint;
472 \f
473
474 /* Things to clean up if we QUIT out of resume ().  */
475 static void
476 resume_cleanups (void *ignore)
477 {
478   normal_stop ();
479 }
480
481 static const char schedlock_off[] = "off";
482 static const char schedlock_on[] = "on";
483 static const char schedlock_step[] = "step";
484 static const char *scheduler_mode = schedlock_off;
485 static const char *scheduler_enums[] = {
486   schedlock_off,
487   schedlock_on,
488   schedlock_step,
489   NULL
490 };
491
492 static void
493 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
494 {
495   /* NOTE: cagney/2002-03-17: The add_show_from_set() function clones
496      the set command passed as a parameter.  The clone operation will
497      include (BUG?) any ``set'' command callback, if present.
498      Commands like ``info set'' call all the ``show'' command
499      callbacks.  Unfortunately, for ``show'' commands cloned from
500      ``set'', this includes callbacks belonging to ``set'' commands.
501      Making this worse, this only occures if add_show_from_set() is
502      called after add_cmd_sfunc() (BUG?).  */
503   if (cmd_type (c) == set_cmd)
504     if (!target_can_lock_scheduler)
505       {
506         scheduler_mode = schedlock_off;
507         error ("Target '%s' cannot support this command.", target_shortname);
508       }
509 }
510
511
512 /* Resume the inferior, but allow a QUIT.  This is useful if the user
513    wants to interrupt some lengthy single-stepping operation
514    (for child processes, the SIGINT goes to the inferior, and so
515    we get a SIGINT random_signal, but for remote debugging and perhaps
516    other targets, that's not true).
517
518    STEP nonzero if we should step (zero to continue instead).
519    SIG is the signal to give the inferior (zero for none).  */
520 void
521 resume (int step, enum target_signal sig)
522 {
523   int should_resume = 1;
524   struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
525   QUIT;
526
527   /* FIXME: calling breakpoint_here_p (read_pc ()) three times! */
528
529
530   /* Some targets (e.g. Solaris x86) have a kernel bug when stepping
531      over an instruction that causes a page fault without triggering
532      a hardware watchpoint. The kernel properly notices that it shouldn't
533      stop, because the hardware watchpoint is not triggered, but it forgets
534      the step request and continues the program normally.
535      Work around the problem by removing hardware watchpoints if a step is
536      requested, GDB will check for a hardware watchpoint trigger after the
537      step anyway.  */
538   if (CANNOT_STEP_HW_WATCHPOINTS && step && breakpoints_inserted)
539     remove_hw_watchpoints ();
540
541
542   /* Normally, by the time we reach `resume', the breakpoints are either
543      removed or inserted, as appropriate.  The exception is if we're sitting
544      at a permanent breakpoint; we need to step over it, but permanent
545      breakpoints can't be removed.  So we have to test for it here.  */
546   if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here)
547     SKIP_PERMANENT_BREAKPOINT ();
548
549   if (SOFTWARE_SINGLE_STEP_P () && step)
550     {
551       /* Do it the hard way, w/temp breakpoints */
552       SOFTWARE_SINGLE_STEP (sig, 1 /*insert-breakpoints */ );
553       /* ...and don't ask hardware to do it.  */
554       step = 0;
555       /* and do not pull these breakpoints until after a `wait' in
556          `wait_for_inferior' */
557       singlestep_breakpoints_inserted_p = 1;
558       singlestep_ptid = inferior_ptid;
559     }
560
561   /* If there were any forks/vforks/execs that were caught and are
562      now to be followed, then do so.  */
563   switch (pending_follow.kind)
564     {
565     case TARGET_WAITKIND_FORKED:
566     case TARGET_WAITKIND_VFORKED:
567       pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
568       if (follow_fork ())
569         should_resume = 0;
570       break;
571
572     case TARGET_WAITKIND_EXECD:
573       /* follow_exec is called as soon as the exec event is seen. */
574       pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
575       break;
576
577     default:
578       break;
579     }
580
581   /* Install inferior's terminal modes.  */
582   target_terminal_inferior ();
583
584   if (should_resume)
585     {
586       ptid_t resume_ptid;
587
588       resume_ptid = RESUME_ALL; /* Default */
589
590       if ((step || singlestep_breakpoints_inserted_p) &&
591           (stepping_past_singlestep_breakpoint
592            || (!breakpoints_inserted && breakpoint_here_p (read_pc ()))))
593         {
594           /* Stepping past a breakpoint without inserting breakpoints.
595              Make sure only the current thread gets to step, so that
596              other threads don't sneak past breakpoints while they are
597              not inserted. */
598
599           resume_ptid = inferior_ptid;
600         }
601
602       if ((scheduler_mode == schedlock_on) ||
603           (scheduler_mode == schedlock_step &&
604            (step || singlestep_breakpoints_inserted_p)))
605         {
606           /* User-settable 'scheduler' mode requires solo thread resume. */
607           resume_ptid = inferior_ptid;
608         }
609
610       if (CANNOT_STEP_BREAKPOINT)
611         {
612           /* Most targets can step a breakpoint instruction, thus
613              executing it normally.  But if this one cannot, just
614              continue and we will hit it anyway.  */
615           if (step && breakpoints_inserted && breakpoint_here_p (read_pc ()))
616             step = 0;
617         }
618       target_resume (resume_ptid, step, sig);
619     }
620
621   discard_cleanups (old_cleanups);
622 }
623 \f
624
625 /* Clear out all variables saying what to do when inferior is continued.
626    First do this, then set the ones you want, then call `proceed'.  */
627
628 void
629 clear_proceed_status (void)
630 {
631   trap_expected = 0;
632   step_range_start = 0;
633   step_range_end = 0;
634   step_frame_id = null_frame_id;
635   step_over_calls = STEP_OVER_UNDEBUGGABLE;
636   stop_after_trap = 0;
637   stop_soon = NO_STOP_QUIETLY;
638   proceed_to_finish = 0;
639   breakpoint_proceeded = 1;     /* We're about to proceed... */
640
641   /* Discard any remaining commands or status from previous stop.  */
642   bpstat_clear (&stop_bpstat);
643 }
644
645 /* This should be suitable for any targets that support threads. */
646
647 static int
648 prepare_to_proceed (void)
649 {
650   ptid_t wait_ptid;
651   struct target_waitstatus wait_status;
652
653   /* Get the last target status returned by target_wait().  */
654   get_last_target_status (&wait_ptid, &wait_status);
655
656   /* Make sure we were stopped either at a breakpoint, or because
657      of a Ctrl-C.  */
658   if (wait_status.kind != TARGET_WAITKIND_STOPPED
659       || (wait_status.value.sig != TARGET_SIGNAL_TRAP &&
660           wait_status.value.sig != TARGET_SIGNAL_INT))
661     {
662       return 0;
663     }
664
665   if (!ptid_equal (wait_ptid, minus_one_ptid)
666       && !ptid_equal (inferior_ptid, wait_ptid))
667     {
668       /* Switched over from WAIT_PID.  */
669       CORE_ADDR wait_pc = read_pc_pid (wait_ptid);
670
671       if (wait_pc != read_pc ())
672         {
673           /* Switch back to WAIT_PID thread.  */
674           inferior_ptid = wait_ptid;
675
676           /* FIXME: This stuff came from switch_to_thread() in
677              thread.c (which should probably be a public function).  */
678           flush_cached_frames ();
679           registers_changed ();
680           stop_pc = wait_pc;
681           select_frame (get_current_frame ());
682         }
683
684         /* We return 1 to indicate that there is a breakpoint here,
685            so we need to step over it before continuing to avoid
686            hitting it straight away. */
687         if (breakpoint_here_p (wait_pc))
688            return 1;
689     }
690
691   return 0;
692   
693 }
694
695 /* Record the pc of the program the last time it stopped.  This is
696    just used internally by wait_for_inferior, but need to be preserved
697    over calls to it and cleared when the inferior is started.  */
698 static CORE_ADDR prev_pc;
699
700 /* Basic routine for continuing the program in various fashions.
701
702    ADDR is the address to resume at, or -1 for resume where stopped.
703    SIGGNAL is the signal to give it, or 0 for none,
704    or -1 for act according to how it stopped.
705    STEP is nonzero if should trap after one instruction.
706    -1 means return after that and print nothing.
707    You should probably set various step_... variables
708    before calling here, if you are stepping.
709
710    You should call clear_proceed_status before calling proceed.  */
711
712 void
713 proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
714 {
715   int oneproc = 0;
716
717   if (step > 0)
718     step_start_function = find_pc_function (read_pc ());
719   if (step < 0)
720     stop_after_trap = 1;
721
722   if (addr == (CORE_ADDR) -1)
723     {
724       /* If there is a breakpoint at the address we will resume at,
725          step one instruction before inserting breakpoints
726          so that we do not stop right away (and report a second
727          hit at this breakpoint).  */
728
729       if (read_pc () == stop_pc && breakpoint_here_p (read_pc ()))
730         oneproc = 1;
731
732 #ifndef STEP_SKIPS_DELAY
733 #define STEP_SKIPS_DELAY(pc) (0)
734 #define STEP_SKIPS_DELAY_P (0)
735 #endif
736       /* Check breakpoint_here_p first, because breakpoint_here_p is fast
737          (it just checks internal GDB data structures) and STEP_SKIPS_DELAY
738          is slow (it needs to read memory from the target).  */
739       if (STEP_SKIPS_DELAY_P
740           && breakpoint_here_p (read_pc () + 4)
741           && STEP_SKIPS_DELAY (read_pc ()))
742         oneproc = 1;
743     }
744   else
745     {
746       write_pc (addr);
747     }
748
749   /* In a multi-threaded task we may select another thread
750      and then continue or step.
751
752      But if the old thread was stopped at a breakpoint, it
753      will immediately cause another breakpoint stop without
754      any execution (i.e. it will report a breakpoint hit
755      incorrectly).  So we must step over it first.
756
757      prepare_to_proceed checks the current thread against the thread
758      that reported the most recent event.  If a step-over is required
759      it returns TRUE and sets the current thread to the old thread. */
760   if (prepare_to_proceed () && breakpoint_here_p (read_pc ()))
761     oneproc = 1;
762
763   if (oneproc)
764     /* We will get a trace trap after one instruction.
765        Continue it automatically and insert breakpoints then.  */
766     trap_expected = 1;
767   else
768     {
769       insert_breakpoints ();
770       /* If we get here there was no call to error() in 
771          insert breakpoints -- so they were inserted.  */
772       breakpoints_inserted = 1;
773     }
774
775   if (siggnal != TARGET_SIGNAL_DEFAULT)
776     stop_signal = siggnal;
777   /* If this signal should not be seen by program,
778      give it zero.  Used for debugging signals.  */
779   else if (!signal_program[stop_signal])
780     stop_signal = TARGET_SIGNAL_0;
781
782   annotate_starting ();
783
784   /* Make sure that output from GDB appears before output from the
785      inferior.  */
786   gdb_flush (gdb_stdout);
787
788   /* Refresh prev_pc value just prior to resuming.  This used to be
789      done in stop_stepping, however, setting prev_pc there did not handle
790      scenarios such as inferior function calls or returning from
791      a function via the return command.  In those cases, the prev_pc
792      value was not set properly for subsequent commands.  The prev_pc value 
793      is used to initialize the starting line number in the ecs.  With an 
794      invalid value, the gdb next command ends up stopping at the position
795      represented by the next line table entry past our start position.
796      On platforms that generate one line table entry per line, this
797      is not a problem.  However, on the ia64, the compiler generates
798      extraneous line table entries that do not increase the line number.
799      When we issue the gdb next command on the ia64 after an inferior call
800      or a return command, we often end up a few instructions forward, still 
801      within the original line we started.
802
803      An attempt was made to have init_execution_control_state () refresh
804      the prev_pc value before calculating the line number.  This approach
805      did not work because on platforms that use ptrace, the pc register
806      cannot be read unless the inferior is stopped.  At that point, we
807      are not guaranteed the inferior is stopped and so the read_pc ()
808      call can fail.  Setting the prev_pc value here ensures the value is 
809      updated correctly when the inferior is stopped.  */  
810   prev_pc = read_pc ();
811
812   /* Resume inferior.  */
813   resume (oneproc || step || bpstat_should_step (), stop_signal);
814
815   /* Wait for it to stop (if not standalone)
816      and in any case decode why it stopped, and act accordingly.  */
817   /* Do this only if we are not using the event loop, or if the target
818      does not support asynchronous execution. */
819   if (!event_loop_p || !target_can_async_p ())
820     {
821       wait_for_inferior ();
822       normal_stop ();
823     }
824 }
825 \f
826
827 /* Start remote-debugging of a machine over a serial link.  */
828
829 void
830 start_remote (void)
831 {
832   init_thread_list ();
833   init_wait_for_inferior ();
834   stop_soon = STOP_QUIETLY;
835   trap_expected = 0;
836
837   /* Always go on waiting for the target, regardless of the mode. */
838   /* FIXME: cagney/1999-09-23: At present it isn't possible to
839      indicate to wait_for_inferior that a target should timeout if
840      nothing is returned (instead of just blocking).  Because of this,
841      targets expecting an immediate response need to, internally, set
842      things up so that the target_wait() is forced to eventually
843      timeout. */
844   /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
845      differentiate to its caller what the state of the target is after
846      the initial open has been performed.  Here we're assuming that
847      the target has stopped.  It should be possible to eventually have
848      target_open() return to the caller an indication that the target
849      is currently running and GDB state should be set to the same as
850      for an async run. */
851   wait_for_inferior ();
852   normal_stop ();
853 }
854
855 /* Initialize static vars when a new inferior begins.  */
856
857 void
858 init_wait_for_inferior (void)
859 {
860   /* These are meaningless until the first time through wait_for_inferior.  */
861   prev_pc = 0;
862
863   breakpoints_inserted = 0;
864   breakpoint_init_inferior (inf_starting);
865
866   /* Don't confuse first call to proceed(). */
867   stop_signal = TARGET_SIGNAL_0;
868
869   /* The first resume is not following a fork/vfork/exec. */
870   pending_follow.kind = TARGET_WAITKIND_SPURIOUS;       /* I.e., none. */
871
872   /* See wait_for_inferior's handling of SYSCALL_ENTRY/RETURN events. */
873   number_of_threads_in_syscalls = 0;
874
875   clear_proceed_status ();
876
877   stepping_past_singlestep_breakpoint = 0;
878 }
879 \f
880 /* This enum encodes possible reasons for doing a target_wait, so that
881    wfi can call target_wait in one place.  (Ultimately the call will be
882    moved out of the infinite loop entirely.) */
883
884 enum infwait_states
885 {
886   infwait_normal_state,
887   infwait_thread_hop_state,
888   infwait_nullified_state,
889   infwait_nonstep_watch_state
890 };
891
892 /* Why did the inferior stop? Used to print the appropriate messages
893    to the interface from within handle_inferior_event(). */
894 enum inferior_stop_reason
895 {
896   /* We don't know why. */
897   STOP_UNKNOWN,
898   /* Step, next, nexti, stepi finished. */
899   END_STEPPING_RANGE,
900   /* Found breakpoint. */
901   BREAKPOINT_HIT,
902   /* Inferior terminated by signal. */
903   SIGNAL_EXITED,
904   /* Inferior exited. */
905   EXITED,
906   /* Inferior received signal, and user asked to be notified. */
907   SIGNAL_RECEIVED
908 };
909
910 /* This structure contains what used to be local variables in
911    wait_for_inferior.  Probably many of them can return to being
912    locals in handle_inferior_event.  */
913
914 struct execution_control_state
915 {
916   struct target_waitstatus ws;
917   struct target_waitstatus *wp;
918   int another_trap;
919   int random_signal;
920   CORE_ADDR stop_func_start;
921   CORE_ADDR stop_func_end;
922   char *stop_func_name;
923   struct symtab_and_line sal;
924   int remove_breakpoints_on_following_step;
925   int current_line;
926   struct symtab *current_symtab;
927   int handling_longjmp;         /* FIXME */
928   ptid_t ptid;
929   ptid_t saved_inferior_ptid;
930   int stepping_through_solib_after_catch;
931   bpstat stepping_through_solib_catchpoints;
932   int enable_hw_watchpoints_after_wait;
933   int stepping_through_sigtramp;
934   int new_thread_event;
935   struct target_waitstatus tmpstatus;
936   enum infwait_states infwait_state;
937   ptid_t waiton_ptid;
938   int wait_some_more;
939 };
940
941 void init_execution_control_state (struct execution_control_state *ecs);
942
943 void handle_inferior_event (struct execution_control_state *ecs);
944
945 static void step_into_function (struct execution_control_state *ecs);
946 static void insert_step_resume_breakpoint (struct frame_info *step_frame,
947                                            struct execution_control_state *ecs);
948 static void stop_stepping (struct execution_control_state *ecs);
949 static void prepare_to_wait (struct execution_control_state *ecs);
950 static void keep_going (struct execution_control_state *ecs);
951 static void print_stop_reason (enum inferior_stop_reason stop_reason,
952                                int stop_info);
953
954 /* Wait for control to return from inferior to debugger.
955    If inferior gets a signal, we may decide to start it up again
956    instead of returning.  That is why there is a loop in this function.
957    When this function actually returns it means the inferior
958    should be left stopped and GDB should read more commands.  */
959
960 void
961 wait_for_inferior (void)
962 {
963   struct cleanup *old_cleanups;
964   struct execution_control_state ecss;
965   struct execution_control_state *ecs;
966
967   old_cleanups = make_cleanup (delete_step_resume_breakpoint,
968                                &step_resume_breakpoint);
969
970   /* wfi still stays in a loop, so it's OK just to take the address of
971      a local to get the ecs pointer.  */
972   ecs = &ecss;
973
974   /* Fill in with reasonable starting values.  */
975   init_execution_control_state (ecs);
976
977   /* We'll update this if & when we switch to a new thread. */
978   previous_inferior_ptid = inferior_ptid;
979
980   overlay_cache_invalid = 1;
981
982   /* We have to invalidate the registers BEFORE calling target_wait
983      because they can be loaded from the target while in target_wait.
984      This makes remote debugging a bit more efficient for those
985      targets that provide critical registers as part of their normal
986      status mechanism. */
987
988   registers_changed ();
989
990   while (1)
991     {
992       if (deprecated_target_wait_hook)
993         ecs->ptid = deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp);
994       else
995         ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp);
996
997       /* Now figure out what to do with the result of the result.  */
998       handle_inferior_event (ecs);
999
1000       if (!ecs->wait_some_more)
1001         break;
1002     }
1003   do_cleanups (old_cleanups);
1004 }
1005
1006 /* Asynchronous version of wait_for_inferior. It is called by the
1007    event loop whenever a change of state is detected on the file
1008    descriptor corresponding to the target. It can be called more than
1009    once to complete a single execution command. In such cases we need
1010    to keep the state in a global variable ASYNC_ECSS. If it is the
1011    last time that this function is called for a single execution
1012    command, then report to the user that the inferior has stopped, and
1013    do the necessary cleanups. */
1014
1015 struct execution_control_state async_ecss;
1016 struct execution_control_state *async_ecs;
1017
1018 void
1019 fetch_inferior_event (void *client_data)
1020 {
1021   static struct cleanup *old_cleanups;
1022
1023   async_ecs = &async_ecss;
1024
1025   if (!async_ecs->wait_some_more)
1026     {
1027       old_cleanups = make_exec_cleanup (delete_step_resume_breakpoint,
1028                                         &step_resume_breakpoint);
1029
1030       /* Fill in with reasonable starting values.  */
1031       init_execution_control_state (async_ecs);
1032
1033       /* We'll update this if & when we switch to a new thread. */
1034       previous_inferior_ptid = inferior_ptid;
1035
1036       overlay_cache_invalid = 1;
1037
1038       /* We have to invalidate the registers BEFORE calling target_wait
1039          because they can be loaded from the target while in target_wait.
1040          This makes remote debugging a bit more efficient for those
1041          targets that provide critical registers as part of their normal
1042          status mechanism. */
1043
1044       registers_changed ();
1045     }
1046
1047   if (deprecated_target_wait_hook)
1048     async_ecs->ptid =
1049       deprecated_target_wait_hook (async_ecs->waiton_ptid, async_ecs->wp);
1050   else
1051     async_ecs->ptid = target_wait (async_ecs->waiton_ptid, async_ecs->wp);
1052
1053   /* Now figure out what to do with the result of the result.  */
1054   handle_inferior_event (async_ecs);
1055
1056   if (!async_ecs->wait_some_more)
1057     {
1058       /* Do only the cleanups that have been added by this
1059          function. Let the continuations for the commands do the rest,
1060          if there are any. */
1061       do_exec_cleanups (old_cleanups);
1062       normal_stop ();
1063       if (step_multi && stop_step)
1064         inferior_event_handler (INF_EXEC_CONTINUE, NULL);
1065       else
1066         inferior_event_handler (INF_EXEC_COMPLETE, NULL);
1067     }
1068 }
1069
1070 /* Prepare an execution control state for looping through a
1071    wait_for_inferior-type loop.  */
1072
1073 void
1074 init_execution_control_state (struct execution_control_state *ecs)
1075 {
1076   /* ecs->another_trap? */
1077   ecs->random_signal = 0;
1078   ecs->remove_breakpoints_on_following_step = 0;
1079   ecs->handling_longjmp = 0;    /* FIXME */
1080   ecs->stepping_through_solib_after_catch = 0;
1081   ecs->stepping_through_solib_catchpoints = NULL;
1082   ecs->enable_hw_watchpoints_after_wait = 0;
1083   ecs->stepping_through_sigtramp = 0;
1084   ecs->sal = find_pc_line (prev_pc, 0);
1085   ecs->current_line = ecs->sal.line;
1086   ecs->current_symtab = ecs->sal.symtab;
1087   ecs->infwait_state = infwait_normal_state;
1088   ecs->waiton_ptid = pid_to_ptid (-1);
1089   ecs->wp = &(ecs->ws);
1090 }
1091
1092 /* Call this function before setting step_resume_breakpoint, as a
1093    sanity check.  There should never be more than one step-resume
1094    breakpoint per thread, so we should never be setting a new
1095    step_resume_breakpoint when one is already active.  */
1096 static void
1097 check_for_old_step_resume_breakpoint (void)
1098 {
1099   if (step_resume_breakpoint)
1100     warning
1101       ("GDB bug: infrun.c (wait_for_inferior): dropping old step_resume breakpoint");
1102 }
1103
1104 /* Return the cached copy of the last pid/waitstatus returned by
1105    target_wait()/deprecated_target_wait_hook().  The data is actually
1106    cached by handle_inferior_event(), which gets called immediately
1107    after target_wait()/deprecated_target_wait_hook().  */
1108
1109 void
1110 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
1111 {
1112   *ptidp = target_last_wait_ptid;
1113   *status = target_last_waitstatus;
1114 }
1115
1116 /* Switch thread contexts, maintaining "infrun state". */
1117
1118 static void
1119 context_switch (struct execution_control_state *ecs)
1120 {
1121   /* Caution: it may happen that the new thread (or the old one!)
1122      is not in the thread list.  In this case we must not attempt
1123      to "switch context", or we run the risk that our context may
1124      be lost.  This may happen as a result of the target module
1125      mishandling thread creation.  */
1126
1127   if (in_thread_list (inferior_ptid) && in_thread_list (ecs->ptid))
1128     {                           /* Perform infrun state context switch: */
1129       /* Save infrun state for the old thread.  */
1130       save_infrun_state (inferior_ptid, prev_pc,
1131                          trap_expected, step_resume_breakpoint,
1132                          step_range_start,
1133                          step_range_end, &step_frame_id,
1134                          ecs->handling_longjmp, ecs->another_trap,
1135                          ecs->stepping_through_solib_after_catch,
1136                          ecs->stepping_through_solib_catchpoints,
1137                          ecs->stepping_through_sigtramp,
1138                          ecs->current_line, ecs->current_symtab);
1139
1140       /* Load infrun state for the new thread.  */
1141       load_infrun_state (ecs->ptid, &prev_pc,
1142                          &trap_expected, &step_resume_breakpoint,
1143                          &step_range_start,
1144                          &step_range_end, &step_frame_id,
1145                          &ecs->handling_longjmp, &ecs->another_trap,
1146                          &ecs->stepping_through_solib_after_catch,
1147                          &ecs->stepping_through_solib_catchpoints,
1148                          &ecs->stepping_through_sigtramp,
1149                          &ecs->current_line, &ecs->current_symtab);
1150     }
1151   inferior_ptid = ecs->ptid;
1152 }
1153
1154 static void
1155 adjust_pc_after_break (struct execution_control_state *ecs)
1156 {
1157   CORE_ADDR breakpoint_pc;
1158
1159   /* If this target does not decrement the PC after breakpoints, then
1160      we have nothing to do.  */
1161   if (DECR_PC_AFTER_BREAK == 0)
1162     return;
1163
1164   /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP.  If
1165      we aren't, just return.
1166
1167      We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
1168      affected by DECR_PC_AFTER_BREAK.  Other waitkinds which are implemented
1169      by software breakpoints should be handled through the normal breakpoint
1170      layer.
1171      
1172      NOTE drow/2004-01-31: On some targets, breakpoints may generate
1173      different signals (SIGILL or SIGEMT for instance), but it is less
1174      clear where the PC is pointing afterwards.  It may not match
1175      DECR_PC_AFTER_BREAK.  I don't know any specific target that generates
1176      these signals at breakpoints (the code has been in GDB since at least
1177      1992) so I can not guess how to handle them here.
1178      
1179      In earlier versions of GDB, a target with HAVE_NONSTEPPABLE_WATCHPOINTS
1180      would have the PC after hitting a watchpoint affected by
1181      DECR_PC_AFTER_BREAK.  I haven't found any target with both of these set
1182      in GDB history, and it seems unlikely to be correct, so
1183      HAVE_NONSTEPPABLE_WATCHPOINTS is not checked here.  */
1184
1185   if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
1186     return;
1187
1188   if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP)
1189     return;
1190
1191   /* Find the location where (if we've hit a breakpoint) the
1192      breakpoint would be.  */
1193   breakpoint_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK;
1194
1195   if (SOFTWARE_SINGLE_STEP_P ())
1196     {
1197       /* When using software single-step, a SIGTRAP can only indicate
1198          an inserted breakpoint.  This actually makes things
1199          easier.  */
1200       if (singlestep_breakpoints_inserted_p)
1201         /* When software single stepping, the instruction at [prev_pc]
1202            is never a breakpoint, but the instruction following
1203            [prev_pc] (in program execution order) always is.  Assume
1204            that following instruction was reached and hence a software
1205            breakpoint was hit.  */
1206         write_pc_pid (breakpoint_pc, ecs->ptid);
1207       else if (software_breakpoint_inserted_here_p (breakpoint_pc))
1208         /* The inferior was free running (i.e., no single-step
1209            breakpoints inserted) and it hit a software breakpoint.  */
1210         write_pc_pid (breakpoint_pc, ecs->ptid);
1211     }
1212   else
1213     {
1214       /* When using hardware single-step, a SIGTRAP is reported for
1215          both a completed single-step and a software breakpoint.  Need
1216          to differentiate between the two as the latter needs
1217          adjusting but the former does not.  */
1218       if (currently_stepping (ecs))
1219         {
1220           if (prev_pc == breakpoint_pc
1221               && software_breakpoint_inserted_here_p (breakpoint_pc))
1222             /* Hardware single-stepped a software breakpoint (as
1223                occures when the inferior is resumed with PC pointing
1224                at not-yet-hit software breakpoint).  Since the
1225                breakpoint really is executed, the inferior needs to be
1226                backed up to the breakpoint address.  */
1227             write_pc_pid (breakpoint_pc, ecs->ptid);
1228         }
1229       else
1230         {
1231           if (software_breakpoint_inserted_here_p (breakpoint_pc))
1232             /* The inferior was free running (i.e., no hardware
1233                single-step and no possibility of a false SIGTRAP) and
1234                hit a software breakpoint.  */
1235             write_pc_pid (breakpoint_pc, ecs->ptid);
1236         }
1237     }
1238 }
1239
1240 /* Given an execution control state that has been freshly filled in
1241    by an event from the inferior, figure out what it means and take
1242    appropriate action.  */
1243
1244 int stepped_after_stopped_by_watchpoint;
1245
1246 void
1247 handle_inferior_event (struct execution_control_state *ecs)
1248 {
1249   /* NOTE: cagney/2003-03-28: If you're looking at this code and
1250      thinking that the variable stepped_after_stopped_by_watchpoint
1251      isn't used, then you're wrong!  The macro STOPPED_BY_WATCHPOINT,
1252      defined in the file "config/pa/nm-hppah.h", accesses the variable
1253      indirectly.  Mutter something rude about the HP merge.  */
1254   int sw_single_step_trap_p = 0;
1255   int stopped_by_watchpoint = -1;  /* Mark as unknown.  */
1256
1257   /* Cache the last pid/waitstatus. */
1258   target_last_wait_ptid = ecs->ptid;
1259   target_last_waitstatus = *ecs->wp;
1260
1261   adjust_pc_after_break (ecs);
1262
1263   switch (ecs->infwait_state)
1264     {
1265     case infwait_thread_hop_state:
1266       /* Cancel the waiton_ptid. */
1267       ecs->waiton_ptid = pid_to_ptid (-1);
1268       /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event
1269          is serviced in this loop, below. */
1270       if (ecs->enable_hw_watchpoints_after_wait)
1271         {
1272           TARGET_ENABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid));
1273           ecs->enable_hw_watchpoints_after_wait = 0;
1274         }
1275       stepped_after_stopped_by_watchpoint = 0;
1276       break;
1277
1278     case infwait_normal_state:
1279       /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event
1280          is serviced in this loop, below. */
1281       if (ecs->enable_hw_watchpoints_after_wait)
1282         {
1283           TARGET_ENABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid));
1284           ecs->enable_hw_watchpoints_after_wait = 0;
1285         }
1286       stepped_after_stopped_by_watchpoint = 0;
1287       break;
1288
1289     case infwait_nullified_state:
1290       stepped_after_stopped_by_watchpoint = 0;
1291       break;
1292
1293     case infwait_nonstep_watch_state:
1294       insert_breakpoints ();
1295
1296       /* FIXME-maybe: is this cleaner than setting a flag?  Does it
1297          handle things like signals arriving and other things happening
1298          in combination correctly?  */
1299       stepped_after_stopped_by_watchpoint = 1;
1300       break;
1301
1302     default:
1303       internal_error (__FILE__, __LINE__, "bad switch");
1304     }
1305   ecs->infwait_state = infwait_normal_state;
1306
1307   flush_cached_frames ();
1308
1309   /* If it's a new process, add it to the thread database */
1310
1311   ecs->new_thread_event = (!ptid_equal (ecs->ptid, inferior_ptid)
1312                            && !ptid_equal (ecs->ptid, minus_one_ptid)
1313                            && !in_thread_list (ecs->ptid));
1314
1315   if (ecs->ws.kind != TARGET_WAITKIND_EXITED
1316       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event)
1317     {
1318       add_thread (ecs->ptid);
1319
1320       ui_out_text (uiout, "[New ");
1321       ui_out_text (uiout, target_pid_or_tid_to_str (ecs->ptid));
1322       ui_out_text (uiout, "]\n");
1323
1324 #if 0
1325       /* NOTE: This block is ONLY meant to be invoked in case of a
1326          "thread creation event"!  If it is invoked for any other
1327          sort of event (such as a new thread landing on a breakpoint),
1328          the event will be discarded, which is almost certainly
1329          a bad thing!
1330
1331          To avoid this, the low-level module (eg. target_wait)
1332          should call in_thread_list and add_thread, so that the
1333          new thread is known by the time we get here.  */
1334
1335       /* We may want to consider not doing a resume here in order
1336          to give the user a chance to play with the new thread.
1337          It might be good to make that a user-settable option.  */
1338
1339       /* At this point, all threads are stopped (happens
1340          automatically in either the OS or the native code).
1341          Therefore we need to continue all threads in order to
1342          make progress.  */
1343
1344       target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0);
1345       prepare_to_wait (ecs);
1346       return;
1347 #endif
1348     }
1349
1350   switch (ecs->ws.kind)
1351     {
1352     case TARGET_WAITKIND_LOADED:
1353       /* Ignore gracefully during startup of the inferior, as it
1354          might be the shell which has just loaded some objects,
1355          otherwise add the symbols for the newly loaded objects.  */
1356 #ifdef SOLIB_ADD
1357       if (stop_soon == NO_STOP_QUIETLY)
1358         {
1359           /* Remove breakpoints, SOLIB_ADD might adjust
1360              breakpoint addresses via breakpoint_re_set.  */
1361           if (breakpoints_inserted)
1362             remove_breakpoints ();
1363
1364           /* Check for any newly added shared libraries if we're
1365              supposed to be adding them automatically.  Switch
1366              terminal for any messages produced by
1367              breakpoint_re_set.  */
1368           target_terminal_ours_for_output ();
1369           /* NOTE: cagney/2003-11-25: Make certain that the target
1370              stack's section table is kept up-to-date.  Architectures,
1371              (e.g., PPC64), use the section table to perform
1372              operations such as address => section name and hence
1373              require the table to contain all sections (including
1374              those found in shared libraries).  */
1375           /* NOTE: cagney/2003-11-25: Pass current_target and not
1376              exec_ops to SOLIB_ADD.  This is because current GDB is
1377              only tooled to propagate section_table changes out from
1378              the "current_target" (see target_resize_to_sections), and
1379              not up from the exec stratum.  This, of course, isn't
1380              right.  "infrun.c" should only interact with the
1381              exec/process stratum, instead relying on the target stack
1382              to propagate relevant changes (stop, section table
1383              changed, ...) up to other layers.  */
1384           SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
1385           target_terminal_inferior ();
1386
1387           /* Reinsert breakpoints and continue.  */
1388           if (breakpoints_inserted)
1389             insert_breakpoints ();
1390         }
1391 #endif
1392       resume (0, TARGET_SIGNAL_0);
1393       prepare_to_wait (ecs);
1394       return;
1395
1396     case TARGET_WAITKIND_SPURIOUS:
1397       resume (0, TARGET_SIGNAL_0);
1398       prepare_to_wait (ecs);
1399       return;
1400
1401     case TARGET_WAITKIND_EXITED:
1402       target_terminal_ours ();  /* Must do this before mourn anyway */
1403       print_stop_reason (EXITED, ecs->ws.value.integer);
1404
1405       /* Record the exit code in the convenience variable $_exitcode, so
1406          that the user can inspect this again later.  */
1407       set_internalvar (lookup_internalvar ("_exitcode"),
1408                        value_from_longest (builtin_type_int,
1409                                            (LONGEST) ecs->ws.value.integer));
1410       gdb_flush (gdb_stdout);
1411       target_mourn_inferior ();
1412       singlestep_breakpoints_inserted_p = 0;    /*SOFTWARE_SINGLE_STEP_P() */
1413       stop_print_frame = 0;
1414       stop_stepping (ecs);
1415       return;
1416
1417     case TARGET_WAITKIND_SIGNALLED:
1418       stop_print_frame = 0;
1419       stop_signal = ecs->ws.value.sig;
1420       target_terminal_ours ();  /* Must do this before mourn anyway */
1421
1422       /* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't
1423          reach here unless the inferior is dead.  However, for years
1424          target_kill() was called here, which hints that fatal signals aren't
1425          really fatal on some systems.  If that's true, then some changes
1426          may be needed. */
1427       target_mourn_inferior ();
1428
1429       print_stop_reason (SIGNAL_EXITED, stop_signal);
1430       singlestep_breakpoints_inserted_p = 0;    /*SOFTWARE_SINGLE_STEP_P() */
1431       stop_stepping (ecs);
1432       return;
1433
1434       /* The following are the only cases in which we keep going;
1435          the above cases end in a continue or goto. */
1436     case TARGET_WAITKIND_FORKED:
1437     case TARGET_WAITKIND_VFORKED:
1438       stop_signal = TARGET_SIGNAL_TRAP;
1439       pending_follow.kind = ecs->ws.kind;
1440
1441       pending_follow.fork_event.parent_pid = PIDGET (ecs->ptid);
1442       pending_follow.fork_event.child_pid = ecs->ws.value.related_pid;
1443
1444       stop_pc = read_pc ();
1445
1446       stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid, 0);
1447
1448       ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
1449
1450       /* If no catchpoint triggered for this, then keep going.  */
1451       if (ecs->random_signal)
1452         {
1453           stop_signal = TARGET_SIGNAL_0;
1454           keep_going (ecs);
1455           return;
1456         }
1457       goto process_event_stop_test;
1458
1459     case TARGET_WAITKIND_EXECD:
1460       stop_signal = TARGET_SIGNAL_TRAP;
1461
1462       /* NOTE drow/2002-12-05: This code should be pushed down into the
1463          target_wait function.  Until then following vfork on HP/UX 10.20
1464          is probably broken by this.  Of course, it's broken anyway.  */
1465       /* Is this a target which reports multiple exec events per actual
1466          call to exec()?  (HP-UX using ptrace does, for example.)  If so,
1467          ignore all but the last one.  Just resume the exec'r, and wait
1468          for the next exec event. */
1469       if (inferior_ignoring_leading_exec_events)
1470         {
1471           inferior_ignoring_leading_exec_events--;
1472           if (pending_follow.kind == TARGET_WAITKIND_VFORKED)
1473             ENSURE_VFORKING_PARENT_REMAINS_STOPPED (pending_follow.fork_event.
1474                                                     parent_pid);
1475           target_resume (ecs->ptid, 0, TARGET_SIGNAL_0);
1476           prepare_to_wait (ecs);
1477           return;
1478         }
1479       inferior_ignoring_leading_exec_events =
1480         target_reported_exec_events_per_exec_call () - 1;
1481
1482       pending_follow.execd_pathname =
1483         savestring (ecs->ws.value.execd_pathname,
1484                     strlen (ecs->ws.value.execd_pathname));
1485
1486       /* This causes the eventpoints and symbol table to be reset.  Must
1487          do this now, before trying to determine whether to stop. */
1488       follow_exec (PIDGET (inferior_ptid), pending_follow.execd_pathname);
1489       xfree (pending_follow.execd_pathname);
1490
1491       stop_pc = read_pc_pid (ecs->ptid);
1492       ecs->saved_inferior_ptid = inferior_ptid;
1493       inferior_ptid = ecs->ptid;
1494
1495       stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid, 0);
1496
1497       ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
1498       inferior_ptid = ecs->saved_inferior_ptid;
1499
1500       /* If no catchpoint triggered for this, then keep going.  */
1501       if (ecs->random_signal)
1502         {
1503           stop_signal = TARGET_SIGNAL_0;
1504           keep_going (ecs);
1505           return;
1506         }
1507       goto process_event_stop_test;
1508
1509       /* These syscall events are returned on HP-UX, as part of its
1510          implementation of page-protection-based "hardware" watchpoints.
1511          HP-UX has unfortunate interactions between page-protections and
1512          some system calls.  Our solution is to disable hardware watches
1513          when a system call is entered, and reenable them when the syscall
1514          completes.  The downside of this is that we may miss the precise
1515          point at which a watched piece of memory is modified.  "Oh well."
1516
1517          Note that we may have multiple threads running, which may each
1518          enter syscalls at roughly the same time.  Since we don't have a
1519          good notion currently of whether a watched piece of memory is
1520          thread-private, we'd best not have any page-protections active
1521          when any thread is in a syscall.  Thus, we only want to reenable
1522          hardware watches when no threads are in a syscall.
1523
1524          Also, be careful not to try to gather much state about a thread
1525          that's in a syscall.  It's frequently a losing proposition. */
1526     case TARGET_WAITKIND_SYSCALL_ENTRY:
1527       number_of_threads_in_syscalls++;
1528       if (number_of_threads_in_syscalls == 1)
1529         {
1530           TARGET_DISABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid));
1531         }
1532       resume (0, TARGET_SIGNAL_0);
1533       prepare_to_wait (ecs);
1534       return;
1535
1536       /* Before examining the threads further, step this thread to
1537          get it entirely out of the syscall.  (We get notice of the
1538          event when the thread is just on the verge of exiting a
1539          syscall.  Stepping one instruction seems to get it back
1540          into user code.)
1541
1542          Note that although the logical place to reenable h/w watches
1543          is here, we cannot.  We cannot reenable them before stepping
1544          the thread (this causes the next wait on the thread to hang).
1545
1546          Nor can we enable them after stepping until we've done a wait.
1547          Thus, we simply set the flag ecs->enable_hw_watchpoints_after_wait
1548          here, which will be serviced immediately after the target
1549          is waited on. */
1550     case TARGET_WAITKIND_SYSCALL_RETURN:
1551       target_resume (ecs->ptid, 1, TARGET_SIGNAL_0);
1552
1553       if (number_of_threads_in_syscalls > 0)
1554         {
1555           number_of_threads_in_syscalls--;
1556           ecs->enable_hw_watchpoints_after_wait =
1557             (number_of_threads_in_syscalls == 0);
1558         }
1559       prepare_to_wait (ecs);
1560       return;
1561
1562     case TARGET_WAITKIND_STOPPED:
1563       stop_signal = ecs->ws.value.sig;
1564       break;
1565
1566       /* We had an event in the inferior, but we are not interested
1567          in handling it at this level. The lower layers have already
1568          done what needs to be done, if anything.
1569          
1570          One of the possible circumstances for this is when the
1571          inferior produces output for the console. The inferior has
1572          not stopped, and we are ignoring the event.  Another possible
1573          circumstance is any event which the lower level knows will be
1574          reported multiple times without an intervening resume.  */
1575     case TARGET_WAITKIND_IGNORE:
1576       prepare_to_wait (ecs);
1577       return;
1578     }
1579
1580   /* We may want to consider not doing a resume here in order to give
1581      the user a chance to play with the new thread.  It might be good
1582      to make that a user-settable option.  */
1583
1584   /* At this point, all threads are stopped (happens automatically in
1585      either the OS or the native code).  Therefore we need to continue
1586      all threads in order to make progress.  */
1587   if (ecs->new_thread_event)
1588     {
1589       target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0);
1590       prepare_to_wait (ecs);
1591       return;
1592     }
1593
1594   stop_pc = read_pc_pid (ecs->ptid);
1595
1596   if (stepping_past_singlestep_breakpoint)
1597     {
1598       gdb_assert (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p);
1599       gdb_assert (ptid_equal (singlestep_ptid, ecs->ptid));
1600       gdb_assert (!ptid_equal (singlestep_ptid, saved_singlestep_ptid));
1601
1602       stepping_past_singlestep_breakpoint = 0;
1603
1604       /* We've either finished single-stepping past the single-step
1605          breakpoint, or stopped for some other reason.  It would be nice if
1606          we could tell, but we can't reliably.  */
1607       if (stop_signal == TARGET_SIGNAL_TRAP)
1608         {
1609           /* Pull the single step breakpoints out of the target.  */
1610           SOFTWARE_SINGLE_STEP (0, 0);
1611           singlestep_breakpoints_inserted_p = 0;
1612
1613           ecs->random_signal = 0;
1614
1615           ecs->ptid = saved_singlestep_ptid;
1616           context_switch (ecs);
1617           if (deprecated_context_hook)
1618             deprecated_context_hook (pid_to_thread_id (ecs->ptid));
1619
1620           resume (1, TARGET_SIGNAL_0);
1621           prepare_to_wait (ecs);
1622           return;
1623         }
1624     }
1625
1626   stepping_past_singlestep_breakpoint = 0;
1627
1628   /* See if a thread hit a thread-specific breakpoint that was meant for
1629      another thread.  If so, then step that thread past the breakpoint,
1630      and continue it.  */
1631
1632   if (stop_signal == TARGET_SIGNAL_TRAP)
1633     {
1634       int thread_hop_needed = 0;
1635
1636       /* Check if a regular breakpoint has been hit before checking
1637          for a potential single step breakpoint. Otherwise, GDB will
1638          not see this breakpoint hit when stepping onto breakpoints.  */
1639       if (breakpoints_inserted && breakpoint_here_p (stop_pc))
1640         {
1641           ecs->random_signal = 0;
1642           if (!breakpoint_thread_match (stop_pc, ecs->ptid))
1643             thread_hop_needed = 1;
1644         }
1645       else if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
1646         {
1647           ecs->random_signal = 0;
1648           /* The call to in_thread_list is necessary because PTIDs sometimes
1649              change when we go from single-threaded to multi-threaded.  If
1650              the singlestep_ptid is still in the list, assume that it is
1651              really different from ecs->ptid.  */
1652           if (!ptid_equal (singlestep_ptid, ecs->ptid)
1653               && in_thread_list (singlestep_ptid))
1654             {
1655               thread_hop_needed = 1;
1656               stepping_past_singlestep_breakpoint = 1;
1657               saved_singlestep_ptid = singlestep_ptid;
1658             }
1659         }
1660
1661       if (thread_hop_needed)
1662             {
1663               int remove_status;
1664
1665               /* Saw a breakpoint, but it was hit by the wrong thread.
1666                  Just continue. */
1667
1668               if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
1669                 {
1670                   /* Pull the single step breakpoints out of the target. */
1671                   SOFTWARE_SINGLE_STEP (0, 0);
1672                   singlestep_breakpoints_inserted_p = 0;
1673                 }
1674
1675               remove_status = remove_breakpoints ();
1676               /* Did we fail to remove breakpoints?  If so, try
1677                  to set the PC past the bp.  (There's at least
1678                  one situation in which we can fail to remove
1679                  the bp's: On HP-UX's that use ttrace, we can't
1680                  change the address space of a vforking child
1681                  process until the child exits (well, okay, not
1682                  then either :-) or execs. */
1683               if (remove_status != 0)
1684                 {
1685                   /* FIXME!  This is obviously non-portable! */
1686                   write_pc_pid (stop_pc + 4, ecs->ptid);
1687                   /* We need to restart all the threads now,
1688                    * unles we're running in scheduler-locked mode. 
1689                    * Use currently_stepping to determine whether to 
1690                    * step or continue.
1691                    */
1692                   /* FIXME MVS: is there any reason not to call resume()? */
1693                   if (scheduler_mode == schedlock_on)
1694                     target_resume (ecs->ptid,
1695                                    currently_stepping (ecs), TARGET_SIGNAL_0);
1696                   else
1697                     target_resume (RESUME_ALL,
1698                                    currently_stepping (ecs), TARGET_SIGNAL_0);
1699                   prepare_to_wait (ecs);
1700                   return;
1701                 }
1702               else
1703                 {               /* Single step */
1704                   breakpoints_inserted = 0;
1705                   if (!ptid_equal (inferior_ptid, ecs->ptid))
1706                     context_switch (ecs);
1707                   ecs->waiton_ptid = ecs->ptid;
1708                   ecs->wp = &(ecs->ws);
1709                   ecs->another_trap = 1;
1710
1711                   ecs->infwait_state = infwait_thread_hop_state;
1712                   keep_going (ecs);
1713                   registers_changed ();
1714                   return;
1715                 }
1716         }
1717       else if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
1718         {
1719           sw_single_step_trap_p = 1;
1720           ecs->random_signal = 0;
1721         }
1722     }
1723   else
1724     ecs->random_signal = 1;
1725
1726   /* See if something interesting happened to the non-current thread.  If
1727      so, then switch to that thread.  */
1728   if (!ptid_equal (ecs->ptid, inferior_ptid))
1729     {
1730       context_switch (ecs);
1731
1732       if (deprecated_context_hook)
1733         deprecated_context_hook (pid_to_thread_id (ecs->ptid));
1734
1735       flush_cached_frames ();
1736     }
1737
1738   if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
1739     {
1740       /* Pull the single step breakpoints out of the target. */
1741       SOFTWARE_SINGLE_STEP (0, 0);
1742       singlestep_breakpoints_inserted_p = 0;
1743     }
1744
1745   /* If PC is pointing at a nullified instruction, then step beyond
1746      it so that the user won't be confused when GDB appears to be ready
1747      to execute it. */
1748
1749   /*      if (INSTRUCTION_NULLIFIED && currently_stepping (ecs)) */
1750   if (INSTRUCTION_NULLIFIED)
1751     {
1752       registers_changed ();
1753       target_resume (ecs->ptid, 1, TARGET_SIGNAL_0);
1754
1755       /* We may have received a signal that we want to pass to
1756          the inferior; therefore, we must not clobber the waitstatus
1757          in WS. */
1758
1759       ecs->infwait_state = infwait_nullified_state;
1760       ecs->waiton_ptid = ecs->ptid;
1761       ecs->wp = &(ecs->tmpstatus);
1762       prepare_to_wait (ecs);
1763       return;
1764     }
1765
1766   /* It may not be necessary to disable the watchpoint to stop over
1767      it.  For example, the PA can (with some kernel cooperation)
1768      single step over a watchpoint without disabling the watchpoint.  */
1769   if (HAVE_STEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws))
1770     {
1771       resume (1, 0);
1772       prepare_to_wait (ecs);
1773       return;
1774     }
1775
1776   /* It is far more common to need to disable a watchpoint to step
1777      the inferior over it.  FIXME.  What else might a debug
1778      register or page protection watchpoint scheme need here?  */
1779   if (HAVE_NONSTEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws))
1780     {
1781       /* At this point, we are stopped at an instruction which has
1782          attempted to write to a piece of memory under control of
1783          a watchpoint.  The instruction hasn't actually executed
1784          yet.  If we were to evaluate the watchpoint expression
1785          now, we would get the old value, and therefore no change
1786          would seem to have occurred.
1787
1788          In order to make watchpoints work `right', we really need
1789          to complete the memory write, and then evaluate the
1790          watchpoint expression.  The following code does that by
1791          removing the watchpoint (actually, all watchpoints and
1792          breakpoints), single-stepping the target, re-inserting
1793          watchpoints, and then falling through to let normal
1794          single-step processing handle proceed.  Since this
1795          includes evaluating watchpoints, things will come to a
1796          stop in the correct manner.  */
1797
1798       remove_breakpoints ();
1799       registers_changed ();
1800       target_resume (ecs->ptid, 1, TARGET_SIGNAL_0);    /* Single step */
1801
1802       ecs->waiton_ptid = ecs->ptid;
1803       ecs->wp = &(ecs->ws);
1804       ecs->infwait_state = infwait_nonstep_watch_state;
1805       prepare_to_wait (ecs);
1806       return;
1807     }
1808
1809   /* It may be possible to simply continue after a watchpoint.  */
1810   if (HAVE_CONTINUABLE_WATCHPOINT)
1811     stopped_by_watchpoint = STOPPED_BY_WATCHPOINT (ecs->ws);
1812
1813   ecs->stop_func_start = 0;
1814   ecs->stop_func_end = 0;
1815   ecs->stop_func_name = 0;
1816   /* Don't care about return value; stop_func_start and stop_func_name
1817      will both be 0 if it doesn't work.  */
1818   find_pc_partial_function (stop_pc, &ecs->stop_func_name,
1819                             &ecs->stop_func_start, &ecs->stop_func_end);
1820   ecs->stop_func_start += DEPRECATED_FUNCTION_START_OFFSET;
1821   ecs->another_trap = 0;
1822   bpstat_clear (&stop_bpstat);
1823   stop_step = 0;
1824   stop_stack_dummy = 0;
1825   stop_print_frame = 1;
1826   ecs->random_signal = 0;
1827   stopped_by_random_signal = 0;
1828   breakpoints_failed = 0;
1829
1830   /* Look at the cause of the stop, and decide what to do.
1831      The alternatives are:
1832      1) break; to really stop and return to the debugger,
1833      2) drop through to start up again
1834      (set ecs->another_trap to 1 to single step once)
1835      3) set ecs->random_signal to 1, and the decision between 1 and 2
1836      will be made according to the signal handling tables.  */
1837
1838   /* First, distinguish signals caused by the debugger from signals
1839      that have to do with the program's own actions.  Note that
1840      breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
1841      on the operating system version.  Here we detect when a SIGILL or
1842      SIGEMT is really a breakpoint and change it to SIGTRAP.  We do
1843      something similar for SIGSEGV, since a SIGSEGV will be generated
1844      when we're trying to execute a breakpoint instruction on a
1845      non-executable stack.  This happens for call dummy breakpoints
1846      for architectures like SPARC that place call dummies on the
1847      stack.  */
1848
1849   if (stop_signal == TARGET_SIGNAL_TRAP
1850       || (breakpoints_inserted &&
1851           (stop_signal == TARGET_SIGNAL_ILL
1852            || stop_signal == TARGET_SIGNAL_SEGV
1853            || stop_signal == TARGET_SIGNAL_EMT))
1854       || stop_soon == STOP_QUIETLY
1855       || stop_soon == STOP_QUIETLY_NO_SIGSTOP)
1856     {
1857       if (stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap)
1858         {
1859           stop_print_frame = 0;
1860           stop_stepping (ecs);
1861           return;
1862         }
1863
1864       /* This is originated from start_remote(), start_inferior() and
1865          shared libraries hook functions.  */
1866       if (stop_soon == STOP_QUIETLY)
1867         {
1868           stop_stepping (ecs);
1869           return;
1870         }
1871
1872       /* This originates from attach_command().  We need to overwrite
1873          the stop_signal here, because some kernels don't ignore a
1874          SIGSTOP in a subsequent ptrace(PTRACE_SONT,SOGSTOP) call.
1875          See more comments in inferior.h.  */
1876       if (stop_soon == STOP_QUIETLY_NO_SIGSTOP)
1877         {
1878           stop_stepping (ecs);
1879           if (stop_signal == TARGET_SIGNAL_STOP)
1880             stop_signal = TARGET_SIGNAL_0;
1881           return;
1882         }
1883
1884       /* Don't even think about breakpoints if just proceeded over a
1885          breakpoint.  */
1886       if (stop_signal == TARGET_SIGNAL_TRAP && trap_expected)
1887         bpstat_clear (&stop_bpstat);
1888       else
1889         {
1890           /* See if there is a breakpoint at the current PC.  */
1891           stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid, 
1892                                             stopped_by_watchpoint);
1893
1894           /* Following in case break condition called a
1895              function.  */
1896           stop_print_frame = 1;
1897         }
1898
1899       /* NOTE: cagney/2003-03-29: These two checks for a random signal
1900          at one stage in the past included checks for an inferior
1901          function call's call dummy's return breakpoint.  The original
1902          comment, that went with the test, read:
1903
1904          ``End of a stack dummy.  Some systems (e.g. Sony news) give
1905          another signal besides SIGTRAP, so check here as well as
1906          above.''
1907
1908          If someone ever tries to get get call dummys on a
1909          non-executable stack to work (where the target would stop
1910          with something like a SIGSEGV), then those tests might need
1911          to be re-instated.  Given, however, that the tests were only
1912          enabled when momentary breakpoints were not being used, I
1913          suspect that it won't be the case.
1914
1915          NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
1916          be necessary for call dummies on a non-executable stack on
1917          SPARC.  */
1918
1919       if (stop_signal == TARGET_SIGNAL_TRAP)
1920         ecs->random_signal
1921           = !(bpstat_explains_signal (stop_bpstat)
1922               || trap_expected
1923               || (step_range_end && step_resume_breakpoint == NULL));
1924       else
1925         {
1926           ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
1927           if (!ecs->random_signal)
1928             stop_signal = TARGET_SIGNAL_TRAP;
1929         }
1930     }
1931
1932   /* When we reach this point, we've pretty much decided
1933      that the reason for stopping must've been a random
1934      (unexpected) signal. */
1935
1936   else
1937     ecs->random_signal = 1;
1938
1939 process_event_stop_test:
1940   /* For the program's own signals, act according to
1941      the signal handling tables.  */
1942
1943   if (ecs->random_signal)
1944     {
1945       /* Signal not for debugging purposes.  */
1946       int printed = 0;
1947
1948       stopped_by_random_signal = 1;
1949
1950       if (signal_print[stop_signal])
1951         {
1952           printed = 1;
1953           target_terminal_ours_for_output ();
1954           print_stop_reason (SIGNAL_RECEIVED, stop_signal);
1955         }
1956       if (signal_stop[stop_signal])
1957         {
1958           stop_stepping (ecs);
1959           return;
1960         }
1961       /* If not going to stop, give terminal back
1962          if we took it away.  */
1963       else if (printed)
1964         target_terminal_inferior ();
1965
1966       /* Clear the signal if it should not be passed.  */
1967       if (signal_program[stop_signal] == 0)
1968         stop_signal = TARGET_SIGNAL_0;
1969
1970       if (step_range_end != 0
1971           && stop_signal != TARGET_SIGNAL_0
1972           && stop_pc >= step_range_start && stop_pc < step_range_end
1973           && frame_id_eq (get_frame_id (get_current_frame ()), step_frame_id))
1974         {
1975           /* The inferior is about to take a signal that will take it
1976              out of the single step range.  Set a breakpoint at the
1977              current PC (which is presumably where the signal handler
1978              will eventually return) and then allow the inferior to
1979              run free.
1980
1981              Note that this is only needed for a signal delivered
1982              while in the single-step range.  Nested signals aren't a
1983              problem as they eventually all return.  */
1984           insert_step_resume_breakpoint (get_current_frame (), ecs);
1985         }
1986       keep_going (ecs);
1987       return;
1988     }
1989
1990   /* Handle cases caused by hitting a breakpoint.  */
1991   {
1992     CORE_ADDR jmp_buf_pc;
1993     struct bpstat_what what;
1994
1995     what = bpstat_what (stop_bpstat);
1996
1997     if (what.call_dummy)
1998       {
1999         stop_stack_dummy = 1;
2000       }
2001
2002     switch (what.main_action)
2003       {
2004       case BPSTAT_WHAT_SET_LONGJMP_RESUME:
2005         /* If we hit the breakpoint at longjmp, disable it for the
2006            duration of this command.  Then, install a temporary
2007            breakpoint at the target of the jmp_buf. */
2008         disable_longjmp_breakpoint ();
2009         remove_breakpoints ();
2010         breakpoints_inserted = 0;
2011         if (!GET_LONGJMP_TARGET_P () || !GET_LONGJMP_TARGET (&jmp_buf_pc))
2012           {
2013             keep_going (ecs);
2014             return;
2015           }
2016
2017         /* Need to blow away step-resume breakpoint, as it
2018            interferes with us */
2019         if (step_resume_breakpoint != NULL)
2020           {
2021             delete_step_resume_breakpoint (&step_resume_breakpoint);
2022           }
2023
2024 #if 0
2025         /* FIXME - Need to implement nested temporary breakpoints */
2026         if (step_over_calls > 0)
2027           set_longjmp_resume_breakpoint (jmp_buf_pc, get_current_frame ());
2028         else
2029 #endif /* 0 */
2030           set_longjmp_resume_breakpoint (jmp_buf_pc, null_frame_id);
2031         ecs->handling_longjmp = 1;      /* FIXME */
2032         keep_going (ecs);
2033         return;
2034
2035       case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
2036       case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE:
2037         remove_breakpoints ();
2038         breakpoints_inserted = 0;
2039 #if 0
2040         /* FIXME - Need to implement nested temporary breakpoints */
2041         if (step_over_calls
2042             && (frame_id_inner (get_frame_id (get_current_frame ()),
2043                                 step_frame_id)))
2044           {
2045             ecs->another_trap = 1;
2046             keep_going (ecs);
2047             return;
2048           }
2049 #endif /* 0 */
2050         disable_longjmp_breakpoint ();
2051         ecs->handling_longjmp = 0;      /* FIXME */
2052         if (what.main_action == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME)
2053           break;
2054         /* else fallthrough */
2055
2056       case BPSTAT_WHAT_SINGLE:
2057         if (breakpoints_inserted)
2058           {
2059             remove_breakpoints ();
2060           }
2061         breakpoints_inserted = 0;
2062         ecs->another_trap = 1;
2063         /* Still need to check other stuff, at least the case
2064            where we are stepping and step out of the right range.  */
2065         break;
2066
2067       case BPSTAT_WHAT_STOP_NOISY:
2068         stop_print_frame = 1;
2069
2070         /* We are about to nuke the step_resume_breakpointt via the
2071            cleanup chain, so no need to worry about it here.  */
2072
2073         stop_stepping (ecs);
2074         return;
2075
2076       case BPSTAT_WHAT_STOP_SILENT:
2077         stop_print_frame = 0;
2078
2079         /* We are about to nuke the step_resume_breakpoin via the
2080            cleanup chain, so no need to worry about it here.  */
2081
2082         stop_stepping (ecs);
2083         return;
2084
2085       case BPSTAT_WHAT_STEP_RESUME:
2086         /* This proably demands a more elegant solution, but, yeah
2087            right...
2088
2089            This function's use of the simple variable
2090            step_resume_breakpoint doesn't seem to accomodate
2091            simultaneously active step-resume bp's, although the
2092            breakpoint list certainly can.
2093
2094            If we reach here and step_resume_breakpoint is already
2095            NULL, then apparently we have multiple active
2096            step-resume bp's.  We'll just delete the breakpoint we
2097            stopped at, and carry on.  
2098
2099            Correction: what the code currently does is delete a
2100            step-resume bp, but it makes no effort to ensure that
2101            the one deleted is the one currently stopped at.  MVS  */
2102
2103         if (step_resume_breakpoint == NULL)
2104           {
2105             step_resume_breakpoint =
2106               bpstat_find_step_resume_breakpoint (stop_bpstat);
2107           }
2108         delete_step_resume_breakpoint (&step_resume_breakpoint);
2109         break;
2110
2111       case BPSTAT_WHAT_THROUGH_SIGTRAMP:
2112         /* If were waiting for a trap, hitting the step_resume_break
2113            doesn't count as getting it.  */
2114         if (trap_expected)
2115           ecs->another_trap = 1;
2116         break;
2117
2118       case BPSTAT_WHAT_CHECK_SHLIBS:
2119       case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK:
2120 #ifdef SOLIB_ADD
2121         {
2122           /* Remove breakpoints, we eventually want to step over the
2123              shlib event breakpoint, and SOLIB_ADD might adjust
2124              breakpoint addresses via breakpoint_re_set.  */
2125           if (breakpoints_inserted)
2126             remove_breakpoints ();
2127           breakpoints_inserted = 0;
2128
2129           /* Check for any newly added shared libraries if we're
2130              supposed to be adding them automatically.  Switch
2131              terminal for any messages produced by
2132              breakpoint_re_set.  */
2133           target_terminal_ours_for_output ();
2134           /* NOTE: cagney/2003-11-25: Make certain that the target
2135              stack's section table is kept up-to-date.  Architectures,
2136              (e.g., PPC64), use the section table to perform
2137              operations such as address => section name and hence
2138              require the table to contain all sections (including
2139              those found in shared libraries).  */
2140           /* NOTE: cagney/2003-11-25: Pass current_target and not
2141              exec_ops to SOLIB_ADD.  This is because current GDB is
2142              only tooled to propagate section_table changes out from
2143              the "current_target" (see target_resize_to_sections), and
2144              not up from the exec stratum.  This, of course, isn't
2145              right.  "infrun.c" should only interact with the
2146              exec/process stratum, instead relying on the target stack
2147              to propagate relevant changes (stop, section table
2148              changed, ...) up to other layers.  */
2149           SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
2150           target_terminal_inferior ();
2151
2152           /* Try to reenable shared library breakpoints, additional
2153              code segments in shared libraries might be mapped in now. */
2154           re_enable_breakpoints_in_shlibs ();
2155
2156           /* If requested, stop when the dynamic linker notifies
2157              gdb of events.  This allows the user to get control
2158              and place breakpoints in initializer routines for
2159              dynamically loaded objects (among other things).  */
2160           if (stop_on_solib_events || stop_stack_dummy)
2161             {
2162               stop_stepping (ecs);
2163               return;
2164             }
2165
2166           /* If we stopped due to an explicit catchpoint, then the
2167              (see above) call to SOLIB_ADD pulled in any symbols
2168              from a newly-loaded library, if appropriate.
2169
2170              We do want the inferior to stop, but not where it is
2171              now, which is in the dynamic linker callback.  Rather,
2172              we would like it stop in the user's program, just after
2173              the call that caused this catchpoint to trigger.  That
2174              gives the user a more useful vantage from which to
2175              examine their program's state. */
2176           else if (what.main_action ==
2177                    BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK)
2178             {
2179               /* ??rehrauer: If I could figure out how to get the
2180                  right return PC from here, we could just set a temp
2181                  breakpoint and resume.  I'm not sure we can without
2182                  cracking open the dld's shared libraries and sniffing
2183                  their unwind tables and text/data ranges, and that's
2184                  not a terribly portable notion.
2185
2186                  Until that time, we must step the inferior out of the
2187                  dld callback, and also out of the dld itself (and any
2188                  code or stubs in libdld.sl, such as "shl_load" and
2189                  friends) until we reach non-dld code.  At that point,
2190                  we can stop stepping. */
2191               bpstat_get_triggered_catchpoints (stop_bpstat,
2192                                                 &ecs->
2193                                                 stepping_through_solib_catchpoints);
2194               ecs->stepping_through_solib_after_catch = 1;
2195
2196               /* Be sure to lift all breakpoints, so the inferior does
2197                  actually step past this point... */
2198               ecs->another_trap = 1;
2199               break;
2200             }
2201           else
2202             {
2203               /* We want to step over this breakpoint, then keep going.  */
2204               ecs->another_trap = 1;
2205               break;
2206             }
2207         }
2208 #endif
2209         break;
2210
2211       case BPSTAT_WHAT_LAST:
2212         /* Not a real code, but listed here to shut up gcc -Wall.  */
2213
2214       case BPSTAT_WHAT_KEEP_CHECKING:
2215         break;
2216       }
2217   }
2218
2219   /* We come here if we hit a breakpoint but should not
2220      stop for it.  Possibly we also were stepping
2221      and should stop for that.  So fall through and
2222      test for stepping.  But, if not stepping,
2223      do not stop.  */
2224
2225   /* Are we stepping to get the inferior out of the dynamic
2226      linker's hook (and possibly the dld itself) after catching
2227      a shlib event? */
2228   if (ecs->stepping_through_solib_after_catch)
2229     {
2230 #if defined(SOLIB_ADD)
2231       /* Have we reached our destination?  If not, keep going. */
2232       if (SOLIB_IN_DYNAMIC_LINKER (PIDGET (ecs->ptid), stop_pc))
2233         {
2234           ecs->another_trap = 1;
2235           keep_going (ecs);
2236           return;
2237         }
2238 #endif
2239       /* Else, stop and report the catchpoint(s) whose triggering
2240          caused us to begin stepping. */
2241       ecs->stepping_through_solib_after_catch = 0;
2242       bpstat_clear (&stop_bpstat);
2243       stop_bpstat = bpstat_copy (ecs->stepping_through_solib_catchpoints);
2244       bpstat_clear (&ecs->stepping_through_solib_catchpoints);
2245       stop_print_frame = 1;
2246       stop_stepping (ecs);
2247       return;
2248     }
2249
2250   if (step_resume_breakpoint)
2251     {
2252       /* Having a step-resume breakpoint overrides anything
2253          else having to do with stepping commands until
2254          that breakpoint is reached.  */
2255       keep_going (ecs);
2256       return;
2257     }
2258
2259   if (step_range_end == 0)
2260     {
2261       /* Likewise if we aren't even stepping.  */
2262       keep_going (ecs);
2263       return;
2264     }
2265
2266   /* If stepping through a line, keep going if still within it.
2267
2268      Note that step_range_end is the address of the first instruction
2269      beyond the step range, and NOT the address of the last instruction
2270      within it! */
2271   if (stop_pc >= step_range_start && stop_pc < step_range_end)
2272     {
2273       keep_going (ecs);
2274       return;
2275     }
2276
2277   /* We stepped out of the stepping range.  */
2278
2279   /* If we are stepping at the source level and entered the runtime
2280      loader dynamic symbol resolution code, we keep on single stepping
2281      until we exit the run time loader code and reach the callee's
2282      address.  */
2283   if (step_over_calls == STEP_OVER_UNDEBUGGABLE
2284       && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc))
2285     {
2286       CORE_ADDR pc_after_resolver =
2287         gdbarch_skip_solib_resolver (current_gdbarch, stop_pc);
2288
2289       if (pc_after_resolver)
2290         {
2291           /* Set up a step-resume breakpoint at the address
2292              indicated by SKIP_SOLIB_RESOLVER.  */
2293           struct symtab_and_line sr_sal;
2294           init_sal (&sr_sal);
2295           sr_sal.pc = pc_after_resolver;
2296
2297           check_for_old_step_resume_breakpoint ();
2298           step_resume_breakpoint =
2299             set_momentary_breakpoint (sr_sal, null_frame_id, bp_step_resume);
2300           if (breakpoints_inserted)
2301             insert_breakpoints ();
2302         }
2303
2304       keep_going (ecs);
2305       return;
2306     }
2307
2308   if (step_range_end != 1
2309       && (step_over_calls == STEP_OVER_UNDEBUGGABLE
2310           || step_over_calls == STEP_OVER_ALL)
2311       && get_frame_type (get_current_frame ()) == SIGTRAMP_FRAME)
2312     {
2313       /* The inferior, while doing a "step" or "next", has ended up in
2314          a signal trampoline (either by a signal being delivered or by
2315          the signal handler returning).  Just single-step until the
2316          inferior leaves the trampoline (either by calling the handler
2317          or returning).  */
2318       keep_going (ecs);
2319       return;
2320     }
2321
2322   if (frame_id_eq (frame_unwind_id (get_current_frame ()),
2323                    step_frame_id))
2324     {
2325       /* It's a subroutine call.  */
2326       CORE_ADDR real_stop_pc;
2327         
2328       if ((step_over_calls == STEP_OVER_NONE)
2329           || ((step_range_end == 1)
2330               && in_prologue (prev_pc, ecs->stop_func_start)))
2331         {
2332           /* I presume that step_over_calls is only 0 when we're
2333              supposed to be stepping at the assembly language level
2334              ("stepi").  Just stop.  */
2335           /* Also, maybe we just did a "nexti" inside a prolog, so we
2336              thought it was a subroutine call but it was not.  Stop as
2337              well.  FENN */
2338           stop_step = 1;
2339           print_stop_reason (END_STEPPING_RANGE, 0);
2340           stop_stepping (ecs);
2341           return;
2342         }
2343         
2344       if (step_over_calls == STEP_OVER_ALL || IGNORE_HELPER_CALL (stop_pc))
2345         {
2346           /* We're doing a "next", set a breakpoint at callee's return
2347              address (the address at which the caller will
2348              resume).  */
2349           insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()),
2350                                          ecs);
2351           keep_going (ecs);
2352           return;
2353         }
2354       
2355       /* If we are in a function call trampoline (a stub between the
2356          calling routine and the real function), locate the real
2357          function.  That's what tells us (a) whether we want to step
2358          into it at all, and (b) what prologue we want to run to the
2359          end of, if we do step into it.  */
2360       real_stop_pc = skip_language_trampoline (stop_pc);
2361       if (real_stop_pc == 0)
2362         real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
2363       if (real_stop_pc != 0)
2364         ecs->stop_func_start = real_stop_pc;
2365       
2366       if (IN_SOLIB_DYNSYM_RESOLVE_CODE (ecs->stop_func_start))
2367         {
2368           struct symtab_and_line sr_sal;
2369           init_sal (&sr_sal);
2370           sr_sal.pc = ecs->stop_func_start;
2371
2372           check_for_old_step_resume_breakpoint ();
2373           step_resume_breakpoint =
2374             set_momentary_breakpoint (sr_sal, null_frame_id, bp_step_resume);
2375           if (breakpoints_inserted)
2376             insert_breakpoints ();
2377
2378           keep_going (ecs);
2379           return;
2380         }
2381
2382       /* If we have line number information for the function we are
2383          thinking of stepping into, step into it.
2384
2385          If there are several symtabs at that PC (e.g. with include
2386          files), just want to know whether *any* of them have line
2387          numbers.  find_pc_line handles this.  */
2388       {
2389         struct symtab_and_line tmp_sal;
2390         
2391         tmp_sal = find_pc_line (ecs->stop_func_start, 0);
2392         if (tmp_sal.line != 0)
2393           {
2394             step_into_function (ecs);
2395             return;
2396           }
2397       }
2398
2399       /* If we have no line number and the step-stop-if-no-debug is
2400          set, we stop the step so that the user has a chance to switch
2401          in assembly mode.  */
2402       if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug)
2403         {
2404           stop_step = 1;
2405           print_stop_reason (END_STEPPING_RANGE, 0);
2406           stop_stepping (ecs);
2407           return;
2408         }
2409
2410       /* Set a breakpoint at callee's return address (the address at
2411          which the caller will resume).  */
2412       insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()), ecs);
2413       keep_going (ecs);
2414       return;
2415     }
2416
2417   /* If we're in the return path from a shared library trampoline,
2418      we want to proceed through the trampoline when stepping.  */
2419   if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, ecs->stop_func_name))
2420     {
2421       /* Determine where this trampoline returns.  */
2422       CORE_ADDR real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
2423
2424       /* Only proceed through if we know where it's going.  */
2425       if (real_stop_pc)
2426         {
2427           /* And put the step-breakpoint there and go until there. */
2428           struct symtab_and_line sr_sal;
2429
2430           init_sal (&sr_sal);   /* initialize to zeroes */
2431           sr_sal.pc = real_stop_pc;
2432           sr_sal.section = find_pc_overlay (sr_sal.pc);
2433           /* Do not specify what the fp should be when we stop
2434              since on some machines the prologue
2435              is where the new fp value is established.  */
2436           check_for_old_step_resume_breakpoint ();
2437           step_resume_breakpoint =
2438             set_momentary_breakpoint (sr_sal, null_frame_id, bp_step_resume);
2439           if (breakpoints_inserted)
2440             insert_breakpoints ();
2441
2442           /* Restart without fiddling with the step ranges or
2443              other state.  */
2444           keep_going (ecs);
2445           return;
2446         }
2447     }
2448
2449   /* NOTE: tausq/2004-05-24: This if block used to be done before all
2450      the trampoline processing logic, however, there are some trampolines 
2451      that have no names, so we should do trampoline handling first.  */
2452   if (step_over_calls == STEP_OVER_UNDEBUGGABLE
2453       && ecs->stop_func_name == NULL)
2454     {
2455       /* The inferior just stepped into, or returned to, an
2456          undebuggable function (where there is no symbol, not even a
2457          minimal symbol, corresponding to the address where the
2458          inferior stopped).  Since we want to skip this kind of code,
2459          we keep going until the inferior returns from this
2460          function.  */
2461       if (step_stop_if_no_debug)
2462         {
2463           /* If we have no line number and the step-stop-if-no-debug
2464              is set, we stop the step so that the user has a chance to
2465              switch in assembly mode.  */
2466           stop_step = 1;
2467           print_stop_reason (END_STEPPING_RANGE, 0);
2468           stop_stepping (ecs);
2469           return;
2470         }
2471       else
2472         {
2473           /* Set a breakpoint at callee's return address (the address
2474              at which the caller will resume).  */
2475           insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()),
2476                                          ecs);
2477           keep_going (ecs);
2478           return;
2479         }
2480     }
2481
2482   if (step_range_end == 1)
2483     {
2484       /* It is stepi or nexti.  We always want to stop stepping after
2485          one instruction.  */
2486       stop_step = 1;
2487       print_stop_reason (END_STEPPING_RANGE, 0);
2488       stop_stepping (ecs);
2489       return;
2490     }
2491
2492   ecs->sal = find_pc_line (stop_pc, 0);
2493
2494   if (ecs->sal.line == 0)
2495     {
2496       /* We have no line number information.  That means to stop
2497          stepping (does this always happen right after one instruction,
2498          when we do "s" in a function with no line numbers,
2499          or can this happen as a result of a return or longjmp?).  */
2500       stop_step = 1;
2501       print_stop_reason (END_STEPPING_RANGE, 0);
2502       stop_stepping (ecs);
2503       return;
2504     }
2505
2506   if ((stop_pc == ecs->sal.pc)
2507       && (ecs->current_line != ecs->sal.line
2508           || ecs->current_symtab != ecs->sal.symtab))
2509     {
2510       /* We are at the start of a different line.  So stop.  Note that
2511          we don't stop if we step into the middle of a different line.
2512          That is said to make things like for (;;) statements work
2513          better.  */
2514       stop_step = 1;
2515       print_stop_reason (END_STEPPING_RANGE, 0);
2516       stop_stepping (ecs);
2517       return;
2518     }
2519
2520   /* We aren't done stepping.
2521
2522      Optimize by setting the stepping range to the line.
2523      (We might not be in the original line, but if we entered a
2524      new line in mid-statement, we continue stepping.  This makes
2525      things like for(;;) statements work better.)  */
2526
2527   if (ecs->stop_func_end && ecs->sal.end >= ecs->stop_func_end)
2528     {
2529       /* If this is the last line of the function, don't keep stepping
2530          (it would probably step us out of the function).
2531          This is particularly necessary for a one-line function,
2532          in which after skipping the prologue we better stop even though
2533          we will be in mid-line.  */
2534       stop_step = 1;
2535       print_stop_reason (END_STEPPING_RANGE, 0);
2536       stop_stepping (ecs);
2537       return;
2538     }
2539   step_range_start = ecs->sal.pc;
2540   step_range_end = ecs->sal.end;
2541   step_frame_id = get_frame_id (get_current_frame ());
2542   ecs->current_line = ecs->sal.line;
2543   ecs->current_symtab = ecs->sal.symtab;
2544
2545   /* In the case where we just stepped out of a function into the
2546      middle of a line of the caller, continue stepping, but
2547      step_frame_id must be modified to current frame */
2548 #if 0
2549   /* NOTE: cagney/2003-10-16: I think this frame ID inner test is too
2550      generous.  It will trigger on things like a step into a frameless
2551      stackless leaf function.  I think the logic should instead look
2552      at the unwound frame ID has that should give a more robust
2553      indication of what happened.  */
2554      if (step-ID == current-ID)
2555        still stepping in same function;
2556      else if (step-ID == unwind (current-ID))
2557        stepped into a function;
2558      else
2559        stepped out of a function;
2560      /* Of course this assumes that the frame ID unwind code is robust
2561         and we're willing to introduce frame unwind logic into this
2562         function.  Fortunately, those days are nearly upon us.  */
2563 #endif
2564   {
2565     struct frame_id current_frame = get_frame_id (get_current_frame ());
2566     if (!(frame_id_inner (current_frame, step_frame_id)))
2567       step_frame_id = current_frame;
2568   }
2569
2570   keep_going (ecs);
2571 }
2572
2573 /* Are we in the middle of stepping?  */
2574
2575 static int
2576 currently_stepping (struct execution_control_state *ecs)
2577 {
2578   return ((!ecs->handling_longjmp
2579            && ((step_range_end && step_resume_breakpoint == NULL)
2580                || trap_expected))
2581           || ecs->stepping_through_solib_after_catch
2582           || bpstat_should_step ());
2583 }
2584
2585 /* Subroutine call with source code we should not step over.  Do step
2586    to the first line of code in it.  */
2587
2588 static void
2589 step_into_function (struct execution_control_state *ecs)
2590 {
2591   struct symtab *s;
2592   struct symtab_and_line sr_sal;
2593
2594   s = find_pc_symtab (stop_pc);
2595   if (s && s->language != language_asm)
2596     ecs->stop_func_start = SKIP_PROLOGUE (ecs->stop_func_start);
2597
2598   ecs->sal = find_pc_line (ecs->stop_func_start, 0);
2599   /* Use the step_resume_break to step until the end of the prologue,
2600      even if that involves jumps (as it seems to on the vax under
2601      4.2).  */
2602   /* If the prologue ends in the middle of a source line, continue to
2603      the end of that source line (if it is still within the function).
2604      Otherwise, just go to end of prologue.  */
2605   if (ecs->sal.end
2606       && ecs->sal.pc != ecs->stop_func_start
2607       && ecs->sal.end < ecs->stop_func_end)
2608     ecs->stop_func_start = ecs->sal.end;
2609
2610   /* Architectures which require breakpoint adjustment might not be able
2611      to place a breakpoint at the computed address.  If so, the test
2612      ``ecs->stop_func_start == stop_pc'' will never succeed.  Adjust
2613      ecs->stop_func_start to an address at which a breakpoint may be
2614      legitimately placed.
2615      
2616      Note:  kevinb/2004-01-19:  On FR-V, if this adjustment is not
2617      made, GDB will enter an infinite loop when stepping through
2618      optimized code consisting of VLIW instructions which contain
2619      subinstructions corresponding to different source lines.  On
2620      FR-V, it's not permitted to place a breakpoint on any but the
2621      first subinstruction of a VLIW instruction.  When a breakpoint is
2622      set, GDB will adjust the breakpoint address to the beginning of
2623      the VLIW instruction.  Thus, we need to make the corresponding
2624      adjustment here when computing the stop address.  */
2625      
2626   if (gdbarch_adjust_breakpoint_address_p (current_gdbarch))
2627     {
2628       ecs->stop_func_start
2629         = gdbarch_adjust_breakpoint_address (current_gdbarch,
2630                                              ecs->stop_func_start);
2631     }
2632
2633   if (ecs->stop_func_start == stop_pc)
2634     {
2635       /* We are already there: stop now.  */
2636       stop_step = 1;
2637       print_stop_reason (END_STEPPING_RANGE, 0);
2638       stop_stepping (ecs);
2639       return;
2640     }
2641   else
2642     {
2643       /* Put the step-breakpoint there and go until there.  */
2644       init_sal (&sr_sal);       /* initialize to zeroes */
2645       sr_sal.pc = ecs->stop_func_start;
2646       sr_sal.section = find_pc_overlay (ecs->stop_func_start);
2647       /* Do not specify what the fp should be when we stop since on
2648          some machines the prologue is where the new fp value is
2649          established.  */
2650       check_for_old_step_resume_breakpoint ();
2651       step_resume_breakpoint =
2652         set_momentary_breakpoint (sr_sal, null_frame_id, bp_step_resume);
2653       if (breakpoints_inserted)
2654         insert_breakpoints ();
2655
2656       /* And make sure stepping stops right away then.  */
2657       step_range_end = step_range_start;
2658     }
2659   keep_going (ecs);
2660 }
2661
2662 /* Insert a "step resume breakpoint" at RETURN_FRAME.pc.  This is used
2663    to skip a function (next, skip-no-debug) or signal.  It's assumed
2664    that the function/signal handler being skipped eventually returns
2665    to the breakpoint inserted at RETURN_FRAME.pc.
2666
2667    For the skip-function case, the function may have been reached by
2668    either single stepping a call / return / signal-return instruction,
2669    or by hitting a breakpoint.  In all cases, the RETURN_FRAME belongs
2670    to the skip-function's caller.
2671
2672    For the signals case, this is called with the interrupted
2673    function's frame.  The signal handler, when it returns, will resume
2674    the interrupted function at RETURN_FRAME.pc.  */
2675
2676 static void
2677 insert_step_resume_breakpoint (struct frame_info *return_frame,
2678                                struct execution_control_state *ecs)
2679 {
2680   struct symtab_and_line sr_sal;
2681
2682   init_sal (&sr_sal);           /* initialize to zeros */
2683
2684   sr_sal.pc = ADDR_BITS_REMOVE (get_frame_pc (return_frame));
2685   sr_sal.section = find_pc_overlay (sr_sal.pc);
2686
2687   check_for_old_step_resume_breakpoint ();
2688
2689   step_resume_breakpoint
2690     = set_momentary_breakpoint (sr_sal, get_frame_id (return_frame),
2691                                 bp_step_resume);
2692
2693   if (breakpoints_inserted)
2694     insert_breakpoints ();
2695 }
2696
2697 static void
2698 stop_stepping (struct execution_control_state *ecs)
2699 {
2700   /* Let callers know we don't want to wait for the inferior anymore.  */
2701   ecs->wait_some_more = 0;
2702 }
2703
2704 /* This function handles various cases where we need to continue
2705    waiting for the inferior.  */
2706 /* (Used to be the keep_going: label in the old wait_for_inferior) */
2707
2708 static void
2709 keep_going (struct execution_control_state *ecs)
2710 {
2711   /* Save the pc before execution, to compare with pc after stop.  */
2712   prev_pc = read_pc ();         /* Might have been DECR_AFTER_BREAK */
2713
2714   /* If we did not do break;, it means we should keep running the
2715      inferior and not return to debugger.  */
2716
2717   if (trap_expected && stop_signal != TARGET_SIGNAL_TRAP)
2718     {
2719       /* We took a signal (which we are supposed to pass through to
2720          the inferior, else we'd have done a break above) and we
2721          haven't yet gotten our trap.  Simply continue.  */
2722       resume (currently_stepping (ecs), stop_signal);
2723     }
2724   else
2725     {
2726       /* Either the trap was not expected, but we are continuing
2727          anyway (the user asked that this signal be passed to the
2728          child)
2729          -- or --
2730          The signal was SIGTRAP, e.g. it was our signal, but we
2731          decided we should resume from it.
2732
2733          We're going to run this baby now!
2734
2735          Insert breakpoints now, unless we are trying to one-proceed
2736          past a breakpoint.  */
2737       /* If we've just finished a special step resume and we don't
2738          want to hit a breakpoint, pull em out.  */
2739       if (step_resume_breakpoint == NULL
2740           && ecs->remove_breakpoints_on_following_step)
2741         {
2742           ecs->remove_breakpoints_on_following_step = 0;
2743           remove_breakpoints ();
2744           breakpoints_inserted = 0;
2745         }
2746       else if (!breakpoints_inserted && !ecs->another_trap)
2747         {
2748           breakpoints_failed = insert_breakpoints ();
2749           if (breakpoints_failed)
2750             {
2751               stop_stepping (ecs);
2752               return;
2753             }
2754           breakpoints_inserted = 1;
2755         }
2756
2757       trap_expected = ecs->another_trap;
2758
2759       /* Do not deliver SIGNAL_TRAP (except when the user explicitly
2760          specifies that such a signal should be delivered to the
2761          target program).
2762
2763          Typically, this would occure when a user is debugging a
2764          target monitor on a simulator: the target monitor sets a
2765          breakpoint; the simulator encounters this break-point and
2766          halts the simulation handing control to GDB; GDB, noteing
2767          that the break-point isn't valid, returns control back to the
2768          simulator; the simulator then delivers the hardware
2769          equivalent of a SIGNAL_TRAP to the program being debugged. */
2770
2771       if (stop_signal == TARGET_SIGNAL_TRAP && !signal_program[stop_signal])
2772         stop_signal = TARGET_SIGNAL_0;
2773
2774
2775       resume (currently_stepping (ecs), stop_signal);
2776     }
2777
2778   prepare_to_wait (ecs);
2779 }
2780
2781 /* This function normally comes after a resume, before
2782    handle_inferior_event exits.  It takes care of any last bits of
2783    housekeeping, and sets the all-important wait_some_more flag.  */
2784
2785 static void
2786 prepare_to_wait (struct execution_control_state *ecs)
2787 {
2788   if (ecs->infwait_state == infwait_normal_state)
2789     {
2790       overlay_cache_invalid = 1;
2791
2792       /* We have to invalidate the registers BEFORE calling
2793          target_wait because they can be loaded from the target while
2794          in target_wait.  This makes remote debugging a bit more
2795          efficient for those targets that provide critical registers
2796          as part of their normal status mechanism. */
2797
2798       registers_changed ();
2799       ecs->waiton_ptid = pid_to_ptid (-1);
2800       ecs->wp = &(ecs->ws);
2801     }
2802   /* This is the old end of the while loop.  Let everybody know we
2803      want to wait for the inferior some more and get called again
2804      soon.  */
2805   ecs->wait_some_more = 1;
2806 }
2807
2808 /* Print why the inferior has stopped. We always print something when
2809    the inferior exits, or receives a signal. The rest of the cases are
2810    dealt with later on in normal_stop() and print_it_typical().  Ideally
2811    there should be a call to this function from handle_inferior_event()
2812    each time stop_stepping() is called.*/
2813 static void
2814 print_stop_reason (enum inferior_stop_reason stop_reason, int stop_info)
2815 {
2816   switch (stop_reason)
2817     {
2818     case STOP_UNKNOWN:
2819       /* We don't deal with these cases from handle_inferior_event()
2820          yet. */
2821       break;
2822     case END_STEPPING_RANGE:
2823       /* We are done with a step/next/si/ni command. */
2824       /* For now print nothing. */
2825       /* Print a message only if not in the middle of doing a "step n"
2826          operation for n > 1 */
2827       if (!step_multi || !stop_step)
2828         if (ui_out_is_mi_like_p (uiout))
2829           ui_out_field_string (uiout, "reason", "end-stepping-range");
2830       break;
2831     case BREAKPOINT_HIT:
2832       /* We found a breakpoint. */
2833       /* For now print nothing. */
2834       break;
2835     case SIGNAL_EXITED:
2836       /* The inferior was terminated by a signal. */
2837       annotate_signalled ();
2838       if (ui_out_is_mi_like_p (uiout))
2839         ui_out_field_string (uiout, "reason", "exited-signalled");
2840       ui_out_text (uiout, "\nProgram terminated with signal ");
2841       annotate_signal_name ();
2842       ui_out_field_string (uiout, "signal-name",
2843                            target_signal_to_name (stop_info));
2844       annotate_signal_name_end ();
2845       ui_out_text (uiout, ", ");
2846       annotate_signal_string ();
2847       ui_out_field_string (uiout, "signal-meaning",
2848                            target_signal_to_string (stop_info));
2849       annotate_signal_string_end ();
2850       ui_out_text (uiout, ".\n");
2851       ui_out_text (uiout, "The program no longer exists.\n");
2852       break;
2853     case EXITED:
2854       /* The inferior program is finished. */
2855       annotate_exited (stop_info);
2856       if (stop_info)
2857         {
2858           if (ui_out_is_mi_like_p (uiout))
2859             ui_out_field_string (uiout, "reason", "exited");
2860           ui_out_text (uiout, "\nProgram exited with code ");
2861           ui_out_field_fmt (uiout, "exit-code", "0%o",
2862                             (unsigned int) stop_info);
2863           ui_out_text (uiout, ".\n");
2864         }
2865       else
2866         {
2867           if (ui_out_is_mi_like_p (uiout))
2868             ui_out_field_string (uiout, "reason", "exited-normally");
2869           ui_out_text (uiout, "\nProgram exited normally.\n");
2870         }
2871       break;
2872     case SIGNAL_RECEIVED:
2873       /* Signal received. The signal table tells us to print about
2874          it. */
2875       annotate_signal ();
2876       ui_out_text (uiout, "\nProgram received signal ");
2877       annotate_signal_name ();
2878       if (ui_out_is_mi_like_p (uiout))
2879         ui_out_field_string (uiout, "reason", "signal-received");
2880       ui_out_field_string (uiout, "signal-name",
2881                            target_signal_to_name (stop_info));
2882       annotate_signal_name_end ();
2883       ui_out_text (uiout, ", ");
2884       annotate_signal_string ();
2885       ui_out_field_string (uiout, "signal-meaning",
2886                            target_signal_to_string (stop_info));
2887       annotate_signal_string_end ();
2888       ui_out_text (uiout, ".\n");
2889       break;
2890     default:
2891       internal_error (__FILE__, __LINE__,
2892                       "print_stop_reason: unrecognized enum value");
2893       break;
2894     }
2895 }
2896 \f
2897
2898 /* Here to return control to GDB when the inferior stops for real.
2899    Print appropriate messages, remove breakpoints, give terminal our modes.
2900
2901    STOP_PRINT_FRAME nonzero means print the executing frame
2902    (pc, function, args, file, line number and line text).
2903    BREAKPOINTS_FAILED nonzero means stop was due to error
2904    attempting to insert breakpoints.  */
2905
2906 void
2907 normal_stop (void)
2908 {
2909   struct target_waitstatus last;
2910   ptid_t last_ptid;
2911
2912   get_last_target_status (&last_ptid, &last);
2913
2914   /* As with the notification of thread events, we want to delay
2915      notifying the user that we've switched thread context until
2916      the inferior actually stops.
2917
2918      There's no point in saying anything if the inferior has exited.
2919      Note that SIGNALLED here means "exited with a signal", not
2920      "received a signal".  */
2921   if (!ptid_equal (previous_inferior_ptid, inferior_ptid)
2922       && target_has_execution
2923       && last.kind != TARGET_WAITKIND_SIGNALLED
2924       && last.kind != TARGET_WAITKIND_EXITED)
2925     {
2926       target_terminal_ours_for_output ();
2927       printf_filtered ("[Switching to %s]\n",
2928                        target_pid_or_tid_to_str (inferior_ptid));
2929       previous_inferior_ptid = inferior_ptid;
2930     }
2931
2932   /* NOTE drow/2004-01-17: Is this still necessary?  */
2933   /* Make sure that the current_frame's pc is correct.  This
2934      is a correction for setting up the frame info before doing
2935      DECR_PC_AFTER_BREAK */
2936   if (target_has_execution)
2937     /* FIXME: cagney/2002-12-06: Has the PC changed?  Thanks to
2938        DECR_PC_AFTER_BREAK, the program counter can change.  Ask the
2939        frame code to check for this and sort out any resultant mess.
2940        DECR_PC_AFTER_BREAK needs to just go away.  */
2941     deprecated_update_frame_pc_hack (get_current_frame (), read_pc ());
2942
2943   if (target_has_execution && breakpoints_inserted)
2944     {
2945       if (remove_breakpoints ())
2946         {
2947           target_terminal_ours_for_output ();
2948           printf_filtered ("Cannot remove breakpoints because ");
2949           printf_filtered ("program is no longer writable.\n");
2950           printf_filtered ("It might be running in another process.\n");
2951           printf_filtered ("Further execution is probably impossible.\n");
2952         }
2953     }
2954   breakpoints_inserted = 0;
2955
2956   /* Delete the breakpoint we stopped at, if it wants to be deleted.
2957      Delete any breakpoint that is to be deleted at the next stop.  */
2958
2959   breakpoint_auto_delete (stop_bpstat);
2960
2961   /* If an auto-display called a function and that got a signal,
2962      delete that auto-display to avoid an infinite recursion.  */
2963
2964   if (stopped_by_random_signal)
2965     disable_current_display ();
2966
2967   /* Don't print a message if in the middle of doing a "step n"
2968      operation for n > 1 */
2969   if (step_multi && stop_step)
2970     goto done;
2971
2972   target_terminal_ours ();
2973
2974   /* Look up the hook_stop and run it (CLI internally handles problem
2975      of stop_command's pre-hook not existing).  */
2976   if (stop_command)
2977     catch_errors (hook_stop_stub, stop_command,
2978                   "Error while running hook_stop:\n", RETURN_MASK_ALL);
2979
2980   if (!target_has_stack)
2981     {
2982
2983       goto done;
2984     }
2985
2986   /* Select innermost stack frame - i.e., current frame is frame 0,
2987      and current location is based on that.
2988      Don't do this on return from a stack dummy routine,
2989      or if the program has exited. */
2990
2991   if (!stop_stack_dummy)
2992     {
2993       select_frame (get_current_frame ());
2994
2995       /* Print current location without a level number, if
2996          we have changed functions or hit a breakpoint.
2997          Print source line if we have one.
2998          bpstat_print() contains the logic deciding in detail
2999          what to print, based on the event(s) that just occurred. */
3000
3001       if (stop_print_frame && deprecated_selected_frame)
3002         {
3003           int bpstat_ret;
3004           int source_flag;
3005           int do_frame_printing = 1;
3006
3007           bpstat_ret = bpstat_print (stop_bpstat);
3008           switch (bpstat_ret)
3009             {
3010             case PRINT_UNKNOWN:
3011               /* FIXME: cagney/2002-12-01: Given that a frame ID does
3012                  (or should) carry around the function and does (or
3013                  should) use that when doing a frame comparison.  */
3014               if (stop_step
3015                   && frame_id_eq (step_frame_id,
3016                                   get_frame_id (get_current_frame ()))
3017                   && step_start_function == find_pc_function (stop_pc))
3018                 source_flag = SRC_LINE; /* finished step, just print source line */
3019               else
3020                 source_flag = SRC_AND_LOC;      /* print location and source line */
3021               break;
3022             case PRINT_SRC_AND_LOC:
3023               source_flag = SRC_AND_LOC;        /* print location and source line */
3024               break;
3025             case PRINT_SRC_ONLY:
3026               source_flag = SRC_LINE;
3027               break;
3028             case PRINT_NOTHING:
3029               source_flag = SRC_LINE;   /* something bogus */
3030               do_frame_printing = 0;
3031               break;
3032             default:
3033               internal_error (__FILE__, __LINE__, "Unknown value.");
3034             }
3035           /* For mi, have the same behavior every time we stop:
3036              print everything but the source line. */
3037           if (ui_out_is_mi_like_p (uiout))
3038             source_flag = LOC_AND_ADDRESS;
3039
3040           if (ui_out_is_mi_like_p (uiout))
3041             ui_out_field_int (uiout, "thread-id",
3042                               pid_to_thread_id (inferior_ptid));
3043           /* The behavior of this routine with respect to the source
3044              flag is:
3045              SRC_LINE: Print only source line
3046              LOCATION: Print only location
3047              SRC_AND_LOC: Print location and source line */
3048           if (do_frame_printing)
3049             print_stack_frame (get_selected_frame (), 0, source_flag);
3050
3051           /* Display the auto-display expressions.  */
3052           do_displays ();
3053         }
3054     }
3055
3056   /* Save the function value return registers, if we care.
3057      We might be about to restore their previous contents.  */
3058   if (proceed_to_finish)
3059     /* NB: The copy goes through to the target picking up the value of
3060        all the registers.  */
3061     regcache_cpy (stop_registers, current_regcache);
3062
3063   if (stop_stack_dummy)
3064     {
3065       /* Pop the empty frame that contains the stack dummy.  POP_FRAME
3066          ends with a setting of the current frame, so we can use that
3067          next. */
3068       frame_pop (get_current_frame ());
3069       /* Set stop_pc to what it was before we called the function.
3070          Can't rely on restore_inferior_status because that only gets
3071          called if we don't stop in the called function.  */
3072       stop_pc = read_pc ();
3073       select_frame (get_current_frame ());
3074     }
3075
3076 done:
3077   annotate_stopped ();
3078   observer_notify_normal_stop (stop_bpstat);
3079 }
3080
3081 static int
3082 hook_stop_stub (void *cmd)
3083 {
3084   execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
3085   return (0);
3086 }
3087 \f
3088 int
3089 signal_stop_state (int signo)
3090 {
3091   return signal_stop[signo];
3092 }
3093
3094 int
3095 signal_print_state (int signo)
3096 {
3097   return signal_print[signo];
3098 }
3099
3100 int
3101 signal_pass_state (int signo)
3102 {
3103   return signal_program[signo];
3104 }
3105
3106 int
3107 signal_stop_update (int signo, int state)
3108 {
3109   int ret = signal_stop[signo];
3110   signal_stop[signo] = state;
3111   return ret;
3112 }
3113
3114 int
3115 signal_print_update (int signo, int state)
3116 {
3117   int ret = signal_print[signo];
3118   signal_print[signo] = state;
3119   return ret;
3120 }
3121
3122 int
3123 signal_pass_update (int signo, int state)
3124 {
3125   int ret = signal_program[signo];
3126   signal_program[signo] = state;
3127   return ret;
3128 }
3129
3130 static void
3131 sig_print_header (void)
3132 {
3133   printf_filtered ("\
3134 Signal        Stop\tPrint\tPass to program\tDescription\n");
3135 }
3136
3137 static void
3138 sig_print_info (enum target_signal oursig)
3139 {
3140   char *name = target_signal_to_name (oursig);
3141   int name_padding = 13 - strlen (name);
3142
3143   if (name_padding <= 0)
3144     name_padding = 0;
3145
3146   printf_filtered ("%s", name);
3147   printf_filtered ("%*.*s ", name_padding, name_padding, "                 ");
3148   printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
3149   printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
3150   printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
3151   printf_filtered ("%s\n", target_signal_to_string (oursig));
3152 }
3153
3154 /* Specify how various signals in the inferior should be handled.  */
3155
3156 static void
3157 handle_command (char *args, int from_tty)
3158 {
3159   char **argv;
3160   int digits, wordlen;
3161   int sigfirst, signum, siglast;
3162   enum target_signal oursig;
3163   int allsigs;
3164   int nsigs;
3165   unsigned char *sigs;
3166   struct cleanup *old_chain;
3167
3168   if (args == NULL)
3169     {
3170       error_no_arg ("signal to handle");
3171     }
3172
3173   /* Allocate and zero an array of flags for which signals to handle. */
3174
3175   nsigs = (int) TARGET_SIGNAL_LAST;
3176   sigs = (unsigned char *) alloca (nsigs);
3177   memset (sigs, 0, nsigs);
3178
3179   /* Break the command line up into args. */
3180
3181   argv = buildargv (args);
3182   if (argv == NULL)
3183     {
3184       nomem (0);
3185     }
3186   old_chain = make_cleanup_freeargv (argv);
3187
3188   /* Walk through the args, looking for signal oursigs, signal names, and
3189      actions.  Signal numbers and signal names may be interspersed with
3190      actions, with the actions being performed for all signals cumulatively
3191      specified.  Signal ranges can be specified as <LOW>-<HIGH>. */
3192
3193   while (*argv != NULL)
3194     {
3195       wordlen = strlen (*argv);
3196       for (digits = 0; isdigit ((*argv)[digits]); digits++)
3197         {;
3198         }
3199       allsigs = 0;
3200       sigfirst = siglast = -1;
3201
3202       if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
3203         {
3204           /* Apply action to all signals except those used by the
3205              debugger.  Silently skip those. */
3206           allsigs = 1;
3207           sigfirst = 0;
3208           siglast = nsigs - 1;
3209         }
3210       else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
3211         {
3212           SET_SIGS (nsigs, sigs, signal_stop);
3213           SET_SIGS (nsigs, sigs, signal_print);
3214         }
3215       else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
3216         {
3217           UNSET_SIGS (nsigs, sigs, signal_program);
3218         }
3219       else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
3220         {
3221           SET_SIGS (nsigs, sigs, signal_print);
3222         }
3223       else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
3224         {
3225           SET_SIGS (nsigs, sigs, signal_program);
3226         }
3227       else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
3228         {
3229           UNSET_SIGS (nsigs, sigs, signal_stop);
3230         }
3231       else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
3232         {
3233           SET_SIGS (nsigs, sigs, signal_program);
3234         }
3235       else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
3236         {
3237           UNSET_SIGS (nsigs, sigs, signal_print);
3238           UNSET_SIGS (nsigs, sigs, signal_stop);
3239         }
3240       else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
3241         {
3242           UNSET_SIGS (nsigs, sigs, signal_program);
3243         }
3244       else if (digits > 0)
3245         {
3246           /* It is numeric.  The numeric signal refers to our own
3247              internal signal numbering from target.h, not to host/target
3248              signal  number.  This is a feature; users really should be
3249              using symbolic names anyway, and the common ones like
3250              SIGHUP, SIGINT, SIGALRM, etc. will work right anyway.  */
3251
3252           sigfirst = siglast = (int)
3253             target_signal_from_command (atoi (*argv));
3254           if ((*argv)[digits] == '-')
3255             {
3256               siglast = (int)
3257                 target_signal_from_command (atoi ((*argv) + digits + 1));
3258             }
3259           if (sigfirst > siglast)
3260             {
3261               /* Bet he didn't figure we'd think of this case... */
3262               signum = sigfirst;
3263               sigfirst = siglast;
3264               siglast = signum;
3265             }
3266         }
3267       else
3268         {
3269           oursig = target_signal_from_name (*argv);
3270           if (oursig != TARGET_SIGNAL_UNKNOWN)
3271             {
3272               sigfirst = siglast = (int) oursig;
3273             }
3274           else
3275             {
3276               /* Not a number and not a recognized flag word => complain.  */
3277               error ("Unrecognized or ambiguous flag word: \"%s\".", *argv);
3278             }
3279         }
3280
3281       /* If any signal numbers or symbol names were found, set flags for
3282          which signals to apply actions to. */
3283
3284       for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
3285         {
3286           switch ((enum target_signal) signum)
3287             {
3288             case TARGET_SIGNAL_TRAP:
3289             case TARGET_SIGNAL_INT:
3290               if (!allsigs && !sigs[signum])
3291                 {
3292                   if (query ("%s is used by the debugger.\n\
3293 Are you sure you want to change it? ", target_signal_to_name ((enum target_signal) signum)))
3294                     {
3295                       sigs[signum] = 1;
3296                     }
3297                   else
3298                     {
3299                       printf_unfiltered ("Not confirmed, unchanged.\n");
3300                       gdb_flush (gdb_stdout);
3301                     }
3302                 }
3303               break;
3304             case TARGET_SIGNAL_0:
3305             case TARGET_SIGNAL_DEFAULT:
3306             case TARGET_SIGNAL_UNKNOWN:
3307               /* Make sure that "all" doesn't print these.  */
3308               break;
3309             default:
3310               sigs[signum] = 1;
3311               break;
3312             }
3313         }
3314
3315       argv++;
3316     }
3317
3318   target_notice_signals (inferior_ptid);
3319
3320   if (from_tty)
3321     {
3322       /* Show the results.  */
3323       sig_print_header ();
3324       for (signum = 0; signum < nsigs; signum++)
3325         {
3326           if (sigs[signum])
3327             {
3328               sig_print_info (signum);
3329             }
3330         }
3331     }
3332
3333   do_cleanups (old_chain);
3334 }
3335
3336 static void
3337 xdb_handle_command (char *args, int from_tty)
3338 {
3339   char **argv;
3340   struct cleanup *old_chain;
3341
3342   /* Break the command line up into args. */
3343
3344   argv = buildargv (args);
3345   if (argv == NULL)
3346     {
3347       nomem (0);
3348     }
3349   old_chain = make_cleanup_freeargv (argv);
3350   if (argv[1] != (char *) NULL)
3351     {
3352       char *argBuf;
3353       int bufLen;
3354
3355       bufLen = strlen (argv[0]) + 20;
3356       argBuf = (char *) xmalloc (bufLen);
3357       if (argBuf)
3358         {
3359           int validFlag = 1;
3360           enum target_signal oursig;
3361
3362           oursig = target_signal_from_name (argv[0]);
3363           memset (argBuf, 0, bufLen);
3364           if (strcmp (argv[1], "Q") == 0)
3365             sprintf (argBuf, "%s %s", argv[0], "noprint");
3366           else
3367             {
3368               if (strcmp (argv[1], "s") == 0)
3369                 {
3370                   if (!signal_stop[oursig])
3371                     sprintf (argBuf, "%s %s", argv[0], "stop");
3372                   else
3373                     sprintf (argBuf, "%s %s", argv[0], "nostop");
3374                 }
3375               else if (strcmp (argv[1], "i") == 0)
3376                 {
3377                   if (!signal_program[oursig])
3378                     sprintf (argBuf, "%s %s", argv[0], "pass");
3379                   else
3380                     sprintf (argBuf, "%s %s", argv[0], "nopass");
3381                 }
3382               else if (strcmp (argv[1], "r") == 0)
3383                 {
3384                   if (!signal_print[oursig])
3385                     sprintf (argBuf, "%s %s", argv[0], "print");
3386                   else
3387                     sprintf (argBuf, "%s %s", argv[0], "noprint");
3388                 }
3389               else
3390                 validFlag = 0;
3391             }
3392           if (validFlag)
3393             handle_command (argBuf, from_tty);
3394           else
3395             printf_filtered ("Invalid signal handling flag.\n");
3396           if (argBuf)
3397             xfree (argBuf);
3398         }
3399     }
3400   do_cleanups (old_chain);
3401 }
3402
3403 /* Print current contents of the tables set by the handle command.
3404    It is possible we should just be printing signals actually used
3405    by the current target (but for things to work right when switching
3406    targets, all signals should be in the signal tables).  */
3407
3408 static void
3409 signals_info (char *signum_exp, int from_tty)
3410 {
3411   enum target_signal oursig;
3412   sig_print_header ();
3413
3414   if (signum_exp)
3415     {
3416       /* First see if this is a symbol name.  */
3417       oursig = target_signal_from_name (signum_exp);
3418       if (oursig == TARGET_SIGNAL_UNKNOWN)
3419         {
3420           /* No, try numeric.  */
3421           oursig =
3422             target_signal_from_command (parse_and_eval_long (signum_exp));
3423         }
3424       sig_print_info (oursig);
3425       return;
3426     }
3427
3428   printf_filtered ("\n");
3429   /* These ugly casts brought to you by the native VAX compiler.  */
3430   for (oursig = TARGET_SIGNAL_FIRST;
3431        (int) oursig < (int) TARGET_SIGNAL_LAST;
3432        oursig = (enum target_signal) ((int) oursig + 1))
3433     {
3434       QUIT;
3435
3436       if (oursig != TARGET_SIGNAL_UNKNOWN
3437           && oursig != TARGET_SIGNAL_DEFAULT && oursig != TARGET_SIGNAL_0)
3438         sig_print_info (oursig);
3439     }
3440
3441   printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
3442 }
3443 \f
3444 struct inferior_status
3445 {
3446   enum target_signal stop_signal;
3447   CORE_ADDR stop_pc;
3448   bpstat stop_bpstat;
3449   int stop_step;
3450   int stop_stack_dummy;
3451   int stopped_by_random_signal;
3452   int trap_expected;
3453   CORE_ADDR step_range_start;
3454   CORE_ADDR step_range_end;
3455   struct frame_id step_frame_id;
3456   enum step_over_calls_kind step_over_calls;
3457   CORE_ADDR step_resume_break_address;
3458   int stop_after_trap;
3459   int stop_soon;
3460   struct regcache *stop_registers;
3461
3462   /* These are here because if call_function_by_hand has written some
3463      registers and then decides to call error(), we better not have changed
3464      any registers.  */
3465   struct regcache *registers;
3466
3467   /* A frame unique identifier.  */
3468   struct frame_id selected_frame_id;
3469
3470   int breakpoint_proceeded;
3471   int restore_stack_info;
3472   int proceed_to_finish;
3473 };
3474
3475 void
3476 write_inferior_status_register (struct inferior_status *inf_status, int regno,
3477                                 LONGEST val)
3478 {
3479   int size = DEPRECATED_REGISTER_RAW_SIZE (regno);
3480   void *buf = alloca (size);
3481   store_signed_integer (buf, size, val);
3482   regcache_raw_write (inf_status->registers, regno, buf);
3483 }
3484
3485 /* Save all of the information associated with the inferior<==>gdb
3486    connection.  INF_STATUS is a pointer to a "struct inferior_status"
3487    (defined in inferior.h).  */
3488
3489 struct inferior_status *
3490 save_inferior_status (int restore_stack_info)
3491 {
3492   struct inferior_status *inf_status = XMALLOC (struct inferior_status);
3493
3494   inf_status->stop_signal = stop_signal;
3495   inf_status->stop_pc = stop_pc;
3496   inf_status->stop_step = stop_step;
3497   inf_status->stop_stack_dummy = stop_stack_dummy;
3498   inf_status->stopped_by_random_signal = stopped_by_random_signal;
3499   inf_status->trap_expected = trap_expected;
3500   inf_status->step_range_start = step_range_start;
3501   inf_status->step_range_end = step_range_end;
3502   inf_status->step_frame_id = step_frame_id;
3503   inf_status->step_over_calls = step_over_calls;
3504   inf_status->stop_after_trap = stop_after_trap;
3505   inf_status->stop_soon = stop_soon;
3506   /* Save original bpstat chain here; replace it with copy of chain.
3507      If caller's caller is walking the chain, they'll be happier if we
3508      hand them back the original chain when restore_inferior_status is
3509      called.  */
3510   inf_status->stop_bpstat = stop_bpstat;
3511   stop_bpstat = bpstat_copy (stop_bpstat);
3512   inf_status->breakpoint_proceeded = breakpoint_proceeded;
3513   inf_status->restore_stack_info = restore_stack_info;
3514   inf_status->proceed_to_finish = proceed_to_finish;
3515
3516   inf_status->stop_registers = regcache_dup_no_passthrough (stop_registers);
3517
3518   inf_status->registers = regcache_dup (current_regcache);
3519
3520   inf_status->selected_frame_id = get_frame_id (deprecated_selected_frame);
3521   return inf_status;
3522 }
3523
3524 static int
3525 restore_selected_frame (void *args)
3526 {
3527   struct frame_id *fid = (struct frame_id *) args;
3528   struct frame_info *frame;
3529
3530   frame = frame_find_by_id (*fid);
3531
3532   /* If inf_status->selected_frame_id is NULL, there was no previously
3533      selected frame.  */
3534   if (frame == NULL)
3535     {
3536       warning ("Unable to restore previously selected frame.\n");
3537       return 0;
3538     }
3539
3540   select_frame (frame);
3541
3542   return (1);
3543 }
3544
3545 void
3546 restore_inferior_status (struct inferior_status *inf_status)
3547 {
3548   stop_signal = inf_status->stop_signal;
3549   stop_pc = inf_status->stop_pc;
3550   stop_step = inf_status->stop_step;
3551   stop_stack_dummy = inf_status->stop_stack_dummy;
3552   stopped_by_random_signal = inf_status->stopped_by_random_signal;
3553   trap_expected = inf_status->trap_expected;
3554   step_range_start = inf_status->step_range_start;
3555   step_range_end = inf_status->step_range_end;
3556   step_frame_id = inf_status->step_frame_id;
3557   step_over_calls = inf_status->step_over_calls;
3558   stop_after_trap = inf_status->stop_after_trap;
3559   stop_soon = inf_status->stop_soon;
3560   bpstat_clear (&stop_bpstat);
3561   stop_bpstat = inf_status->stop_bpstat;
3562   breakpoint_proceeded = inf_status->breakpoint_proceeded;
3563   proceed_to_finish = inf_status->proceed_to_finish;
3564
3565   /* FIXME: Is the restore of stop_registers always needed. */
3566   regcache_xfree (stop_registers);
3567   stop_registers = inf_status->stop_registers;
3568
3569   /* The inferior can be gone if the user types "print exit(0)"
3570      (and perhaps other times).  */
3571   if (target_has_execution)
3572     /* NB: The register write goes through to the target.  */
3573     regcache_cpy (current_regcache, inf_status->registers);
3574   regcache_xfree (inf_status->registers);
3575
3576   /* FIXME: If we are being called after stopping in a function which
3577      is called from gdb, we should not be trying to restore the
3578      selected frame; it just prints a spurious error message (The
3579      message is useful, however, in detecting bugs in gdb (like if gdb
3580      clobbers the stack)).  In fact, should we be restoring the
3581      inferior status at all in that case?  .  */
3582
3583   if (target_has_stack && inf_status->restore_stack_info)
3584     {
3585       /* The point of catch_errors is that if the stack is clobbered,
3586          walking the stack might encounter a garbage pointer and
3587          error() trying to dereference it.  */
3588       if (catch_errors
3589           (restore_selected_frame, &inf_status->selected_frame_id,
3590            "Unable to restore previously selected frame:\n",
3591            RETURN_MASK_ERROR) == 0)
3592         /* Error in restoring the selected frame.  Select the innermost
3593            frame.  */
3594         select_frame (get_current_frame ());
3595
3596     }
3597
3598   xfree (inf_status);
3599 }
3600
3601 static void
3602 do_restore_inferior_status_cleanup (void *sts)
3603 {
3604   restore_inferior_status (sts);
3605 }
3606
3607 struct cleanup *
3608 make_cleanup_restore_inferior_status (struct inferior_status *inf_status)
3609 {
3610   return make_cleanup (do_restore_inferior_status_cleanup, inf_status);
3611 }
3612
3613 void
3614 discard_inferior_status (struct inferior_status *inf_status)
3615 {
3616   /* See save_inferior_status for info on stop_bpstat. */
3617   bpstat_clear (&inf_status->stop_bpstat);
3618   regcache_xfree (inf_status->registers);
3619   regcache_xfree (inf_status->stop_registers);
3620   xfree (inf_status);
3621 }
3622
3623 int
3624 inferior_has_forked (int pid, int *child_pid)
3625 {
3626   struct target_waitstatus last;
3627   ptid_t last_ptid;
3628
3629   get_last_target_status (&last_ptid, &last);
3630
3631   if (last.kind != TARGET_WAITKIND_FORKED)
3632     return 0;
3633
3634   if (ptid_get_pid (last_ptid) != pid)
3635     return 0;
3636
3637   *child_pid = last.value.related_pid;
3638   return 1;
3639 }
3640
3641 int
3642 inferior_has_vforked (int pid, int *child_pid)
3643 {
3644   struct target_waitstatus last;
3645   ptid_t last_ptid;
3646
3647   get_last_target_status (&last_ptid, &last);
3648
3649   if (last.kind != TARGET_WAITKIND_VFORKED)
3650     return 0;
3651
3652   if (ptid_get_pid (last_ptid) != pid)
3653     return 0;
3654
3655   *child_pid = last.value.related_pid;
3656   return 1;
3657 }
3658
3659 int
3660 inferior_has_execd (int pid, char **execd_pathname)
3661 {
3662   struct target_waitstatus last;
3663   ptid_t last_ptid;
3664
3665   get_last_target_status (&last_ptid, &last);
3666
3667   if (last.kind != TARGET_WAITKIND_EXECD)
3668     return 0;
3669
3670   if (ptid_get_pid (last_ptid) != pid)
3671     return 0;
3672
3673   *execd_pathname = xstrdup (last.value.execd_pathname);
3674   return 1;
3675 }
3676
3677 /* Oft used ptids */
3678 ptid_t null_ptid;
3679 ptid_t minus_one_ptid;
3680
3681 /* Create a ptid given the necessary PID, LWP, and TID components.  */
3682
3683 ptid_t
3684 ptid_build (int pid, long lwp, long tid)
3685 {
3686   ptid_t ptid;
3687
3688   ptid.pid = pid;
3689   ptid.lwp = lwp;
3690   ptid.tid = tid;
3691   return ptid;
3692 }
3693
3694 /* Create a ptid from just a pid.  */
3695
3696 ptid_t
3697 pid_to_ptid (int pid)
3698 {
3699   return ptid_build (pid, 0, 0);
3700 }
3701
3702 /* Fetch the pid (process id) component from a ptid.  */
3703
3704 int
3705 ptid_get_pid (ptid_t ptid)
3706 {
3707   return ptid.pid;
3708 }
3709
3710 /* Fetch the lwp (lightweight process) component from a ptid.  */
3711
3712 long
3713 ptid_get_lwp (ptid_t ptid)
3714 {
3715   return ptid.lwp;
3716 }
3717
3718 /* Fetch the tid (thread id) component from a ptid.  */
3719
3720 long
3721 ptid_get_tid (ptid_t ptid)
3722 {
3723   return ptid.tid;
3724 }
3725
3726 /* ptid_equal() is used to test equality of two ptids.  */
3727
3728 int
3729 ptid_equal (ptid_t ptid1, ptid_t ptid2)
3730 {
3731   return (ptid1.pid == ptid2.pid && ptid1.lwp == ptid2.lwp
3732           && ptid1.tid == ptid2.tid);
3733 }
3734
3735 /* restore_inferior_ptid() will be used by the cleanup machinery
3736    to restore the inferior_ptid value saved in a call to
3737    save_inferior_ptid().  */
3738
3739 static void
3740 restore_inferior_ptid (void *arg)
3741 {
3742   ptid_t *saved_ptid_ptr = arg;
3743   inferior_ptid = *saved_ptid_ptr;
3744   xfree (arg);
3745 }
3746
3747 /* Save the value of inferior_ptid so that it may be restored by a
3748    later call to do_cleanups().  Returns the struct cleanup pointer
3749    needed for later doing the cleanup.  */
3750
3751 struct cleanup *
3752 save_inferior_ptid (void)
3753 {
3754   ptid_t *saved_ptid_ptr;
3755
3756   saved_ptid_ptr = xmalloc (sizeof (ptid_t));
3757   *saved_ptid_ptr = inferior_ptid;
3758   return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
3759 }
3760 \f
3761
3762 static void
3763 build_infrun (void)
3764 {
3765   stop_registers = regcache_xmalloc (current_gdbarch);
3766 }
3767
3768 void
3769 _initialize_infrun (void)
3770 {
3771   int i;
3772   int numsigs;
3773   struct cmd_list_element *c;
3774
3775   DEPRECATED_REGISTER_GDBARCH_SWAP (stop_registers);
3776   deprecated_register_gdbarch_swap (NULL, 0, build_infrun);
3777
3778   add_info ("signals", signals_info,
3779             "What debugger does when program gets various signals.\n\
3780 Specify a signal as argument to print info on that signal only.");
3781   add_info_alias ("handle", "signals", 0);
3782
3783   add_com ("handle", class_run, handle_command,
3784            concat ("Specify how to handle a signal.\n\
3785 Args are signals and actions to apply to those signals.\n\
3786 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
3787 from 1-15 are allowed for compatibility with old versions of GDB.\n\
3788 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
3789 The special arg \"all\" is recognized to mean all signals except those\n\
3790 used by the debugger, typically SIGTRAP and SIGINT.\n", "Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
3791 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
3792 Stop means reenter debugger if this signal happens (implies print).\n\
3793 Print means print a message if this signal happens.\n\
3794 Pass means let program see this signal; otherwise program doesn't know.\n\
3795 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
3796 Pass and Stop may be combined.", NULL));
3797   if (xdb_commands)
3798     {
3799       add_com ("lz", class_info, signals_info,
3800                "What debugger does when program gets various signals.\n\
3801 Specify a signal as argument to print info on that signal only.");
3802       add_com ("z", class_run, xdb_handle_command,
3803                concat ("Specify how to handle a signal.\n\
3804 Args are signals and actions to apply to those signals.\n\
3805 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
3806 from 1-15 are allowed for compatibility with old versions of GDB.\n\
3807 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
3808 The special arg \"all\" is recognized to mean all signals except those\n\
3809 used by the debugger, typically SIGTRAP and SIGINT.\n", "Recognized actions include \"s\" (toggles between stop and nostop), \n\
3810 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \
3811 nopass), \"Q\" (noprint)\n\
3812 Stop means reenter debugger if this signal happens (implies print).\n\
3813 Print means print a message if this signal happens.\n\
3814 Pass means let program see this signal; otherwise program doesn't know.\n\
3815 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
3816 Pass and Stop may be combined.", NULL));
3817     }
3818
3819   if (!dbx_commands)
3820     stop_command =
3821       add_cmd ("stop", class_obscure, not_just_help_class_command, "There is no `stop' command, but you can set a hook on `stop'.\n\
3822 This allows you to set a list of commands to be run each time execution\n\
3823 of the program stops.", &cmdlist);
3824
3825   numsigs = (int) TARGET_SIGNAL_LAST;
3826   signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
3827   signal_print = (unsigned char *)
3828     xmalloc (sizeof (signal_print[0]) * numsigs);
3829   signal_program = (unsigned char *)
3830     xmalloc (sizeof (signal_program[0]) * numsigs);
3831   for (i = 0; i < numsigs; i++)
3832     {
3833       signal_stop[i] = 1;
3834       signal_print[i] = 1;
3835       signal_program[i] = 1;
3836     }
3837
3838   /* Signals caused by debugger's own actions
3839      should not be given to the program afterwards.  */
3840   signal_program[TARGET_SIGNAL_TRAP] = 0;
3841   signal_program[TARGET_SIGNAL_INT] = 0;
3842
3843   /* Signals that are not errors should not normally enter the debugger.  */
3844   signal_stop[TARGET_SIGNAL_ALRM] = 0;
3845   signal_print[TARGET_SIGNAL_ALRM] = 0;
3846   signal_stop[TARGET_SIGNAL_VTALRM] = 0;
3847   signal_print[TARGET_SIGNAL_VTALRM] = 0;
3848   signal_stop[TARGET_SIGNAL_PROF] = 0;
3849   signal_print[TARGET_SIGNAL_PROF] = 0;
3850   signal_stop[TARGET_SIGNAL_CHLD] = 0;
3851   signal_print[TARGET_SIGNAL_CHLD] = 0;
3852   signal_stop[TARGET_SIGNAL_IO] = 0;
3853   signal_print[TARGET_SIGNAL_IO] = 0;
3854   signal_stop[TARGET_SIGNAL_POLL] = 0;
3855   signal_print[TARGET_SIGNAL_POLL] = 0;
3856   signal_stop[TARGET_SIGNAL_URG] = 0;
3857   signal_print[TARGET_SIGNAL_URG] = 0;
3858   signal_stop[TARGET_SIGNAL_WINCH] = 0;
3859   signal_print[TARGET_SIGNAL_WINCH] = 0;
3860
3861   /* These signals are used internally by user-level thread
3862      implementations.  (See signal(5) on Solaris.)  Like the above
3863      signals, a healthy program receives and handles them as part of
3864      its normal operation.  */
3865   signal_stop[TARGET_SIGNAL_LWP] = 0;
3866   signal_print[TARGET_SIGNAL_LWP] = 0;
3867   signal_stop[TARGET_SIGNAL_WAITING] = 0;
3868   signal_print[TARGET_SIGNAL_WAITING] = 0;
3869   signal_stop[TARGET_SIGNAL_CANCEL] = 0;
3870   signal_print[TARGET_SIGNAL_CANCEL] = 0;
3871
3872 #ifdef SOLIB_ADD
3873   add_show_from_set
3874     (add_set_cmd ("stop-on-solib-events", class_support, var_zinteger,
3875                   (char *) &stop_on_solib_events,
3876                   "Set stopping for shared library events.\n\
3877 If nonzero, gdb will give control to the user when the dynamic linker\n\
3878 notifies gdb of shared library events.  The most common event of interest\n\
3879 to the user would be loading/unloading of a new library.\n", &setlist), &showlist);
3880 #endif
3881
3882   c = add_set_enum_cmd ("follow-fork-mode",
3883                         class_run,
3884                         follow_fork_mode_kind_names, &follow_fork_mode_string,
3885                         "Set debugger response to a program call of fork \
3886 or vfork.\n\
3887 A fork or vfork creates a new process.  follow-fork-mode can be:\n\
3888   parent  - the original process is debugged after a fork\n\
3889   child   - the new process is debugged after a fork\n\
3890 The unfollowed process will continue to run.\n\
3891 By default, the debugger will follow the parent process.", &setlist);
3892   add_show_from_set (c, &showlist);
3893
3894   c = add_set_enum_cmd ("scheduler-locking", class_run, scheduler_enums,        /* array of string names */
3895                         &scheduler_mode,        /* current mode  */
3896                         "Set mode for locking scheduler during execution.\n\
3897 off  == no locking (threads may preempt at any time)\n\
3898 on   == full locking (no thread except the current thread may run)\n\
3899 step == scheduler locked during every single-step operation.\n\
3900         In this mode, no other thread may run during a step command.\n\
3901         Other threads may run while stepping over a function call ('next').", &setlist);
3902
3903   set_cmd_sfunc (c, set_schedlock_func);        /* traps on target vector */
3904   add_show_from_set (c, &showlist);
3905
3906   c = add_set_cmd ("step-mode", class_run,
3907                    var_boolean, (char *) &step_stop_if_no_debug,
3908                    "Set mode of the step operation. When set, doing a step over a\n\
3909 function without debug line information will stop at the first\n\
3910 instruction of that function. Otherwise, the function is skipped and\n\
3911 the step command stops at a different source line.", &setlist);
3912   add_show_from_set (c, &showlist);
3913
3914   /* ptid initializations */
3915   null_ptid = ptid_build (0, 0, 0);
3916   minus_one_ptid = ptid_build (-1, 0, 0);
3917   inferior_ptid = null_ptid;
3918   target_last_wait_ptid = minus_one_ptid;
3919 }