projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd/
[deliverable/binutils-gdb.git] / gdb / target.c
CommitLineData
c906108c 1/* Select target systems and architectures at runtime for GDB.
7998dfc3 2
6aba47ca 3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
0fb0cc75 4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
f6519ebc 5 Free Software Foundation, Inc.
7998dfc3 6
c906108c
SS		 7 Contributed by Cygnus Support.
8
c5aa993b 9 This file is part of GDB.
c906108c 10
c5aa993b
JM		 11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
a9762ec7 13 the Free Software Foundation; either version 3 of the License, or
c5aa993b 14 (at your option) any later version.
c906108c 15
c5aa993b
JM		 16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
c906108c 20
c5aa993b 21 You should have received a copy of the GNU General Public License
a9762ec7 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS		 23
24#include "defs.h"
25#include <errno.h>
c906108c
SS		 26#include "gdb_string.h"
27#include "target.h"
28#include "gdbcmd.h"
29#include "symtab.h"
30#include "inferior.h"
31#include "bfd.h"
32#include "symfile.h"
33#include "objfiles.h"
03f2053f 34#include "gdb_wait.h"
4930751a 35#include "dcache.h"
c906108c 36#include <signal.h>
4e052eda 37#include "regcache.h"
0088c768 38#include "gdb_assert.h"
b6591e8b 39#include "gdbcore.h"
9e35dae4 40#include "exceptions.h"
424163ea 41#include "target-descriptions.h"
e1ac3328 42#include "gdbthread.h"
b9db4ced 43#include "solib.h"
c906108c 44
a14ed312 45static void target_info (char *, int);
c906108c 46
a14ed312 47static void kill_or_be_killed (int);
c906108c 48
a14ed312 49static void default_terminal_info (char *, int);
c906108c 50
5009afc5
AS		 51static int default_watchpoint_addr_within_range (struct target_ops *,
52 CORE_ADDR, CORE_ADDR, int);
53
e0d24f8d
WZ		 54static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
55
a14ed312 56static int nosymbol (char *, CORE_ADDR *);
c906108c 57
4ecb6f27 58static void tcomplain (void) ATTR_NORETURN;
c906108c 59
a14ed312 60static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
c906108c 61
a14ed312 62static int return_zero (void);
c906108c 63
a14ed312 64static int return_one (void);
c906108c 65
ccaa32c7
GS		 66static int return_minus_one (void);
67
a14ed312 68void target_ignore (void);
c906108c 69
a14ed312 70static void target_command (char *, int);
c906108c 71
a14ed312 72static struct target_ops *find_default_run_target (char *);
c906108c 73
a14ed312 74static void nosupport_runtime (void);
392a587b 75
4b8a223f 76static LONGEST default_xfer_partial (struct target_ops *ops,
0088c768 77 enum target_object object,
1b0ba102
AC		 78 const char *annex, gdb_byte *readbuf,
79 const gdb_byte *writebuf,
8aa91c1e 80 ULONGEST offset, LONGEST len);
0088c768 81
cf7a04e8
DJ		 82static LONGEST current_xfer_partial (struct target_ops *ops,
83 enum target_object object,
84 const char *annex, gdb_byte *readbuf,
85 const gdb_byte *writebuf,
86 ULONGEST offset, LONGEST len);
c906108c 87
cf7a04e8
DJ		 88static LONGEST target_xfer_partial (struct target_ops *ops,
89 enum target_object object,
90 const char *annex,
91 void *readbuf, const void *writebuf,
92 ULONGEST offset, LONGEST len);
c906108c 93
a14ed312 94static void init_dummy_target (void);
c906108c 95
aa869812
AC		 96static struct target_ops debug_target;
97
a14ed312 98static void debug_to_open (char *, int);
c906108c 99
a14ed312 100static void debug_to_close (int);
c906108c 101
136d6dae 102static void debug_to_attach (struct target_ops *ops, char *, int);
c906108c 103
136d6dae 104static void debug_to_detach (struct target_ops *ops, char *, int);
c906108c 105
39f77062 106static void debug_to_resume (ptid_t, int, enum target_signal);
c906108c 107
39f77062 108static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
c906108c 109
56be3814 110static void debug_to_fetch_registers (struct regcache *, int);
c906108c 111
56be3814 112static void debug_to_store_registers (struct regcache *, int);
c906108c 113
316f2060 114static void debug_to_prepare_to_store (struct regcache *);
c906108c 115
a14ed312 116static void debug_to_files_info (struct target_ops *);
c906108c 117
8181d85f 118static int debug_to_insert_breakpoint (struct bp_target_info *);
c906108c 119
8181d85f 120static int debug_to_remove_breakpoint (struct bp_target_info *);
c906108c 121
ccaa32c7
GS		 122static int debug_to_can_use_hw_breakpoint (int, int, int);
123
8181d85f 124static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
ccaa32c7 125
8181d85f 126static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
ccaa32c7
GS		 127
128static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
129
130static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
131
132static int debug_to_stopped_by_watchpoint (void);
133
4aa7a7f5 134static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
ccaa32c7 135
5009afc5
AS		 136static int debug_to_watchpoint_addr_within_range (struct target_ops *,
137 CORE_ADDR, CORE_ADDR, int);
138
e0d24f8d
WZ		 139static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
140
a14ed312 141static void debug_to_terminal_init (void);
c906108c 142
a14ed312 143static void debug_to_terminal_inferior (void);
c906108c 144
a14ed312 145static void debug_to_terminal_ours_for_output (void);
c906108c 146
a790ad35
SC		 147static void debug_to_terminal_save_ours (void);
148
a14ed312 149static void debug_to_terminal_ours (void);
c906108c 150
a14ed312 151static void debug_to_terminal_info (char *, int);
c906108c 152
a14ed312 153static void debug_to_kill (void);
c906108c 154
a14ed312 155static void debug_to_load (char *, int);
c906108c 156
a14ed312 157static int debug_to_lookup_symbol (char *, CORE_ADDR *);
c906108c 158
136d6dae 159static void debug_to_mourn_inferior (struct target_ops *);
c906108c 160
a14ed312 161static int debug_to_can_run (void);
c906108c 162
39f77062 163static void debug_to_notice_signals (ptid_t);
c906108c 164
39f77062 165static int debug_to_thread_alive (ptid_t);
c906108c 166
94cc34af 167static void debug_to_stop (ptid_t);
c906108c 168
5ac10fd1
AC		 169/* NOTE: cagney/2004-09-29: Many targets reference this variable in
170 wierd and mysterious ways. Putting the variable here lets those
171 wierd and mysterious ways keep building while they are being
172 converted to the inferior inheritance structure. */
1df84f13 173struct target_ops deprecated_child_ops;
5ac10fd1 174
c906108c 175/* Pointer to array of target architecture structures; the size of the
2bc416ba 176 array; the current index into the array; the allocated size of the
c906108c
SS		 177 array. */
178struct target_ops **target_structs;
179unsigned target_struct_size;
180unsigned target_struct_index;
181unsigned target_struct_allocsize;
182#define DEFAULT_ALLOCSIZE 10
183
184/* The initial current target, so that there is always a semi-valid
185 current target. */
186
187static struct target_ops dummy_target;
188
189/* Top of target stack. */
190
258b763a 191static struct target_ops *target_stack;
c906108c
SS		 192
193/* The target structure we are currently using to talk to a process
194 or file or whatever "inferior" we have. */
195
196struct target_ops current_target;
197
198/* Command list for target. */
199
200static struct cmd_list_element *targetlist = NULL;
201
cf7a04e8
DJ		 202/* Nonzero if we should trust readonly sections from the
203 executable when reading memory. */
204
205static int trust_readonly = 0;
206
8defab1a
DJ		 207/* Nonzero if we should show true memory content including
208 memory breakpoint inserted by gdb. */
209
210static int show_memory_breakpoints = 0;
211
c906108c
SS		 212/* Non-zero if we want to see trace of target level stuff. */
213
214static int targetdebug = 0;
920d2a44
AC		 215static void
216show_targetdebug (struct ui_file *file, int from_tty,
217 struct cmd_list_element *c, const char *value)
218{
219 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
220}
c906108c 221
a14ed312 222static void setup_target_debug (void);
c906108c 223
4930751a
C		 224DCACHE *target_dcache;
225
c906108c
SS		 226/* The user just typed 'target' without the name of a target. */
227
c906108c 228static void
fba45db2 229target_command (char *arg, int from_tty)
c906108c
SS		 230{
231 fputs_filtered ("Argument required (target name). Try `help target'\n",
232 gdb_stdout);
233}
234
235/* Add a possible target architecture to the list. */
236
237void
fba45db2 238add_target (struct target_ops *t)
c906108c 239{
0088c768 240 /* Provide default values for all "must have" methods. */
0b603eba
AC		 241 if (t->to_xfer_partial == NULL)
242 t->to_xfer_partial = default_xfer_partial;
0088c768 243
c906108c
SS		 244 if (!target_structs)
245 {
246 target_struct_allocsize = DEFAULT_ALLOCSIZE;
247 target_structs = (struct target_ops **) xmalloc
248 (target_struct_allocsize * sizeof (*target_structs));
249 }
250 if (target_struct_size >= target_struct_allocsize)
251 {
252 target_struct_allocsize *= 2;
253 target_structs = (struct target_ops **)
c5aa993b
JM		 254 xrealloc ((char *) target_structs,
255 target_struct_allocsize * sizeof (*target_structs));
c906108c
SS		 256 }
257 target_structs[target_struct_size++] = t;
c906108c
SS		 258
259 if (targetlist == NULL)
1bedd215
AC		 260 add_prefix_cmd ("target", class_run, target_command, _("\
261Connect to a target machine or process.\n\
c906108c
SS		 262The first argument is the type or protocol of the target machine.\n\
263Remaining arguments are interpreted by the target protocol. For more\n\
264information on the arguments for a particular protocol, type\n\
1bedd215 265`help target ' followed by the protocol name."),
c906108c
SS		 266 &targetlist, "target ", 0, &cmdlist);
267 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
268}
269
270/* Stub functions */
271
272void
fba45db2 273target_ignore (void)
c906108c
SS		 274{
275}
276
11cf8741
JM		 277void
278target_load (char *arg, int from_tty)
279{
4930751a 280 dcache_invalidate (target_dcache);
11cf8741
JM		 281 (*current_target.to_load) (arg, from_tty);
282}
283
136d6dae
VP		 284void target_create_inferior (char *exec_file, char *args,
285 char **env, int from_tty)
286{
287 struct target_ops *t;
288 for (t = current_target.beneath; t != NULL; t = t->beneath)
289 {
290 if (t->to_create_inferior != NULL)
291 {
292 t->to_create_inferior (t, exec_file, args, env, from_tty);
293 return;
294 }
295 }
296
297 internal_error (__FILE__, __LINE__,
298 "could not find a target to create inferior");
299}
300
301
c906108c 302static int
fba45db2
KB		 303nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
304 struct target_ops *t)
c906108c 305{
c5aa993b
JM		 306 errno = EIO; /* Can't read/write this location */
307 return 0; /* No bytes handled */
c906108c
SS		 308}
309
310static void
fba45db2 311tcomplain (void)
c906108c 312{
8a3fe4f8 313 error (_("You can't do that when your target is `%s'"),
c906108c
SS		 314 current_target.to_shortname);
315}
316
317void
fba45db2 318noprocess (void)
c906108c 319{
8a3fe4f8 320 error (_("You can't do that without a process to debug."));
c906108c
SS		 321}
322
c906108c 323static int
fba45db2 324nosymbol (char *name, CORE_ADDR *addrp)
c906108c 325{
c5aa993b 326 return 1; /* Symbol does not exist in target env */
c906108c
SS		 327}
328
392a587b 329static void
fba45db2 330nosupport_runtime (void)
c906108c 331{
39f77062 332 if (ptid_equal (inferior_ptid, null_ptid))
c906108c
SS		 333 noprocess ();
334 else
8a3fe4f8 335 error (_("No run-time support for this"));
c906108c
SS		 336}
337
338
c906108c 339static void
fba45db2 340default_terminal_info (char *args, int from_tty)
c906108c 341{
a3f17187 342 printf_unfiltered (_("No saved terminal information.\n"));
c906108c
SS		 343}
344
345/* This is the default target_create_inferior and target_attach function.
346 If the current target is executing, it asks whether to kill it off.
347 If this function returns without calling error(), it has killed off
348 the target, and the operation should be attempted. */
349
350static void
fba45db2 351kill_or_be_killed (int from_tty)
c906108c
SS		 352{
353 if (target_has_execution)
354 {
a3f17187 355 printf_unfiltered (_("You are already running a program:\n"));
c906108c 356 target_files_info ();
c5aa993b
JM		 357 if (query ("Kill it? "))
358 {
359 target_kill ();
360 if (target_has_execution)
8a3fe4f8 361 error (_("Killing the program did not help."));
c5aa993b
JM		 362 return;
363 }
364 else
365 {
8a3fe4f8 366 error (_("Program not killed."));
c5aa993b 367 }
c906108c 368 }
c5aa993b 369 tcomplain ();
c906108c
SS		 370}
371
0ef643c8
JB		 372/* A default implementation for the to_get_ada_task_ptid target method.
373
374 This function builds the PTID by using both LWP and TID as part of
375 the PTID lwp and tid elements. The pid used is the pid of the
376 inferior_ptid. */
377
378ptid_t
379default_get_ada_task_ptid (long lwp, long tid)
380{
381 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
382}
383
7998dfc3
AC		 384/* Go through the target stack from top to bottom, copying over zero
385 entries in current_target, then filling in still empty entries. In
386 effect, we are doing class inheritance through the pushed target
387 vectors.
388
389 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
390 is currently implemented, is that it discards any knowledge of
391 which target an inherited method originally belonged to.
392 Consequently, new new target methods should instead explicitly and
393 locally search the target stack for the target that can handle the
394 request. */
c906108c
SS		 395
396static void
7998dfc3 397update_current_target (void)
c906108c 398{
7998dfc3
AC		 399 struct target_ops *t;
400
08d8bcd7 401 /* First, reset current's contents. */
7998dfc3
AC		 402 memset (&current_target, 0, sizeof (current_target));
403
404#define INHERIT(FIELD, TARGET) \
405 if (!current_target.FIELD) \
406 current_target.FIELD = (TARGET)->FIELD
407
408 for (t = target_stack; t; t = t->beneath)
409 {
410 INHERIT (to_shortname, t);
411 INHERIT (to_longname, t);
412 INHERIT (to_doc, t);
b52323fa
UW		 413 /* Do not inherit to_open. */
414 /* Do not inherit to_close. */
136d6dae 415 /* Do not inherit to_attach. */
7998dfc3 416 INHERIT (to_post_attach, t);
dc177b7a 417 INHERIT (to_attach_no_wait, t);
136d6dae 418 /* Do not inherit to_detach. */
597320e7 419 /* Do not inherit to_disconnect. */
7998dfc3
AC		 420 INHERIT (to_resume, t);
421 INHERIT (to_wait, t);
7998dfc3
AC		 422 INHERIT (to_fetch_registers, t);
423 INHERIT (to_store_registers, t);
424 INHERIT (to_prepare_to_store, t);
c8e73a31 425 INHERIT (deprecated_xfer_memory, t);
7998dfc3
AC		 426 INHERIT (to_files_info, t);
427 INHERIT (to_insert_breakpoint, t);
428 INHERIT (to_remove_breakpoint, t);
429 INHERIT (to_can_use_hw_breakpoint, t);
430 INHERIT (to_insert_hw_breakpoint, t);
431 INHERIT (to_remove_hw_breakpoint, t);
432 INHERIT (to_insert_watchpoint, t);
433 INHERIT (to_remove_watchpoint, t);
434 INHERIT (to_stopped_data_address, t);
74174d2e 435 INHERIT (to_have_steppable_watchpoint, t);
7998dfc3 436 INHERIT (to_have_continuable_watchpoint, t);
5009afc5
AS		 437 INHERIT (to_stopped_by_watchpoint, t);
438 INHERIT (to_watchpoint_addr_within_range, t);
e0d24f8d 439 INHERIT (to_region_ok_for_hw_watchpoint, t);
7998dfc3
AC		 440 INHERIT (to_terminal_init, t);
441 INHERIT (to_terminal_inferior, t);
442 INHERIT (to_terminal_ours_for_output, t);
443 INHERIT (to_terminal_ours, t);
444 INHERIT (to_terminal_save_ours, t);
445 INHERIT (to_terminal_info, t);
446 INHERIT (to_kill, t);
447 INHERIT (to_load, t);
448 INHERIT (to_lookup_symbol, t);
136d6dae 449 /* Do no inherit to_create_inferior. */
7998dfc3
AC		 450 INHERIT (to_post_startup_inferior, t);
451 INHERIT (to_acknowledge_created_inferior, t);
452 INHERIT (to_insert_fork_catchpoint, t);
453 INHERIT (to_remove_fork_catchpoint, t);
454 INHERIT (to_insert_vfork_catchpoint, t);
455 INHERIT (to_remove_vfork_catchpoint, t);
ee057212 456 /* Do not inherit to_follow_fork. */
7998dfc3
AC		 457 INHERIT (to_insert_exec_catchpoint, t);
458 INHERIT (to_remove_exec_catchpoint, t);
7998dfc3 459 INHERIT (to_has_exited, t);
136d6dae 460 /* Do no inherit to_mourn_inferiour. */
7998dfc3
AC		 461 INHERIT (to_can_run, t);
462 INHERIT (to_notice_signals, t);
463 INHERIT (to_thread_alive, t);
464 INHERIT (to_find_new_threads, t);
465 INHERIT (to_pid_to_str, t);
466 INHERIT (to_extra_thread_info, t);
467 INHERIT (to_stop, t);
4b8a223f 468 /* Do not inherit to_xfer_partial. */
7998dfc3 469 INHERIT (to_rcmd, t);
7998dfc3 470 INHERIT (to_pid_to_exec_file, t);
49d03eab 471 INHERIT (to_log_command, t);
7998dfc3
AC		 472 INHERIT (to_stratum, t);
473 INHERIT (to_has_all_memory, t);
474 INHERIT (to_has_memory, t);
475 INHERIT (to_has_stack, t);
476 INHERIT (to_has_registers, t);
477 INHERIT (to_has_execution, t);
478 INHERIT (to_has_thread_control, t);
479 INHERIT (to_sections, t);
480 INHERIT (to_sections_end, t);
481 INHERIT (to_can_async_p, t);
482 INHERIT (to_is_async_p, t);
483 INHERIT (to_async, t);
b84876c2 484 INHERIT (to_async_mask, t);
7998dfc3
AC		 485 INHERIT (to_find_memory_regions, t);
486 INHERIT (to_make_corefile_notes, t);
487 INHERIT (to_get_thread_local_address, t);
b2175913 488 INHERIT (to_can_execute_reverse, t);
424163ea 489 /* Do not inherit to_read_description. */
0ef643c8 490 INHERIT (to_get_ada_task_ptid, t);
08388c79 491 /* Do not inherit to_search_memory. */
8a305172 492 INHERIT (to_supports_multi_process, t);
7998dfc3 493 INHERIT (to_magic, t);
fd79ecee 494 /* Do not inherit to_memory_map. */
a76d924d
DJ		 495 /* Do not inherit to_flash_erase. */
496 /* Do not inherit to_flash_done. */
7998dfc3
AC		 497 }
498#undef INHERIT
499
500 /* Clean up a target struct so it no longer has any zero pointers in
0088c768
AC		 501 it. Some entries are defaulted to a method that print an error,
502 others are hard-wired to a standard recursive default. */
c906108c
SS		 503
504#define de_fault(field, value) \
7998dfc3
AC		 505 if (!current_target.field) \
506 current_target.field = value
0d06e24b 507
2bc416ba
DJ		 508 de_fault (to_open,
509 (void (*) (char *, int))
0d06e24b 510 tcomplain);
2bc416ba
DJ		 511 de_fault (to_close,
512 (void (*) (int))
0d06e24b 513 target_ignore);
2bc416ba
DJ		 514 de_fault (to_post_attach,
515 (void (*) (int))
0d06e24b 516 target_ignore);
2bc416ba
DJ		 517 de_fault (to_resume,
518 (void (*) (ptid_t, int, enum target_signal))
0d06e24b 519 noprocess);
2bc416ba
DJ		 520 de_fault (to_wait,
521 (ptid_t (*) (ptid_t, struct target_waitstatus *))
0d06e24b 522 noprocess);
2bc416ba 523 de_fault (to_fetch_registers,
56be3814 524 (void (*) (struct regcache *, int))
0d06e24b 525 target_ignore);
2bc416ba 526 de_fault (to_store_registers,
56be3814 527 (void (*) (struct regcache *, int))
0d06e24b 528 noprocess);
2bc416ba 529 de_fault (to_prepare_to_store,
316f2060 530 (void (*) (struct regcache *))
0d06e24b 531 noprocess);
2bc416ba
DJ		 532 de_fault (deprecated_xfer_memory,
533 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
0d06e24b 534 nomemory);
2bc416ba
DJ		 535 de_fault (to_files_info,
536 (void (*) (struct target_ops *))
0d06e24b 537 target_ignore);
2bc416ba 538 de_fault (to_insert_breakpoint,
0d06e24b 539 memory_insert_breakpoint);
2bc416ba 540 de_fault (to_remove_breakpoint,
0d06e24b 541 memory_remove_breakpoint);
ccaa32c7
GS		 542 de_fault (to_can_use_hw_breakpoint,
543 (int (*) (int, int, int))
544 return_zero);
545 de_fault (to_insert_hw_breakpoint,
8181d85f 546 (int (*) (struct bp_target_info *))
ccaa32c7
GS		 547 return_minus_one);
548 de_fault (to_remove_hw_breakpoint,
8181d85f 549 (int (*) (struct bp_target_info *))
ccaa32c7
GS		 550 return_minus_one);
551 de_fault (to_insert_watchpoint,
552 (int (*) (CORE_ADDR, int, int))
553 return_minus_one);
554 de_fault (to_remove_watchpoint,
555 (int (*) (CORE_ADDR, int, int))
556 return_minus_one);
557 de_fault (to_stopped_by_watchpoint,
558 (int (*) (void))
559 return_zero);
560 de_fault (to_stopped_data_address,
4aa7a7f5 561 (int (*) (struct target_ops *, CORE_ADDR *))
ccaa32c7 562 return_zero);
5009afc5
AS		 563 de_fault (to_watchpoint_addr_within_range,
564 default_watchpoint_addr_within_range);
e0d24f8d
WZ		 565 de_fault (to_region_ok_for_hw_watchpoint,
566 default_region_ok_for_hw_watchpoint);
2bc416ba
DJ		 567 de_fault (to_terminal_init,
568 (void (*) (void))
0d06e24b 569 target_ignore);
2bc416ba
DJ		 570 de_fault (to_terminal_inferior,
571 (void (*) (void))
0d06e24b 572 target_ignore);
2bc416ba
DJ		 573 de_fault (to_terminal_ours_for_output,
574 (void (*) (void))
0d06e24b 575 target_ignore);
2bc416ba
DJ		 576 de_fault (to_terminal_ours,
577 (void (*) (void))
0d06e24b 578 target_ignore);
2bc416ba
DJ		 579 de_fault (to_terminal_save_ours,
580 (void (*) (void))
a790ad35 581 target_ignore);
2bc416ba 582 de_fault (to_terminal_info,
0d06e24b 583 default_terminal_info);
2bc416ba
DJ		 584 de_fault (to_kill,
585 (void (*) (void))
0d06e24b 586 noprocess);
2bc416ba
DJ		 587 de_fault (to_load,
588 (void (*) (char *, int))
0d06e24b 589 tcomplain);
2bc416ba
DJ		 590 de_fault (to_lookup_symbol,
591 (int (*) (char *, CORE_ADDR *))
0d06e24b 592 nosymbol);
2bc416ba
DJ		 593 de_fault (to_post_startup_inferior,
594 (void (*) (ptid_t))
0d06e24b 595 target_ignore);
2bc416ba
DJ		 596 de_fault (to_acknowledge_created_inferior,
597 (void (*) (int))
0d06e24b 598 target_ignore);
2bc416ba
DJ		 599 de_fault (to_insert_fork_catchpoint,
600 (void (*) (int))
0d06e24b 601 tcomplain);
2bc416ba
DJ		 602 de_fault (to_remove_fork_catchpoint,
603 (int (*) (int))
0d06e24b 604 tcomplain);
2bc416ba
DJ		 605 de_fault (to_insert_vfork_catchpoint,
606 (void (*) (int))
0d06e24b 607 tcomplain);
2bc416ba
DJ		 608 de_fault (to_remove_vfork_catchpoint,
609 (int (*) (int))
0d06e24b 610 tcomplain);
2bc416ba
DJ		 611 de_fault (to_insert_exec_catchpoint,
612 (void (*) (int))
0d06e24b 613 tcomplain);
2bc416ba
DJ		 614 de_fault (to_remove_exec_catchpoint,
615 (int (*) (int))
0d06e24b 616 tcomplain);
2bc416ba
DJ		 617 de_fault (to_has_exited,
618 (int (*) (int, int, int *))
0d06e24b 619 return_zero);
2bc416ba 620 de_fault (to_can_run,
0d06e24b 621 return_zero);
2bc416ba
DJ		 622 de_fault (to_notice_signals,
623 (void (*) (ptid_t))
0d06e24b 624 target_ignore);
2bc416ba
DJ		 625 de_fault (to_thread_alive,
626 (int (*) (ptid_t))
0d06e24b 627 return_zero);
2bc416ba
DJ		 628 de_fault (to_find_new_threads,
629 (void (*) (void))
0d06e24b 630 target_ignore);
2bc416ba
DJ		 631 de_fault (to_extra_thread_info,
632 (char *(*) (struct thread_info *))
0d06e24b 633 return_zero);
2bc416ba 634 de_fault (to_stop,
94cc34af 635 (void (*) (ptid_t))
0d06e24b 636 target_ignore);
cf7a04e8 637 current_target.to_xfer_partial = current_xfer_partial;
2bc416ba
DJ		 638 de_fault (to_rcmd,
639 (void (*) (char *, struct ui_file *))
0d06e24b 640 tcomplain);
2bc416ba
DJ		 641 de_fault (to_pid_to_exec_file,
642 (char *(*) (int))
0d06e24b 643 return_zero);
2bc416ba
DJ		 644 de_fault (to_async,
645 (void (*) (void (*) (enum inferior_event_type, void*), void*))
0d06e24b 646 tcomplain);
b84876c2
PA		 647 de_fault (to_async_mask,
648 (int (*) (int))
649 return_one);
424163ea 650 current_target.to_read_description = NULL;
0ef643c8
JB		 651 de_fault (to_get_ada_task_ptid,
652 (ptid_t (*) (long, long))
653 default_get_ada_task_ptid);
8a305172
PA		 654 de_fault (to_supports_multi_process,
655 (int (*) (void))
656 return_zero);
c906108c 657#undef de_fault
c906108c 658
7998dfc3
AC		 659 /* Finally, position the target-stack beneath the squashed
660 "current_target". That way code looking for a non-inherited
661 target method can quickly and simply find it. */
662 current_target.beneath = target_stack;
b4b61fdb
DJ		 663
664 if (targetdebug)
665 setup_target_debug ();
c906108c
SS		 666}
667
52bb452f
DJ		 668/* Mark OPS as a running target. This reverses the effect
669 of target_mark_exited. */
670
671void
672target_mark_running (struct target_ops *ops)
673{
674 struct target_ops *t;
675
676 for (t = target_stack; t != NULL; t = t->beneath)
677 if (t == ops)
678 break;
679 if (t == NULL)
680 internal_error (__FILE__, __LINE__,
681 "Attempted to mark unpushed target \"%s\" as running",
682 ops->to_shortname);
683
684 ops->to_has_execution = 1;
685 ops->to_has_all_memory = 1;
686 ops->to_has_memory = 1;
687 ops->to_has_stack = 1;
688 ops->to_has_registers = 1;
689
690 update_current_target ();
691}
692
693/* Mark OPS as a non-running target. This reverses the effect
694 of target_mark_running. */
695
696void
697target_mark_exited (struct target_ops *ops)
698{
699 struct target_ops *t;
700
701 for (t = target_stack; t != NULL; t = t->beneath)
702 if (t == ops)
703 break;
704 if (t == NULL)
705 internal_error (__FILE__, __LINE__,
706 "Attempted to mark unpushed target \"%s\" as running",
707 ops->to_shortname);
708
709 ops->to_has_execution = 0;
710 ops->to_has_all_memory = 0;
711 ops->to_has_memory = 0;
712 ops->to_has_stack = 0;
713 ops->to_has_registers = 0;
714
715 update_current_target ();
716}
717
c906108c
SS		 718/* Push a new target type into the stack of the existing target accessors,
719 possibly superseding some of the existing accessors.
720
721 Result is zero if the pushed target ended up on top of the stack,
722 nonzero if at least one target is on top of it.
723
724 Rather than allow an empty stack, we always have the dummy target at
725 the bottom stratum, so we can call the function vectors without
726 checking them. */
727
728int
fba45db2 729push_target (struct target_ops *t)
c906108c 730{
258b763a 731 struct target_ops **cur;
c906108c
SS		 732
733 /* Check magic number. If wrong, it probably means someone changed
734 the struct definition, but not all the places that initialize one. */
735 if (t->to_magic != OPS_MAGIC)
736 {
c5aa993b
JM		 737 fprintf_unfiltered (gdb_stderr,
738 "Magic number of %s target struct wrong\n",
739 t->to_shortname);
e2e0b3e5 740 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
c906108c
SS		 741 }
742
258b763a
AC		 743 /* Find the proper stratum to install this target in. */
744 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
c906108c 745 {
258b763a 746 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
c906108c
SS		 747 break;
748 }
749
258b763a 750 /* If there's already targets at this stratum, remove them. */
88c231eb 751 /* FIXME: cagney/2003-10-15: I think this should be popping all
258b763a
AC		 752 targets to CUR, and not just those at this stratum level. */
753 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
754 {
755 /* There's already something at this stratum level. Close it,
756 and un-hook it from the stack. */
757 struct target_ops *tmp = (*cur);
758 (*cur) = (*cur)->beneath;
759 tmp->beneath = NULL;
f1c07ab0 760 target_close (tmp, 0);
258b763a 761 }
c906108c
SS		 762
763 /* We have removed all targets in our stratum, now add the new one. */
258b763a
AC		 764 t->beneath = (*cur);
765 (*cur) = t;
c906108c
SS		 766
767 update_current_target ();
768
258b763a
AC		 769 /* Not on top? */
770 return (t != target_stack);
c906108c
SS		 771}
772
2bc416ba 773/* Remove a target_ops vector from the stack, wherever it may be.
c906108c
SS		 774 Return how many times it was removed (0 or 1). */
775
776int
fba45db2 777unpush_target (struct target_ops *t)
c906108c 778{
258b763a
AC		 779 struct target_ops **cur;
780 struct target_ops *tmp;
c906108c 781
c8d104ad
PA		 782 if (t->to_stratum == dummy_stratum)
783 internal_error (__FILE__, __LINE__,
784 "Attempt to unpush the dummy target");
785
c906108c
SS		 786 /* Look for the specified target. Note that we assume that a target
787 can only occur once in the target stack. */
788
258b763a
AC		 789 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
790 {
791 if ((*cur) == t)
792 break;
793 }
c906108c 794
258b763a 795 if ((*cur) == NULL)
c906108c
SS		 796 return 0; /* Didn't find target_ops, quit now */
797
5269965e
AC		 798 /* NOTE: cagney/2003-12-06: In '94 the close call was made
799 unconditional by moving it to before the above check that the
800 target was in the target stack (something about "Change the way
801 pushing and popping of targets work to support target overlays
802 and inheritance"). This doesn't make much sense - only open
803 targets should be closed. */
804 target_close (t, 0);
805
c906108c 806 /* Unchain the target */
258b763a
AC		 807 tmp = (*cur);
808 (*cur) = (*cur)->beneath;
809 tmp->beneath = NULL;
c906108c
SS		 810
811 update_current_target ();
c906108c
SS		 812
813 return 1;
814}
815
816void
fba45db2 817pop_target (void)
c906108c 818{
b52323fa 819 target_close (target_stack, 0); /* Let it clean up */
258b763a 820 if (unpush_target (target_stack) == 1)
c906108c
SS		 821 return;
822
c5aa993b
JM		 823 fprintf_unfiltered (gdb_stderr,
824 "pop_target couldn't find target %s\n",
825 current_target.to_shortname);
e2e0b3e5 826 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
c906108c
SS		 827}
828
aa76d38d 829void
87ab71f0 830pop_all_targets_above (enum strata above_stratum, int quitting)
aa76d38d 831{
87ab71f0 832 while ((int) (current_target.to_stratum) > (int) above_stratum)
aa76d38d 833 {
b52323fa 834 target_close (target_stack, quitting);
aa76d38d
PA		 835 if (!unpush_target (target_stack))
836 {
837 fprintf_unfiltered (gdb_stderr,
838 "pop_all_targets couldn't find target %s\n",
b52323fa 839 target_stack->to_shortname);
aa76d38d
PA		 840 internal_error (__FILE__, __LINE__,
841 _("failed internal consistency check"));
842 break;
843 }
844 }
845}
846
87ab71f0
PA		 847void
848pop_all_targets (int quitting)
849{
850 pop_all_targets_above (dummy_stratum, quitting);
851}
852
72f5cf0e 853/* Using the objfile specified in OBJFILE, find the address for the
9e35dae4
DJ		 854 current thread's thread-local storage with offset OFFSET. */
855CORE_ADDR
856target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
857{
858 volatile CORE_ADDR addr = 0;
859
860 if (target_get_thread_local_address_p ()
1cf3db46 861 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
9e35dae4
DJ		 862 {
863 ptid_t ptid = inferior_ptid;
864 volatile struct gdb_exception ex;
865
866 TRY_CATCH (ex, RETURN_MASK_ALL)
867 {
868 CORE_ADDR lm_addr;
869
870 /* Fetch the load module address for this objfile. */
1cf3db46 871 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
9e35dae4
DJ		 872 objfile);
873 /* If it's 0, throw the appropriate exception. */
874 if (lm_addr == 0)
875 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
876 _("TLS load module not found"));
877
878 addr = target_get_thread_local_address (ptid, lm_addr, offset);
879 }
880 /* If an error occurred, print TLS related messages here. Otherwise,
881 throw the error to some higher catcher. */
882 if (ex.reason < 0)
883 {
884 int objfile_is_library = (objfile->flags & OBJF_SHARED);
885
886 switch (ex.error)
887 {
888 case TLS_NO_LIBRARY_SUPPORT_ERROR:
889 error (_("Cannot find thread-local variables in this thread library."));
890 break;
891 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
892 if (objfile_is_library)
893 error (_("Cannot find shared library `%s' in dynamic"
894 " linker's load module list"), objfile->name);
895 else
896 error (_("Cannot find executable file `%s' in dynamic"
897 " linker's load module list"), objfile->name);
898 break;
899 case TLS_NOT_ALLOCATED_YET_ERROR:
900 if (objfile_is_library)
901 error (_("The inferior has not yet allocated storage for"
902 " thread-local variables in\n"
903 "the shared library `%s'\n"
904 "for %s"),
905 objfile->name, target_pid_to_str (ptid));
906 else
907 error (_("The inferior has not yet allocated storage for"
908 " thread-local variables in\n"
909 "the executable `%s'\n"
910 "for %s"),
911 objfile->name, target_pid_to_str (ptid));
912 break;
913 case TLS_GENERIC_ERROR:
914 if (objfile_is_library)
915 error (_("Cannot find thread-local storage for %s, "
916 "shared library %s:\n%s"),
917 target_pid_to_str (ptid),
918 objfile->name, ex.message);
919 else
920 error (_("Cannot find thread-local storage for %s, "
921 "executable file %s:\n%s"),
922 target_pid_to_str (ptid),
923 objfile->name, ex.message);
924 break;
925 default:
926 throw_exception (ex);
927 break;
928 }
929 }
930 }
931 /* It wouldn't be wrong here to try a gdbarch method, too; finding
932 TLS is an ABI-specific thing. But we don't do that yet. */
933 else
934 error (_("Cannot find thread-local variables on this target"));
935
936 return addr;
937}
938
c906108c
SS		 939#undef MIN
940#define MIN(A, B) (((A) <= (B)) ? (A) : (B))
941
942/* target_read_string -- read a null terminated string, up to LEN bytes,
943 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
944 Set *STRING to a pointer to malloc'd memory containing the data; the caller
945 is responsible for freeing it. Return the number of bytes successfully
946 read. */
947
948int
fba45db2 949target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
c906108c
SS		 950{
951 int tlen, origlen, offset, i;
1b0ba102 952 gdb_byte buf[4];
c906108c
SS		 953 int errcode = 0;
954 char *buffer;
955 int buffer_allocated;
956 char *bufptr;
957 unsigned int nbytes_read = 0;
958
6217bf3e
MS		 959 gdb_assert (string);
960
c906108c
SS		 961 /* Small for testing. */
962 buffer_allocated = 4;
963 buffer = xmalloc (buffer_allocated);
964 bufptr = buffer;
965
966 origlen = len;
967
968 while (len > 0)
969 {
970 tlen = MIN (len, 4 - (memaddr & 3));
971 offset = memaddr & 3;
972
1b0ba102 973 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
c906108c
SS		 974 if (errcode != 0)
975 {
976 /* The transfer request might have crossed the boundary to an
977 unallocated region of memory. Retry the transfer, requesting
978 a single byte. */
979 tlen = 1;
980 offset = 0;
b8eb5af0 981 errcode = target_read_memory (memaddr, buf, 1);
c906108c
SS		 982 if (errcode != 0)
983 goto done;
984 }
985
986 if (bufptr - buffer + tlen > buffer_allocated)
987 {
988 unsigned int bytes;
989 bytes = bufptr - buffer;
990 buffer_allocated *= 2;
991 buffer = xrealloc (buffer, buffer_allocated);
992 bufptr = buffer + bytes;
993 }
994
995 for (i = 0; i < tlen; i++)
996 {
997 *bufptr++ = buf[i + offset];
998 if (buf[i + offset] == '\000')
999 {
1000 nbytes_read += i + 1;
1001 goto done;
1002 }
1003 }
1004
1005 memaddr += tlen;
1006 len -= tlen;
1007 nbytes_read += tlen;
1008 }
c5aa993b 1009done:
6217bf3e 1010 *string = buffer;
c906108c
SS		 1011 if (errnop != NULL)
1012 *errnop = errcode;
c906108c
SS		 1013 return nbytes_read;
1014}
1015
8db32d44
AC		 1016/* Find a section containing ADDR. */
1017struct section_table *
1018target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1019{
1020 struct section_table *secp;
1021 for (secp = target->to_sections;
1022 secp < target->to_sections_end;
1023 secp++)
1024 {
1025 if (addr >= secp->addr && addr < secp->endaddr)
1026 return secp;
1027 }
1028 return NULL;
1029}
1030
cf7a04e8
DJ		 1031/* Perform a partial memory transfer. The arguments and return
1032 value are just as for target_xfer_partial. */
1033
1034static LONGEST
1035memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
1036 ULONGEST memaddr, LONGEST len)
0779438d 1037{
cf7a04e8
DJ		 1038 LONGEST res;
1039 int reg_len;
1040 struct mem_region *region;
1041
1042 /* Zero length requests are ok and require no work. */
1043 if (len == 0)
1044 return 0;
1045
1046 /* Try the executable file, if "trust-readonly-sections" is set. */
1047 if (readbuf != NULL && trust_readonly)
1048 {
1049 struct section_table *secp;
1050
1051 secp = target_section_by_addr (ops, memaddr);
1052 if (secp != NULL
1053 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1054 & SEC_READONLY))
1055 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1056 }
1057
98646950
UW		 1058 /* Likewise for accesses to unmapped overlay sections. */
1059 if (readbuf != NULL && overlay_debugging)
1060 {
714835d5 1061 struct obj_section *section = find_pc_overlay (memaddr);
98646950
UW		 1062 if (pc_in_unmapped_range (memaddr, section))
1063 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1064 }
1065
cf7a04e8
DJ		 1066 /* Try GDB's internal data cache. */
1067 region = lookup_mem_region (memaddr);
4b5752d0
VP		 1068 /* region->hi == 0 means there's no upper bound. */
1069 if (memaddr + len < region->hi || region->hi == 0)
cf7a04e8
DJ		 1070 reg_len = len;
1071 else
1072 reg_len = region->hi - memaddr;
1073
1074 switch (region->attrib.mode)
1075 {
1076 case MEM_RO:
1077 if (writebuf != NULL)
1078 return -1;
1079 break;
1080
1081 case MEM_WO:
1082 if (readbuf != NULL)
1083 return -1;
1084 break;
a76d924d
DJ		 1085
1086 case MEM_FLASH:
1087 /* We only support writing to flash during "load" for now. */
1088 if (writebuf != NULL)
1089 error (_("Writing to flash memory forbidden in this context"));
1090 break;
4b5752d0
VP		 1091
1092 case MEM_NONE:
1093 return -1;
cf7a04e8
DJ		 1094 }
1095
1096 if (region->attrib.cache)
1097 {
1098 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1099 memory request will start back at current_target. */
1100 if (readbuf != NULL)
1101 res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
1102 reg_len, 0);
1103 else
1104 /* FIXME drow/2006-08-09: If we're going to preserve const
1105 correctness dcache_xfer_memory should take readbuf and
1106 writebuf. */
1107 res = dcache_xfer_memory (target_dcache, memaddr,
1108 (void *) writebuf,
1109 reg_len, 1);
1110 if (res <= 0)
1111 return -1;
1112 else
8defab1a
DJ		 1113 {
1114 if (readbuf && !show_memory_breakpoints)
1115 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1116 return res;
1117 }
cf7a04e8
DJ		 1118 }
1119
1120 /* If none of those methods found the memory we wanted, fall back
1121 to a target partial transfer. Normally a single call to
1122 to_xfer_partial is enough; if it doesn't recognize an object
1123 it will call the to_xfer_partial of the next target down.
1124 But for memory this won't do. Memory is the only target
1125 object which can be read from more than one valid target.
1126 A core file, for instance, could have some of memory but
1127 delegate other bits to the target below it. So, we must
1128 manually try all targets. */
1129
1130 do
1131 {
1132 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
4b5752d0 1133 readbuf, writebuf, memaddr, reg_len);
cf7a04e8 1134 if (res > 0)
8defab1a 1135 break;
cf7a04e8 1136
5ad3a4ca
DJ		 1137 /* We want to continue past core files to executables, but not
1138 past a running target's memory. */
1139 if (ops->to_has_all_memory)
8defab1a 1140 break;
5ad3a4ca 1141
cf7a04e8
DJ		 1142 ops = ops->beneath;
1143 }
1144 while (ops != NULL);
1145
8defab1a
DJ		 1146 if (readbuf && !show_memory_breakpoints)
1147 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1148
cf7a04e8
DJ		 1149 /* If we still haven't got anything, return the last error. We
1150 give up. */
1151 return res;
0779438d
AC		 1152}
1153
8defab1a
DJ		 1154static void
1155restore_show_memory_breakpoints (void *arg)
1156{
1157 show_memory_breakpoints = (uintptr_t) arg;
1158}
1159
1160struct cleanup *
1161make_show_memory_breakpoints_cleanup (int show)
1162{
1163 int current = show_memory_breakpoints;
1164 show_memory_breakpoints = show;
1165
1166 return make_cleanup (restore_show_memory_breakpoints,
1167 (void *) (uintptr_t) current);
1168}
1169
27394598
AC		 1170static LONGEST
1171target_xfer_partial (struct target_ops *ops,
1172 enum target_object object, const char *annex,
1173 void *readbuf, const void *writebuf,
1174 ULONGEST offset, LONGEST len)
1175{
1176 LONGEST retval;
1177
1178 gdb_assert (ops->to_xfer_partial != NULL);
cf7a04e8
DJ		 1179
1180 /* If this is a memory transfer, let the memory-specific code
1181 have a look at it instead. Memory transfers are more
1182 complicated. */
1183 if (object == TARGET_OBJECT_MEMORY)
1184 retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
1185 else
1186 {
1187 enum target_object raw_object = object;
1188
1189 /* If this is a raw memory transfer, request the normal
1190 memory object from other layers. */
1191 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1192 raw_object = TARGET_OBJECT_MEMORY;
1193
1194 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1195 writebuf, offset, len);
1196 }
1197
27394598
AC		 1198 if (targetdebug)
1199 {
1200 const unsigned char *myaddr = NULL;
1201
1202 fprintf_unfiltered (gdb_stdlog,
53b71562 1203 "%s:target_xfer_partial (%d, %s, %s, %s, %s, %s) = %s",
27394598
AC		 1204 ops->to_shortname,
1205 (int) object,
1206 (annex ? annex : "(null)"),
53b71562
JB		 1207 host_address_to_string (readbuf),
1208 host_address_to_string (writebuf),
0b1553bc
UW		 1209 core_addr_to_string_nz (offset),
1210 plongest (len), plongest (retval));
27394598
AC		 1211
1212 if (readbuf)
1213 myaddr = readbuf;
1214 if (writebuf)
1215 myaddr = writebuf;
1216 if (retval > 0 && myaddr != NULL)
1217 {
1218 int i;
2bc416ba 1219
27394598
AC		 1220 fputs_unfiltered (", bytes =", gdb_stdlog);
1221 for (i = 0; i < retval; i++)
1222 {
53b71562 1223 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
27394598
AC		 1224 {
1225 if (targetdebug < 2 && i > 0)
1226 {
1227 fprintf_unfiltered (gdb_stdlog, " ...");
1228 break;
1229 }
1230 fprintf_unfiltered (gdb_stdlog, "\n");
1231 }
2bc416ba 1232
27394598
AC		 1233 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1234 }
1235 }
2bc416ba 1236
27394598
AC		 1237 fputc_unfiltered ('\n', gdb_stdlog);
1238 }
1239 return retval;
1240}
1241
c906108c
SS		 1242/* Read LEN bytes of target memory at address MEMADDR, placing the results in
1243 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1244 if any error occurs.
1245
1246 If an error occurs, no guarantee is made about the contents of the data at
1247 MYADDR. In particular, the caller should not depend upon partial reads
1248 filling the buffer with good data. There is no way for the caller to know
1249 how much good data might have been transfered anyway. Callers that can
cf7a04e8
DJ		 1250 deal with partial reads should call target_read (which will retry until
1251 it makes no progress, and then return how much was transferred). */
c906108c
SS		 1252
1253int
fc1a4b47 1254target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
c906108c 1255{
cf7a04e8
DJ		 1256 if (target_read (&current_target, TARGET_OBJECT_MEMORY, NULL,
1257 myaddr, memaddr, len) == len)
1258 return 0;
0779438d 1259 else
cf7a04e8 1260 return EIO;
c906108c
SS		 1261}
1262
c906108c 1263int
fc1a4b47 1264target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
c906108c 1265{
cf7a04e8
DJ		 1266 if (target_write (&current_target, TARGET_OBJECT_MEMORY, NULL,
1267 myaddr, memaddr, len) == len)
1268 return 0;
0779438d 1269 else
cf7a04e8 1270 return EIO;
c906108c 1271}
c5aa993b 1272
fd79ecee
DJ		 1273/* Fetch the target's memory map. */
1274
1275VEC(mem_region_s) *
1276target_memory_map (void)
1277{
1278 VEC(mem_region_s) *result;
1279 struct mem_region *last_one, *this_one;
1280 int ix;
1281 struct target_ops *t;
1282
1283 if (targetdebug)
1284 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1285
1286 for (t = current_target.beneath; t != NULL; t = t->beneath)
1287 if (t->to_memory_map != NULL)
1288 break;
1289
1290 if (t == NULL)
1291 return NULL;
1292
1293 result = t->to_memory_map (t);
1294 if (result == NULL)
1295 return NULL;
1296
1297 qsort (VEC_address (mem_region_s, result),
1298 VEC_length (mem_region_s, result),
1299 sizeof (struct mem_region), mem_region_cmp);
1300
1301 /* Check that regions do not overlap. Simultaneously assign
1302 a numbering for the "mem" commands to use to refer to
1303 each region. */
1304 last_one = NULL;
1305 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1306 {
1307 this_one->number = ix;
1308
1309 if (last_one && last_one->hi > this_one->lo)
1310 {
1311 warning (_("Overlapping regions in memory map: ignoring"));
1312 VEC_free (mem_region_s, result);
1313 return NULL;
1314 }
1315 last_one = this_one;
1316 }
1317
1318 return result;
1319}
1320
a76d924d
DJ		 1321void
1322target_flash_erase (ULONGEST address, LONGEST length)
1323{
1324 struct target_ops *t;
1325
1326 for (t = current_target.beneath; t != NULL; t = t->beneath)
1327 if (t->to_flash_erase != NULL)
1328 {
1329 if (targetdebug)
1330 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1331 paddr (address), phex (length, 0));
8944021f
DJ		 1332 t->to_flash_erase (t, address, length);
1333 return;
a76d924d
DJ		 1334 }
1335
1336 tcomplain ();
1337}
1338
1339void
1340target_flash_done (void)
1341{
1342 struct target_ops *t;
1343
1344 for (t = current_target.beneath; t != NULL; t = t->beneath)
1345 if (t->to_flash_done != NULL)
1346 {
1347 if (targetdebug)
1348 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
8944021f
DJ		 1349 t->to_flash_done (t);
1350 return;
a76d924d
DJ		 1351 }
1352
1353 tcomplain ();
1354}
1355
4aa7a7f5
JJ		 1356#ifndef target_stopped_data_address_p
1357int
1358target_stopped_data_address_p (struct target_ops *target)
1359{
aa869812
AC		 1360 if (target->to_stopped_data_address
1361 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
4aa7a7f5 1362 return 0;
aa869812
AC		 1363 if (target->to_stopped_data_address == debug_to_stopped_data_address
1364 && (debug_target.to_stopped_data_address
1365 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1366 return 0;
1367 return 1;
4aa7a7f5
JJ		 1368}
1369#endif
1370
920d2a44
AC		 1371static void
1372show_trust_readonly (struct ui_file *file, int from_tty,
1373 struct cmd_list_element *c, const char *value)
1374{
1375 fprintf_filtered (file, _("\
1376Mode for reading from readonly sections is %s.\n"),
1377 value);
1378}
3a11626d 1379
1e3ff5ad
AC		 1380/* More generic transfers. */
1381
0088c768 1382static LONGEST
8aa91c1e 1383default_xfer_partial (struct target_ops *ops, enum target_object object,
2bc416ba 1384 const char *annex, gdb_byte *readbuf,
1b0ba102 1385 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
0088c768
AC		 1386{
1387 if (object == TARGET_OBJECT_MEMORY
c8e73a31
AC		 1388 && ops->deprecated_xfer_memory != NULL)
1389 /* If available, fall back to the target's
1390 "deprecated_xfer_memory" method. */
0088c768 1391 {
4b8a223f 1392 int xfered = -1;
0088c768 1393 errno = 0;
4b8a223f
AC		 1394 if (writebuf != NULL)
1395 {
1396 void *buffer = xmalloc (len);
1397 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1398 memcpy (buffer, writebuf, len);
c8e73a31
AC		 1399 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1400 1/*write*/, NULL, ops);
4b8a223f
AC		 1401 do_cleanups (cleanup);
1402 }
1403 if (readbuf != NULL)
244e85c8
MS		 1404 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1405 0/*read*/, NULL, ops);
0088c768
AC		 1406 if (xfered > 0)
1407 return xfered;
1408 else if (xfered == 0 && errno == 0)
c8e73a31
AC		 1409 /* "deprecated_xfer_memory" uses 0, cross checked against
1410 ERRNO as one indication of an error. */
0088c768
AC		 1411 return 0;
1412 else
1413 return -1;
1414 }
1415 else if (ops->beneath != NULL)
cf7a04e8
DJ		 1416 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1417 readbuf, writebuf, offset, len);
1418 else
1419 return -1;
1420}
1421
1422/* The xfer_partial handler for the topmost target. Unlike the default,
1423 it does not need to handle memory specially; it just passes all
1424 requests down the stack. */
1425
1426static LONGEST
1427current_xfer_partial (struct target_ops *ops, enum target_object object,
1428 const char *annex, gdb_byte *readbuf,
1429 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1430{
1431 if (ops->beneath != NULL)
1432 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1433 readbuf, writebuf, offset, len);
0088c768
AC		 1434 else
1435 return -1;
1436}
1437
1438/* Target vector read/write partial wrapper functions.
1439
1440 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1441 (inbuf, outbuf)", instead of separate read/write methods, make life
1442 easier. */
1443
13547ab6 1444static LONGEST
1e3ff5ad
AC		 1445target_read_partial (struct target_ops *ops,
1446 enum target_object object,
1b0ba102 1447 const char *annex, gdb_byte *buf,
1e3ff5ad
AC		 1448 ULONGEST offset, LONGEST len)
1449{
27394598 1450 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1e3ff5ad
AC		 1451}
1452
13547ab6 1453static LONGEST
1e3ff5ad
AC		 1454target_write_partial (struct target_ops *ops,
1455 enum target_object object,
1b0ba102 1456 const char *annex, const gdb_byte *buf,
1e3ff5ad
AC		 1457 ULONGEST offset, LONGEST len)
1458{
27394598 1459 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1e3ff5ad
AC		 1460}
1461
1462/* Wrappers to perform the full transfer. */
1463LONGEST
1464target_read (struct target_ops *ops,
1465 enum target_object object,
1b0ba102 1466 const char *annex, gdb_byte *buf,
1e3ff5ad
AC		 1467 ULONGEST offset, LONGEST len)
1468{
1469 LONGEST xfered = 0;
1470 while (xfered < len)
1471 {
0088c768 1472 LONGEST xfer = target_read_partial (ops, object, annex,
fc1a4b47 1473 (gdb_byte *) buf + xfered,
0088c768 1474 offset + xfered, len - xfered);
1e3ff5ad 1475 /* Call an observer, notifying them of the xfer progress? */
13547ab6
DJ		 1476 if (xfer == 0)
1477 return xfered;
1478 if (xfer < 0)
0088c768 1479 return -1;
1e3ff5ad
AC		 1480 xfered += xfer;
1481 QUIT;
1482 }
1483 return len;
1484}
1485
d5086790
VP		 1486LONGEST
1487target_read_until_error (struct target_ops *ops,
1488 enum target_object object,
1489 const char *annex, gdb_byte *buf,
1490 ULONGEST offset, LONGEST len)
1491{
1492 LONGEST xfered = 0;
1493 while (xfered < len)
1494 {
1495 LONGEST xfer = target_read_partial (ops, object, annex,
1496 (gdb_byte *) buf + xfered,
1497 offset + xfered, len - xfered);
1498 /* Call an observer, notifying them of the xfer progress? */
1499 if (xfer == 0)
1500 return xfered;
1501 if (xfer < 0)
1502 {
1503 /* We've got an error. Try to read in smaller blocks. */
1504 ULONGEST start = offset + xfered;
1505 ULONGEST remaining = len - xfered;
1506 ULONGEST half;
1507
1508 /* If an attempt was made to read a random memory address,
1509 it's likely that the very first byte is not accessible.
1510 Try reading the first byte, to avoid doing log N tries
1511 below. */
1512 xfer = target_read_partial (ops, object, annex,
1513 (gdb_byte *) buf + xfered, start, 1);
1514 if (xfer <= 0)
1515 return xfered;
1516 start += 1;
1517 remaining -= 1;
1518 half = remaining/2;
1519
1520 while (half > 0)
1521 {
1522 xfer = target_read_partial (ops, object, annex,
1523 (gdb_byte *) buf + xfered,
1524 start, half);
1525 if (xfer == 0)
1526 return xfered;
1527 if (xfer < 0)
1528 {
1529 remaining = half;
1530 }
1531 else
1532 {
1533 /* We have successfully read the first half. So, the
1534 error must be in the second half. Adjust start and
1535 remaining to point at the second half. */
1536 xfered += xfer;
1537 start += xfer;
1538 remaining -= xfer;
1539 }
1540 half = remaining/2;
1541 }
1542
1543 return xfered;
1544 }
1545 xfered += xfer;
1546 QUIT;
1547 }
1548 return len;
1549}
1550
1551
cf7a04e8
DJ		 1552/* An alternative to target_write with progress callbacks. */
1553
1e3ff5ad 1554LONGEST
cf7a04e8
DJ		 1555target_write_with_progress (struct target_ops *ops,
1556 enum target_object object,
1557 const char *annex, const gdb_byte *buf,
1558 ULONGEST offset, LONGEST len,
1559 void (*progress) (ULONGEST, void *), void *baton)
1e3ff5ad
AC		 1560{
1561 LONGEST xfered = 0;
a76d924d
DJ		 1562
1563 /* Give the progress callback a chance to set up. */
1564 if (progress)
1565 (*progress) (0, baton);
1566
1e3ff5ad
AC		 1567 while (xfered < len)
1568 {
1569 LONGEST xfer = target_write_partial (ops, object, annex,
fc1a4b47 1570 (gdb_byte *) buf + xfered,
1e3ff5ad 1571 offset + xfered, len - xfered);
cf7a04e8 1572
13547ab6
DJ		 1573 if (xfer == 0)
1574 return xfered;
1575 if (xfer < 0)
0088c768 1576 return -1;
cf7a04e8
DJ		 1577
1578 if (progress)
1579 (*progress) (xfer, baton);
1580
1e3ff5ad
AC		 1581 xfered += xfer;
1582 QUIT;
1583 }
1584 return len;
1585}
1586
cf7a04e8
DJ		 1587LONGEST
1588target_write (struct target_ops *ops,
1589 enum target_object object,
1590 const char *annex, const gdb_byte *buf,
1591 ULONGEST offset, LONGEST len)
1592{
1593 return target_write_with_progress (ops, object, annex, buf, offset, len,
1594 NULL, NULL);
1595}
1596
159f81f3
DJ		 1597/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1598 the size of the transferred data. PADDING additional bytes are
1599 available in *BUF_P. This is a helper function for
1600 target_read_alloc; see the declaration of that function for more
1601 information. */
13547ab6 1602
159f81f3
DJ		 1603static LONGEST
1604target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1605 const char *annex, gdb_byte **buf_p, int padding)
13547ab6
DJ		 1606{
1607 size_t buf_alloc, buf_pos;
1608 gdb_byte *buf;
1609 LONGEST n;
1610
1611 /* This function does not have a length parameter; it reads the
1612 entire OBJECT). Also, it doesn't support objects fetched partly
1613 from one target and partly from another (in a different stratum,
1614 e.g. a core file and an executable). Both reasons make it
1615 unsuitable for reading memory. */
1616 gdb_assert (object != TARGET_OBJECT_MEMORY);
1617
1618 /* Start by reading up to 4K at a time. The target will throttle
1619 this number down if necessary. */
1620 buf_alloc = 4096;
1621 buf = xmalloc (buf_alloc);
1622 buf_pos = 0;
1623 while (1)
1624 {
1625 n = target_read_partial (ops, object, annex, &buf[buf_pos],
159f81f3 1626 buf_pos, buf_alloc - buf_pos - padding);
13547ab6
DJ		 1627 if (n < 0)
1628 {
1629 /* An error occurred. */
1630 xfree (buf);
1631 return -1;
1632 }
1633 else if (n == 0)
1634 {
1635 /* Read all there was. */
1636 if (buf_pos == 0)
1637 xfree (buf);
1638 else
1639 *buf_p = buf;
1640 return buf_pos;
1641 }
1642
1643 buf_pos += n;
1644
1645 /* If the buffer is filling up, expand it. */
1646 if (buf_alloc < buf_pos * 2)
1647 {
1648 buf_alloc *= 2;
1649 buf = xrealloc (buf, buf_alloc);
1650 }
1651
1652 QUIT;
1653 }
1654}
1655
159f81f3
DJ		 1656/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1657 the size of the transferred data. See the declaration in "target.h"
1658 function for more information about the return value. */
1659
1660LONGEST
1661target_read_alloc (struct target_ops *ops, enum target_object object,
1662 const char *annex, gdb_byte **buf_p)
1663{
1664 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1665}
1666
1667/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1668 returned as a string, allocated using xmalloc. If an error occurs
1669 or the transfer is unsupported, NULL is returned. Empty objects
1670 are returned as allocated but empty strings. A warning is issued
1671 if the result contains any embedded NUL bytes. */
1672
1673char *
1674target_read_stralloc (struct target_ops *ops, enum target_object object,
1675 const char *annex)
1676{
1677 gdb_byte *buffer;
1678 LONGEST transferred;
1679
1680 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1681
1682 if (transferred < 0)
1683 return NULL;
1684
1685 if (transferred == 0)
1686 return xstrdup ("");
1687
1688 buffer[transferred] = 0;
1689 if (strlen (buffer) < transferred)
1690 warning (_("target object %d, annex %s, "
1691 "contained unexpected null characters"),
1692 (int) object, annex ? annex : "(none)");
1693
1694 return (char *) buffer;
1695}
1696
b6591e8b
AC		 1697/* Memory transfer methods. */
1698
1699void
1b0ba102 1700get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
b6591e8b
AC		 1701 LONGEST len)
1702{
1703 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1704 != len)
1705 memory_error (EIO, addr);
1706}
1707
1708ULONGEST
1709get_target_memory_unsigned (struct target_ops *ops,
1710 CORE_ADDR addr, int len)
1711{
f6519ebc 1712 gdb_byte buf[sizeof (ULONGEST)];
b6591e8b
AC		 1713
1714 gdb_assert (len <= sizeof (buf));
1715 get_target_memory (ops, addr, buf, len);
1716 return extract_unsigned_integer (buf, len);
1717}
1718
c906108c 1719static void
fba45db2 1720target_info (char *args, int from_tty)
c906108c
SS		 1721{
1722 struct target_ops *t;
c906108c 1723 int has_all_mem = 0;
c5aa993b 1724
c906108c 1725 if (symfile_objfile != NULL)
a3f17187 1726 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
c906108c 1727
258b763a 1728 for (t = target_stack; t != NULL; t = t->beneath)
c906108c 1729 {
c906108c
SS		 1730 if (!t->to_has_memory)
1731 continue;
1732
c5aa993b 1733 if ((int) (t->to_stratum) <= (int) dummy_stratum)
c906108c
SS		 1734 continue;
1735 if (has_all_mem)
a3f17187 1736 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
c5aa993b
JM		 1737 printf_unfiltered ("%s:\n", t->to_longname);
1738 (t->to_files_info) (t);
c906108c
SS		 1739 has_all_mem = t->to_has_all_memory;
1740 }
1741}
1742
fd79ecee
DJ		 1743/* This function is called before any new inferior is created, e.g.
1744 by running a program, attaching, or connecting to a target.
1745 It cleans up any state from previous invocations which might
1746 change between runs. This is a subset of what target_preopen
1747 resets (things which might change between targets). */
1748
1749void
1750target_pre_inferior (int from_tty)
1751{
b9db4ced
UW		 1752 /* Clear out solib state. Otherwise the solib state of the previous
1753 inferior might have survived and is entirely wrong for the new
1754 target. This has been observed on GNU/Linux using glibc 2.3. How
1755 to reproduce:
1756
1757 bash$ ./foo&
1758 [1] 4711
1759 bash$ ./foo&
1760 [1] 4712
1761 bash$ gdb ./foo
1762 [...]
1763 (gdb) attach 4711
1764 (gdb) detach
1765 (gdb) attach 4712
1766 Cannot access memory at address 0xdeadbeef
1767 */
b9db4ced 1768
50c71eaf
PA		 1769 /* In some OSs, the shared library list is the same/global/shared
1770 across inferiors. If code is shared between processes, so are
1771 memory regions and features. */
1772 if (!gdbarch_has_global_solist (target_gdbarch))
1773 {
1774 no_shared_libraries (NULL, from_tty);
1775
1776 invalidate_target_mem_regions ();
424163ea 1777
50c71eaf
PA		 1778 target_clear_description ();
1779 }
fd79ecee
DJ		 1780}
1781
c906108c
SS		 1782/* This is to be called by the open routine before it does
1783 anything. */
1784
1785void
fba45db2 1786target_preopen (int from_tty)
c906108c 1787{
c5aa993b 1788 dont_repeat ();
c906108c
SS		 1789
1790 if (target_has_execution)
c5aa993b 1791 {
adf40b2e 1792 if (!from_tty
e2e0b3e5 1793 || query (_("A program is being debugged already. Kill it? ")))
c5aa993b 1794 target_kill ();
c906108c 1795 else
8a3fe4f8 1796 error (_("Program not killed."));
c906108c
SS		 1797 }
1798
1799 /* Calling target_kill may remove the target from the stack. But if
1800 it doesn't (which seems like a win for UDI), remove it now. */
87ab71f0
PA		 1801 /* Leave the exec target, though. The user may be switching from a
1802 live process to a core of the same program. */
1803 pop_all_targets_above (file_stratum, 0);
fd79ecee
DJ		 1804
1805 target_pre_inferior (from_tty);
c906108c
SS		 1806}
1807
1808/* Detach a target after doing deferred register stores. */
1809
1810void
fba45db2 1811target_detach (char *args, int from_tty)
c906108c 1812{
136d6dae
VP		 1813 struct target_ops* t;
1814
50c71eaf
PA		 1815 if (gdbarch_has_global_solist (target_gdbarch))
1816 /* Don't remove global breakpoints here. They're removed on
1817 disconnection from the target. */
1818 ;
1819 else
1820 /* If we're in breakpoints-always-inserted mode, have to remove
1821 them before detaching. */
1822 remove_breakpoints ();
74960c60 1823
136d6dae
VP		 1824 for (t = current_target.beneath; t != NULL; t = t->beneath)
1825 {
1826 if (t->to_detach != NULL)
1827 {
1828 t->to_detach (t, args, from_tty);
1829 return;
1830 }
1831 }
1832
1833 internal_error (__FILE__, __LINE__, "could not find a target to detach");
c906108c
SS		 1834}
1835
6ad8ae5c
DJ		 1836void
1837target_disconnect (char *args, int from_tty)
1838{
597320e7
DJ		 1839 struct target_ops *t;
1840
50c71eaf
PA		 1841 /* If we're in breakpoints-always-inserted mode or if breakpoints
1842 are global across processes, we have to remove them before
1843 disconnecting. */
74960c60
VP		 1844 remove_breakpoints ();
1845
597320e7
DJ		 1846 for (t = current_target.beneath; t != NULL; t = t->beneath)
1847 if (t->to_disconnect != NULL)
1848 {
1849 if (targetdebug)
1850 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1851 args, from_tty);
1852 t->to_disconnect (t, args, from_tty);
1853 return;
1854 }
1855
1856 tcomplain ();
6ad8ae5c
DJ		 1857}
1858
e1ac3328
VP		 1859void
1860target_resume (ptid_t ptid, int step, enum target_signal signal)
1861{
1862 dcache_invalidate (target_dcache);
1863 (*current_target.to_resume) (ptid, step, signal);
8ea051c5 1864 set_executing (ptid, 1);
e1ac3328 1865 set_running (ptid, 1);
e1ac3328 1866}
ee057212
DJ		 1867/* Look through the list of possible targets for a target that can
1868 follow forks. */
1869
1870int
1871target_follow_fork (int follow_child)
1872{
1873 struct target_ops *t;
1874
1875 for (t = current_target.beneath; t != NULL; t = t->beneath)
1876 {
1877 if (t->to_follow_fork != NULL)
1878 {
1879 int retval = t->to_follow_fork (t, follow_child);
1880 if (targetdebug)
1881 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1882 follow_child, retval);
1883 return retval;
1884 }
1885 }
1886
1887 /* Some target returned a fork event, but did not know how to follow it. */
1888 internal_error (__FILE__, __LINE__,
1889 "could not find a target to follow fork");
1890}
1891
136d6dae
VP		 1892void
1893target_mourn_inferior (void)
1894{
1895 struct target_ops *t;
1896 for (t = current_target.beneath; t != NULL; t = t->beneath)
1897 {
1898 if (t->to_mourn_inferior != NULL)
1899 {
1900 t->to_mourn_inferior (t);
1901 return;
1902 }
1903 }
1904
1905 internal_error (__FILE__, __LINE__,
1906 "could not find a target to follow mourn inferiour");
1907}
1908
424163ea
DJ		 1909/* Look for a target which can describe architectural features, starting
1910 from TARGET. If we find one, return its description. */
1911
1912const struct target_desc *
1913target_read_description (struct target_ops *target)
1914{
1915 struct target_ops *t;
1916
1917 for (t = target; t != NULL; t = t->beneath)
1918 if (t->to_read_description != NULL)
1919 {
1920 const struct target_desc *tdesc;
1921
1922 tdesc = t->to_read_description (t);
1923 if (tdesc)
1924 return tdesc;
1925 }
1926
1927 return NULL;
1928}
1929
08388c79
DE		 1930/* The default implementation of to_search_memory.
1931 This implements a basic search of memory, reading target memory and
1932 performing the search here (as opposed to performing the search in on the
1933 target side with, for example, gdbserver). */
1934
1935int
1936simple_search_memory (struct target_ops *ops,
1937 CORE_ADDR start_addr, ULONGEST search_space_len,
1938 const gdb_byte *pattern, ULONGEST pattern_len,
1939 CORE_ADDR *found_addrp)
1940{
1941 /* NOTE: also defined in find.c testcase. */
1942#define SEARCH_CHUNK_SIZE 16000
1943 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1944 /* Buffer to hold memory contents for searching. */
1945 gdb_byte *search_buf;
1946 unsigned search_buf_size;
1947 struct cleanup *old_cleanups;
1948
1949 search_buf_size = chunk_size + pattern_len - 1;
1950
1951 /* No point in trying to allocate a buffer larger than the search space. */
1952 if (search_space_len < search_buf_size)
1953 search_buf_size = search_space_len;
1954
1955 search_buf = malloc (search_buf_size);
1956 if (search_buf == NULL)
5e1471f5 1957 error (_("Unable to allocate memory to perform the search."));
08388c79
DE		 1958 old_cleanups = make_cleanup (free_current_contents, &search_buf);
1959
1960 /* Prime the search buffer. */
1961
1962 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1963 search_buf, start_addr, search_buf_size) != search_buf_size)
1964 {
5e1471f5 1965 warning (_("Unable to access target memory at %s, halting search."),
08388c79
DE		 1966 hex_string (start_addr));
1967 do_cleanups (old_cleanups);
1968 return -1;
1969 }
1970
1971 /* Perform the search.
1972
1973 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1974 When we've scanned N bytes we copy the trailing bytes to the start and
1975 read in another N bytes. */
1976
1977 while (search_space_len >= pattern_len)
1978 {
1979 gdb_byte *found_ptr;
1980 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
1981
1982 found_ptr = memmem (search_buf, nr_search_bytes,
1983 pattern, pattern_len);
1984
1985 if (found_ptr != NULL)
1986 {
1987 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
1988 *found_addrp = found_addr;
1989 do_cleanups (old_cleanups);
1990 return 1;
1991 }
1992
1993 /* Not found in this chunk, skip to next chunk. */
1994
1995 /* Don't let search_space_len wrap here, it's unsigned. */
1996 if (search_space_len >= chunk_size)
1997 search_space_len -= chunk_size;
1998 else
1999 search_space_len = 0;
2000
2001 if (search_space_len >= pattern_len)
2002 {
2003 unsigned keep_len = search_buf_size - chunk_size;
2004 CORE_ADDR read_addr = start_addr + keep_len;
2005 int nr_to_read;
2006
2007 /* Copy the trailing part of the previous iteration to the front
2008 of the buffer for the next iteration. */
2009 gdb_assert (keep_len == pattern_len - 1);
2010 memcpy (search_buf, search_buf + chunk_size, keep_len);
2011
2012 nr_to_read = min (search_space_len - keep_len, chunk_size);
2013
2014 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2015 search_buf + keep_len, read_addr,
2016 nr_to_read) != nr_to_read)
2017 {
5e1471f5 2018 warning (_("Unable to access target memory at %s, halting search."),
08388c79
DE		 2019 hex_string (read_addr));
2020 do_cleanups (old_cleanups);
2021 return -1;
2022 }
2023
2024 start_addr += chunk_size;
2025 }
2026 }
2027
2028 /* Not found. */
2029
2030 do_cleanups (old_cleanups);
2031 return 0;
2032}
2033
2034/* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2035 sequence of bytes in PATTERN with length PATTERN_LEN.
2036
2037 The result is 1 if found, 0 if not found, and -1 if there was an error
2038 requiring halting of the search (e.g. memory read error).
2039 If the pattern is found the address is recorded in FOUND_ADDRP. */
2040
2041int
2042target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2043 const gdb_byte *pattern, ULONGEST pattern_len,
2044 CORE_ADDR *found_addrp)
2045{
2046 struct target_ops *t;
2047 int found;
2048
2049 /* We don't use INHERIT to set current_target.to_search_memory,
2050 so we have to scan the target stack and handle targetdebug
2051 ourselves. */
2052
2053 if (targetdebug)
2054 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2055 hex_string (start_addr));
2056
2057 for (t = current_target.beneath; t != NULL; t = t->beneath)
2058 if (t->to_search_memory != NULL)
2059 break;
2060
2061 if (t != NULL)
2062 {
2063 found = t->to_search_memory (t, start_addr, search_space_len,
2064 pattern, pattern_len, found_addrp);
2065 }
2066 else
2067 {
2068 /* If a special version of to_search_memory isn't available, use the
2069 simple version. */
2070 found = simple_search_memory (&current_target,
2071 start_addr, search_space_len,
2072 pattern, pattern_len, found_addrp);
2073 }
2074
2075 if (targetdebug)
2076 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2077
2078 return found;
2079}
2080
8edfe269
DJ		 2081/* Look through the currently pushed targets. If none of them will
2082 be able to restart the currently running process, issue an error
2083 message. */
2084
2085void
2086target_require_runnable (void)
2087{
2088 struct target_ops *t;
2089
2090 for (t = target_stack; t != NULL; t = t->beneath)
2091 {
2092 /* If this target knows how to create a new program, then
2093 assume we will still be able to after killing the current
2094 one. Either killing and mourning will not pop T, or else
2095 find_default_run_target will find it again. */
2096 if (t->to_create_inferior != NULL)
2097 return;
2098
2099 /* Do not worry about thread_stratum targets that can not
2100 create inferiors. Assume they will be pushed again if
2101 necessary, and continue to the process_stratum. */
2102 if (t->to_stratum == thread_stratum)
2103 continue;
2104
2105 error (_("\
2106The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2107 t->to_shortname);
2108 }
2109
2110 /* This function is only called if the target is running. In that
2111 case there should have been a process_stratum target and it
2112 should either know how to create inferiors, or not... */
2113 internal_error (__FILE__, __LINE__, "No targets found");
2114}
2115
c906108c
SS		 2116/* Look through the list of possible targets for a target that can
2117 execute a run or attach command without any other data. This is
2118 used to locate the default process stratum.
2119
5f667f2d
PA		 2120 If DO_MESG is not NULL, the result is always valid (error() is
2121 called for errors); else, return NULL on error. */
c906108c
SS		 2122
2123static struct target_ops *
fba45db2 2124find_default_run_target (char *do_mesg)
c906108c
SS		 2125{
2126 struct target_ops **t;
2127 struct target_ops *runable = NULL;
2128 int count;
2129
2130 count = 0;
2131
2132 for (t = target_structs; t < target_structs + target_struct_size;
2133 ++t)
2134 {
c5aa993b 2135 if ((*t)->to_can_run && target_can_run (*t))
c906108c
SS		 2136 {
2137 runable = *t;
2138 ++count;
2139 }
2140 }
2141
2142 if (count != 1)
5f667f2d
PA		 2143 {
2144 if (do_mesg)
2145 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2146 else
2147 return NULL;
2148 }
c906108c
SS		 2149
2150 return runable;
2151}
2152
2153void
136d6dae 2154find_default_attach (struct target_ops *ops, char *args, int from_tty)
c906108c
SS		 2155{
2156 struct target_ops *t;
2157
c5aa993b 2158 t = find_default_run_target ("attach");
136d6dae 2159 (t->to_attach) (t, args, from_tty);
c906108c
SS		 2160 return;
2161}
2162
c906108c 2163void
136d6dae
VP		 2164find_default_create_inferior (struct target_ops *ops,
2165 char *exec_file, char *allargs, char **env,
c27cda74 2166 int from_tty)
c906108c
SS		 2167{
2168 struct target_ops *t;
2169
c5aa993b 2170 t = find_default_run_target ("run");
136d6dae 2171 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
c906108c
SS		 2172 return;
2173}
2174
b84876c2
PA		 2175int
2176find_default_can_async_p (void)
2177{
2178 struct target_ops *t;
2179
5f667f2d
PA		 2180 /* This may be called before the target is pushed on the stack;
2181 look for the default process stratum. If there's none, gdb isn't
2182 configured with a native debugger, and target remote isn't
2183 connected yet. */
2184 t = find_default_run_target (NULL);
2185 if (t && t->to_can_async_p)
b84876c2
PA		 2186 return (t->to_can_async_p) ();
2187 return 0;
2188}
2189
2190int
2191find_default_is_async_p (void)
2192{
2193 struct target_ops *t;
2194
5f667f2d
PA		 2195 /* This may be called before the target is pushed on the stack;
2196 look for the default process stratum. If there's none, gdb isn't
2197 configured with a native debugger, and target remote isn't
2198 connected yet. */
2199 t = find_default_run_target (NULL);
2200 if (t && t->to_is_async_p)
b84876c2
PA		 2201 return (t->to_is_async_p) ();
2202 return 0;
2203}
2204
9908b566
VP		 2205int
2206find_default_supports_non_stop (void)
2207{
2208 struct target_ops *t;
2209
2210 t = find_default_run_target (NULL);
2211 if (t && t->to_supports_non_stop)
2212 return (t->to_supports_non_stop) ();
2213 return 0;
2214}
2215
2216int
2217target_supports_non_stop ()
2218{
2219 struct target_ops *t;
2220 for (t = &current_target; t != NULL; t = t->beneath)
2221 if (t->to_supports_non_stop)
2222 return t->to_supports_non_stop ();
2223
2224 return 0;
2225}
2226
2227
07e059b5
VP		 2228char *
2229target_get_osdata (const char *type)
2230{
2231 char *document;
2232 struct target_ops *t;
2233
2234 if (target_can_run (&current_target))
2235 t = &current_target;
2236 else
2237 t = find_default_run_target ("get OS data");
2238
2239 if (!t)
2240 return NULL;
2241
2242 document = target_read_stralloc (t,
2243 TARGET_OBJECT_OSDATA,
2244 type);
2245 return document;
2246}
2247
e0d24f8d
WZ		 2248static int
2249default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2250{
ffe5a37e 2251 return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
ccaa32c7
GS		 2252}
2253
5009afc5
AS		 2254static int
2255default_watchpoint_addr_within_range (struct target_ops *target,
2256 CORE_ADDR addr,
2257 CORE_ADDR start, int length)
2258{
2259 return addr >= start && addr < start + length;
2260}
2261
c906108c 2262static int
fba45db2 2263return_zero (void)
c906108c
SS		 2264{
2265 return 0;
2266}
2267
2268static int
fba45db2 2269return_one (void)
c906108c
SS		 2270{
2271 return 1;
2272}
2273
ccaa32c7
GS		 2274static int
2275return_minus_one (void)
2276{
2277 return -1;
2278}
2279
6426a772
JM		 2280/*
2281 * Resize the to_sections pointer. Also make sure that anyone that
2282 * was holding on to an old value of it gets updated.
2283 * Returns the old size.
2284 */
2285
2286int
2287target_resize_to_sections (struct target_ops *target, int num_added)
2288{
2289 struct target_ops **t;
2290 struct section_table *old_value;
2291 int old_count;
2292
2293 old_value = target->to_sections;
2294
2295 if (target->to_sections)
2296 {
2297 old_count = target->to_sections_end - target->to_sections;
2298 target->to_sections = (struct section_table *)
2299 xrealloc ((char *) target->to_sections,
2300 (sizeof (struct section_table)) * (num_added + old_count));
2301 }
2302 else
2303 {
2304 old_count = 0;
2305 target->to_sections = (struct section_table *)
2306 xmalloc ((sizeof (struct section_table)) * num_added);
2307 }
2308 target->to_sections_end = target->to_sections + (num_added + old_count);
2309
2310 /* Check to see if anyone else was pointing to this structure.
2311 If old_value was null, then no one was. */
2bc416ba 2312
6426a772
JM		 2313 if (old_value)
2314 {
2315 for (t = target_structs; t < target_structs + target_struct_size;
2316 ++t)
2317 {
2318 if ((*t)->to_sections == old_value)
2319 {
2320 (*t)->to_sections = target->to_sections;
2321 (*t)->to_sections_end = target->to_sections_end;
2322 }
2323 }
e354df01
NW		 2324 /* There is a flattened view of the target stack in current_target,
2325 so its to_sections pointer might also need updating. */
2326 if (current_target.to_sections == old_value)
2327 {
2328 current_target.to_sections = target->to_sections;
2329 current_target.to_sections_end = target->to_sections_end;
2330 }
6426a772 2331 }
2bc416ba 2332
6426a772
JM		 2333 return old_count;
2334
2335}
2336
07cd4b97
JB		 2337/* Remove all target sections taken from ABFD.
2338
2339 Scan the current target stack for targets whose section tables
2340 refer to sections from BFD, and remove those sections. We use this
2341 when we notice that the inferior has unloaded a shared object, for
2342 example. */
2343void
2344remove_target_sections (bfd *abfd)
2345{
2346 struct target_ops **t;
2347
2348 for (t = target_structs; t < target_structs + target_struct_size; t++)
2349 {
2350 struct section_table *src, *dest;
2351
2352 dest = (*t)->to_sections;
2353 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
2354 if (src->bfd != abfd)
2355 {
2356 /* Keep this section. */
2357 if (dest < src) *dest = *src;
2358 dest++;
2359 }
2360
2361 /* If we've dropped any sections, resize the section table. */
2362 if (dest < src)
2363 target_resize_to_sections (*t, dest - src);
2364 }
2365}
2366
2367
2368
2369
7a292a7a
SS		 2370/* Find a single runnable target in the stack and return it. If for
2371 some reason there is more than one, return NULL. */
2372
2373struct target_ops *
fba45db2 2374find_run_target (void)
7a292a7a
SS		 2375{
2376 struct target_ops **t;
2377 struct target_ops *runable = NULL;
2378 int count;
c5aa993b 2379
7a292a7a 2380 count = 0;
c5aa993b 2381
7a292a7a
SS		 2382 for (t = target_structs; t < target_structs + target_struct_size; ++t)
2383 {
c5aa993b 2384 if ((*t)->to_can_run && target_can_run (*t))
7a292a7a
SS		 2385 {
2386 runable = *t;
2387 ++count;
2388 }
2389 }
c5aa993b 2390
7a292a7a
SS		 2391 return (count == 1 ? runable : NULL);
2392}
2393
ed9a39eb
JM		 2394/* Find a single core_stratum target in the list of targets and return it.
2395 If for some reason there is more than one, return NULL. */
2396
c906108c 2397struct target_ops *
fba45db2 2398find_core_target (void)
c906108c
SS		 2399{
2400 struct target_ops **t;
2401 struct target_ops *runable = NULL;
2402 int count;
c5aa993b 2403
c906108c 2404 count = 0;
c5aa993b 2405
c906108c
SS		 2406 for (t = target_structs; t < target_structs + target_struct_size;
2407 ++t)
2408 {
2409 if ((*t)->to_stratum == core_stratum)
2410 {
2411 runable = *t;
2412 ++count;
2413 }
2414 }
c5aa993b
JM		 2415
2416 return (count == 1 ? runable : NULL);
c906108c 2417}
ed9a39eb
JM		 2418
2419/*
2420 * Find the next target down the stack from the specified target.
2421 */
2422
2423struct target_ops *
fba45db2 2424find_target_beneath (struct target_ops *t)
ed9a39eb 2425{
258b763a 2426 return t->beneath;
ed9a39eb
JM		 2427}
2428
c906108c
SS		 2429\f
2430/* The inferior process has died. Long live the inferior! */
2431
2432void
fba45db2 2433generic_mourn_inferior (void)
c906108c 2434{
7f9f62ba 2435 ptid_t ptid;
c906108c 2436
7f9f62ba 2437 ptid = inferior_ptid;
39f77062 2438 inferior_ptid = null_ptid;
7f9f62ba
PA		 2439
2440 if (!ptid_equal (ptid, null_ptid))
2441 {
2442 int pid = ptid_get_pid (ptid);
2443 delete_inferior (pid);
2444 }
2445
c906108c
SS		 2446 breakpoint_init_inferior (inf_exited);
2447 registers_changed ();
2448
c906108c
SS		 2449 reopen_exec_file ();
2450 reinit_frame_cache ();
2451
9a4105ab
AC		 2452 if (deprecated_detach_hook)
2453 deprecated_detach_hook ();
c906108c
SS		 2454}
2455\f
8807d78b 2456/* Helper function for child_wait and the derivatives of child_wait.
c906108c
SS		 2457 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2458 translation of that in OURSTATUS. */
2459void
fba45db2 2460store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
c906108c 2461{
c906108c
SS		 2462 if (WIFEXITED (hoststatus))
2463 {
2464 ourstatus->kind = TARGET_WAITKIND_EXITED;
2465 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2466 }
2467 else if (!WIFSTOPPED (hoststatus))
2468 {
2469 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2470 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2471 }
2472 else
2473 {
2474 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2475 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2476 }
2477}
2478\f
fd0a2a6f
MK		 2479/* Convert a normal process ID to a string. Returns the string in a
2480 static buffer. */
c906108c
SS		 2481
2482char *
39f77062 2483normal_pid_to_str (ptid_t ptid)
c906108c 2484{
fd0a2a6f 2485 static char buf[32];
c906108c 2486
5fff8fc0 2487 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
c906108c
SS		 2488 return buf;
2489}
2490
be4d1333 2491/* Error-catcher for target_find_memory_regions */
be4d1333
MS		 2492static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2493{
8a3fe4f8 2494 error (_("No target."));
be4d1333
MS		 2495 return 0;
2496}
2497
2498/* Error-catcher for target_make_corefile_notes */
be4d1333
MS		 2499static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2500{
8a3fe4f8 2501 error (_("No target."));
be4d1333
MS		 2502 return NULL;
2503}
2504
c906108c
SS		 2505/* Set up the handful of non-empty slots needed by the dummy target
2506 vector. */
2507
2508static void
fba45db2 2509init_dummy_target (void)
c906108c
SS		 2510{
2511 dummy_target.to_shortname = "None";
2512 dummy_target.to_longname = "None";
2513 dummy_target.to_doc = "";
2514 dummy_target.to_attach = find_default_attach;
136d6dae
VP		 2515 dummy_target.to_detach =
2516 (void (*)(struct target_ops *, char *, int))target_ignore;
c906108c 2517 dummy_target.to_create_inferior = find_default_create_inferior;
b84876c2
PA		 2518 dummy_target.to_can_async_p = find_default_can_async_p;
2519 dummy_target.to_is_async_p = find_default_is_async_p;
9908b566 2520 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
ed9a39eb 2521 dummy_target.to_pid_to_str = normal_pid_to_str;
c906108c 2522 dummy_target.to_stratum = dummy_stratum;
be4d1333
MS		 2523 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2524 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
0b603eba 2525 dummy_target.to_xfer_partial = default_xfer_partial;
c906108c
SS		 2526 dummy_target.to_magic = OPS_MAGIC;
2527}
c906108c 2528\f
c906108c 2529static void
fba45db2 2530debug_to_open (char *args, int from_tty)
c906108c
SS		 2531{
2532 debug_target.to_open (args, from_tty);
2533
96baa820 2534 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
c906108c
SS		 2535}
2536
2537static void
fba45db2 2538debug_to_close (int quitting)
c906108c 2539{
f1c07ab0 2540 target_close (&debug_target, quitting);
96baa820 2541 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
c906108c
SS		 2542}
2543
f1c07ab0
AC		 2544void
2545target_close (struct target_ops *targ, int quitting)
2546{
2547 if (targ->to_xclose != NULL)
2548 targ->to_xclose (targ, quitting);
2549 else if (targ->to_close != NULL)
2550 targ->to_close (quitting);
2551}
2552
136d6dae
VP		 2553void
2554target_attach (char *args, int from_tty)
2555{
2556 struct target_ops *t;
2557 for (t = current_target.beneath; t != NULL; t = t->beneath)
2558 {
2559 if (t->to_attach != NULL)
2560 {
2561 t->to_attach (t, args, from_tty);
2562 return;
2563 }
2564 }
2565
2566 internal_error (__FILE__, __LINE__,
2567 "could not find a target to attach");
2568}
2569
2570
c906108c 2571static void
136d6dae 2572debug_to_attach (struct target_ops *ops, char *args, int from_tty)
c906108c 2573{
136d6dae 2574 debug_target.to_attach (&debug_target, args, from_tty);
c906108c 2575
96baa820 2576 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
c906108c
SS		 2577}
2578
2579
2580static void
fba45db2 2581debug_to_post_attach (int pid)
c906108c
SS		 2582{
2583 debug_target.to_post_attach (pid);
2584
96baa820 2585 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
c906108c
SS		 2586}
2587
c906108c 2588static void
136d6dae 2589debug_to_detach (struct target_ops *ops, char *args, int from_tty)
c906108c 2590{
136d6dae 2591 debug_target.to_detach (&debug_target, args, from_tty);
c906108c 2592
96baa820 2593 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
c906108c
SS		 2594}
2595
c906108c 2596static void
39f77062 2597debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
c906108c 2598{
39f77062 2599 debug_target.to_resume (ptid, step, siggnal);
c906108c 2600
39f77062 2601 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
c906108c
SS		 2602 step ? "step" : "continue",
2603 target_signal_to_name (siggnal));
2604}
2605
39f77062
KB		 2606static ptid_t
2607debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
c906108c 2608{
39f77062 2609 ptid_t retval;
c906108c 2610
39f77062 2611 retval = debug_target.to_wait (ptid, status);
c906108c 2612
96baa820 2613 fprintf_unfiltered (gdb_stdlog,
39f77062
KB		 2614 "target_wait (%d, status) = %d, ", PIDGET (ptid),
2615 PIDGET (retval));
96baa820 2616 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
c906108c
SS		 2617 switch (status->kind)
2618 {
2619 case TARGET_WAITKIND_EXITED:
96baa820 2620 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
c906108c
SS		 2621 status->value.integer);
2622 break;
2623 case TARGET_WAITKIND_STOPPED:
96baa820 2624 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
c906108c
SS		 2625 target_signal_to_name (status->value.sig));
2626 break;
2627 case TARGET_WAITKIND_SIGNALLED:
96baa820 2628 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
c906108c
SS		 2629 target_signal_to_name (status->value.sig));
2630 break;
2631 case TARGET_WAITKIND_LOADED:
96baa820 2632 fprintf_unfiltered (gdb_stdlog, "loaded\n");
c906108c
SS		 2633 break;
2634 case TARGET_WAITKIND_FORKED:
96baa820 2635 fprintf_unfiltered (gdb_stdlog, "forked\n");
c906108c
SS		 2636 break;
2637 case TARGET_WAITKIND_VFORKED:
96baa820 2638 fprintf_unfiltered (gdb_stdlog, "vforked\n");
c906108c
SS		 2639 break;
2640 case TARGET_WAITKIND_EXECD:
96baa820 2641 fprintf_unfiltered (gdb_stdlog, "execd\n");
c906108c
SS		 2642 break;
2643 case TARGET_WAITKIND_SPURIOUS:
96baa820 2644 fprintf_unfiltered (gdb_stdlog, "spurious\n");
c906108c
SS		 2645 break;
2646 default:
96baa820 2647 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
c906108c
SS		 2648 break;
2649 }
2650
2651 return retval;
2652}
2653
bf0c5130 2654static void
56be3814
UW		 2655debug_print_register (const char * func,
2656 struct regcache *regcache, int regno)
bf0c5130 2657{
f8d29908 2658 struct gdbarch *gdbarch = get_regcache_arch (regcache);
bf0c5130 2659 fprintf_unfiltered (gdb_stdlog, "%s ", func);
f8d29908 2660 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
f8d29908
UW		 2661 && gdbarch_register_name (gdbarch, regno) != NULL
2662 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
2663 fprintf_unfiltered (gdb_stdlog, "(%s)",
2664 gdbarch_register_name (gdbarch, regno));
bf0c5130
AC		 2665 else
2666 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
0ff58721 2667 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
bf0c5130 2668 {
f8d29908 2669 int i, size = register_size (gdbarch, regno);
d9d9c31f 2670 unsigned char buf[MAX_REGISTER_SIZE];
0ff58721 2671 regcache_raw_collect (regcache, regno, buf);
bf0c5130 2672 fprintf_unfiltered (gdb_stdlog, " = ");
81c4a259 2673 for (i = 0; i < size; i++)
bf0c5130
AC		 2674 {
2675 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2676 }
81c4a259 2677 if (size <= sizeof (LONGEST))
bf0c5130 2678 {
81c4a259 2679 ULONGEST val = extract_unsigned_integer (buf, size);
0b1553bc
UW		 2680 fprintf_unfiltered (gdb_stdlog, " %s %s",
2681 core_addr_to_string_nz (val), plongest (val));
bf0c5130
AC		 2682 }
2683 }
2684 fprintf_unfiltered (gdb_stdlog, "\n");
2685}
2686
c906108c 2687static void
56be3814 2688debug_to_fetch_registers (struct regcache *regcache, int regno)
c906108c 2689{
56be3814
UW		 2690 debug_target.to_fetch_registers (regcache, regno);
2691 debug_print_register ("target_fetch_registers", regcache, regno);
c906108c
SS		 2692}
2693
2694static void
56be3814 2695debug_to_store_registers (struct regcache *regcache, int regno)
c906108c 2696{
56be3814
UW		 2697 debug_target.to_store_registers (regcache, regno);
2698 debug_print_register ("target_store_registers", regcache, regno);
bf0c5130 2699 fprintf_unfiltered (gdb_stdlog, "\n");
c906108c
SS		 2700}
2701
2702static void
316f2060 2703debug_to_prepare_to_store (struct regcache *regcache)
c906108c 2704{
316f2060 2705 debug_target.to_prepare_to_store (regcache);
c906108c 2706
96baa820 2707 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
c906108c
SS		 2708}
2709
2710static int
961cb7b5 2711deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
c8e73a31
AC		 2712 int write, struct mem_attrib *attrib,
2713 struct target_ops *target)
c906108c
SS		 2714{
2715 int retval;
2716
c8e73a31
AC		 2717 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2718 attrib, target);
c906108c 2719
96baa820 2720 fprintf_unfiltered (gdb_stdlog,
53b71562
JB		 2721 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
2722 paddress (memaddr), len, write ? "write" : "read",
2723 retval);
c906108c 2724
c906108c
SS		 2725 if (retval > 0)
2726 {
2727 int i;
2728
96baa820 2729 fputs_unfiltered (", bytes =", gdb_stdlog);
c906108c
SS		 2730 for (i = 0; i < retval; i++)
2731 {
53b71562 2732 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
333dabeb
DJ		 2733 {
2734 if (targetdebug < 2 && i > 0)
2735 {
2736 fprintf_unfiltered (gdb_stdlog, " ...");
2737 break;
2738 }
2739 fprintf_unfiltered (gdb_stdlog, "\n");
2740 }
2bc416ba 2741
96baa820 2742 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
c906108c
SS		 2743 }
2744 }
2745
96baa820 2746 fputc_unfiltered ('\n', gdb_stdlog);
c906108c
SS		 2747
2748 return retval;
2749}
2750
2751static void
fba45db2 2752debug_to_files_info (struct target_ops *target)
c906108c
SS		 2753{
2754 debug_target.to_files_info (target);
2755
96baa820 2756 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
c906108c
SS		 2757}
2758
2759static int
8181d85f 2760debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
c906108c
SS		 2761{
2762 int retval;
2763
8181d85f 2764 retval = debug_target.to_insert_breakpoint (bp_tgt);
c906108c 2765
96baa820 2766 fprintf_unfiltered (gdb_stdlog,
104c1213 2767 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
8181d85f 2768 (unsigned long) bp_tgt->placed_address,
104c1213 2769 (unsigned long) retval);
c906108c
SS		 2770 return retval;
2771}
2772
2773static int
8181d85f 2774debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
c906108c
SS		 2775{
2776 int retval;
2777
8181d85f 2778 retval = debug_target.to_remove_breakpoint (bp_tgt);
c906108c 2779
96baa820 2780 fprintf_unfiltered (gdb_stdlog,
104c1213 2781 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
8181d85f 2782 (unsigned long) bp_tgt->placed_address,
104c1213 2783 (unsigned long) retval);
c906108c
SS		 2784 return retval;
2785}
2786
ccaa32c7
GS		 2787static int
2788debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2789{
2790 int retval;
2791
2792 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2793
2794 fprintf_unfiltered (gdb_stdlog,
2795 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2796 (unsigned long) type,
2797 (unsigned long) cnt,
2798 (unsigned long) from_tty,
2799 (unsigned long) retval);
2800 return retval;
2801}
2802
e0d24f8d
WZ		 2803static int
2804debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2805{
2806 CORE_ADDR retval;
2807
2808 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2809
2810 fprintf_unfiltered (gdb_stdlog,
2811 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2812 (unsigned long) addr,
2813 (unsigned long) len,
2814 (unsigned long) retval);
2815 return retval;
2816}
2817
ccaa32c7
GS		 2818static int
2819debug_to_stopped_by_watchpoint (void)
2820{
2821 int retval;
2822
2823 retval = debug_target.to_stopped_by_watchpoint ();
2824
2825 fprintf_unfiltered (gdb_stdlog,
2826 "STOPPED_BY_WATCHPOINT () = %ld\n",
2827 (unsigned long) retval);
2828 return retval;
2829}
2830
4aa7a7f5
JJ		 2831static int
2832debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
ccaa32c7 2833{
4aa7a7f5 2834 int retval;
ccaa32c7 2835
4aa7a7f5 2836 retval = debug_target.to_stopped_data_address (target, addr);
ccaa32c7
GS		 2837
2838 fprintf_unfiltered (gdb_stdlog,
4aa7a7f5
JJ		 2839 "target_stopped_data_address ([0x%lx]) = %ld\n",
2840 (unsigned long)*addr,
2841 (unsigned long)retval);
ccaa32c7
GS		 2842 return retval;
2843}
2844
5009afc5
AS		 2845static int
2846debug_to_watchpoint_addr_within_range (struct target_ops *target,
2847 CORE_ADDR addr,
2848 CORE_ADDR start, int length)
2849{
2850 int retval;
2851
2852 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
2853 start, length);
2854
2855 fprintf_filtered (gdb_stdlog,
2856 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2857 (unsigned long) addr, (unsigned long) start, length,
2858 retval);
2859 return retval;
2860}
2861
ccaa32c7 2862static int
8181d85f 2863debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
ccaa32c7
GS		 2864{
2865 int retval;
2866
8181d85f 2867 retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
ccaa32c7
GS		 2868
2869 fprintf_unfiltered (gdb_stdlog,
2870 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
8181d85f 2871 (unsigned long) bp_tgt->placed_address,
ccaa32c7
GS		 2872 (unsigned long) retval);
2873 return retval;
2874}
2875
2876static int
8181d85f 2877debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
ccaa32c7
GS		 2878{
2879 int retval;
2880
8181d85f 2881 retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
ccaa32c7
GS		 2882
2883 fprintf_unfiltered (gdb_stdlog,
2884 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
8181d85f 2885 (unsigned long) bp_tgt->placed_address,
ccaa32c7
GS		 2886 (unsigned long) retval);
2887 return retval;
2888}
2889
2890static int
2891debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2892{
2893 int retval;
2894
2895 retval = debug_target.to_insert_watchpoint (addr, len, type);
2896
2897 fprintf_unfiltered (gdb_stdlog,
2898 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2899 (unsigned long) addr, len, type, (unsigned long) retval);
2900 return retval;
2901}
2902
2903static int
2904debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2905{
2906 int retval;
2907
ecde4882 2908 retval = debug_target.to_remove_watchpoint (addr, len, type);
ccaa32c7
GS		 2909
2910 fprintf_unfiltered (gdb_stdlog,
ecde4882 2911 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
ccaa32c7
GS		 2912 (unsigned long) addr, len, type, (unsigned long) retval);
2913 return retval;
2914}
2915
c906108c 2916static void
fba45db2 2917debug_to_terminal_init (void)
c906108c
SS		 2918{
2919 debug_target.to_terminal_init ();
2920
96baa820 2921 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
c906108c
SS		 2922}
2923
2924static void
fba45db2 2925debug_to_terminal_inferior (void)
c906108c
SS		 2926{
2927 debug_target.to_terminal_inferior ();
2928
96baa820 2929 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
c906108c
SS		 2930}
2931
2932static void
fba45db2 2933debug_to_terminal_ours_for_output (void)
c906108c
SS		 2934{
2935 debug_target.to_terminal_ours_for_output ();
2936
96baa820 2937 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
c906108c
SS		 2938}
2939
2940static void
fba45db2 2941debug_to_terminal_ours (void)
c906108c
SS		 2942{
2943 debug_target.to_terminal_ours ();
2944
96baa820 2945 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
c906108c
SS		 2946}
2947
a790ad35
SC		 2948static void
2949debug_to_terminal_save_ours (void)
2950{
2951 debug_target.to_terminal_save_ours ();
2952
2953 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2954}
2955
c906108c 2956static void
fba45db2 2957debug_to_terminal_info (char *arg, int from_tty)
c906108c
SS		 2958{
2959 debug_target.to_terminal_info (arg, from_tty);
2960
96baa820 2961 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
c906108c
SS		 2962 from_tty);
2963}
2964
2965static void
fba45db2 2966debug_to_kill (void)
c906108c
SS		 2967{
2968 debug_target.to_kill ();
2969
96baa820 2970 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
c906108c
SS		 2971}
2972
2973static void
fba45db2 2974debug_to_load (char *args, int from_tty)
c906108c
SS		 2975{
2976 debug_target.to_load (args, from_tty);
2977
96baa820 2978 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
c906108c
SS		 2979}
2980
2981static int
fba45db2 2982debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
c906108c
SS		 2983{
2984 int retval;
2985
2986 retval = debug_target.to_lookup_symbol (name, addrp);
2987
96baa820 2988 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
c906108c
SS		 2989
2990 return retval;
2991}
2992
2993static void
136d6dae
VP		 2994debug_to_create_inferior (struct target_ops *ops,
2995 char *exec_file, char *args, char **env,
c27cda74 2996 int from_tty)
c906108c 2997{
136d6dae 2998 debug_target.to_create_inferior (ops, exec_file, args, env, from_tty);
c906108c 2999
c27cda74
AC		 3000 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
3001 exec_file, args, from_tty);
c906108c
SS		 3002}
3003
3004static void
39f77062 3005debug_to_post_startup_inferior (ptid_t ptid)
c906108c 3006{
39f77062 3007 debug_target.to_post_startup_inferior (ptid);
c906108c 3008
96baa820 3009 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
39f77062 3010 PIDGET (ptid));
c906108c
SS		 3011}
3012
3013static void
fba45db2 3014debug_to_acknowledge_created_inferior (int pid)
c906108c
SS		 3015{
3016 debug_target.to_acknowledge_created_inferior (pid);
3017
96baa820 3018 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
c906108c
SS		 3019 pid);
3020}
3021
fa113d1a 3022static void
fba45db2 3023debug_to_insert_fork_catchpoint (int pid)
c906108c 3024{
fa113d1a 3025 debug_target.to_insert_fork_catchpoint (pid);
c906108c 3026
fa113d1a
AC		 3027 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
3028 pid);
c906108c
SS		 3029}
3030
3031static int
fba45db2 3032debug_to_remove_fork_catchpoint (int pid)
c906108c 3033{
c5aa993b 3034 int retval;
c906108c
SS		 3035
3036 retval = debug_target.to_remove_fork_catchpoint (pid);
3037
96baa820 3038 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
c5aa993b 3039 pid, retval);
c906108c
SS		 3040
3041 return retval;
3042}
3043
fa113d1a 3044static void
fba45db2 3045debug_to_insert_vfork_catchpoint (int pid)
c906108c 3046{
fa113d1a 3047 debug_target.to_insert_vfork_catchpoint (pid);
c906108c 3048
fa113d1a
AC		 3049 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
3050 pid);
c906108c
SS		 3051}
3052
3053static int
fba45db2 3054debug_to_remove_vfork_catchpoint (int pid)
c906108c 3055{
c5aa993b 3056 int retval;
c906108c
SS		 3057
3058 retval = debug_target.to_remove_vfork_catchpoint (pid);
3059
96baa820 3060 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
c5aa993b 3061 pid, retval);
c906108c
SS		 3062
3063 return retval;
3064}
3065
fa113d1a 3066static void
fba45db2 3067debug_to_insert_exec_catchpoint (int pid)
c906108c 3068{
fa113d1a 3069 debug_target.to_insert_exec_catchpoint (pid);
c906108c 3070
fa113d1a
AC		 3071 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
3072 pid);
c906108c
SS		 3073}
3074
3075static int
fba45db2 3076debug_to_remove_exec_catchpoint (int pid)
c906108c 3077{
c5aa993b 3078 int retval;
c906108c
SS		 3079
3080 retval = debug_target.to_remove_exec_catchpoint (pid);
3081
96baa820 3082 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
c5aa993b 3083 pid, retval);
c906108c
SS		 3084
3085 return retval;
3086}
3087
c906108c 3088static int
fba45db2 3089debug_to_has_exited (int pid, int wait_status, int *exit_status)
c906108c 3090{
c5aa993b 3091 int has_exited;
c906108c
SS		 3092
3093 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
3094
96baa820 3095 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
c5aa993b 3096 pid, wait_status, *exit_status, has_exited);
c906108c
SS		 3097
3098 return has_exited;
3099}
3100
3101static void
136d6dae 3102debug_to_mourn_inferior (struct target_ops *ops)
c906108c 3103{
136d6dae 3104 debug_target.to_mourn_inferior (&debug_target);
c906108c 3105
96baa820 3106 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
c906108c
SS		 3107}
3108
3109static int
fba45db2 3110debug_to_can_run (void)
c906108c
SS		 3111{
3112 int retval;
3113
3114 retval = debug_target.to_can_run ();
3115
96baa820 3116 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
c906108c
SS		 3117
3118 return retval;
3119}
3120
3121static void
39f77062 3122debug_to_notice_signals (ptid_t ptid)
c906108c 3123{
39f77062 3124 debug_target.to_notice_signals (ptid);
c906108c 3125
39f77062
KB		 3126 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
3127 PIDGET (ptid));
c906108c
SS		 3128}
3129
3130static int
39f77062 3131debug_to_thread_alive (ptid_t ptid)
c906108c
SS		 3132{
3133 int retval;
3134
39f77062 3135 retval = debug_target.to_thread_alive (ptid);
c906108c 3136
96baa820 3137 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
39f77062 3138 PIDGET (ptid), retval);
c906108c
SS		 3139
3140 return retval;
3141}
3142
0d06e24b 3143static void
fba45db2 3144debug_to_find_new_threads (void)
0d06e24b
JM		 3145{
3146 debug_target.to_find_new_threads ();
3147
3148 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
3149}
3150
c906108c 3151static void
94cc34af 3152debug_to_stop (ptid_t ptid)
c906108c 3153{
94cc34af 3154 debug_target.to_stop (ptid);
c906108c 3155
94cc34af
PA		 3156 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
3157 target_pid_to_str (ptid));
c906108c
SS		 3158}
3159
96baa820
JM		 3160static void
3161debug_to_rcmd (char *command,
d9fcf2fb 3162 struct ui_file *outbuf)
96baa820
JM		 3163{
3164 debug_target.to_rcmd (command, outbuf);
3165 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
3166}
3167
c906108c 3168static char *
fba45db2 3169debug_to_pid_to_exec_file (int pid)
c906108c 3170{
c5aa993b 3171 char *exec_file;
c906108c
SS		 3172
3173 exec_file = debug_target.to_pid_to_exec_file (pid);
3174
96baa820 3175 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
c5aa993b 3176 pid, exec_file);
c906108c
SS		 3177
3178 return exec_file;
3179}
3180
c906108c 3181static void
fba45db2 3182setup_target_debug (void)
c906108c
SS		 3183{
3184 memcpy (&debug_target, &current_target, sizeof debug_target);
3185
3186 current_target.to_open = debug_to_open;
3187 current_target.to_close = debug_to_close;
3188 current_target.to_attach = debug_to_attach;
3189 current_target.to_post_attach = debug_to_post_attach;
c906108c 3190 current_target.to_detach = debug_to_detach;
c906108c
SS		 3191 current_target.to_resume = debug_to_resume;
3192 current_target.to_wait = debug_to_wait;
c906108c
SS		 3193 current_target.to_fetch_registers = debug_to_fetch_registers;
3194 current_target.to_store_registers = debug_to_store_registers;
3195 current_target.to_prepare_to_store = debug_to_prepare_to_store;
c8e73a31 3196 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
c906108c
SS		 3197 current_target.to_files_info = debug_to_files_info;
3198 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
3199 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
ccaa32c7
GS		 3200 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
3201 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
3202 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
3203 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
3204 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
3205 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
3206 current_target.to_stopped_data_address = debug_to_stopped_data_address;
5009afc5 3207 current_target.to_watchpoint_addr_within_range = debug_to_watchpoint_addr_within_range;
e0d24f8d 3208 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
c906108c
SS		 3209 current_target.to_terminal_init = debug_to_terminal_init;
3210 current_target.to_terminal_inferior = debug_to_terminal_inferior;
3211 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
3212 current_target.to_terminal_ours = debug_to_terminal_ours;
a790ad35 3213 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
c906108c
SS		 3214 current_target.to_terminal_info = debug_to_terminal_info;
3215 current_target.to_kill = debug_to_kill;
3216 current_target.to_load = debug_to_load;
3217 current_target.to_lookup_symbol = debug_to_lookup_symbol;
3218 current_target.to_create_inferior = debug_to_create_inferior;
3219 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
3220 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
c906108c
SS		 3221 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
3222 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
3223 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
3224 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
c906108c
SS		 3225 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
3226 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
c906108c
SS		 3227 current_target.to_has_exited = debug_to_has_exited;
3228 current_target.to_mourn_inferior = debug_to_mourn_inferior;
3229 current_target.to_can_run = debug_to_can_run;
3230 current_target.to_notice_signals = debug_to_notice_signals;
3231 current_target.to_thread_alive = debug_to_thread_alive;
0d06e24b 3232 current_target.to_find_new_threads = debug_to_find_new_threads;
c906108c 3233 current_target.to_stop = debug_to_stop;
96baa820 3234 current_target.to_rcmd = debug_to_rcmd;
c906108c 3235 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
c906108c 3236}
c906108c 3237\f
c5aa993b
JM		 3238
3239static char targ_desc[] =
3240"Names of targets and files being debugged.\n\
c906108c
SS		 3241Shows the entire stack of targets currently in use (including the exec-file,\n\
3242core-file, and process, if any), as well as the symbol file name.";
3243
96baa820
JM		 3244static void
3245do_monitor_command (char *cmd,
3246 int from_tty)
3247{
2b5fe715
AC		 3248 if ((current_target.to_rcmd
3249 == (void (*) (char *, struct ui_file *)) tcomplain)
96baa820 3250 || (current_target.to_rcmd == debug_to_rcmd
2b5fe715
AC		 3251 && (debug_target.to_rcmd
3252 == (void (*) (char *, struct ui_file *)) tcomplain)))
8a3fe4f8 3253 error (_("\"monitor\" command not supported by this target."));
96baa820
JM		 3254 target_rcmd (cmd, gdb_stdtarg);
3255}
3256
87680a14
JB		 3257/* Print the name of each layers of our target stack. */
3258
3259static void
3260maintenance_print_target_stack (char *cmd, int from_tty)
3261{
3262 struct target_ops *t;
3263
3264 printf_filtered (_("The current target stack is:\n"));
3265
3266 for (t = target_stack; t != NULL; t = t->beneath)
3267 {
3268 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3269 }
3270}
3271
c6ebd6cf
VP		 3272/* Controls if async mode is permitted. */
3273int target_async_permitted = 0;
3274
3275/* The set command writes to this variable. If the inferior is
3276 executing, linux_nat_async_permitted is *not* updated. */
3277static int target_async_permitted_1 = 0;
3278
3279static void
3280set_maintenance_target_async_permitted (char *args, int from_tty,
3281 struct cmd_list_element *c)
3282{
3283 if (target_has_execution)
3284 {
3285 target_async_permitted_1 = target_async_permitted;
3286 error (_("Cannot change this setting while the inferior is running."));
3287 }
3288
3289 target_async_permitted = target_async_permitted_1;
3290}
3291
3292static void
3293show_maintenance_target_async_permitted (struct ui_file *file, int from_tty,
3294 struct cmd_list_element *c,
3295 const char *value)
3296{
3297 fprintf_filtered (file, _("\
3298Controlling the inferior in asynchronous mode is %s.\n"), value);
3299}
3300
c906108c 3301void
fba45db2 3302initialize_targets (void)
c906108c
SS		 3303{
3304 init_dummy_target ();
3305 push_target (&dummy_target);
3306
3307 add_info ("target", target_info, targ_desc);
3308 add_info ("files", target_info, targ_desc);
3309
85c07804
AC		 3310 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3311Set target debugging."), _("\
3312Show target debugging."), _("\
333dabeb
DJ		 3313When non-zero, target debugging is enabled. Higher numbers are more\n\
3314verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
85c07804
AC		 3315command."),
3316 NULL,
920d2a44 3317 show_targetdebug,
85c07804 3318 &setdebuglist, &showdebuglist);
3a11626d 3319
2bc416ba 3320 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
7915a72c
AC		 3321 &trust_readonly, _("\
3322Set mode for reading from readonly sections."), _("\
3323Show mode for reading from readonly sections."), _("\
3a11626d
MS		 3324When this mode is on, memory reads from readonly sections (such as .text)\n\
3325will be read from the object file instead of from the target. This will\n\
7915a72c 3326result in significant performance improvement for remote targets."),
2c5b56ce 3327 NULL,
920d2a44 3328 show_trust_readonly,
e707bbc2 3329 &setlist, &showlist);
96baa820
JM		 3330
3331 add_com ("monitor", class_obscure, do_monitor_command,
1bedd215 3332 _("Send a command to the remote monitor (remote targets only)."));
96baa820 3333
87680a14
JB		 3334 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3335 _("Print the name of each layer of the internal target stack."),
3336 &maintenanceprintlist);
3337
c6ebd6cf
VP		 3338 add_setshow_boolean_cmd ("target-async", no_class,
3339 &target_async_permitted_1, _("\
3340Set whether gdb controls the inferior in asynchronous mode."), _("\
3341Show whether gdb controls the inferior in asynchronous mode."), _("\
3342Tells gdb whether to control the inferior in asynchronous mode."),
3343 set_maintenance_target_async_permitted,
3344 show_maintenance_target_async_permitted,
3345 &setlist,
3346 &showlist);
3347
8add0441 3348 target_dcache = dcache_init ();
c906108c 3349}
GDB Binutils - Deliverables
This page took 1.022648 seconds and 4 git commands to generate.