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

Bug Summary

File:	src/gnu/usr.bin/binutils/gdb/target.c
Warning:	line 780, column 3 Value stored to 'origlen' 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 target.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/target.c

1	/* Select target systems and architectures at runtime for GDB.
2
3	Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4	1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6	Contributed by Cygnus Support.
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 <errno(*__errno()).h>
27	#include "gdb_string.h"
28	#include "target.h"
29	#include "gdbcmd.h"
30	#include "symtab.h"
31	#include "inferior.h"
32	#include "bfd.h"
33	#include "symfile.h"
34	#include "objfiles.h"
35	#include "gdb_wait.h"
36	#include "dcache.h"
37	#include <signal.h>
38	#include "regcache.h"
39	#include "gdb_assert.h"
40	#include "gdbcore.h"
41
42	static void target_info (char *, int);
43
44	static void maybe_kill_then_attach (char *, int);
45
46	static void kill_or_be_killed (int);
47
48	static void default_terminal_info (char *, int);
49
50	static int default_region_size_ok_for_hw_watchpoint (int);
51
52	static int nosymbol (char , CORE_ADDR );
53
54	static void tcomplain (void);
55
56	static int nomemory (CORE_ADDR, char , int, int, struct target_ops );
57
58	static int return_zero (void);
59
60	static int return_one (void);
61
62	static int return_minus_one (void);
63
64	void target_ignore (void);
65
66	static void target_command (char *, int);
67
68	static struct target_ops find_default_run_target (char );
69
70	static void nosupport_runtime (void);
71
72	static LONGESTlong default_xfer_partial (struct target_ops *ops,
73	enum target_object object,
74	const char annex, void readbuf,
75	const void *writebuf,
76	ULONGESTunsigned long offset, LONGESTlong len);
77
78	/* Transfer LEN bytes between target address MEMADDR and GDB address
79	MYADDR. Returns 0 for success, errno code for failure (which
80	includes partial transfers -- if you want a more useful response to
81	partial transfers, try either target_read_memory_partial or
82	target_write_memory_partial). */
83
84	static int target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
85	int write);
86
87	static void init_dummy_target (void);
88
89	static struct target_ops debug_target;
90
91	static void debug_to_open (char *, int);
92
93	static void debug_to_close (int);
94
95	static void debug_to_attach (char *, int);
96
97	static void debug_to_detach (char *, int);
98
99	static void debug_to_disconnect (char *, int);
100
101	static void debug_to_resume (ptid_t, int, enum target_signal);
102
103	static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
104
105	static void debug_to_fetch_registers (int);
106
107	static void debug_to_store_registers (int);
108
109	static void debug_to_prepare_to_store (void);
110
111	static int deprecated_debug_xfer_memory (CORE_ADDR, char *, int, int,
112	struct mem_attrib *,
113	struct target_ops *);
114
115	static void debug_to_files_info (struct target_ops *);
116
117	static int debug_to_insert_breakpoint (CORE_ADDR, char *);
118
119	static int debug_to_remove_breakpoint (CORE_ADDR, char *);
120
121	static int debug_to_can_use_hw_breakpoint (int, int, int);
122
123	static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *);
124
125	static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *);
126
127	static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
128
129	static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
130
131	static int debug_to_stopped_by_watchpoint (void);
132
133	static int debug_to_stopped_data_address (struct target_ops , CORE_ADDR );
134
135	static int debug_to_region_size_ok_for_hw_watchpoint (int);
136
137	static void debug_to_terminal_init (void);
138
139	static void debug_to_terminal_inferior (void);
140
141	static void debug_to_terminal_ours_for_output (void);
142
143	static void debug_to_terminal_save_ours (void);
144
145	static void debug_to_terminal_ours (void);
146
147	static void debug_to_terminal_info (char *, int);
148
149	static void debug_to_kill (void);
150
151	static void debug_to_load (char *, int);
152
153	static int debug_to_lookup_symbol (char , CORE_ADDR );
154
155	static void debug_to_mourn_inferior (void);
156
157	static int debug_to_can_run (void);
158
159	static void debug_to_notice_signals (ptid_t);
160
161	static int debug_to_thread_alive (ptid_t);
162
163	static void debug_to_stop (void);
164
165	/* NOTE: cagney/2004-09-29: Many targets reference this variable in
166	wierd and mysterious ways. Putting the variable here lets those
167	wierd and mysterious ways keep building while they are being
168	converted to the inferior inheritance structure. */
169	struct target_ops deprecated_child_ops;
170
171	/* Pointer to array of target architecture structures; the size of the
172	array; the current index into the array; the allocated size of the
173	array. */
174	struct target_ops **target_structs;
175	unsigned target_struct_size;
176	unsigned target_struct_index;
177	unsigned target_struct_allocsize;
178	#define DEFAULT_ALLOCSIZE10 10
179
180	/* The initial current target, so that there is always a semi-valid
181	current target. */
182
183	static struct target_ops dummy_target;
184
185	/* Top of target stack. */
186
187	static struct target_ops *target_stack;
188
189	/* The target structure we are currently using to talk to a process
190	or file or whatever "inferior" we have. */
191
192	struct target_ops current_target;
193
194	/* Command list for target. */
195
196	static struct cmd_list_element targetlist = NULL((void)0);
197
198	/* Nonzero if we are debugging an attached outside process
199	rather than an inferior. */
200
201	int attach_flag;
202
203	/* Non-zero if we want to see trace of target level stuff. */
204
205	static int targetdebug = 0;
206
207	static void setup_target_debug (void);
208
209	DCACHE *target_dcache;
210
211	/* The user just typed 'target' without the name of a target. */
212
213	static void
214	target_command (char *arg, int from_tty)
215	{
216	fputs_filtered ("Argument required (target name). Try `help target'\n",
217	gdb_stdout);
218	}
219
220	/* Add a possible target architecture to the list. */
221
222	void
223	add_target (struct target_ops *t)
224	{
225	/* Provide default values for all "must have" methods. */
226	if (t->to_xfer_partial == NULL((void*)0))
227	t->to_xfer_partial = default_xfer_partial;
228
229	if (!target_structs)
230	{
231	target_struct_allocsize = DEFAULT_ALLOCSIZE10;
232	target_structs = (struct target_ops **) xmalloc
233	(target_struct_allocsize * sizeof (*target_structs));
234	}
235	if (target_struct_size >= target_struct_allocsize)
236	{
237	target_struct_allocsize *= 2;
238	target_structs = (struct target_ops **)
239	xrealloc ((char *) target_structs,
240	target_struct_allocsize * sizeof (*target_structs));
241	}
242	target_structs[target_struct_size++] = t;
243
244	if (targetlist == NULL((void*)0))
245	add_prefix_cmd ("target", class_run, target_command,
246	"Connect to a target machine or process.\n\
247	The first argument is the type or protocol of the target machine.\n\
248	Remaining arguments are interpreted by the target protocol. For more\n\
249	information on the arguments for a particular protocol, type\n\
250	`help target ' followed by the protocol name.",
251	&targetlist, "target ", 0, &cmdlist);
252	add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
253	}
254
255	/* Stub functions */
256
257	void
258	target_ignore (void)
259	{
260	}
261
262	void
263	target_load (char *arg, int from_tty)
264	{
265	dcache_invalidate (target_dcache);
266	(*current_target.to_load) (arg, from_tty);
267	}
268
269	static int
270	nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
271	struct target_ops *t)
272	{
273	errno(__errno()) = EIO5; / Can't read/write this location */
274	return 0; /* No bytes handled */
275	}
276
277	static void
278	tcomplain (void)
279	{
280	error ("You can't do that when your target is `%s'",
281	current_target.to_shortname);
282	}
283
284	void
285	noprocess (void)
286	{
287	error ("You can't do that without a process to debug.");
288	}
289
290	static int
291	nosymbol (char name, CORE_ADDR addrp)
292	{
293	return 1; /* Symbol does not exist in target env */
294	}
295
296	static void
297	nosupport_runtime (void)
298	{
299	if (ptid_equal (inferior_ptid, null_ptid))
300	noprocess ();
301	else
302	error ("No run-time support for this");
303	}
304
305
306	static void
307	default_terminal_info (char *args, int from_tty)
308	{
309	printf_unfiltered ("No saved terminal information.\n");
310	}
311
312	/* This is the default target_create_inferior and target_attach function.
313	If the current target is executing, it asks whether to kill it off.
314	If this function returns without calling error(), it has killed off
315	the target, and the operation should be attempted. */
316
317	static void
318	kill_or_be_killed (int from_tty)
319	{
320	if (target_has_execution(current_target.to_has_execution))
321	{
322	printf_unfiltered ("You are already running a program:\n");
323	target_files_info ()(*current_target.to_files_info) (&current_target);
324	if (query ("Kill it? "))
325	{
326	target_kill ()(*current_target.to_kill) ();
327	if (target_has_execution(current_target.to_has_execution))
328	error ("Killing the program did not help.");
329	return;
330	}
331	else
332	{
333	error ("Program not killed.");
334	}
335	}
336	tcomplain ();
337	}
338
339	static void
340	maybe_kill_then_attach (char *args, int from_tty)
341	{
342	kill_or_be_killed (from_tty);
343	target_attach (args, from_tty)(*current_target.to_attach) (args, from_tty);
344	}
345
346	static void
347	maybe_kill_then_create_inferior (char exec, char args, char **env,
348	int from_tty)
349	{
350	kill_or_be_killed (0);
351	target_create_inferior (exec, args, env, from_tty)(*current_target.to_create_inferior) (exec, args, env, (from_tty ));
352	}
353
354	/* Go through the target stack from top to bottom, copying over zero
355	entries in current_target, then filling in still empty entries. In
356	effect, we are doing class inheritance through the pushed target
357	vectors.
358
359	NOTE: cagney/2003-10-17: The problem with this inheritance, as it
360	is currently implemented, is that it discards any knowledge of
361	which target an inherited method originally belonged to.
362	Consequently, new new target methods should instead explicitly and
363	locally search the target stack for the target that can handle the
364	request. */
365
366	static void
367	update_current_target (void)
368	{
369	struct target_ops *t;
370
371	/* First, reset curren'ts contents. */
372	memset (&current_target, 0, sizeof (current_target));
373
374	#define INHERIT(FIELD, TARGET) \
375	if (!current_target.FIELD) \
376	current_target.FIELD = (TARGET)->FIELD
377
378	for (t = target_stack; t; t = t->beneath)
379	{
380	INHERIT (to_shortname, t);
381	INHERIT (to_longname, t);
382	INHERIT (to_doc, t);
383	INHERIT (to_open, t);
384	INHERIT (to_close, t);
385	INHERIT (to_attach, t);
386	INHERIT (to_post_attach, t);
387	INHERIT (to_detach, t);
388	INHERIT (to_disconnect, t);
389	INHERIT (to_resume, t);
390	INHERIT (to_wait, t);
391	INHERIT (to_fetch_registers, t);
392	INHERIT (to_store_registers, t);
393	INHERIT (to_prepare_to_store, t);
394	INHERIT (deprecated_xfer_memory, t);
395	INHERIT (to_files_info, t);
396	INHERIT (to_insert_breakpoint, t);
397	INHERIT (to_remove_breakpoint, t);
398	INHERIT (to_can_use_hw_breakpoint, t);
399	INHERIT (to_insert_hw_breakpoint, t);
400	INHERIT (to_remove_hw_breakpoint, t);
401	INHERIT (to_insert_watchpoint, t);
402	INHERIT (to_remove_watchpoint, t);
403	INHERIT (to_stopped_data_address, t);
404	INHERIT (to_stopped_by_watchpoint, t);
405	INHERIT (to_have_continuable_watchpoint, t);
406	INHERIT (to_region_size_ok_for_hw_watchpoint, t);
407	INHERIT (to_terminal_init, t);
408	INHERIT (to_terminal_inferior, t);
409	INHERIT (to_terminal_ours_for_output, t);
410	INHERIT (to_terminal_ours, t);
411	INHERIT (to_terminal_save_ours, t);
412	INHERIT (to_terminal_info, t);
413	INHERIT (to_kill, t);
414	INHERIT (to_load, t);
415	INHERIT (to_lookup_symbol, t);
416	INHERIT (to_create_inferior, t);
417	INHERIT (to_post_startup_inferior, t);
418	INHERIT (to_acknowledge_created_inferior, t);
419	INHERIT (to_insert_fork_catchpoint, t);
420	INHERIT (to_remove_fork_catchpoint, t);
421	INHERIT (to_insert_vfork_catchpoint, t);
422	INHERIT (to_remove_vfork_catchpoint, t);
423	INHERIT (to_follow_fork, t);
424	INHERIT (to_insert_exec_catchpoint, t);
425	INHERIT (to_remove_exec_catchpoint, t);
426	INHERIT (to_reported_exec_events_per_exec_call, t);
427	INHERIT (to_has_exited, t);
428	INHERIT (to_mourn_inferior, t);
429	INHERIT (to_can_run, t);
430	INHERIT (to_notice_signals, t);
431	INHERIT (to_thread_alive, t);
432	INHERIT (to_find_new_threads, t);
433	INHERIT (to_pid_to_str, t);
434	INHERIT (to_extra_thread_info, t);
435	INHERIT (to_stop, t);
436	/* Do not inherit to_xfer_partial. */
437	INHERIT (to_rcmd, t);
438	INHERIT (to_enable_exception_callback, t);
439	INHERIT (to_get_current_exception_event, t);
440	INHERIT (to_pid_to_exec_file, t);
441	INHERIT (to_stratum, t);
442	INHERIT (to_has_all_memory, t);
443	INHERIT (to_has_memory, t);
444	INHERIT (to_has_stack, t);
445	INHERIT (to_has_registers, t);
446	INHERIT (to_has_execution, t);
447	INHERIT (to_has_thread_control, t);
448	INHERIT (to_sections, t);
449	INHERIT (to_sections_end, t);
450	INHERIT (to_can_async_p, t);
451	INHERIT (to_is_async_p, t);
452	INHERIT (to_async, t);
453	INHERIT (to_async_mask_value, t);
454	INHERIT (to_find_memory_regions, t);
455	INHERIT (to_make_corefile_notes, t);
456	INHERIT (to_get_thread_local_address, t);
457	INHERIT (to_magic, t);
458	}
459	#undef INHERIT
460
461	/* Clean up a target struct so it no longer has any zero pointers in
462	it. Some entries are defaulted to a method that print an error,
463	others are hard-wired to a standard recursive default. */
464
465	#define de_fault(field, value) \
466	if (!current_target.field) \
467	current_target.field = value
468
469	de_fault (to_open,
470	(void () (char , int))
471	tcomplain);
472	de_fault (to_close,
473	(void (*) (int))
474	target_ignore);
475	de_fault (to_attach,
476	maybe_kill_then_attach);
477	de_fault (to_post_attach,
478	(void (*) (int))
479	target_ignore);
480	de_fault (to_detach,
481	(void () (char , int))
482	target_ignore);
483	de_fault (to_disconnect,
484	(void () (char , int))
485	tcomplain);
486	de_fault (to_resume,
487	(void (*) (ptid_t, int, enum target_signal))
488	noprocess);
489	de_fault (to_wait,
490	(ptid_t () (ptid_t, struct target_waitstatus ))
491	noprocess);
492	de_fault (to_fetch_registers,
493	(void (*) (int))
494	target_ignore);
495	de_fault (to_store_registers,
496	(void (*) (int))
497	noprocess);
498	de_fault (to_prepare_to_store,
499	(void (*) (void))
500	noprocess);
501	de_fault (deprecated_xfer_memory,
502	(int () (CORE_ADDR, char , int, int, struct mem_attrib , struct target_ops ))
503	nomemory);
504	de_fault (to_files_info,
505	(void () (struct target_ops ))
506	target_ignore);
507	de_fault (to_insert_breakpoint,
508	memory_insert_breakpoint);
509	de_fault (to_remove_breakpoint,
510	memory_remove_breakpoint);
511	de_fault (to_can_use_hw_breakpoint,
512	(int (*) (int, int, int))
513	return_zero);
514	de_fault (to_insert_hw_breakpoint,
515	(int () (CORE_ADDR, char ))
516	return_minus_one);
517	de_fault (to_remove_hw_breakpoint,
518	(int () (CORE_ADDR, char ))
519	return_minus_one);
520	de_fault (to_insert_watchpoint,
521	(int (*) (CORE_ADDR, int, int))
522	return_minus_one);
523	de_fault (to_remove_watchpoint,
524	(int (*) (CORE_ADDR, int, int))
525	return_minus_one);
526	de_fault (to_stopped_by_watchpoint,
527	(int (*) (void))
528	return_zero);
529	de_fault (to_stopped_data_address,
530	(int () (struct target_ops , CORE_ADDR *))
531	return_zero);
532	de_fault (to_region_size_ok_for_hw_watchpoint,
533	default_region_size_ok_for_hw_watchpoint);
534	de_fault (to_terminal_init,
535	(void (*) (void))
536	target_ignore);
537	de_fault (to_terminal_inferior,
538	(void (*) (void))
539	target_ignore);
540	de_fault (to_terminal_ours_for_output,
541	(void (*) (void))
542	target_ignore);
543	de_fault (to_terminal_ours,
544	(void (*) (void))
545	target_ignore);
546	de_fault (to_terminal_save_ours,
547	(void (*) (void))
548	target_ignore);
549	de_fault (to_terminal_info,
550	default_terminal_info);
551	de_fault (to_kill,
552	(void (*) (void))
553	noprocess);
554	de_fault (to_load,
555	(void () (char , int))
556	tcomplain);
557	de_fault (to_lookup_symbol,
558	(int () (char , CORE_ADDR *))
559	nosymbol);
560	de_fault (to_create_inferior,
561	maybe_kill_then_create_inferior);
562	de_fault (to_post_startup_inferior,
563	(void (*) (ptid_t))
564	target_ignore);
565	de_fault (to_acknowledge_created_inferior,
566	(void (*) (int))
567	target_ignore);
568	de_fault (to_insert_fork_catchpoint,
569	(int (*) (int))
570	tcomplain);
571	de_fault (to_remove_fork_catchpoint,
572	(int (*) (int))
573	tcomplain);
574	de_fault (to_insert_vfork_catchpoint,
575	(int (*) (int))
576	tcomplain);
577	de_fault (to_remove_vfork_catchpoint,
578	(int (*) (int))
579	tcomplain);
580	de_fault (to_follow_fork,
581	(int (*) (int))
582	target_ignore);
583	de_fault (to_insert_exec_catchpoint,
584	(int (*) (int))
585	tcomplain);
586	de_fault (to_remove_exec_catchpoint,
587	(int (*) (int))
588	tcomplain);
589	de_fault (to_reported_exec_events_per_exec_call,
590	(int (*) (void))
591	return_one);
592	de_fault (to_has_exited,
593	(int () (int, int, int ))
594	return_zero);
595	de_fault (to_mourn_inferior,
596	(void (*) (void))
597	noprocess);
598	de_fault (to_can_run,
599	return_zero);
600	de_fault (to_notice_signals,
601	(void (*) (ptid_t))
602	target_ignore);
603	de_fault (to_thread_alive,
604	(int (*) (ptid_t))
605	return_zero);
606	de_fault (to_find_new_threads,
607	(void (*) (void))
608	target_ignore);
609	de_fault (to_extra_thread_info,
610	(char () (struct thread_info *))
611	return_zero);
612	de_fault (to_stop,
613	(void (*) (void))
614	target_ignore);
615	current_target.to_xfer_partial = default_xfer_partial;
616	de_fault (to_rcmd,
617	(void () (char , struct ui_file *))
618	tcomplain);
619	de_fault (to_enable_exception_callback,
620	(struct symtab_and_line * (*) (enum exception_event_kind, int))
621	nosupport_runtime);
622	de_fault (to_get_current_exception_event,
623	(struct exception_event_record * (*) (void))
624	nosupport_runtime);
625	de_fault (to_pid_to_exec_file,
626	(char () (int))
627	return_zero);
628	de_fault (to_can_async_p,
629	(int (*) (void))
630	return_zero);
631	de_fault (to_is_async_p,
632	(int (*) (void))
633	return_zero);
634	de_fault (to_async,
635	(void () (void () (enum inferior_event_type, void), void))
636	tcomplain);
637	#undef de_fault
638
639	/* Finally, position the target-stack beneath the squashed
640	"current_target". That way code looking for a non-inherited
641	target method can quickly and simply find it. */
642	current_target.beneath = target_stack;
643	}
644
645	/* Push a new target type into the stack of the existing target accessors,
646	possibly superseding some of the existing accessors.
647
648	Result is zero if the pushed target ended up on top of the stack,
649	nonzero if at least one target is on top of it.
650
651	Rather than allow an empty stack, we always have the dummy target at
652	the bottom stratum, so we can call the function vectors without
653	checking them. */
654
655	int
656	push_target (struct target_ops *t)
657	{
658	struct target_ops **cur;
659
660	/* Check magic number. If wrong, it probably means someone changed
661	the struct definition, but not all the places that initialize one. */
662	if (t->to_magic != OPS_MAGIC3840)
663	{
664	fprintf_unfiltered (gdb_stderr,
665	"Magic number of %s target struct wrong\n",
666	t->to_shortname);
667	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/target.c", __LINE__667, "failed internal consistency check");
668	}
669
670	/* Find the proper stratum to install this target in. */
671	for (cur = &target_stack; (cur) != NULL((void)0); cur = &(*cur)->beneath)
672	{
673	if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
674	break;
675	}
676
677	/* If there's already targets at this stratum, remove them. */
678	/* FIXME: cagney/2003-10-15: I think this should be poping all
679	targets to CUR, and not just those at this stratum level. */
680	while ((cur) != NULL((void)0) && t->to_stratum == (*cur)->to_stratum)
681	{
682	/* There's already something at this stratum level. Close it,
683	and un-hook it from the stack. */
684	struct target_ops tmp = (cur);
685	(cur) = (cur)->beneath;
686	tmp->beneath = NULL((void*)0);
687	target_close (tmp, 0);
688	}
689
690	/* We have removed all targets in our stratum, now add the new one. */
691	t->beneath = (*cur);
692	(*cur) = t;
693
694	update_current_target ();
695
696	if (targetdebug)
697	setup_target_debug ();
698
699	/* Not on top? */
700	return (t != target_stack);
701	}
702
703	/* Remove a target_ops vector from the stack, wherever it may be.
704	Return how many times it was removed (0 or 1). */
705
706	int
707	unpush_target (struct target_ops *t)
708	{
709	struct target_ops **cur;
710	struct target_ops *tmp;
711
712	/* Look for the specified target. Note that we assume that a target
713	can only occur once in the target stack. */
714
715	for (cur = &target_stack; (cur) != NULL((void)0); cur = &(*cur)->beneath)
716	{
717	if ((*cur) == t)
718	break;
719	}
720
721	if ((cur) == NULL((void)0))
722	return 0; /* Didn't find target_ops, quit now */
723
724	/* NOTE: cagney/2003-12-06: In '94 the close call was made
725	unconditional by moving it to before the above check that the
726	target was in the target stack (something about "Change the way
727	pushing and popping of targets work to support target overlays
728	and inheritance"). This doesn't make much sense - only open
729	targets should be closed. */
730	target_close (t, 0);
731
732	/* Unchain the target */
733	tmp = (*cur);
734	(cur) = (cur)->beneath;
735	tmp->beneath = NULL((void*)0);
736
737	update_current_target ();
738
739	return 1;
740	}
741
742	void
743	pop_target (void)
744	{
745	target_close (&current_target, 0); /* Let it clean up */
746	if (unpush_target (target_stack) == 1)
747	return;
748
749	fprintf_unfiltered (gdb_stderr,
750	"pop_target couldn't find target %s\n",
751	current_target.to_shortname);
752	internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/target.c", __LINE__752, "failed internal consistency check");
753	}
754
755	#undef MIN
756	#define MIN(A, B)(((A) <= (B)) ? (A) : (B)) (((A) <= (B)) ? (A) : (B))
757
758	/* target_read_string -- read a null terminated string, up to LEN bytes,
759	from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
760	Set *STRING to a pointer to malloc'd memory containing the data; the caller
761	is responsible for freeing it. Return the number of bytes successfully
762	read. */
763
764	int
765	target_read_string (CORE_ADDR memaddr, char *string, int len, int errnop)
766	{
767	int tlen, origlen, offset, i;
768	char buf[4];
769	int errcode = 0;
770	char *buffer;
771	int buffer_allocated;
772	char *bufptr;
773	unsigned int nbytes_read = 0;
774
775	/* Small for testing. */
776	buffer_allocated = 4;
777	buffer = xmalloc (buffer_allocated);
778	bufptr = buffer;
779
780	origlen = len;
	Value stored to 'origlen' is never read
781
782	while (len > 0)
783	{
784	tlen = MIN (len, 4 - (memaddr & 3))(((len) <= (4 - (memaddr & 3))) ? (len) : (4 - (memaddr & 3)));
785	offset = memaddr & 3;
786
787	errcode = target_read_memory (memaddr & ~3, buf, 4);
788	if (errcode != 0)
789	{
790	/* The transfer request might have crossed the boundary to an
791	unallocated region of memory. Retry the transfer, requesting
792	a single byte. */
793	tlen = 1;
794	offset = 0;
795	errcode = target_read_memory (memaddr, buf, 1);
796	if (errcode != 0)
797	goto done;
798	}
799
800	if (bufptr - buffer + tlen > buffer_allocated)
801	{
802	unsigned int bytes;
803	bytes = bufptr - buffer;
804	buffer_allocated *= 2;
805	buffer = xrealloc (buffer, buffer_allocated);
806	bufptr = buffer + bytes;
807	}
808
809	for (i = 0; i < tlen; i++)
810	{
811	*bufptr++ = buf[i + offset];
812	if (buf[i + offset] == '\000')
813	{
814	nbytes_read += i + 1;
815	goto done;
816	}
817	}
818
819	memaddr += tlen;
820	len -= tlen;
821	nbytes_read += tlen;
822	}
823	done:
824	if (errnop != NULL((void*)0))
825	*errnop = errcode;
826	if (string != NULL((void*)0))
827	*string = buffer;
828	return nbytes_read;
829	}
830
831	/* Find a section containing ADDR. */
832	struct section_table *
833	target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
834	{
835	struct section_table *secp;
836	for (secp = target->to_sections;
837	secp < target->to_sections_end;
838	secp++)
839	{
840	if (addr >= secp->addr && addr < secp->endaddr)
841	return secp;
842	}
843	return NULL((void*)0);
844	}
845
846	/* Return non-zero when the target vector has supplied an xfer_partial
847	method and it, rather than xfer_memory, should be used. */
848	static int
849	target_xfer_partial_p (void)
850	{
851	return (target_stack != NULL((void*)0)
852	&& target_stack->to_xfer_partial != default_xfer_partial);
853	}
854
855	static LONGESTlong
856	target_xfer_partial (struct target_ops *ops,
857	enum target_object object, const char *annex,
858	void readbuf, const void writebuf,
859	ULONGESTunsigned long offset, LONGESTlong len)
860	{
861	LONGESTlong retval;
862
863	gdb_assert (ops->to_xfer_partial != NULL)((void) ((ops->to_xfer_partial != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/target.c", 863, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "ops->to_xfer_partial != NULL"), 0) ));
864	retval = ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
865	offset, len);
866	if (targetdebug)
867	{
868	const unsigned char myaddr = NULL((void)0);
869
870	fprintf_unfiltered (gdb_stdlog,
871	"%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
872	ops->to_shortname,
873	(int) object,
874	(annex ? annex : "(null)"),
875	(long) readbuf, (long) writebuf,
876	paddr_nz (offset), paddr_d (len), paddr_d (retval));
877
878	if (readbuf)
879	myaddr = readbuf;
880	if (writebuf)
881	myaddr = writebuf;
882	if (retval > 0 && myaddr != NULL((void*)0))
883	{
884	int i;
885
886	fputs_unfiltered (", bytes =", gdb_stdlog);
887	for (i = 0; i < retval; i++)
888	{
889	if ((((long) &(myaddr[i])) & 0xf) == 0)
890	{
891	if (targetdebug < 2 && i > 0)
892	{
893	fprintf_unfiltered (gdb_stdlog, " ...");
894	break;
895	}
896	fprintf_unfiltered (gdb_stdlog, "\n");
897	}
898
899	fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
900	}
901	}
902
903	fputc_unfiltered ('\n', gdb_stdlog);
904	}
905	return retval;
906	}
907
908	/* Attempt a transfer all LEN bytes starting at OFFSET between the
909	inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
910	the transfer succeeds, return zero, otherwize the host ERRNO is
911	returned.
912
913	The inferior is formed from several layers. In the case of
914	corefiles, inf-corefile is layered above inf-exec and a request for
915	text (corefiles do not include text pages) will be first sent to
916	the core-stratum, fail, and then sent to the object-file where it
917	will succeed.
918
919	NOTE: cagney/2004-09-30:
920
921	The old code tried to use four separate mechanisms for mapping an
922	object:offset:len tuple onto an inferior and its address space: the
923	target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
924	overlays.
925
926	This is stupid.
927
928	The code below is instead using a single mechanism (currently
929	strata). If that mechanism proves insufficient then re-factor it
930	implementing another singluar mechanism (for instance, a generic
931	object:annex onto inferior:object:annex say). */
932
933	static LONGESTlong
934	xfer_using_stratum (enum target_object object, const char *annex,
935	ULONGESTunsigned long offset, LONGESTlong len, void *readbuf,
936	const void *writebuf)
937	{
938	LONGESTlong xfered;
939	struct target_ops *target;
940
941	/* Always successful. */
942	if (len == 0)
943	return 0;
944	/* Never successful. */
945	if (target_stack == NULL((void*)0))
946	return EIO5;
947
948	target = target_stack;
949	while (1)
950	{
951	xfered = target_xfer_partial (target, object, annex,
952	readbuf, writebuf, offset, len);
953	if (xfered > 0)
954	{
955	/* The partial xfer succeeded, update the counts, check that
956	the xfer hasn't finished and if it hasn't set things up
957	for the next round. */
958	len -= xfered;
959	if (len <= 0)
960	return 0;
961	offset += xfered;
962	if (readbuf != NULL((void*)0))
963	readbuf = (bfd_byte *) readbuf + xfered;
964	if (writebuf != NULL((void*)0))
965	writebuf = (bfd_byte *) writebuf + xfered;
966	target = target_stack;
967	}
968	else if (xfered < 0)
969	{
970	/* Something totally screwed up, abandon the attempt to
971	xfer. */
972	if (errno(*__errno()))
973	return errno(*__errno());
974	else
975	return EIO5;
976	}
977	else
978	{
979	/* This "stratum" didn't work, try the next one down. */
980	target = target->beneath;
981	if (target == NULL((void*)0))
982	return EIO5;
983	}
984	}
985	}
986
987	/* Read LEN bytes of target memory at address MEMADDR, placing the results in
988	GDB's memory at MYADDR. Returns either 0 for success or an errno value
989	if any error occurs.
990
991	If an error occurs, no guarantee is made about the contents of the data at
992	MYADDR. In particular, the caller should not depend upon partial reads
993	filling the buffer with good data. There is no way for the caller to know
994	how much good data might have been transfered anyway. Callers that can
995	deal with partial reads should call target_read_memory_partial. */
996
997	int
998	target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
999	{
1000	if (target_xfer_partial_p ())
1001	return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL((void*)0),
1002	memaddr, len, myaddr, NULL((void*)0));
1003	else
1004	return target_xfer_memory (memaddr, myaddr, len, 0);
1005	}
1006
1007	int
1008	target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
1009	{
1010	if (target_xfer_partial_p ())
1011	return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL((void*)0),
1012	memaddr, len, NULL((void*)0), myaddr);
1013	else
1014	return target_xfer_memory (memaddr, myaddr, len, 1);
1015	}
1016
1017	#ifndef target_stopped_data_address_p
1018	int
1019	target_stopped_data_address_p (struct target_ops *target)
1020	{
1021	if (target->to_stopped_data_address
1022	== (int () (struct target_ops , CORE_ADDR *)) return_zero)
1023	return 0;
1024	if (target->to_stopped_data_address == debug_to_stopped_data_address
1025	&& (debug_target.to_stopped_data_address
1026	== (int () (struct target_ops , CORE_ADDR *)) return_zero))
1027	return 0;
1028	return 1;
1029	}
1030	#endif
1031
1032	static int trust_readonly = 0;
1033
1034	/* Move memory to or from the targets. The top target gets priority;
1035	if it cannot handle it, it is offered to the next one down, etc.
1036
1037	Result is -1 on error, or the number of bytes transfered. */
1038
1039	int
1040	do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1041	struct mem_attrib *attrib)
1042	{
1043	int res;
1044	int done = 0;
1045	struct target_ops *t;
1046
1047	/* Zero length requests are ok and require no work. */
1048	if (len == 0)
1049	return 0;
1050
1051	/* deprecated_xfer_memory is not guaranteed to set errno, even when
1052	it returns 0. */
1053	errno(*__errno()) = 0;
1054
1055	if (!write && trust_readonly)
1056	{
1057	struct section_table *secp;
1058	/* User-settable option, "trust-readonly-sections". If true,
1059	then memory from any SEC_READONLY bfd section may be read
1060	directly from the bfd file. */
1061	secp = target_section_by_addr (&current_target, memaddr);
1062	if (secp != NULL((void*)0)
1063	&& (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)((secp->the_bfd_section)->flags + 0)
1064	& SEC_READONLY0x010))
1065	return xfer_memory (memaddr, myaddr, len, 0, attrib, &current_target);
1066	}
1067
1068	/* The quick case is that the top target can handle the transfer. */
1069	res = current_target.deprecated_xfer_memory
1070	(memaddr, myaddr, len, write, attrib, &current_target);
1071
1072	/* If res <= 0 then we call it again in the loop. Ah well. */
1073	if (res <= 0)
1074	{
1075	for (t = target_stack; t != NULL((void*)0); t = t->beneath)
1076	{
1077	if (!t->to_has_memory)
1078	continue;
1079
1080	res = t->deprecated_xfer_memory (memaddr, myaddr, len, write, attrib, t);
1081	if (res > 0)
1082	break; /* Handled all or part of xfer */
1083	if (t->to_has_all_memory)
1084	break;
1085	}
1086
1087	if (res <= 0)
1088	return -1;
1089	}
1090
1091	return res;
1092	}
1093
1094
1095	/* Perform a memory transfer. Iterate until the entire region has
1096	been transfered.
1097
1098	Result is 0 or errno value. */
1099
1100	static int
1101	target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
1102	{
1103	int res;
1104	int reg_len;
1105	struct mem_region *region;
1106
1107	/* Zero length requests are ok and require no work. */
1108	if (len == 0)
1109	{
1110	return 0;
1111	}
1112
1113	while (len > 0)
1114	{
1115	region = lookup_mem_region(memaddr);
1116	if (memaddr + len < region->hi)
1117	reg_len = len;
1118	else
1119	reg_len = region->hi - memaddr;
1120
1121	switch (region->attrib.mode)
1122	{
1123	case MEM_RO:
1124	if (write)
1125	return EIO5;
1126	break;
1127
1128	case MEM_WO:
1129	if (!write)
1130	return EIO5;
1131	break;
1132	}
1133
1134	while (reg_len > 0)
1135	{
1136	if (region->attrib.cache)
1137	res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1138	reg_len, write);
1139	else
1140	res = do_xfer_memory (memaddr, myaddr, reg_len, write,
1141	&region->attrib);
1142
1143	if (res <= 0)
1144	{
1145	/* If this address is for nonexistent memory, read zeros
1146	if reading, or do nothing if writing. Return
1147	error. */
1148	if (!write)
1149	memset (myaddr, 0, len);
1150	if (errno(*__errno()) == 0)
1151	return EIO5;
1152	else
1153	return errno(*__errno());
1154	}
1155
1156	memaddr += res;
1157	myaddr += res;
1158	len -= res;
1159	reg_len -= res;
1160	}
1161	}
1162
1163	return 0; /* We managed to cover it all somehow. */
1164	}
1165
1166
1167	/* Perform a partial memory transfer.
1168
1169	Result is -1 on error, or the number of bytes transfered. */
1170
1171	static int
1172	target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
1173	int write_p, int *err)
1174	{
1175	int res;
1176	int reg_len;
1177	struct mem_region *region;
1178
1179	/* Zero length requests are ok and require no work. */
1180	if (len == 0)
1181	{
1182	*err = 0;
1183	return 0;
1184	}
1185
1186	region = lookup_mem_region(memaddr);
1187	if (memaddr + len < region->hi)
1188	reg_len = len;
1189	else
1190	reg_len = region->hi - memaddr;
1191
1192	switch (region->attrib.mode)
1193	{
1194	case MEM_RO:
1195	if (write_p)
1196	{
1197	*err = EIO5;
1198	return -1;
1199	}
1200	break;
1201
1202	case MEM_WO:
1203	if (write_p)
1204	{
1205	*err = EIO5;
1206	return -1;
1207	}
1208	break;
1209	}
1210
1211	if (region->attrib.cache)
1212	res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1213	reg_len, write_p);
1214	else
1215	res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
1216	&region->attrib);
1217
1218	if (res <= 0)
1219	{
1220	if (errno(*__errno()) != 0)
1221	err = errno(__errno());
1222	else
1223	*err = EIO5;
1224
1225	return -1;
1226	}
1227
1228	*err = 0;
1229	return res;
1230	}
1231
1232	int
1233	target_read_memory_partial (CORE_ADDR memaddr, char buf, int len, int err)
1234	{
1235	if (target_xfer_partial_p ())
1236	return target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY, NULL((void*)0),
1237	buf, NULL((void*)0), memaddr, len);
1238	else
1239	return target_xfer_memory_partial (memaddr, buf, len, 0, err);
1240	}
1241
1242	int
1243	target_write_memory_partial (CORE_ADDR memaddr, char buf, int len, int err)
1244	{
1245	if (target_xfer_partial_p ())
1246	return target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY, NULL((void*)0),
1247	NULL((void*)0), buf, memaddr, len);
1248	else
1249	return target_xfer_memory_partial (memaddr, buf, len, 1, err);
1250	}
1251
1252	/* More generic transfers. */
1253
1254	static LONGESTlong
1255	default_xfer_partial (struct target_ops *ops, enum target_object object,
1256	const char annex, void readbuf,
1257	const void *writebuf, ULONGESTunsigned long offset, LONGESTlong len)
1258	{
1259	if (object == TARGET_OBJECT_MEMORY
1260	&& ops->deprecated_xfer_memory != NULL((void*)0))
1261	/* If available, fall back to the target's
1262	"deprecated_xfer_memory" method. */
1263	{
1264	int xfered = -1;
1265	errno(*__errno()) = 0;
1266	if (writebuf != NULL((void*)0))
1267	{
1268	void *buffer = xmalloc (len);
1269	struct cleanup *cleanup = make_cleanup (xfree, buffer);
1270	memcpy (buffer, writebuf, len);
1271	xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1272	1/write/, NULL((void*)0), ops);
1273	do_cleanups (cleanup);
1274	}
1275	if (readbuf != NULL((void*)0))
1276	xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/read/,
1277	NULL((void*)0), ops);
1278	if (xfered > 0)
1279	return xfered;
1280	else if (xfered == 0 && errno(*__errno()) == 0)
1281	/* "deprecated_xfer_memory" uses 0, cross checked against
1282	ERRNO as one indication of an error. */
1283	return 0;
1284	else
1285	return -1;
1286	}
1287	else if (ops->beneath != NULL((void*)0))
1288	return target_xfer_partial (ops->beneath, object, annex,
1289	readbuf, writebuf, offset, len);
1290	else
1291	return -1;
1292	}
1293
1294	/* Target vector read/write partial wrapper functions.
1295
1296	NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1297	(inbuf, outbuf)", instead of separate read/write methods, make life
1298	easier. */
1299
1300	LONGESTlong
1301	target_read_partial (struct target_ops *ops,
1302	enum target_object object,
1303	const char annex, void buf,
1304	ULONGESTunsigned long offset, LONGESTlong len)
1305	{
1306	return target_xfer_partial (ops, object, annex, buf, NULL((void*)0), offset, len);
1307	}
1308
1309	LONGESTlong
1310	target_write_partial (struct target_ops *ops,
1311	enum target_object object,
1312	const char annex, const void buf,
1313	ULONGESTunsigned long offset, LONGESTlong len)
1314	{
1315	return target_xfer_partial (ops, object, annex, NULL((void*)0), buf, offset, len);
1316	}
1317
1318	/* Wrappers to perform the full transfer. */
1319	LONGESTlong
1320	target_read (struct target_ops *ops,
1321	enum target_object object,
1322	const char annex, void buf,
1323	ULONGESTunsigned long offset, LONGESTlong len)
1324	{
1325	LONGESTlong xfered = 0;
1326	while (xfered < len)
1327	{
1328	LONGESTlong xfer = target_read_partial (ops, object, annex,
1329	(bfd_byte *) buf + xfered,
1330	offset + xfered, len - xfered);
1331	/* Call an observer, notifying them of the xfer progress? */
1332	if (xfer <= 0)
1333	/* Call memory_error? */
1334	return -1;
1335	xfered += xfer;
1336	QUIT{ if (quit_flag) quit (); if (deprecated_interactive_hook) deprecated_interactive_hook (); };
1337	}
1338	return len;
1339	}
1340
1341	LONGESTlong
1342	target_write (struct target_ops *ops,
1343	enum target_object object,
1344	const char annex, const void buf,
1345	ULONGESTunsigned long offset, LONGESTlong len)
1346	{
1347	LONGESTlong xfered = 0;
1348	while (xfered < len)
1349	{
1350	LONGESTlong xfer = target_write_partial (ops, object, annex,
1351	(bfd_byte *) buf + xfered,
1352	offset + xfered, len - xfered);
1353	/* Call an observer, notifying them of the xfer progress? */
1354	if (xfer <= 0)
1355	/* Call memory_error? */
1356	return -1;
1357	xfered += xfer;
1358	QUIT{ if (quit_flag) quit (); if (deprecated_interactive_hook) deprecated_interactive_hook (); };
1359	}
1360	return len;
1361	}
1362
1363	/* Memory transfer methods. */
1364
1365	void
1366	get_target_memory (struct target_ops ops, CORE_ADDR addr, void buf,
1367	LONGESTlong len)
1368	{
1369	if (target_read (ops, TARGET_OBJECT_MEMORY, NULL((void*)0), buf, addr, len)
1370	!= len)
1371	memory_error (EIO5, addr);
1372	}
1373
1374	ULONGESTunsigned long
1375	get_target_memory_unsigned (struct target_ops *ops,
1376	CORE_ADDR addr, int len)
1377	{
1378	char buf[sizeof (ULONGESTunsigned long)];
1379
1380	gdb_assert (len <= sizeof (buf))((void) ((len <= sizeof (buf)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/target.c" , 1380, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "len <= sizeof (buf)" ), 0)));
1381	get_target_memory (ops, addr, buf, len);
1382	return extract_unsigned_integer (buf, len);
1383	}
1384
1385	static void
1386	target_info (char *args, int from_tty)
1387	{
1388	struct target_ops *t;
1389	int has_all_mem = 0;
1390
1391	if (symfile_objfile != NULL((void*)0))
1392	printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
1393
1394	for (t = target_stack; t != NULL((void*)0); t = t->beneath)
1395	{
1396	if (!t->to_has_memory)
1397	continue;
1398
1399	if ((int) (t->to_stratum) <= (int) dummy_stratum)
1400	continue;
1401	if (has_all_mem)
1402	printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1403	printf_unfiltered ("%s:\n", t->to_longname);
1404	(t->to_files_info) (t);
1405	has_all_mem = t->to_has_all_memory;
1406	}
1407	}
1408
1409	/* This is to be called by the open routine before it does
1410	anything. */
1411
1412	void
1413	target_preopen (int from_tty)
1414	{
1415	dont_repeat ();
1416
1417	if (target_has_execution(current_target.to_has_execution))
1418	{
1419	if (!from_tty
1420	\|\| query ("A program is being debugged already. Kill it? "))
1421	target_kill ()(*current_target.to_kill) ();
1422	else
1423	error ("Program not killed.");
1424	}
1425
1426	/* Calling target_kill may remove the target from the stack. But if
1427	it doesn't (which seems like a win for UDI), remove it now. */
1428
1429	if (target_has_execution(current_target.to_has_execution))
1430	pop_target ();
1431	}
1432
1433	/* Detach a target after doing deferred register stores. */
1434
1435	void
1436	target_detach (char *args, int from_tty)
1437	{
1438	(current_target.to_detach) (args, from_tty);
1439	}
1440
1441	void
1442	target_disconnect (char *args, int from_tty)
1443	{
1444	(current_target.to_disconnect) (args, from_tty);
1445	}
1446
1447	void
1448	target_link (char modname, CORE_ADDR t_reloc)
1449	{
1450	if (DEPRECATED_STREQ (current_target.to_shortname, "rombug")(strcmp ((current_target.to_shortname), ("rombug")) == 0))
1451	{
1452	(current_target.to_lookup_symbol) (modname, t_reloc);
1453	if (*t_reloc == 0)
1454	error ("Unable to link to %s and get relocation in rombug", modname);
1455	}
1456	else
1457	*t_reloc = (CORE_ADDR) -1;
1458	}
1459
1460	int
1461	target_async_mask (int mask)
1462	{
1463	int saved_async_masked_status = target_async_mask_value(current_target.to_async_mask_value);
1464	target_async_mask_value(current_target.to_async_mask_value) = mask;
1465	return saved_async_masked_status;
1466	}
1467
1468	/* Look through the list of possible targets for a target that can
1469	execute a run or attach command without any other data. This is
1470	used to locate the default process stratum.
1471
1472	Result is always valid (error() is called for errors). */
1473
1474	static struct target_ops *
1475	find_default_run_target (char *do_mesg)
1476	{
1477	struct target_ops **t;
1478	struct target_ops runable = NULL((void)0);
1479	int count;
1480
1481	count = 0;
1482
1483	for (t = target_structs; t < target_structs + target_struct_size;
1484	++t)
1485	{
1486	if ((t)->to_can_run && target_can_run (t)((*t)->to_can_run) ())
1487	{
1488	runable = *t;
1489	++count;
1490	}
1491	}
1492
1493	if (count != 1)
1494	error ("Don't know how to %s. Try \"help target\".", do_mesg);
1495
1496	return runable;
1497	}
1498
1499	void
1500	find_default_attach (char *args, int from_tty)
1501	{
1502	struct target_ops *t;
1503
1504	t = find_default_run_target ("attach");
1505	(t->to_attach) (args, from_tty);
1506	return;
1507	}
1508
1509	void
1510	find_default_create_inferior (char exec_file, char allargs, char **env,
1511	int from_tty)
1512	{
1513	struct target_ops *t;
1514
1515	t = find_default_run_target ("run");
1516	(t->to_create_inferior) (exec_file, allargs, env, from_tty);
1517	return;
1518	}
1519
1520	static int
1521	default_region_size_ok_for_hw_watchpoint (int byte_count)
1522	{
1523	return (byte_count <= TYPE_LENGTH (builtin_type_void_data_ptr)(builtin_type_void_data_ptr)->length);
1524	}
1525
1526	static int
1527	return_zero (void)
1528	{
1529	return 0;
1530	}
1531
1532	static int
1533	return_one (void)
1534	{
1535	return 1;
1536	}
1537
1538	static int
1539	return_minus_one (void)
1540	{
1541	return -1;
1542	}
1543
1544	/*
1545	* Resize the to_sections pointer. Also make sure that anyone that
1546	* was holding on to an old value of it gets updated.
1547	* Returns the old size.
1548	*/
1549
1550	int
1551	target_resize_to_sections (struct target_ops *target, int num_added)
1552	{
1553	struct target_ops **t;
1554	struct section_table *old_value;
1555	int old_count;
1556
1557	old_value = target->to_sections;
1558
1559	if (target->to_sections)
1560	{
1561	old_count = target->to_sections_end - target->to_sections;
1562	target->to_sections = (struct section_table *)
1563	xrealloc ((char *) target->to_sections,
1564	(sizeof (struct section_table)) * (num_added + old_count));
1565	}
1566	else
1567	{
1568	old_count = 0;
1569	target->to_sections = (struct section_table *)
1570	xmalloc ((sizeof (struct section_table)) * num_added);
1571	}
1572	target->to_sections_end = target->to_sections + (num_added + old_count);
1573
1574	/* Check to see if anyone else was pointing to this structure.
1575	If old_value was null, then no one was. */
1576
1577	if (old_value)
1578	{
1579	for (t = target_structs; t < target_structs + target_struct_size;
1580	++t)
1581	{
1582	if ((*t)->to_sections == old_value)
1583	{
1584	(*t)->to_sections = target->to_sections;
1585	(*t)->to_sections_end = target->to_sections_end;
1586	}
1587	}
1588	/* There is a flattened view of the target stack in current_target,
1589	so its to_sections pointer might also need updating. */
1590	if (current_target.to_sections == old_value)
1591	{
1592	current_target.to_sections = target->to_sections;
1593	current_target.to_sections_end = target->to_sections_end;
1594	}
1595	}
1596
1597	return old_count;
1598
1599	}
1600
1601	/* Remove all target sections taken from ABFD.
1602
1603	Scan the current target stack for targets whose section tables
1604	refer to sections from BFD, and remove those sections. We use this
1605	when we notice that the inferior has unloaded a shared object, for
1606	example. */
1607	void
1608	remove_target_sections (bfd *abfd)
1609	{
1610	struct target_ops **t;
1611
1612	for (t = target_structs; t < target_structs + target_struct_size; t++)
1613	{
1614	struct section_table src, dest;
1615
1616	dest = (*t)->to_sections;
1617	for (src = (t)->to_sections; src < (t)->to_sections_end; src++)
1618	if (src->bfd != abfd)
1619	{
1620	/* Keep this section. */
1621	if (dest < src) dest = src;
1622	dest++;
1623	}
1624
1625	/* If we've dropped any sections, resize the section table. */
1626	if (dest < src)
1627	target_resize_to_sections (*t, dest - src);
1628	}
1629	}
1630
1631
1632
1633
1634	/* Find a single runnable target in the stack and return it. If for
1635	some reason there is more than one, return NULL. */
1636
1637	struct target_ops *
1638	find_run_target (void)
1639	{
1640	struct target_ops **t;
1641	struct target_ops runable = NULL((void)0);
1642	int count;
1643
1644	count = 0;
1645
1646	for (t = target_structs; t < target_structs + target_struct_size; ++t)
1647	{
1648	if ((t)->to_can_run && target_can_run (t)((*t)->to_can_run) ())
1649	{
1650	runable = *t;
1651	++count;
1652	}
1653	}
1654
1655	return (count == 1 ? runable : NULL((void*)0));
1656	}
1657
1658	/* Find a single core_stratum target in the list of targets and return it.
1659	If for some reason there is more than one, return NULL. */
1660
1661	struct target_ops *
1662	find_core_target (void)
1663	{
1664	struct target_ops **t;
1665	struct target_ops runable = NULL((void)0);
1666	int count;
1667
1668	count = 0;
1669
1670	for (t = target_structs; t < target_structs + target_struct_size;
1671	++t)
1672	{
1673	if ((*t)->to_stratum == core_stratum)
1674	{
1675	runable = *t;
1676	++count;
1677	}
1678	}
1679
1680	return (count == 1 ? runable : NULL((void*)0));
1681	}
1682
1683	/*
1684	* Find the next target down the stack from the specified target.
1685	*/
1686
1687	struct target_ops *
1688	find_target_beneath (struct target_ops *t)
1689	{
1690	return t->beneath;
1691	}
1692
1693
1694	/* The inferior process has died. Long live the inferior! */
1695
1696	void
1697	generic_mourn_inferior (void)
1698	{
1699	extern int show_breakpoint_hit_counts;
1700
1701	inferior_ptid = null_ptid;
1702	attach_flag = 0;
1703	breakpoint_init_inferior (inf_exited);
1704	registers_changed ();
1705
1706	reopen_exec_file ();
1707	reinit_frame_cache ();
1708
1709	/* It is confusing to the user for ignore counts to stick around
1710	from previous runs of the inferior. So clear them. */
1711	/* However, it is more confusing for the ignore counts to disappear when
1712	using hit counts. So don't clear them if we're counting hits. */
1713	if (!show_breakpoint_hit_counts)
1714	breakpoint_clear_ignore_counts ();
1715
1716	if (deprecated_detach_hook)
1717	deprecated_detach_hook ();
1718	}
1719
1720	/* Helper function for child_wait and the Lynx derivatives of child_wait.
1721	HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1722	translation of that in OURSTATUS. */
1723	void
1724	store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
1725	{
1726	#ifdef CHILD_SPECIAL_WAITSTATUS
1727	/* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1728	if it wants to deal with hoststatus. */
1729	if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1730	return;
1731	#endif
1732
1733	if (WIFEXITED (hoststatus)(((hoststatus) & 0177) == 0))
1734	{
1735	ourstatus->kind = TARGET_WAITKIND_EXITED;
1736	ourstatus->value.integer = WEXITSTATUS (hoststatus)(int)(((unsigned)(hoststatus) >> 8) & 0xff);
1737	}
1738	else if (!WIFSTOPPED (hoststatus)(((hoststatus) & 0xff) == 0177))
1739	{
1740	ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1741	ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus)(((hoststatus) & 0177)));
1742	}
1743	else
1744	{
1745	ourstatus->kind = TARGET_WAITKIND_STOPPED;
1746	ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus)(int)(((unsigned)(hoststatus) >> 8) & 0xff));
1747	}
1748	}
1749
1750	/* Returns zero to leave the inferior alone, one to interrupt it. */
1751	int (*target_activity_function) (void);
1752	int target_activity_fd;
1753
1754	/* Convert a normal process ID to a string. Returns the string in a static
1755	buffer. */
1756
1757	char *
1758	normal_pid_to_str (ptid_t ptid)
1759	{
1760	static char buf[30];
1761
1762	sprintf (buf, "process %d", PIDGET (ptid)(ptid_get_pid (ptid)));
1763	return buf;
1764	}
1765
1766	/* Error-catcher for target_find_memory_regions */
1767	static int dummy_find_memory_regions (int (ignore1) (), void ignore2)
1768	{
1769	error ("No target.");
1770	return 0;
1771	}
1772
1773	/* Error-catcher for target_make_corefile_notes */
1774	static char * dummy_make_corefile_notes (bfd ignore1, int ignore2)
1775	{
1776	error ("No target.");
1777	return NULL((void*)0);
1778	}
1779
1780	/* Set up the handful of non-empty slots needed by the dummy target
1781	vector. */
1782
1783	static void
1784	init_dummy_target (void)
1785	{
1786	dummy_target.to_shortname = "None";
1787	dummy_target.to_longname = "None";
1788	dummy_target.to_doc = "";
1789	dummy_target.to_attach = find_default_attach;
1790	dummy_target.to_create_inferior = find_default_create_inferior;
1791	dummy_target.to_pid_to_str = normal_pid_to_str;
1792	dummy_target.to_stratum = dummy_stratum;
1793	dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1794	dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1795	dummy_target.to_xfer_partial = default_xfer_partial;
1796	dummy_target.to_magic = OPS_MAGIC3840;
1797	}
1798
1799	static void
1800	debug_to_open (char *args, int from_tty)
1801	{
1802	debug_target.to_open (args, from_tty);
1803
1804	fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1805	}
1806
1807	static void
1808	debug_to_close (int quitting)
1809	{
1810	target_close (&debug_target, quitting);
1811	fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1812	}
1813
1814	void
1815	target_close (struct target_ops *targ, int quitting)
1816	{
1817	if (targ->to_xclose != NULL((void*)0))
1818	targ->to_xclose (targ, quitting);
1819	else if (targ->to_close != NULL((void*)0))
1820	targ->to_close (quitting);
1821	}
1822
1823	static void
1824	debug_to_attach (char *args, int from_tty)
1825	{
1826	debug_target.to_attach (args, from_tty);
1827
1828	fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1829	}
1830
1831
1832	static void
1833	debug_to_post_attach (int pid)
1834	{
1835	debug_target.to_post_attach (pid);
1836
1837	fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1838	}
1839
1840	static void
1841	debug_to_detach (char *args, int from_tty)
1842	{
1843	debug_target.to_detach (args, from_tty);
1844
1845	fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1846	}
1847
1848	static void
1849	debug_to_disconnect (char *args, int from_tty)
1850	{
1851	debug_target.to_disconnect (args, from_tty);
1852
1853	fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1854	args, from_tty);
1855	}
1856
1857	static void
1858	debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1859	{
1860	debug_target.to_resume (ptid, step, siggnal);
1861
1862	fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid)(ptid_get_pid (ptid)),
1863	step ? "step" : "continue",
1864	target_signal_to_name (siggnal));
1865	}
1866
1867	static ptid_t
1868	debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1869	{
1870	ptid_t retval;
1871
1872	retval = debug_target.to_wait (ptid, status);
1873
1874	fprintf_unfiltered (gdb_stdlog,
1875	"target_wait (%d, status) = %d, ", PIDGET (ptid)(ptid_get_pid (ptid)),
1876	PIDGET (retval)(ptid_get_pid (retval)));
1877	fprintf_unfiltered (gdb_stdlog, "status->kind = ");
1878	switch (status->kind)
1879	{
1880	case TARGET_WAITKIND_EXITED:
1881	fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
1882	status->value.integer);
1883	break;
1884	case TARGET_WAITKIND_STOPPED:
1885	fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
1886	target_signal_to_name (status->value.sig));
1887	break;
1888	case TARGET_WAITKIND_SIGNALLED:
1889	fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
1890	target_signal_to_name (status->value.sig));
1891	break;
1892	case TARGET_WAITKIND_LOADED:
1893	fprintf_unfiltered (gdb_stdlog, "loaded\n");
1894	break;
1895	case TARGET_WAITKIND_FORKED:
1896	fprintf_unfiltered (gdb_stdlog, "forked\n");
1897	break;
1898	case TARGET_WAITKIND_VFORKED:
1899	fprintf_unfiltered (gdb_stdlog, "vforked\n");
1900	break;
1901	case TARGET_WAITKIND_EXECD:
1902	fprintf_unfiltered (gdb_stdlog, "execd\n");
1903	break;
1904	case TARGET_WAITKIND_SPURIOUS:
1905	fprintf_unfiltered (gdb_stdlog, "spurious\n");
1906	break;
1907	default:
1908	fprintf_unfiltered (gdb_stdlog, "unknown???\n");
1909	break;
1910	}
1911
1912	return retval;
1913	}
1914
1915	static void
1916	debug_print_register (const char * func, int regno)
1917	{
1918	fprintf_unfiltered (gdb_stdlog, "%s ", func);
1919	if (regno >= 0 && regno < NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch))
1920	&& REGISTER_NAME (regno)(gdbarch_register_name (current_gdbarch, regno)) != NULL((void*)0) && REGISTER_NAME (regno)(gdbarch_register_name (current_gdbarch, regno))[0] != '\0')
1921	fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno)(gdbarch_register_name (current_gdbarch, regno)));
1922	else
1923	fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1924	if (regno >= 0)
1925	{
1926	int i;
1927	unsigned char buf[MAX_REGISTER_SIZE];
1928	deprecated_read_register_gen (regno, buf);
1929	fprintf_unfiltered (gdb_stdlog, " = ");
1930	for (i = 0; i < register_size (current_gdbarch, regno); i++)
1931	{
1932	fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1933	}
1934	if (register_size (current_gdbarch, regno) <= sizeof (LONGESTlong))
1935	{
1936	fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
1937	paddr_nz (read_register (regno)),
1938	paddr_d (read_register (regno)));
1939	}
1940	}
1941	fprintf_unfiltered (gdb_stdlog, "\n");
1942	}
1943
1944	static void
1945	debug_to_fetch_registers (int regno)
1946	{
1947	debug_target.to_fetch_registers (regno);
1948	debug_print_register ("target_fetch_registers", regno);
1949	}
1950
1951	static void
1952	debug_to_store_registers (int regno)
1953	{
1954	debug_target.to_store_registers (regno);
1955	debug_print_register ("target_store_registers", regno);
1956	fprintf_unfiltered (gdb_stdlog, "\n");
1957	}
1958
1959	static void
1960	debug_to_prepare_to_store (void)
1961	{
1962	debug_target.to_prepare_to_store ();
1963
1964	fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
1965	}
1966
1967	static int
1968	deprecated_debug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1969	int write, struct mem_attrib *attrib,
1970	struct target_ops *target)
1971	{
1972	int retval;
1973
1974	retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
1975	attrib, target);
1976
1977	fprintf_unfiltered (gdb_stdlog,
1978	"target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1979	(unsigned int) memaddr, /* possable truncate long long */
1980	len, write ? "write" : "read", retval);
1981
1982	if (retval > 0)
1983	{
1984	int i;
1985
1986	fputs_unfiltered (", bytes =", gdb_stdlog);
1987	for (i = 0; i < retval; i++)
1988	{
1989	if ((((long) &(myaddr[i])) & 0xf) == 0)
1990	{
1991	if (targetdebug < 2 && i > 0)
1992	{
1993	fprintf_unfiltered (gdb_stdlog, " ...");
1994	break;
1995	}
1996	fprintf_unfiltered (gdb_stdlog, "\n");
1997	}
1998
1999	fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2000	}
2001	}
2002
2003	fputc_unfiltered ('\n', gdb_stdlog);
2004
2005	return retval;
2006	}
2007
2008	static void
2009	debug_to_files_info (struct target_ops *target)
2010	{
2011	debug_target.to_files_info (target);
2012
2013	fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2014	}
2015
2016	static int
2017	debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
2018	{
2019	int retval;
2020
2021	retval = debug_target.to_insert_breakpoint (addr, save);
2022
2023	fprintf_unfiltered (gdb_stdlog,
2024	"target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2025	(unsigned long) addr,
2026	(unsigned long) retval);
2027	return retval;
2028	}
2029
2030	static int
2031	debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
2032	{
2033	int retval;
2034
2035	retval = debug_target.to_remove_breakpoint (addr, save);
2036
2037	fprintf_unfiltered (gdb_stdlog,
2038	"target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2039	(unsigned long) addr,
2040	(unsigned long) retval);
2041	return retval;
2042	}
2043
2044	static int
2045	debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2046	{
2047	int retval;
2048
2049	retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2050
2051	fprintf_unfiltered (gdb_stdlog,
2052	"target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2053	(unsigned long) type,
2054	(unsigned long) cnt,
2055	(unsigned long) from_tty,
2056	(unsigned long) retval);
2057	return retval;
2058	}
2059
2060	static int
2061	debug_to_region_size_ok_for_hw_watchpoint (int byte_count)
2062	{
2063	CORE_ADDR retval;
2064
2065	retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count);
2066
2067	fprintf_unfiltered (gdb_stdlog,
2068	"TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2069	(unsigned long) byte_count,
2070	(unsigned long) retval);
2071	return retval;
2072	}
2073
2074	static int
2075	debug_to_stopped_by_watchpoint (void)
2076	{
2077	int retval;
2078
2079	retval = debug_target.to_stopped_by_watchpoint ();
2080
2081	fprintf_unfiltered (gdb_stdlog,
2082	"STOPPED_BY_WATCHPOINT () = %ld\n",
2083	(unsigned long) retval);
2084	return retval;
2085	}
2086
2087	static int
2088	debug_to_stopped_data_address (struct target_ops target, CORE_ADDR addr)
2089	{
2090	int retval;
2091
2092	retval = debug_target.to_stopped_data_address (target, addr);
2093
2094	fprintf_unfiltered (gdb_stdlog,
2095	"target_stopped_data_address ([0x%lx]) = %ld\n",
2096	(unsigned long)*addr,
2097	(unsigned long)retval);
2098	return retval;
2099	}
2100
2101	static int
2102	debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save)
2103	{
2104	int retval;
2105
2106	retval = debug_target.to_insert_hw_breakpoint (addr, save);
2107
2108	fprintf_unfiltered (gdb_stdlog,
2109	"target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2110	(unsigned long) addr,
2111	(unsigned long) retval);
2112	return retval;
2113	}
2114
2115	static int
2116	debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save)
2117	{
2118	int retval;
2119
2120	retval = debug_target.to_remove_hw_breakpoint (addr, save);
2121
2122	fprintf_unfiltered (gdb_stdlog,
2123	"target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2124	(unsigned long) addr,
2125	(unsigned long) retval);
2126	return retval;
2127	}
2128
2129	static int
2130	debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2131	{
2132	int retval;
2133
2134	retval = debug_target.to_insert_watchpoint (addr, len, type);
2135
2136	fprintf_unfiltered (gdb_stdlog,
2137	"target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2138	(unsigned long) addr, len, type, (unsigned long) retval);
2139	return retval;
2140	}
2141
2142	static int
2143	debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2144	{
2145	int retval;
2146
2147	retval = debug_target.to_insert_watchpoint (addr, len, type);
2148
2149	fprintf_unfiltered (gdb_stdlog,
2150	"target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2151	(unsigned long) addr, len, type, (unsigned long) retval);
2152	return retval;
2153	}
2154
2155	static void
2156	debug_to_terminal_init (void)
2157	{
2158	debug_target.to_terminal_init ();
2159
2160	fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2161	}
2162
2163	static void
2164	debug_to_terminal_inferior (void)
2165	{
2166	debug_target.to_terminal_inferior ();
2167
2168	fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2169	}
2170
2171	static void
2172	debug_to_terminal_ours_for_output (void)
2173	{
2174	debug_target.to_terminal_ours_for_output ();
2175
2176	fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2177	}
2178
2179	static void
2180	debug_to_terminal_ours (void)
2181	{
2182	debug_target.to_terminal_ours ();
2183
2184	fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2185	}
2186
2187	static void
2188	debug_to_terminal_save_ours (void)
2189	{
2190	debug_target.to_terminal_save_ours ();
2191
2192	fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2193	}
2194
2195	static void
2196	debug_to_terminal_info (char *arg, int from_tty)
2197	{
2198	debug_target.to_terminal_info (arg, from_tty);
2199
2200	fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2201	from_tty);
2202	}
2203
2204	static void
2205	debug_to_kill (void)
2206	{
2207	debug_target.to_kill ();
2208
2209	fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2210	}
2211
2212	static void
2213	debug_to_load (char *args, int from_tty)
2214	{
2215	debug_target.to_load (args, from_tty);
2216
2217	fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2218	}
2219
2220	static int
2221	debug_to_lookup_symbol (char name, CORE_ADDR addrp)
2222	{
2223	int retval;
2224
2225	retval = debug_target.to_lookup_symbol (name, addrp);
2226
2227	fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2228
2229	return retval;
2230	}
2231
2232	static void
2233	debug_to_create_inferior (char exec_file, char args, char **env,
2234	int from_tty)
2235	{
2236	debug_target.to_create_inferior (exec_file, args, env, from_tty);
2237
2238	fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2239	exec_file, args, from_tty);
2240	}
2241
2242	static void
2243	debug_to_post_startup_inferior (ptid_t ptid)
2244	{
2245	debug_target.to_post_startup_inferior (ptid);
2246
2247	fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2248	PIDGET (ptid)(ptid_get_pid (ptid)));
2249	}
2250
2251	static void
2252	debug_to_acknowledge_created_inferior (int pid)
2253	{
2254	debug_target.to_acknowledge_created_inferior (pid);
2255
2256	fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2257	pid);
2258	}
2259
2260	static int
2261	debug_to_insert_fork_catchpoint (int pid)
2262	{
2263	int retval;
2264
2265	retval = debug_target.to_insert_fork_catchpoint (pid);
2266
2267	fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
2268	pid, retval);
2269
2270	return retval;
2271	}
2272
2273	static int
2274	debug_to_remove_fork_catchpoint (int pid)
2275	{
2276	int retval;
2277
2278	retval = debug_target.to_remove_fork_catchpoint (pid);
2279
2280	fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2281	pid, retval);
2282
2283	return retval;
2284	}
2285
2286	static int
2287	debug_to_insert_vfork_catchpoint (int pid)
2288	{
2289	int retval;
2290
2291	retval = debug_target.to_insert_vfork_catchpoint (pid);
2292
2293	fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
2294	pid, retval);
2295
2296	return retval;
2297	}
2298
2299	static int
2300	debug_to_remove_vfork_catchpoint (int pid)
2301	{
2302	int retval;
2303
2304	retval = debug_target.to_remove_vfork_catchpoint (pid);
2305
2306	fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2307	pid, retval);
2308
2309	return retval;
2310	}
2311
2312	static int
2313	debug_to_follow_fork (int follow_child)
2314	{
2315	int retval = debug_target.to_follow_fork (follow_child);
2316
2317	fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2318	follow_child, retval);
2319
2320	return retval;
2321	}
2322
2323	static int
2324	debug_to_insert_exec_catchpoint (int pid)
2325	{
2326	int retval;
2327
2328	retval = debug_target.to_insert_exec_catchpoint (pid);
2329
2330	fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
2331	pid, retval);
2332
2333	return retval;
2334	}
2335
2336	static int
2337	debug_to_remove_exec_catchpoint (int pid)
2338	{
2339	int retval;
2340
2341	retval = debug_target.to_remove_exec_catchpoint (pid);
2342
2343	fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2344	pid, retval);
2345
2346	return retval;
2347	}
2348
2349	static int
2350	debug_to_reported_exec_events_per_exec_call (void)
2351	{
2352	int reported_exec_events;
2353
2354	reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2355
2356	fprintf_unfiltered (gdb_stdlog,
2357	"target_reported_exec_events_per_exec_call () = %d\n",
2358	reported_exec_events);
2359
2360	return reported_exec_events;
2361	}
2362
2363	static int
2364	debug_to_has_exited (int pid, int wait_status, int *exit_status)
2365	{
2366	int has_exited;
2367
2368	has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2369
2370	fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2371	pid, wait_status, *exit_status, has_exited);
2372
2373	return has_exited;
2374	}
2375
2376	static void
2377	debug_to_mourn_inferior (void)
2378	{
2379	debug_target.to_mourn_inferior ();
2380
2381	fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2382	}
2383
2384	static int
2385	debug_to_can_run (void)
2386	{
2387	int retval;
2388
2389	retval = debug_target.to_can_run ();
2390
2391	fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2392
2393	return retval;
2394	}
2395
2396	static void
2397	debug_to_notice_signals (ptid_t ptid)
2398	{
2399	debug_target.to_notice_signals (ptid);
2400
2401	fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2402	PIDGET (ptid)(ptid_get_pid (ptid)));
2403	}
2404
2405	static int
2406	debug_to_thread_alive (ptid_t ptid)
2407	{
2408	int retval;
2409
2410	retval = debug_target.to_thread_alive (ptid);
2411
2412	fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2413	PIDGET (ptid)(ptid_get_pid (ptid)), retval);
2414
2415	return retval;
2416	}
2417
2418	static void
2419	debug_to_find_new_threads (void)
2420	{
2421	debug_target.to_find_new_threads ();
2422
2423	fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2424	}
2425
2426	static void
2427	debug_to_stop (void)
2428	{
2429	debug_target.to_stop ();
2430
2431	fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2432	}
2433
2434	static void
2435	debug_to_rcmd (char *command,
2436	struct ui_file *outbuf)
2437	{
2438	debug_target.to_rcmd (command, outbuf);
2439	fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2440	}
2441
2442	static struct symtab_and_line *
2443	debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2444	{
2445	struct symtab_and_line *result;
2446	result = debug_target.to_enable_exception_callback (kind, enable);
2447	fprintf_unfiltered (gdb_stdlog,
2448	"target get_exception_callback_sal (%d, %d)\n",
2449	kind, enable);
2450	return result;
2451	}
2452
2453	static struct exception_event_record *
2454	debug_to_get_current_exception_event (void)
2455	{
2456	struct exception_event_record *result;
2457	result = debug_target.to_get_current_exception_event ();
2458	fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2459	return result;
2460	}
2461
2462	static char *
2463	debug_to_pid_to_exec_file (int pid)
2464	{
2465	char *exec_file;
2466
2467	exec_file = debug_target.to_pid_to_exec_file (pid);
2468
2469	fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2470	pid, exec_file);
2471
2472	return exec_file;
2473	}
2474
2475	static void
2476	setup_target_debug (void)
2477	{
2478	memcpy (&debug_target, &current_target, sizeof debug_target);
2479
2480	current_target.to_open = debug_to_open;
2481	current_target.to_close = debug_to_close;
2482	current_target.to_attach = debug_to_attach;
2483	current_target.to_post_attach = debug_to_post_attach;
2484	current_target.to_detach = debug_to_detach;
2485	current_target.to_disconnect = debug_to_disconnect;
2486	current_target.to_resume = debug_to_resume;
2487	current_target.to_wait = debug_to_wait;
2488	current_target.to_fetch_registers = debug_to_fetch_registers;
2489	current_target.to_store_registers = debug_to_store_registers;
2490	current_target.to_prepare_to_store = debug_to_prepare_to_store;
2491	current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
2492	current_target.to_files_info = debug_to_files_info;
2493	current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2494	current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2495	current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2496	current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2497	current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2498	current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2499	current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2500	current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2501	current_target.to_stopped_data_address = debug_to_stopped_data_address;
2502	current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint;
2503	current_target.to_terminal_init = debug_to_terminal_init;
2504	current_target.to_terminal_inferior = debug_to_terminal_inferior;
2505	current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2506	current_target.to_terminal_ours = debug_to_terminal_ours;
2507	current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2508	current_target.to_terminal_info = debug_to_terminal_info;
2509	current_target.to_kill = debug_to_kill;
2510	current_target.to_load = debug_to_load;
2511	current_target.to_lookup_symbol = debug_to_lookup_symbol;
2512	current_target.to_create_inferior = debug_to_create_inferior;
2513	current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2514	current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2515	current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2516	current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2517	current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2518	current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2519	current_target.to_follow_fork = debug_to_follow_fork;
2520	current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2521	current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2522	current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2523	current_target.to_has_exited = debug_to_has_exited;
2524	current_target.to_mourn_inferior = debug_to_mourn_inferior;
2525	current_target.to_can_run = debug_to_can_run;
2526	current_target.to_notice_signals = debug_to_notice_signals;
2527	current_target.to_thread_alive = debug_to_thread_alive;
2528	current_target.to_find_new_threads = debug_to_find_new_threads;
2529	current_target.to_stop = debug_to_stop;
2530	current_target.to_rcmd = debug_to_rcmd;
2531	current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2532	current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2533	current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2534
2535	}
2536
2537
2538	static char targ_desc[] =
2539	"Names of targets and files being debugged.\n\
2540	Shows the entire stack of targets currently in use (including the exec-file,\n\
2541	core-file, and process, if any), as well as the symbol file name.";
2542
2543	static void
2544	do_monitor_command (char *cmd,
2545	int from_tty)
2546	{
2547	if ((current_target.to_rcmd
2548	== (void () (char , struct ui_file *)) tcomplain)
2549	\|\| (current_target.to_rcmd == debug_to_rcmd
2550	&& (debug_target.to_rcmd
2551	== (void () (char , struct ui_file *)) tcomplain)))
2552	{
2553	error ("\"monitor\" command not supported by this target.\n");
2554	}
2555	target_rcmd (cmd, gdb_stdtarg)(*current_target.to_rcmd) (cmd, gdb_stdtarg);
2556	}
2557
2558	void
2559	initialize_targets (void)
2560	{
2561	init_dummy_target ();
2562	push_target (&dummy_target);
2563
2564	add_info ("target", target_info, targ_desc);
2565	add_info ("files", target_info, targ_desc);
2566
2567	deprecated_add_show_from_set
2568	(add_set_cmd ("target", class_maintenance, var_zinteger,
2569	(char *) &targetdebug,
2570	"Set target debugging.\n\
2571	When non-zero, target debugging is enabled. Higher numbers are more\n\
2572	verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2573	command.", &setdebuglist),
2574	&showdebuglist);
2575
2576	add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
2577	&trust_readonly, "\
2578	Set mode for reading from readonly sections.", "\
2579	Show mode for reading from readonly sections.", "\
2580	When this mode is on, memory reads from readonly sections (such as .text)\n\
2581	will be read from the object file instead of from the target. This will\n\
2582	result in significant performance improvement for remote targets.", "\
2583	Mode for reading from readonly sections is %s.",
2584	NULL((void)0), NULL((void)0),
2585	&setlist, &showlist);
2586
2587	add_com ("monitor", class_obscure, do_monitor_command,
2588	"Send a command to the remote monitor (remote targets only).");
2589
2590	target_dcache = dcache_init ();
2591	}