1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
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
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
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.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
38 #include "gdb_assert.h"
40 #include "exceptions.h"
41 #include "target-descriptions.h"
42 #include "gdb_stdint.h"
43 #include "gdbthread.h"
45 static void target_info (char *, int);
47 static void maybe_kill_then_attach (char *, int);
49 static void kill_or_be_killed (int);
51 static void default_terminal_info (char *, int);
53 static int default_watchpoint_addr_within_range (struct target_ops *,
54 CORE_ADDR, CORE_ADDR, int);
56 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
58 static int nosymbol (char *, CORE_ADDR *);
60 static void tcomplain (void) ATTR_NORETURN;
62 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
64 static int return_zero (void);
66 static int return_one (void);
68 static int return_minus_one (void);
70 void target_ignore (void);
72 static void target_command (char *, int);
74 static struct target_ops *find_default_run_target (char *);
76 static void nosupport_runtime (void);
78 static LONGEST default_xfer_partial (struct target_ops *ops,
79 enum target_object object,
80 const char *annex, gdb_byte *readbuf,
81 const gdb_byte *writebuf,
82 ULONGEST offset, LONGEST len);
84 static LONGEST current_xfer_partial (struct target_ops *ops,
85 enum target_object object,
86 const char *annex, gdb_byte *readbuf,
87 const gdb_byte *writebuf,
88 ULONGEST offset, LONGEST len);
90 static LONGEST target_xfer_partial (struct target_ops *ops,
91 enum target_object object,
93 void *readbuf, const void *writebuf,
94 ULONGEST offset, LONGEST len);
96 static void init_dummy_target (void);
98 static struct target_ops debug_target;
100 static void debug_to_open (char *, int);
102 static void debug_to_close (int);
104 static void debug_to_attach (char *, int);
106 static void debug_to_detach (char *, int);
108 static void debug_to_resume (ptid_t, int, enum target_signal);
110 static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
112 static void debug_to_fetch_registers (struct regcache *, int);
114 static void debug_to_store_registers (struct regcache *, int);
116 static void debug_to_prepare_to_store (struct regcache *);
118 static void debug_to_files_info (struct target_ops *);
120 static int debug_to_insert_breakpoint (struct bp_target_info *);
122 static int debug_to_remove_breakpoint (struct bp_target_info *);
124 static int debug_to_can_use_hw_breakpoint (int, int, int);
126 static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
128 static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
130 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
132 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
134 static int debug_to_stopped_by_watchpoint (void);
136 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
138 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
139 CORE_ADDR, CORE_ADDR, int);
141 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
143 static void debug_to_terminal_init (void);
145 static void debug_to_terminal_inferior (void);
147 static void debug_to_terminal_ours_for_output (void);
149 static void debug_to_terminal_save_ours (void);
151 static void debug_to_terminal_ours (void);
153 static void debug_to_terminal_info (char *, int);
155 static void debug_to_kill (void);
157 static void debug_to_load (char *, int);
159 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
161 static void debug_to_mourn_inferior (void);
163 static int debug_to_can_run (void);
165 static void debug_to_notice_signals (ptid_t);
167 static int debug_to_thread_alive (ptid_t);
169 static void debug_to_stop (void);
171 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
172 wierd and mysterious ways. Putting the variable here lets those
173 wierd and mysterious ways keep building while they are being
174 converted to the inferior inheritance structure. */
175 struct target_ops deprecated_child_ops;
177 /* Pointer to array of target architecture structures; the size of the
178 array; the current index into the array; the allocated size of the
180 struct target_ops **target_structs;
181 unsigned target_struct_size;
182 unsigned target_struct_index;
183 unsigned target_struct_allocsize;
184 #define DEFAULT_ALLOCSIZE 10
186 /* The initial current target, so that there is always a semi-valid
189 static struct target_ops dummy_target;
191 /* Top of target stack. */
193 static struct target_ops *target_stack;
195 /* The target structure we are currently using to talk to a process
196 or file or whatever "inferior" we have. */
198 struct target_ops current_target;
200 /* Command list for target. */
202 static struct cmd_list_element *targetlist = NULL;
204 /* Nonzero if we are debugging an attached outside process
205 rather than an inferior. */
209 /* Nonzero if we should trust readonly sections from the
210 executable when reading memory. */
212 static int trust_readonly = 0;
214 /* Nonzero if we should show true memory content including
215 memory breakpoint inserted by gdb. */
217 static int show_memory_breakpoints = 0;
219 /* Non-zero if we want to see trace of target level stuff. */
221 static int targetdebug = 0;
223 show_targetdebug (struct ui_file *file, int from_tty,
224 struct cmd_list_element *c, const char *value)
226 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
229 static void setup_target_debug (void);
231 DCACHE *target_dcache;
233 /* The user just typed 'target' without the name of a target. */
236 target_command (char *arg, int from_tty)
238 fputs_filtered ("Argument required (target name). Try `help target'\n",
242 /* Add a possible target architecture to the list. */
245 add_target (struct target_ops *t)
247 /* Provide default values for all "must have" methods. */
248 if (t->to_xfer_partial == NULL)
249 t->to_xfer_partial = default_xfer_partial;
253 target_struct_allocsize = DEFAULT_ALLOCSIZE;
254 target_structs = (struct target_ops **) xmalloc
255 (target_struct_allocsize * sizeof (*target_structs));
257 if (target_struct_size >= target_struct_allocsize)
259 target_struct_allocsize *= 2;
260 target_structs = (struct target_ops **)
261 xrealloc ((char *) target_structs,
262 target_struct_allocsize * sizeof (*target_structs));
264 target_structs[target_struct_size++] = t;
266 if (targetlist == NULL)
267 add_prefix_cmd ("target", class_run, target_command, _("\
268 Connect to a target machine or process.\n\
269 The first argument is the type or protocol of the target machine.\n\
270 Remaining arguments are interpreted by the target protocol. For more\n\
271 information on the arguments for a particular protocol, type\n\
272 `help target ' followed by the protocol name."),
273 &targetlist, "target ", 0, &cmdlist);
274 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
285 target_load (char *arg, int from_tty)
287 dcache_invalidate (target_dcache);
288 (*current_target.to_load) (arg, from_tty);
292 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
293 struct target_ops *t)
295 errno = EIO; /* Can't read/write this location */
296 return 0; /* No bytes handled */
302 error (_("You can't do that when your target is `%s'"),
303 current_target.to_shortname);
309 error (_("You can't do that without a process to debug."));
313 nosymbol (char *name, CORE_ADDR *addrp)
315 return 1; /* Symbol does not exist in target env */
319 nosupport_runtime (void)
321 if (ptid_equal (inferior_ptid, null_ptid))
324 error (_("No run-time support for this"));
329 default_terminal_info (char *args, int from_tty)
331 printf_unfiltered (_("No saved terminal information.\n"));
334 /* This is the default target_create_inferior and target_attach function.
335 If the current target is executing, it asks whether to kill it off.
336 If this function returns without calling error(), it has killed off
337 the target, and the operation should be attempted. */
340 kill_or_be_killed (int from_tty)
342 if (target_has_execution)
344 printf_unfiltered (_("You are already running a program:\n"));
345 target_files_info ();
346 if (query ("Kill it? "))
349 if (target_has_execution)
350 error (_("Killing the program did not help."));
355 error (_("Program not killed."));
362 maybe_kill_then_attach (char *args, int from_tty)
364 kill_or_be_killed (from_tty);
365 target_attach (args, from_tty);
369 maybe_kill_then_create_inferior (char *exec, char *args, char **env,
372 kill_or_be_killed (0);
373 target_create_inferior (exec, args, env, from_tty);
376 /* Go through the target stack from top to bottom, copying over zero
377 entries in current_target, then filling in still empty entries. In
378 effect, we are doing class inheritance through the pushed target
381 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
382 is currently implemented, is that it discards any knowledge of
383 which target an inherited method originally belonged to.
384 Consequently, new new target methods should instead explicitly and
385 locally search the target stack for the target that can handle the
389 update_current_target (void)
391 struct target_ops *t;
393 /* First, reset current's contents. */
394 memset (¤t_target, 0, sizeof (current_target));
396 #define INHERIT(FIELD, TARGET) \
397 if (!current_target.FIELD) \
398 current_target.FIELD = (TARGET)->FIELD
400 for (t = target_stack; t; t = t->beneath)
402 INHERIT (to_shortname, t);
403 INHERIT (to_longname, t);
405 INHERIT (to_open, t);
406 INHERIT (to_close, t);
407 INHERIT (to_attach, t);
408 INHERIT (to_post_attach, t);
409 INHERIT (to_detach, t);
410 /* Do not inherit to_disconnect. */
411 INHERIT (to_resume, t);
412 INHERIT (to_wait, t);
413 INHERIT (to_fetch_registers, t);
414 INHERIT (to_store_registers, t);
415 INHERIT (to_prepare_to_store, t);
416 INHERIT (deprecated_xfer_memory, t);
417 INHERIT (to_files_info, t);
418 INHERIT (to_insert_breakpoint, t);
419 INHERIT (to_remove_breakpoint, t);
420 INHERIT (to_can_use_hw_breakpoint, t);
421 INHERIT (to_insert_hw_breakpoint, t);
422 INHERIT (to_remove_hw_breakpoint, t);
423 INHERIT (to_insert_watchpoint, t);
424 INHERIT (to_remove_watchpoint, t);
425 INHERIT (to_stopped_data_address, t);
426 INHERIT (to_have_steppable_watchpoint, t);
427 INHERIT (to_have_continuable_watchpoint, t);
428 INHERIT (to_stopped_by_watchpoint, t);
429 INHERIT (to_watchpoint_addr_within_range, t);
430 INHERIT (to_region_ok_for_hw_watchpoint, t);
431 INHERIT (to_terminal_init, t);
432 INHERIT (to_terminal_inferior, t);
433 INHERIT (to_terminal_ours_for_output, t);
434 INHERIT (to_terminal_ours, t);
435 INHERIT (to_terminal_save_ours, t);
436 INHERIT (to_terminal_info, t);
437 INHERIT (to_kill, t);
438 INHERIT (to_load, t);
439 INHERIT (to_lookup_symbol, t);
440 INHERIT (to_create_inferior, t);
441 INHERIT (to_post_startup_inferior, t);
442 INHERIT (to_acknowledge_created_inferior, t);
443 INHERIT (to_insert_fork_catchpoint, t);
444 INHERIT (to_remove_fork_catchpoint, t);
445 INHERIT (to_insert_vfork_catchpoint, t);
446 INHERIT (to_remove_vfork_catchpoint, t);
447 /* Do not inherit to_follow_fork. */
448 INHERIT (to_insert_exec_catchpoint, t);
449 INHERIT (to_remove_exec_catchpoint, t);
450 INHERIT (to_has_exited, t);
451 INHERIT (to_mourn_inferior, t);
452 INHERIT (to_can_run, t);
453 INHERIT (to_notice_signals, t);
454 INHERIT (to_thread_alive, t);
455 INHERIT (to_find_new_threads, t);
456 INHERIT (to_pid_to_str, t);
457 INHERIT (to_extra_thread_info, t);
458 INHERIT (to_stop, t);
459 /* Do not inherit to_xfer_partial. */
460 INHERIT (to_rcmd, t);
461 INHERIT (to_pid_to_exec_file, t);
462 INHERIT (to_log_command, t);
463 INHERIT (to_stratum, t);
464 INHERIT (to_has_all_memory, t);
465 INHERIT (to_has_memory, t);
466 INHERIT (to_has_stack, t);
467 INHERIT (to_has_registers, t);
468 INHERIT (to_has_execution, t);
469 INHERIT (to_has_thread_control, t);
470 INHERIT (to_sections, t);
471 INHERIT (to_sections_end, t);
472 INHERIT (to_can_async_p, t);
473 INHERIT (to_is_async_p, t);
474 INHERIT (to_async, t);
475 INHERIT (to_async_mask, t);
476 INHERIT (to_find_memory_regions, t);
477 INHERIT (to_make_corefile_notes, t);
478 INHERIT (to_get_thread_local_address, t);
479 /* Do not inherit to_read_description. */
480 /* Do not inherit to_search_memory. */
481 INHERIT (to_magic, t);
482 /* Do not inherit to_memory_map. */
483 /* Do not inherit to_flash_erase. */
484 /* Do not inherit to_flash_done. */
488 /* Clean up a target struct so it no longer has any zero pointers in
489 it. Some entries are defaulted to a method that print an error,
490 others are hard-wired to a standard recursive default. */
492 #define de_fault(field, value) \
493 if (!current_target.field) \
494 current_target.field = value
497 (void (*) (char *, int))
503 maybe_kill_then_attach);
504 de_fault (to_post_attach,
508 (void (*) (char *, int))
511 (void (*) (ptid_t, int, enum target_signal))
514 (ptid_t (*) (ptid_t, struct target_waitstatus *))
516 de_fault (to_fetch_registers,
517 (void (*) (struct regcache *, int))
519 de_fault (to_store_registers,
520 (void (*) (struct regcache *, int))
522 de_fault (to_prepare_to_store,
523 (void (*) (struct regcache *))
525 de_fault (deprecated_xfer_memory,
526 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
528 de_fault (to_files_info,
529 (void (*) (struct target_ops *))
531 de_fault (to_insert_breakpoint,
532 memory_insert_breakpoint);
533 de_fault (to_remove_breakpoint,
534 memory_remove_breakpoint);
535 de_fault (to_can_use_hw_breakpoint,
536 (int (*) (int, int, int))
538 de_fault (to_insert_hw_breakpoint,
539 (int (*) (struct bp_target_info *))
541 de_fault (to_remove_hw_breakpoint,
542 (int (*) (struct bp_target_info *))
544 de_fault (to_insert_watchpoint,
545 (int (*) (CORE_ADDR, int, int))
547 de_fault (to_remove_watchpoint,
548 (int (*) (CORE_ADDR, int, int))
550 de_fault (to_stopped_by_watchpoint,
553 de_fault (to_stopped_data_address,
554 (int (*) (struct target_ops *, CORE_ADDR *))
556 de_fault (to_watchpoint_addr_within_range,
557 default_watchpoint_addr_within_range);
558 de_fault (to_region_ok_for_hw_watchpoint,
559 default_region_ok_for_hw_watchpoint);
560 de_fault (to_terminal_init,
563 de_fault (to_terminal_inferior,
566 de_fault (to_terminal_ours_for_output,
569 de_fault (to_terminal_ours,
572 de_fault (to_terminal_save_ours,
575 de_fault (to_terminal_info,
576 default_terminal_info);
581 (void (*) (char *, int))
583 de_fault (to_lookup_symbol,
584 (int (*) (char *, CORE_ADDR *))
586 de_fault (to_create_inferior,
587 maybe_kill_then_create_inferior);
588 de_fault (to_post_startup_inferior,
591 de_fault (to_acknowledge_created_inferior,
594 de_fault (to_insert_fork_catchpoint,
597 de_fault (to_remove_fork_catchpoint,
600 de_fault (to_insert_vfork_catchpoint,
603 de_fault (to_remove_vfork_catchpoint,
606 de_fault (to_insert_exec_catchpoint,
609 de_fault (to_remove_exec_catchpoint,
612 de_fault (to_has_exited,
613 (int (*) (int, int, int *))
615 de_fault (to_mourn_inferior,
618 de_fault (to_can_run,
620 de_fault (to_notice_signals,
623 de_fault (to_thread_alive,
626 de_fault (to_find_new_threads,
629 de_fault (to_extra_thread_info,
630 (char *(*) (struct thread_info *))
635 current_target.to_xfer_partial = current_xfer_partial;
637 (void (*) (char *, struct ui_file *))
639 de_fault (to_pid_to_exec_file,
642 de_fault (to_can_async_p,
645 de_fault (to_is_async_p,
649 (void (*) (void (*) (enum inferior_event_type, void*), void*))
651 de_fault (to_async_mask,
654 current_target.to_read_description = NULL;
657 /* Finally, position the target-stack beneath the squashed
658 "current_target". That way code looking for a non-inherited
659 target method can quickly and simply find it. */
660 current_target.beneath = target_stack;
663 setup_target_debug ();
666 /* Mark OPS as a running target. This reverses the effect
667 of target_mark_exited. */
670 target_mark_running (struct target_ops *ops)
672 struct target_ops *t;
674 for (t = target_stack; t != NULL; t = t->beneath)
678 internal_error (__FILE__, __LINE__,
679 "Attempted to mark unpushed target \"%s\" as running",
682 ops->to_has_execution = 1;
683 ops->to_has_all_memory = 1;
684 ops->to_has_memory = 1;
685 ops->to_has_stack = 1;
686 ops->to_has_registers = 1;
688 update_current_target ();
691 /* Mark OPS as a non-running target. This reverses the effect
692 of target_mark_running. */
695 target_mark_exited (struct target_ops *ops)
697 struct target_ops *t;
699 for (t = target_stack; t != NULL; t = t->beneath)
703 internal_error (__FILE__, __LINE__,
704 "Attempted to mark unpushed target \"%s\" as running",
707 ops->to_has_execution = 0;
708 ops->to_has_all_memory = 0;
709 ops->to_has_memory = 0;
710 ops->to_has_stack = 0;
711 ops->to_has_registers = 0;
713 update_current_target ();
716 /* Push a new target type into the stack of the existing target accessors,
717 possibly superseding some of the existing accessors.
719 Result is zero if the pushed target ended up on top of the stack,
720 nonzero if at least one target is on top of it.
722 Rather than allow an empty stack, we always have the dummy target at
723 the bottom stratum, so we can call the function vectors without
727 push_target (struct target_ops *t)
729 struct target_ops **cur;
731 /* Check magic number. If wrong, it probably means someone changed
732 the struct definition, but not all the places that initialize one. */
733 if (t->to_magic != OPS_MAGIC)
735 fprintf_unfiltered (gdb_stderr,
736 "Magic number of %s target struct wrong\n",
738 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
741 /* Find the proper stratum to install this target in. */
742 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
744 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
748 /* If there's already targets at this stratum, remove them. */
749 /* FIXME: cagney/2003-10-15: I think this should be popping all
750 targets to CUR, and not just those at this stratum level. */
751 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
753 /* There's already something at this stratum level. Close it,
754 and un-hook it from the stack. */
755 struct target_ops *tmp = (*cur);
756 (*cur) = (*cur)->beneath;
758 target_close (tmp, 0);
761 /* We have removed all targets in our stratum, now add the new one. */
765 update_current_target ();
768 return (t != target_stack);
771 /* Remove a target_ops vector from the stack, wherever it may be.
772 Return how many times it was removed (0 or 1). */
775 unpush_target (struct target_ops *t)
777 struct target_ops **cur;
778 struct target_ops *tmp;
780 /* Look for the specified target. Note that we assume that a target
781 can only occur once in the target stack. */
783 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
790 return 0; /* Didn't find target_ops, quit now */
792 /* NOTE: cagney/2003-12-06: In '94 the close call was made
793 unconditional by moving it to before the above check that the
794 target was in the target stack (something about "Change the way
795 pushing and popping of targets work to support target overlays
796 and inheritance"). This doesn't make much sense - only open
797 targets should be closed. */
800 /* Unchain the target */
802 (*cur) = (*cur)->beneath;
805 update_current_target ();
813 target_close (¤t_target, 0); /* Let it clean up */
814 if (unpush_target (target_stack) == 1)
817 fprintf_unfiltered (gdb_stderr,
818 "pop_target couldn't find target %s\n",
819 current_target.to_shortname);
820 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
823 /* Using the objfile specified in OBJFILE, find the address for the
824 current thread's thread-local storage with offset OFFSET. */
826 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
828 volatile CORE_ADDR addr = 0;
830 if (target_get_thread_local_address_p ()
831 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch))
833 ptid_t ptid = inferior_ptid;
834 volatile struct gdb_exception ex;
836 TRY_CATCH (ex, RETURN_MASK_ALL)
840 /* Fetch the load module address for this objfile. */
841 lm_addr = gdbarch_fetch_tls_load_module_address (current_gdbarch,
843 /* If it's 0, throw the appropriate exception. */
845 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
846 _("TLS load module not found"));
848 addr = target_get_thread_local_address (ptid, lm_addr, offset);
850 /* If an error occurred, print TLS related messages here. Otherwise,
851 throw the error to some higher catcher. */
854 int objfile_is_library = (objfile->flags & OBJF_SHARED);
858 case TLS_NO_LIBRARY_SUPPORT_ERROR:
859 error (_("Cannot find thread-local variables in this thread library."));
861 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
862 if (objfile_is_library)
863 error (_("Cannot find shared library `%s' in dynamic"
864 " linker's load module list"), objfile->name);
866 error (_("Cannot find executable file `%s' in dynamic"
867 " linker's load module list"), objfile->name);
869 case TLS_NOT_ALLOCATED_YET_ERROR:
870 if (objfile_is_library)
871 error (_("The inferior has not yet allocated storage for"
872 " thread-local variables in\n"
873 "the shared library `%s'\n"
875 objfile->name, target_pid_to_str (ptid));
877 error (_("The inferior has not yet allocated storage for"
878 " thread-local variables in\n"
879 "the executable `%s'\n"
881 objfile->name, target_pid_to_str (ptid));
883 case TLS_GENERIC_ERROR:
884 if (objfile_is_library)
885 error (_("Cannot find thread-local storage for %s, "
886 "shared library %s:\n%s"),
887 target_pid_to_str (ptid),
888 objfile->name, ex.message);
890 error (_("Cannot find thread-local storage for %s, "
891 "executable file %s:\n%s"),
892 target_pid_to_str (ptid),
893 objfile->name, ex.message);
896 throw_exception (ex);
901 /* It wouldn't be wrong here to try a gdbarch method, too; finding
902 TLS is an ABI-specific thing. But we don't do that yet. */
904 error (_("Cannot find thread-local variables on this target"));
910 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
912 /* target_read_string -- read a null terminated string, up to LEN bytes,
913 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
914 Set *STRING to a pointer to malloc'd memory containing the data; the caller
915 is responsible for freeing it. Return the number of bytes successfully
919 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
921 int tlen, origlen, offset, i;
925 int buffer_allocated;
927 unsigned int nbytes_read = 0;
931 /* Small for testing. */
932 buffer_allocated = 4;
933 buffer = xmalloc (buffer_allocated);
940 tlen = MIN (len, 4 - (memaddr & 3));
941 offset = memaddr & 3;
943 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
946 /* The transfer request might have crossed the boundary to an
947 unallocated region of memory. Retry the transfer, requesting
951 errcode = target_read_memory (memaddr, buf, 1);
956 if (bufptr - buffer + tlen > buffer_allocated)
959 bytes = bufptr - buffer;
960 buffer_allocated *= 2;
961 buffer = xrealloc (buffer, buffer_allocated);
962 bufptr = buffer + bytes;
965 for (i = 0; i < tlen; i++)
967 *bufptr++ = buf[i + offset];
968 if (buf[i + offset] == '\000')
970 nbytes_read += i + 1;
986 /* Find a section containing ADDR. */
987 struct section_table *
988 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
990 struct section_table *secp;
991 for (secp = target->to_sections;
992 secp < target->to_sections_end;
995 if (addr >= secp->addr && addr < secp->endaddr)
1001 /* Perform a partial memory transfer. The arguments and return
1002 value are just as for target_xfer_partial. */
1005 memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
1006 ULONGEST memaddr, LONGEST len)
1010 struct mem_region *region;
1012 /* Zero length requests are ok and require no work. */
1016 /* Try the executable file, if "trust-readonly-sections" is set. */
1017 if (readbuf != NULL && trust_readonly)
1019 struct section_table *secp;
1021 secp = target_section_by_addr (ops, memaddr);
1023 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1025 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1028 /* Likewise for accesses to unmapped overlay sections. */
1029 if (readbuf != NULL && overlay_debugging)
1031 asection *section = find_pc_overlay (memaddr);
1032 if (pc_in_unmapped_range (memaddr, section))
1033 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1036 /* Try GDB's internal data cache. */
1037 region = lookup_mem_region (memaddr);
1038 /* region->hi == 0 means there's no upper bound. */
1039 if (memaddr + len < region->hi || region->hi == 0)
1042 reg_len = region->hi - memaddr;
1044 switch (region->attrib.mode)
1047 if (writebuf != NULL)
1052 if (readbuf != NULL)
1057 /* We only support writing to flash during "load" for now. */
1058 if (writebuf != NULL)
1059 error (_("Writing to flash memory forbidden in this context"));
1066 if (region->attrib.cache)
1068 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1069 memory request will start back at current_target. */
1070 if (readbuf != NULL)
1071 res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
1074 /* FIXME drow/2006-08-09: If we're going to preserve const
1075 correctness dcache_xfer_memory should take readbuf and
1077 res = dcache_xfer_memory (target_dcache, memaddr,
1084 if (readbuf && !show_memory_breakpoints)
1085 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1090 /* If none of those methods found the memory we wanted, fall back
1091 to a target partial transfer. Normally a single call to
1092 to_xfer_partial is enough; if it doesn't recognize an object
1093 it will call the to_xfer_partial of the next target down.
1094 But for memory this won't do. Memory is the only target
1095 object which can be read from more than one valid target.
1096 A core file, for instance, could have some of memory but
1097 delegate other bits to the target below it. So, we must
1098 manually try all targets. */
1102 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1103 readbuf, writebuf, memaddr, reg_len);
1107 /* We want to continue past core files to executables, but not
1108 past a running target's memory. */
1109 if (ops->to_has_all_memory)
1114 while (ops != NULL);
1116 if (readbuf && !show_memory_breakpoints)
1117 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1119 /* If we still haven't got anything, return the last error. We
1125 restore_show_memory_breakpoints (void *arg)
1127 show_memory_breakpoints = (uintptr_t) arg;
1131 make_show_memory_breakpoints_cleanup (int show)
1133 int current = show_memory_breakpoints;
1134 show_memory_breakpoints = show;
1136 return make_cleanup (restore_show_memory_breakpoints,
1137 (void *) (uintptr_t) current);
1141 target_xfer_partial (struct target_ops *ops,
1142 enum target_object object, const char *annex,
1143 void *readbuf, const void *writebuf,
1144 ULONGEST offset, LONGEST len)
1148 gdb_assert (ops->to_xfer_partial != NULL);
1150 /* If this is a memory transfer, let the memory-specific code
1151 have a look at it instead. Memory transfers are more
1153 if (object == TARGET_OBJECT_MEMORY)
1154 retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
1157 enum target_object raw_object = object;
1159 /* If this is a raw memory transfer, request the normal
1160 memory object from other layers. */
1161 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1162 raw_object = TARGET_OBJECT_MEMORY;
1164 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1165 writebuf, offset, len);
1170 const unsigned char *myaddr = NULL;
1172 fprintf_unfiltered (gdb_stdlog,
1173 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1176 (annex ? annex : "(null)"),
1177 (long) readbuf, (long) writebuf,
1178 paddr_nz (offset), paddr_d (len), paddr_d (retval));
1184 if (retval > 0 && myaddr != NULL)
1188 fputs_unfiltered (", bytes =", gdb_stdlog);
1189 for (i = 0; i < retval; i++)
1191 if ((((long) &(myaddr[i])) & 0xf) == 0)
1193 if (targetdebug < 2 && i > 0)
1195 fprintf_unfiltered (gdb_stdlog, " ...");
1198 fprintf_unfiltered (gdb_stdlog, "\n");
1201 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1205 fputc_unfiltered ('\n', gdb_stdlog);
1210 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1211 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1212 if any error occurs.
1214 If an error occurs, no guarantee is made about the contents of the data at
1215 MYADDR. In particular, the caller should not depend upon partial reads
1216 filling the buffer with good data. There is no way for the caller to know
1217 how much good data might have been transfered anyway. Callers that can
1218 deal with partial reads should call target_read (which will retry until
1219 it makes no progress, and then return how much was transferred). */
1222 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1224 if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1225 myaddr, memaddr, len) == len)
1232 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1234 if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1235 myaddr, memaddr, len) == len)
1241 /* Fetch the target's memory map. */
1244 target_memory_map (void)
1246 VEC(mem_region_s) *result;
1247 struct mem_region *last_one, *this_one;
1249 struct target_ops *t;
1252 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1254 for (t = current_target.beneath; t != NULL; t = t->beneath)
1255 if (t->to_memory_map != NULL)
1261 result = t->to_memory_map (t);
1265 qsort (VEC_address (mem_region_s, result),
1266 VEC_length (mem_region_s, result),
1267 sizeof (struct mem_region), mem_region_cmp);
1269 /* Check that regions do not overlap. Simultaneously assign
1270 a numbering for the "mem" commands to use to refer to
1273 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1275 this_one->number = ix;
1277 if (last_one && last_one->hi > this_one->lo)
1279 warning (_("Overlapping regions in memory map: ignoring"));
1280 VEC_free (mem_region_s, result);
1283 last_one = this_one;
1290 target_flash_erase (ULONGEST address, LONGEST length)
1292 struct target_ops *t;
1294 for (t = current_target.beneath; t != NULL; t = t->beneath)
1295 if (t->to_flash_erase != NULL)
1298 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1299 paddr (address), phex (length, 0));
1300 t->to_flash_erase (t, address, length);
1308 target_flash_done (void)
1310 struct target_ops *t;
1312 for (t = current_target.beneath; t != NULL; t = t->beneath)
1313 if (t->to_flash_done != NULL)
1316 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1317 t->to_flash_done (t);
1324 #ifndef target_stopped_data_address_p
1326 target_stopped_data_address_p (struct target_ops *target)
1328 if (target->to_stopped_data_address
1329 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
1331 if (target->to_stopped_data_address == debug_to_stopped_data_address
1332 && (debug_target.to_stopped_data_address
1333 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1340 show_trust_readonly (struct ui_file *file, int from_tty,
1341 struct cmd_list_element *c, const char *value)
1343 fprintf_filtered (file, _("\
1344 Mode for reading from readonly sections is %s.\n"),
1348 /* More generic transfers. */
1351 default_xfer_partial (struct target_ops *ops, enum target_object object,
1352 const char *annex, gdb_byte *readbuf,
1353 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1355 if (object == TARGET_OBJECT_MEMORY
1356 && ops->deprecated_xfer_memory != NULL)
1357 /* If available, fall back to the target's
1358 "deprecated_xfer_memory" method. */
1362 if (writebuf != NULL)
1364 void *buffer = xmalloc (len);
1365 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1366 memcpy (buffer, writebuf, len);
1367 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1368 1/*write*/, NULL, ops);
1369 do_cleanups (cleanup);
1371 if (readbuf != NULL)
1372 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1373 0/*read*/, NULL, ops);
1376 else if (xfered == 0 && errno == 0)
1377 /* "deprecated_xfer_memory" uses 0, cross checked against
1378 ERRNO as one indication of an error. */
1383 else if (ops->beneath != NULL)
1384 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1385 readbuf, writebuf, offset, len);
1390 /* The xfer_partial handler for the topmost target. Unlike the default,
1391 it does not need to handle memory specially; it just passes all
1392 requests down the stack. */
1395 current_xfer_partial (struct target_ops *ops, enum target_object object,
1396 const char *annex, gdb_byte *readbuf,
1397 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1399 if (ops->beneath != NULL)
1400 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1401 readbuf, writebuf, offset, len);
1406 /* Target vector read/write partial wrapper functions.
1408 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1409 (inbuf, outbuf)", instead of separate read/write methods, make life
1413 target_read_partial (struct target_ops *ops,
1414 enum target_object object,
1415 const char *annex, gdb_byte *buf,
1416 ULONGEST offset, LONGEST len)
1418 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1422 target_write_partial (struct target_ops *ops,
1423 enum target_object object,
1424 const char *annex, const gdb_byte *buf,
1425 ULONGEST offset, LONGEST len)
1427 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1430 /* Wrappers to perform the full transfer. */
1432 target_read (struct target_ops *ops,
1433 enum target_object object,
1434 const char *annex, gdb_byte *buf,
1435 ULONGEST offset, LONGEST len)
1438 while (xfered < len)
1440 LONGEST xfer = target_read_partial (ops, object, annex,
1441 (gdb_byte *) buf + xfered,
1442 offset + xfered, len - xfered);
1443 /* Call an observer, notifying them of the xfer progress? */
1454 /* An alternative to target_write with progress callbacks. */
1457 target_write_with_progress (struct target_ops *ops,
1458 enum target_object object,
1459 const char *annex, const gdb_byte *buf,
1460 ULONGEST offset, LONGEST len,
1461 void (*progress) (ULONGEST, void *), void *baton)
1465 /* Give the progress callback a chance to set up. */
1467 (*progress) (0, baton);
1469 while (xfered < len)
1471 LONGEST xfer = target_write_partial (ops, object, annex,
1472 (gdb_byte *) buf + xfered,
1473 offset + xfered, len - xfered);
1481 (*progress) (xfer, baton);
1490 target_write (struct target_ops *ops,
1491 enum target_object object,
1492 const char *annex, const gdb_byte *buf,
1493 ULONGEST offset, LONGEST len)
1495 return target_write_with_progress (ops, object, annex, buf, offset, len,
1499 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1500 the size of the transferred data. PADDING additional bytes are
1501 available in *BUF_P. This is a helper function for
1502 target_read_alloc; see the declaration of that function for more
1506 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1507 const char *annex, gdb_byte **buf_p, int padding)
1509 size_t buf_alloc, buf_pos;
1513 /* This function does not have a length parameter; it reads the
1514 entire OBJECT). Also, it doesn't support objects fetched partly
1515 from one target and partly from another (in a different stratum,
1516 e.g. a core file and an executable). Both reasons make it
1517 unsuitable for reading memory. */
1518 gdb_assert (object != TARGET_OBJECT_MEMORY);
1520 /* Start by reading up to 4K at a time. The target will throttle
1521 this number down if necessary. */
1523 buf = xmalloc (buf_alloc);
1527 n = target_read_partial (ops, object, annex, &buf[buf_pos],
1528 buf_pos, buf_alloc - buf_pos - padding);
1531 /* An error occurred. */
1537 /* Read all there was. */
1547 /* If the buffer is filling up, expand it. */
1548 if (buf_alloc < buf_pos * 2)
1551 buf = xrealloc (buf, buf_alloc);
1558 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1559 the size of the transferred data. See the declaration in "target.h"
1560 function for more information about the return value. */
1563 target_read_alloc (struct target_ops *ops, enum target_object object,
1564 const char *annex, gdb_byte **buf_p)
1566 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1569 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1570 returned as a string, allocated using xmalloc. If an error occurs
1571 or the transfer is unsupported, NULL is returned. Empty objects
1572 are returned as allocated but empty strings. A warning is issued
1573 if the result contains any embedded NUL bytes. */
1576 target_read_stralloc (struct target_ops *ops, enum target_object object,
1580 LONGEST transferred;
1582 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1584 if (transferred < 0)
1587 if (transferred == 0)
1588 return xstrdup ("");
1590 buffer[transferred] = 0;
1591 if (strlen (buffer) < transferred)
1592 warning (_("target object %d, annex %s, "
1593 "contained unexpected null characters"),
1594 (int) object, annex ? annex : "(none)");
1596 return (char *) buffer;
1599 /* Memory transfer methods. */
1602 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1605 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1607 memory_error (EIO, addr);
1611 get_target_memory_unsigned (struct target_ops *ops,
1612 CORE_ADDR addr, int len)
1614 gdb_byte buf[sizeof (ULONGEST)];
1616 gdb_assert (len <= sizeof (buf));
1617 get_target_memory (ops, addr, buf, len);
1618 return extract_unsigned_integer (buf, len);
1622 target_info (char *args, int from_tty)
1624 struct target_ops *t;
1625 int has_all_mem = 0;
1627 if (symfile_objfile != NULL)
1628 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1630 for (t = target_stack; t != NULL; t = t->beneath)
1632 if (!t->to_has_memory)
1635 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1638 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1639 printf_unfiltered ("%s:\n", t->to_longname);
1640 (t->to_files_info) (t);
1641 has_all_mem = t->to_has_all_memory;
1645 /* This function is called before any new inferior is created, e.g.
1646 by running a program, attaching, or connecting to a target.
1647 It cleans up any state from previous invocations which might
1648 change between runs. This is a subset of what target_preopen
1649 resets (things which might change between targets). */
1652 target_pre_inferior (int from_tty)
1654 invalidate_target_mem_regions ();
1656 target_clear_description ();
1659 /* This is to be called by the open routine before it does
1663 target_preopen (int from_tty)
1667 if (target_has_execution)
1670 || query (_("A program is being debugged already. Kill it? ")))
1673 error (_("Program not killed."));
1676 /* Calling target_kill may remove the target from the stack. But if
1677 it doesn't (which seems like a win for UDI), remove it now. */
1679 if (target_has_execution)
1682 target_pre_inferior (from_tty);
1685 /* Detach a target after doing deferred register stores. */
1688 target_detach (char *args, int from_tty)
1690 /* If we're in breakpoints-always-inserted mode, have to
1691 remove them before detaching. */
1692 remove_breakpoints ();
1694 (current_target.to_detach) (args, from_tty);
1698 target_disconnect (char *args, int from_tty)
1700 struct target_ops *t;
1702 /* If we're in breakpoints-always-inserted mode, have to
1703 remove them before disconnecting. */
1704 remove_breakpoints ();
1706 for (t = current_target.beneath; t != NULL; t = t->beneath)
1707 if (t->to_disconnect != NULL)
1710 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1712 t->to_disconnect (t, args, from_tty);
1720 target_resume (ptid_t ptid, int step, enum target_signal signal)
1722 dcache_invalidate (target_dcache);
1723 (*current_target.to_resume) (ptid, step, signal);
1724 set_running (ptid, 1);
1727 /* Look through the list of possible targets for a target that can
1731 target_follow_fork (int follow_child)
1733 struct target_ops *t;
1735 for (t = current_target.beneath; t != NULL; t = t->beneath)
1737 if (t->to_follow_fork != NULL)
1739 int retval = t->to_follow_fork (t, follow_child);
1741 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1742 follow_child, retval);
1747 /* Some target returned a fork event, but did not know how to follow it. */
1748 internal_error (__FILE__, __LINE__,
1749 "could not find a target to follow fork");
1752 /* Look for a target which can describe architectural features, starting
1753 from TARGET. If we find one, return its description. */
1755 const struct target_desc *
1756 target_read_description (struct target_ops *target)
1758 struct target_ops *t;
1760 for (t = target; t != NULL; t = t->beneath)
1761 if (t->to_read_description != NULL)
1763 const struct target_desc *tdesc;
1765 tdesc = t->to_read_description (t);
1773 /* The default implementation of to_search_memory.
1774 This implements a basic search of memory, reading target memory and
1775 performing the search here (as opposed to performing the search in on the
1776 target side with, for example, gdbserver). */
1779 simple_search_memory (struct target_ops *ops,
1780 CORE_ADDR start_addr, ULONGEST search_space_len,
1781 const gdb_byte *pattern, ULONGEST pattern_len,
1782 CORE_ADDR *found_addrp)
1784 /* NOTE: also defined in find.c testcase. */
1785 #define SEARCH_CHUNK_SIZE 16000
1786 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1787 /* Buffer to hold memory contents for searching. */
1788 gdb_byte *search_buf;
1789 unsigned search_buf_size;
1790 struct cleanup *old_cleanups;
1792 search_buf_size = chunk_size + pattern_len - 1;
1794 /* No point in trying to allocate a buffer larger than the search space. */
1795 if (search_space_len < search_buf_size)
1796 search_buf_size = search_space_len;
1798 search_buf = malloc (search_buf_size);
1799 if (search_buf == NULL)
1800 error (_("Unable to allocate memory to perform the search."));
1801 old_cleanups = make_cleanup (free_current_contents, &search_buf);
1803 /* Prime the search buffer. */
1805 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1806 search_buf, start_addr, search_buf_size) != search_buf_size)
1808 warning (_("Unable to access target memory at %s, halting search."),
1809 hex_string (start_addr));
1810 do_cleanups (old_cleanups);
1814 /* Perform the search.
1816 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1817 When we've scanned N bytes we copy the trailing bytes to the start and
1818 read in another N bytes. */
1820 while (search_space_len >= pattern_len)
1822 gdb_byte *found_ptr;
1823 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
1825 found_ptr = memmem (search_buf, nr_search_bytes,
1826 pattern, pattern_len);
1828 if (found_ptr != NULL)
1830 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
1831 *found_addrp = found_addr;
1832 do_cleanups (old_cleanups);
1836 /* Not found in this chunk, skip to next chunk. */
1838 /* Don't let search_space_len wrap here, it's unsigned. */
1839 if (search_space_len >= chunk_size)
1840 search_space_len -= chunk_size;
1842 search_space_len = 0;
1844 if (search_space_len >= pattern_len)
1846 unsigned keep_len = search_buf_size - chunk_size;
1847 CORE_ADDR read_addr = start_addr + keep_len;
1850 /* Copy the trailing part of the previous iteration to the front
1851 of the buffer for the next iteration. */
1852 gdb_assert (keep_len == pattern_len - 1);
1853 memcpy (search_buf, search_buf + chunk_size, keep_len);
1855 nr_to_read = min (search_space_len - keep_len, chunk_size);
1857 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1858 search_buf + keep_len, read_addr,
1859 nr_to_read) != nr_to_read)
1861 warning (_("Unable to access target memory at %s, halting search."),
1862 hex_string (read_addr));
1863 do_cleanups (old_cleanups);
1867 start_addr += chunk_size;
1873 do_cleanups (old_cleanups);
1877 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1878 sequence of bytes in PATTERN with length PATTERN_LEN.
1880 The result is 1 if found, 0 if not found, and -1 if there was an error
1881 requiring halting of the search (e.g. memory read error).
1882 If the pattern is found the address is recorded in FOUND_ADDRP. */
1885 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
1886 const gdb_byte *pattern, ULONGEST pattern_len,
1887 CORE_ADDR *found_addrp)
1889 struct target_ops *t;
1892 /* We don't use INHERIT to set current_target.to_search_memory,
1893 so we have to scan the target stack and handle targetdebug
1897 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
1898 hex_string (start_addr));
1900 for (t = current_target.beneath; t != NULL; t = t->beneath)
1901 if (t->to_search_memory != NULL)
1906 found = t->to_search_memory (t, start_addr, search_space_len,
1907 pattern, pattern_len, found_addrp);
1911 /* If a special version of to_search_memory isn't available, use the
1913 found = simple_search_memory (¤t_target,
1914 start_addr, search_space_len,
1915 pattern, pattern_len, found_addrp);
1919 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
1924 /* Look through the currently pushed targets. If none of them will
1925 be able to restart the currently running process, issue an error
1929 target_require_runnable (void)
1931 struct target_ops *t;
1933 for (t = target_stack; t != NULL; t = t->beneath)
1935 /* If this target knows how to create a new program, then
1936 assume we will still be able to after killing the current
1937 one. Either killing and mourning will not pop T, or else
1938 find_default_run_target will find it again. */
1939 if (t->to_create_inferior != NULL)
1942 /* Do not worry about thread_stratum targets that can not
1943 create inferiors. Assume they will be pushed again if
1944 necessary, and continue to the process_stratum. */
1945 if (t->to_stratum == thread_stratum)
1949 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
1953 /* This function is only called if the target is running. In that
1954 case there should have been a process_stratum target and it
1955 should either know how to create inferiors, or not... */
1956 internal_error (__FILE__, __LINE__, "No targets found");
1959 /* Look through the list of possible targets for a target that can
1960 execute a run or attach command without any other data. This is
1961 used to locate the default process stratum.
1963 If DO_MESG is not NULL, the result is always valid (error() is
1964 called for errors); else, return NULL on error. */
1966 static struct target_ops *
1967 find_default_run_target (char *do_mesg)
1969 struct target_ops **t;
1970 struct target_ops *runable = NULL;
1975 for (t = target_structs; t < target_structs + target_struct_size;
1978 if ((*t)->to_can_run && target_can_run (*t))
1988 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
1997 find_default_attach (char *args, int from_tty)
1999 struct target_ops *t;
2001 t = find_default_run_target ("attach");
2002 (t->to_attach) (args, from_tty);
2007 find_default_create_inferior (char *exec_file, char *allargs, char **env,
2010 struct target_ops *t;
2012 t = find_default_run_target ("run");
2013 (t->to_create_inferior) (exec_file, allargs, env, from_tty);
2018 find_default_can_async_p (void)
2020 struct target_ops *t;
2022 /* This may be called before the target is pushed on the stack;
2023 look for the default process stratum. If there's none, gdb isn't
2024 configured with a native debugger, and target remote isn't
2026 t = find_default_run_target (NULL);
2027 if (t && t->to_can_async_p)
2028 return (t->to_can_async_p) ();
2033 find_default_is_async_p (void)
2035 struct target_ops *t;
2037 /* This may be called before the target is pushed on the stack;
2038 look for the default process stratum. If there's none, gdb isn't
2039 configured with a native debugger, and target remote isn't
2041 t = find_default_run_target (NULL);
2042 if (t && t->to_is_async_p)
2043 return (t->to_is_async_p) ();
2048 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2050 return (len <= TYPE_LENGTH (builtin_type_void_data_ptr));
2054 default_watchpoint_addr_within_range (struct target_ops *target,
2056 CORE_ADDR start, int length)
2058 return addr >= start && addr < start + length;
2074 return_minus_one (void)
2080 * Resize the to_sections pointer. Also make sure that anyone that
2081 * was holding on to an old value of it gets updated.
2082 * Returns the old size.
2086 target_resize_to_sections (struct target_ops *target, int num_added)
2088 struct target_ops **t;
2089 struct section_table *old_value;
2092 old_value = target->to_sections;
2094 if (target->to_sections)
2096 old_count = target->to_sections_end - target->to_sections;
2097 target->to_sections = (struct section_table *)
2098 xrealloc ((char *) target->to_sections,
2099 (sizeof (struct section_table)) * (num_added + old_count));
2104 target->to_sections = (struct section_table *)
2105 xmalloc ((sizeof (struct section_table)) * num_added);
2107 target->to_sections_end = target->to_sections + (num_added + old_count);
2109 /* Check to see if anyone else was pointing to this structure.
2110 If old_value was null, then no one was. */
2114 for (t = target_structs; t < target_structs + target_struct_size;
2117 if ((*t)->to_sections == old_value)
2119 (*t)->to_sections = target->to_sections;
2120 (*t)->to_sections_end = target->to_sections_end;
2123 /* There is a flattened view of the target stack in current_target,
2124 so its to_sections pointer might also need updating. */
2125 if (current_target.to_sections == old_value)
2127 current_target.to_sections = target->to_sections;
2128 current_target.to_sections_end = target->to_sections_end;
2136 /* Remove all target sections taken from ABFD.
2138 Scan the current target stack for targets whose section tables
2139 refer to sections from BFD, and remove those sections. We use this
2140 when we notice that the inferior has unloaded a shared object, for
2143 remove_target_sections (bfd *abfd)
2145 struct target_ops **t;
2147 for (t = target_structs; t < target_structs + target_struct_size; t++)
2149 struct section_table *src, *dest;
2151 dest = (*t)->to_sections;
2152 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
2153 if (src->bfd != abfd)
2155 /* Keep this section. */
2156 if (dest < src) *dest = *src;
2160 /* If we've dropped any sections, resize the section table. */
2162 target_resize_to_sections (*t, dest - src);
2169 /* Find a single runnable target in the stack and return it. If for
2170 some reason there is more than one, return NULL. */
2173 find_run_target (void)
2175 struct target_ops **t;
2176 struct target_ops *runable = NULL;
2181 for (t = target_structs; t < target_structs + target_struct_size; ++t)
2183 if ((*t)->to_can_run && target_can_run (*t))
2190 return (count == 1 ? runable : NULL);
2193 /* Find a single core_stratum target in the list of targets and return it.
2194 If for some reason there is more than one, return NULL. */
2197 find_core_target (void)
2199 struct target_ops **t;
2200 struct target_ops *runable = NULL;
2205 for (t = target_structs; t < target_structs + target_struct_size;
2208 if ((*t)->to_stratum == core_stratum)
2215 return (count == 1 ? runable : NULL);
2219 * Find the next target down the stack from the specified target.
2223 find_target_beneath (struct target_ops *t)
2229 /* The inferior process has died. Long live the inferior! */
2232 generic_mourn_inferior (void)
2234 extern int show_breakpoint_hit_counts;
2236 inferior_ptid = null_ptid;
2238 breakpoint_init_inferior (inf_exited);
2239 registers_changed ();
2241 reopen_exec_file ();
2242 reinit_frame_cache ();
2244 /* It is confusing to the user for ignore counts to stick around
2245 from previous runs of the inferior. So clear them. */
2246 /* However, it is more confusing for the ignore counts to disappear when
2247 using hit counts. So don't clear them if we're counting hits. */
2248 if (!show_breakpoint_hit_counts)
2249 breakpoint_clear_ignore_counts ();
2251 if (deprecated_detach_hook)
2252 deprecated_detach_hook ();
2255 /* Helper function for child_wait and the derivatives of child_wait.
2256 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2257 translation of that in OURSTATUS. */
2259 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2261 if (WIFEXITED (hoststatus))
2263 ourstatus->kind = TARGET_WAITKIND_EXITED;
2264 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2266 else if (!WIFSTOPPED (hoststatus))
2268 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2269 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2273 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2274 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2278 /* Returns zero to leave the inferior alone, one to interrupt it. */
2279 int (*target_activity_function) (void);
2280 int target_activity_fd;
2282 /* Convert a normal process ID to a string. Returns the string in a
2286 normal_pid_to_str (ptid_t ptid)
2288 static char buf[32];
2290 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
2294 /* Error-catcher for target_find_memory_regions */
2295 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2297 error (_("No target."));
2301 /* Error-catcher for target_make_corefile_notes */
2302 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2304 error (_("No target."));
2308 /* Set up the handful of non-empty slots needed by the dummy target
2312 init_dummy_target (void)
2314 dummy_target.to_shortname = "None";
2315 dummy_target.to_longname = "None";
2316 dummy_target.to_doc = "";
2317 dummy_target.to_attach = find_default_attach;
2318 dummy_target.to_create_inferior = find_default_create_inferior;
2319 dummy_target.to_can_async_p = find_default_can_async_p;
2320 dummy_target.to_is_async_p = find_default_is_async_p;
2321 dummy_target.to_pid_to_str = normal_pid_to_str;
2322 dummy_target.to_stratum = dummy_stratum;
2323 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2324 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
2325 dummy_target.to_xfer_partial = default_xfer_partial;
2326 dummy_target.to_magic = OPS_MAGIC;
2330 debug_to_open (char *args, int from_tty)
2332 debug_target.to_open (args, from_tty);
2334 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2338 debug_to_close (int quitting)
2340 target_close (&debug_target, quitting);
2341 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2345 target_close (struct target_ops *targ, int quitting)
2347 if (targ->to_xclose != NULL)
2348 targ->to_xclose (targ, quitting);
2349 else if (targ->to_close != NULL)
2350 targ->to_close (quitting);
2354 debug_to_attach (char *args, int from_tty)
2356 debug_target.to_attach (args, from_tty);
2358 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
2363 debug_to_post_attach (int pid)
2365 debug_target.to_post_attach (pid);
2367 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2371 debug_to_detach (char *args, int from_tty)
2373 debug_target.to_detach (args, from_tty);
2375 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
2379 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
2381 debug_target.to_resume (ptid, step, siggnal);
2383 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
2384 step ? "step" : "continue",
2385 target_signal_to_name (siggnal));
2389 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
2393 retval = debug_target.to_wait (ptid, status);
2395 fprintf_unfiltered (gdb_stdlog,
2396 "target_wait (%d, status) = %d, ", PIDGET (ptid),
2398 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
2399 switch (status->kind)
2401 case TARGET_WAITKIND_EXITED:
2402 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
2403 status->value.integer);
2405 case TARGET_WAITKIND_STOPPED:
2406 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
2407 target_signal_to_name (status->value.sig));
2409 case TARGET_WAITKIND_SIGNALLED:
2410 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
2411 target_signal_to_name (status->value.sig));
2413 case TARGET_WAITKIND_LOADED:
2414 fprintf_unfiltered (gdb_stdlog, "loaded\n");
2416 case TARGET_WAITKIND_FORKED:
2417 fprintf_unfiltered (gdb_stdlog, "forked\n");
2419 case TARGET_WAITKIND_VFORKED:
2420 fprintf_unfiltered (gdb_stdlog, "vforked\n");
2422 case TARGET_WAITKIND_EXECD:
2423 fprintf_unfiltered (gdb_stdlog, "execd\n");
2425 case TARGET_WAITKIND_SPURIOUS:
2426 fprintf_unfiltered (gdb_stdlog, "spurious\n");
2429 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
2437 debug_print_register (const char * func,
2438 struct regcache *regcache, int regno)
2440 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2441 fprintf_unfiltered (gdb_stdlog, "%s ", func);
2442 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
2443 + gdbarch_num_pseudo_regs (gdbarch)
2444 && gdbarch_register_name (gdbarch, regno) != NULL
2445 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
2446 fprintf_unfiltered (gdb_stdlog, "(%s)",
2447 gdbarch_register_name (gdbarch, regno));
2449 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2452 int i, size = register_size (gdbarch, regno);
2453 unsigned char buf[MAX_REGISTER_SIZE];
2454 regcache_cooked_read (regcache, regno, buf);
2455 fprintf_unfiltered (gdb_stdlog, " = ");
2456 for (i = 0; i < size; i++)
2458 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2460 if (size <= sizeof (LONGEST))
2462 ULONGEST val = extract_unsigned_integer (buf, size);
2463 fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
2464 paddr_nz (val), paddr_d (val));
2467 fprintf_unfiltered (gdb_stdlog, "\n");
2471 debug_to_fetch_registers (struct regcache *regcache, int regno)
2473 debug_target.to_fetch_registers (regcache, regno);
2474 debug_print_register ("target_fetch_registers", regcache, regno);
2478 debug_to_store_registers (struct regcache *regcache, int regno)
2480 debug_target.to_store_registers (regcache, regno);
2481 debug_print_register ("target_store_registers", regcache, regno);
2482 fprintf_unfiltered (gdb_stdlog, "\n");
2486 debug_to_prepare_to_store (struct regcache *regcache)
2488 debug_target.to_prepare_to_store (regcache);
2490 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2494 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2495 int write, struct mem_attrib *attrib,
2496 struct target_ops *target)
2500 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2503 fprintf_unfiltered (gdb_stdlog,
2504 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2505 (unsigned int) memaddr, /* possable truncate long long */
2506 len, write ? "write" : "read", retval);
2512 fputs_unfiltered (", bytes =", gdb_stdlog);
2513 for (i = 0; i < retval; i++)
2515 if ((((long) &(myaddr[i])) & 0xf) == 0)
2517 if (targetdebug < 2 && i > 0)
2519 fprintf_unfiltered (gdb_stdlog, " ...");
2522 fprintf_unfiltered (gdb_stdlog, "\n");
2525 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2529 fputc_unfiltered ('\n', gdb_stdlog);
2535 debug_to_files_info (struct target_ops *target)
2537 debug_target.to_files_info (target);
2539 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2543 debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
2547 retval = debug_target.to_insert_breakpoint (bp_tgt);
2549 fprintf_unfiltered (gdb_stdlog,
2550 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2551 (unsigned long) bp_tgt->placed_address,
2552 (unsigned long) retval);
2557 debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
2561 retval = debug_target.to_remove_breakpoint (bp_tgt);
2563 fprintf_unfiltered (gdb_stdlog,
2564 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2565 (unsigned long) bp_tgt->placed_address,
2566 (unsigned long) retval);
2571 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2575 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2577 fprintf_unfiltered (gdb_stdlog,
2578 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2579 (unsigned long) type,
2580 (unsigned long) cnt,
2581 (unsigned long) from_tty,
2582 (unsigned long) retval);
2587 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2591 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2593 fprintf_unfiltered (gdb_stdlog,
2594 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2595 (unsigned long) addr,
2596 (unsigned long) len,
2597 (unsigned long) retval);
2602 debug_to_stopped_by_watchpoint (void)
2606 retval = debug_target.to_stopped_by_watchpoint ();
2608 fprintf_unfiltered (gdb_stdlog,
2609 "STOPPED_BY_WATCHPOINT () = %ld\n",
2610 (unsigned long) retval);
2615 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2619 retval = debug_target.to_stopped_data_address (target, addr);
2621 fprintf_unfiltered (gdb_stdlog,
2622 "target_stopped_data_address ([0x%lx]) = %ld\n",
2623 (unsigned long)*addr,
2624 (unsigned long)retval);
2629 debug_to_watchpoint_addr_within_range (struct target_ops *target,
2631 CORE_ADDR start, int length)
2635 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
2638 fprintf_filtered (gdb_stdlog,
2639 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2640 (unsigned long) addr, (unsigned long) start, length,
2646 debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
2650 retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
2652 fprintf_unfiltered (gdb_stdlog,
2653 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2654 (unsigned long) bp_tgt->placed_address,
2655 (unsigned long) retval);
2660 debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
2664 retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
2666 fprintf_unfiltered (gdb_stdlog,
2667 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2668 (unsigned long) bp_tgt->placed_address,
2669 (unsigned long) retval);
2674 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2678 retval = debug_target.to_insert_watchpoint (addr, len, type);
2680 fprintf_unfiltered (gdb_stdlog,
2681 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2682 (unsigned long) addr, len, type, (unsigned long) retval);
2687 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2691 retval = debug_target.to_remove_watchpoint (addr, len, type);
2693 fprintf_unfiltered (gdb_stdlog,
2694 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2695 (unsigned long) addr, len, type, (unsigned long) retval);
2700 debug_to_terminal_init (void)
2702 debug_target.to_terminal_init ();
2704 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2708 debug_to_terminal_inferior (void)
2710 debug_target.to_terminal_inferior ();
2712 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2716 debug_to_terminal_ours_for_output (void)
2718 debug_target.to_terminal_ours_for_output ();
2720 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2724 debug_to_terminal_ours (void)
2726 debug_target.to_terminal_ours ();
2728 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2732 debug_to_terminal_save_ours (void)
2734 debug_target.to_terminal_save_ours ();
2736 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2740 debug_to_terminal_info (char *arg, int from_tty)
2742 debug_target.to_terminal_info (arg, from_tty);
2744 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2749 debug_to_kill (void)
2751 debug_target.to_kill ();
2753 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2757 debug_to_load (char *args, int from_tty)
2759 debug_target.to_load (args, from_tty);
2761 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2765 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2769 retval = debug_target.to_lookup_symbol (name, addrp);
2771 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2777 debug_to_create_inferior (char *exec_file, char *args, char **env,
2780 debug_target.to_create_inferior (exec_file, args, env, from_tty);
2782 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2783 exec_file, args, from_tty);
2787 debug_to_post_startup_inferior (ptid_t ptid)
2789 debug_target.to_post_startup_inferior (ptid);
2791 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2796 debug_to_acknowledge_created_inferior (int pid)
2798 debug_target.to_acknowledge_created_inferior (pid);
2800 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2805 debug_to_insert_fork_catchpoint (int pid)
2807 debug_target.to_insert_fork_catchpoint (pid);
2809 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
2814 debug_to_remove_fork_catchpoint (int pid)
2818 retval = debug_target.to_remove_fork_catchpoint (pid);
2820 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2827 debug_to_insert_vfork_catchpoint (int pid)
2829 debug_target.to_insert_vfork_catchpoint (pid);
2831 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
2836 debug_to_remove_vfork_catchpoint (int pid)
2840 retval = debug_target.to_remove_vfork_catchpoint (pid);
2842 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2849 debug_to_insert_exec_catchpoint (int pid)
2851 debug_target.to_insert_exec_catchpoint (pid);
2853 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
2858 debug_to_remove_exec_catchpoint (int pid)
2862 retval = debug_target.to_remove_exec_catchpoint (pid);
2864 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2871 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2875 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2877 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2878 pid, wait_status, *exit_status, has_exited);
2884 debug_to_mourn_inferior (void)
2886 debug_target.to_mourn_inferior ();
2888 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2892 debug_to_can_run (void)
2896 retval = debug_target.to_can_run ();
2898 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2904 debug_to_notice_signals (ptid_t ptid)
2906 debug_target.to_notice_signals (ptid);
2908 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2913 debug_to_thread_alive (ptid_t ptid)
2917 retval = debug_target.to_thread_alive (ptid);
2919 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2920 PIDGET (ptid), retval);
2926 debug_to_find_new_threads (void)
2928 debug_target.to_find_new_threads ();
2930 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2934 debug_to_stop (void)
2936 debug_target.to_stop ();
2938 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2942 debug_to_rcmd (char *command,
2943 struct ui_file *outbuf)
2945 debug_target.to_rcmd (command, outbuf);
2946 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2950 debug_to_pid_to_exec_file (int pid)
2954 exec_file = debug_target.to_pid_to_exec_file (pid);
2956 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2963 setup_target_debug (void)
2965 memcpy (&debug_target, ¤t_target, sizeof debug_target);
2967 current_target.to_open = debug_to_open;
2968 current_target.to_close = debug_to_close;
2969 current_target.to_attach = debug_to_attach;
2970 current_target.to_post_attach = debug_to_post_attach;
2971 current_target.to_detach = debug_to_detach;
2972 current_target.to_resume = debug_to_resume;
2973 current_target.to_wait = debug_to_wait;
2974 current_target.to_fetch_registers = debug_to_fetch_registers;
2975 current_target.to_store_registers = debug_to_store_registers;
2976 current_target.to_prepare_to_store = debug_to_prepare_to_store;
2977 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
2978 current_target.to_files_info = debug_to_files_info;
2979 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2980 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2981 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2982 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2983 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2984 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2985 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2986 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2987 current_target.to_stopped_data_address = debug_to_stopped_data_address;
2988 current_target.to_watchpoint_addr_within_range = debug_to_watchpoint_addr_within_range;
2989 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
2990 current_target.to_terminal_init = debug_to_terminal_init;
2991 current_target.to_terminal_inferior = debug_to_terminal_inferior;
2992 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2993 current_target.to_terminal_ours = debug_to_terminal_ours;
2994 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2995 current_target.to_terminal_info = debug_to_terminal_info;
2996 current_target.to_kill = debug_to_kill;
2997 current_target.to_load = debug_to_load;
2998 current_target.to_lookup_symbol = debug_to_lookup_symbol;
2999 current_target.to_create_inferior = debug_to_create_inferior;
3000 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
3001 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
3002 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
3003 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
3004 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
3005 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
3006 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
3007 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
3008 current_target.to_has_exited = debug_to_has_exited;
3009 current_target.to_mourn_inferior = debug_to_mourn_inferior;
3010 current_target.to_can_run = debug_to_can_run;
3011 current_target.to_notice_signals = debug_to_notice_signals;
3012 current_target.to_thread_alive = debug_to_thread_alive;
3013 current_target.to_find_new_threads = debug_to_find_new_threads;
3014 current_target.to_stop = debug_to_stop;
3015 current_target.to_rcmd = debug_to_rcmd;
3016 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
3020 static char targ_desc[] =
3021 "Names of targets and files being debugged.\n\
3022 Shows the entire stack of targets currently in use (including the exec-file,\n\
3023 core-file, and process, if any), as well as the symbol file name.";
3026 do_monitor_command (char *cmd,
3029 if ((current_target.to_rcmd
3030 == (void (*) (char *, struct ui_file *)) tcomplain)
3031 || (current_target.to_rcmd == debug_to_rcmd
3032 && (debug_target.to_rcmd
3033 == (void (*) (char *, struct ui_file *)) tcomplain)))
3034 error (_("\"monitor\" command not supported by this target."));
3035 target_rcmd (cmd, gdb_stdtarg);
3038 /* Print the name of each layers of our target stack. */
3041 maintenance_print_target_stack (char *cmd, int from_tty)
3043 struct target_ops *t;
3045 printf_filtered (_("The current target stack is:\n"));
3047 for (t = target_stack; t != NULL; t = t->beneath)
3049 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3054 initialize_targets (void)
3056 init_dummy_target ();
3057 push_target (&dummy_target);
3059 add_info ("target", target_info, targ_desc);
3060 add_info ("files", target_info, targ_desc);
3062 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3063 Set target debugging."), _("\
3064 Show target debugging."), _("\
3065 When non-zero, target debugging is enabled. Higher numbers are more\n\
3066 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3070 &setdebuglist, &showdebuglist);
3072 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
3073 &trust_readonly, _("\
3074 Set mode for reading from readonly sections."), _("\
3075 Show mode for reading from readonly sections."), _("\
3076 When this mode is on, memory reads from readonly sections (such as .text)\n\
3077 will be read from the object file instead of from the target. This will\n\
3078 result in significant performance improvement for remote targets."),
3080 show_trust_readonly,
3081 &setlist, &showlist);
3083 add_com ("monitor", class_obscure, do_monitor_command,
3084 _("Send a command to the remote monitor (remote targets only)."));
3086 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3087 _("Print the name of each layer of the internal target stack."),
3088 &maintenanceprintlist);
3090 target_dcache = dcache_init ();