/usr/src/gnu/usr.bin/binutils/gdb/infrun.c

Bug Summary

File:	src/gnu/usr.bin/binutils/gdb/infrun.c
Warning:	line 1673, column 4 Value stored to 'sw_single_step_trap_p' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name infrun.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/infrun.c

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