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