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