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
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"
43 static void target_info (char *, int);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
53 static int nosymbol (char *, CORE_ADDR *);
55 static void tcomplain (void) ATTR_NORETURN;
57 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops *find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static LONGEST default_xfer_partial (struct target_ops *ops,
74 enum target_object object,
75 const char *annex, gdb_byte *readbuf,
76 const gdb_byte *writebuf,
77 ULONGEST offset, LONGEST len);
79 static LONGEST current_xfer_partial (struct target_ops *ops,
80 enum target_object object,
81 const char *annex, gdb_byte *readbuf,
82 const gdb_byte *writebuf,
83 ULONGEST offset, LONGEST len);
85 static LONGEST target_xfer_partial (struct target_ops *ops,
86 enum target_object object,
88 void *readbuf, const void *writebuf,
89 ULONGEST offset, LONGEST len);
91 static void init_dummy_target (void);
93 static struct target_ops debug_target;
95 static void debug_to_open (char *, int);
97 static void debug_to_close (int);
99 static void debug_to_attach (char *, int);
101 static void debug_to_detach (char *, int);
103 static void debug_to_resume (ptid_t, int, enum target_signal);
105 static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
107 static void debug_to_fetch_registers (struct regcache *, int);
109 static void debug_to_store_registers (struct regcache *, int);
111 static void debug_to_prepare_to_store (struct regcache *);
113 static void debug_to_files_info (struct target_ops *);
115 static int debug_to_insert_breakpoint (struct bp_target_info *);
117 static int debug_to_remove_breakpoint (struct bp_target_info *);
119 static int debug_to_can_use_hw_breakpoint (int, int, int);
121 static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
123 static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
125 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
127 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
129 static int debug_to_stopped_by_watchpoint (void);
131 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
133 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_terminal_info (char *, int);
147 static void debug_to_kill (void);
149 static void debug_to_load (char *, int);
151 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t);
159 static int debug_to_thread_alive (ptid_t);
161 static void debug_to_stop (void);
163 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
164 wierd and mysterious ways. Putting the variable here lets those
165 wierd and mysterious ways keep building while they are being
166 converted to the inferior inheritance structure. */
167 struct target_ops deprecated_child_ops;
169 /* Pointer to array of target architecture structures; the size of the
170 array; the current index into the array; the allocated size of the
172 struct target_ops **target_structs;
173 unsigned target_struct_size;
174 unsigned target_struct_index;
175 unsigned target_struct_allocsize;
176 #define DEFAULT_ALLOCSIZE 10
178 /* The initial current target, so that there is always a semi-valid
181 static struct target_ops dummy_target;
183 /* Top of target stack. */
185 static struct target_ops *target_stack;
187 /* The target structure we are currently using to talk to a process
188 or file or whatever "inferior" we have. */
190 struct target_ops current_target;
192 /* Command list for target. */
194 static struct cmd_list_element *targetlist = NULL;
196 /* Nonzero if we are debugging an attached outside process
197 rather than an inferior. */
201 /* Nonzero if we should trust readonly sections from the
202 executable when reading memory. */
204 static int trust_readonly = 0;
206 /* Non-zero if we want to see trace of target level stuff. */
208 static int targetdebug = 0;
210 show_targetdebug (struct ui_file *file, int from_tty,
211 struct cmd_list_element *c, const char *value)
213 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
216 static void setup_target_debug (void);
218 DCACHE *target_dcache;
220 /* The user just typed 'target' without the name of a target. */
223 target_command (char *arg, int from_tty)
225 fputs_filtered ("Argument required (target name). Try `help target'\n",
229 /* Add a possible target architecture to the list. */
232 add_target (struct target_ops *t)
234 /* Provide default values for all "must have" methods. */
235 if (t->to_xfer_partial == NULL)
236 t->to_xfer_partial = default_xfer_partial;
240 target_struct_allocsize = DEFAULT_ALLOCSIZE;
241 target_structs = (struct target_ops **) xmalloc
242 (target_struct_allocsize * sizeof (*target_structs));
244 if (target_struct_size >= target_struct_allocsize)
246 target_struct_allocsize *= 2;
247 target_structs = (struct target_ops **)
248 xrealloc ((char *) target_structs,
249 target_struct_allocsize * sizeof (*target_structs));
251 target_structs[target_struct_size++] = t;
253 if (targetlist == NULL)
254 add_prefix_cmd ("target", class_run, target_command, _("\
255 Connect to a target machine or process.\n\
256 The first argument is the type or protocol of the target machine.\n\
257 Remaining arguments are interpreted by the target protocol. For more\n\
258 information on the arguments for a particular protocol, type\n\
259 `help target ' followed by the protocol name."),
260 &targetlist, "target ", 0, &cmdlist);
261 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
272 target_load (char *arg, int from_tty)
274 dcache_invalidate (target_dcache);
275 (*current_target.to_load) (arg, from_tty);
279 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
280 struct target_ops *t)
282 errno = EIO; /* Can't read/write this location */
283 return 0; /* No bytes handled */
289 error (_("You can't do that when your target is `%s'"),
290 current_target.to_shortname);
296 error (_("You can't do that without a process to debug."));
300 nosymbol (char *name, CORE_ADDR *addrp)
302 return 1; /* Symbol does not exist in target env */
306 nosupport_runtime (void)
308 if (ptid_equal (inferior_ptid, null_ptid))
311 error (_("No run-time support for this"));
316 default_terminal_info (char *args, int from_tty)
318 printf_unfiltered (_("No saved terminal information.\n"));
321 /* This is the default target_create_inferior and target_attach function.
322 If the current target is executing, it asks whether to kill it off.
323 If this function returns without calling error(), it has killed off
324 the target, and the operation should be attempted. */
327 kill_or_be_killed (int from_tty)
329 if (target_has_execution)
331 printf_unfiltered (_("You are already running a program:\n"));
332 target_files_info ();
333 if (query ("Kill it? "))
336 if (target_has_execution)
337 error (_("Killing the program did not help."));
342 error (_("Program not killed."));
349 maybe_kill_then_attach (char *args, int from_tty)
351 kill_or_be_killed (from_tty);
352 target_attach (args, from_tty);
356 maybe_kill_then_create_inferior (char *exec, char *args, char **env,
359 kill_or_be_killed (0);
360 target_create_inferior (exec, args, env, from_tty);
363 /* Go through the target stack from top to bottom, copying over zero
364 entries in current_target, then filling in still empty entries. In
365 effect, we are doing class inheritance through the pushed target
368 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
369 is currently implemented, is that it discards any knowledge of
370 which target an inherited method originally belonged to.
371 Consequently, new new target methods should instead explicitly and
372 locally search the target stack for the target that can handle the
376 update_current_target (void)
378 struct target_ops *t;
380 /* First, reset current's contents. */
381 memset (¤t_target, 0, sizeof (current_target));
383 #define INHERIT(FIELD, TARGET) \
384 if (!current_target.FIELD) \
385 current_target.FIELD = (TARGET)->FIELD
387 for (t = target_stack; t; t = t->beneath)
389 INHERIT (to_shortname, t);
390 INHERIT (to_longname, t);
392 INHERIT (to_open, t);
393 INHERIT (to_close, t);
394 INHERIT (to_attach, t);
395 INHERIT (to_post_attach, t);
396 INHERIT (to_detach, t);
397 /* Do not inherit to_disconnect. */
398 INHERIT (to_resume, t);
399 INHERIT (to_wait, t);
400 INHERIT (to_fetch_registers, t);
401 INHERIT (to_store_registers, t);
402 INHERIT (to_prepare_to_store, t);
403 INHERIT (deprecated_xfer_memory, t);
404 INHERIT (to_files_info, t);
405 INHERIT (to_insert_breakpoint, t);
406 INHERIT (to_remove_breakpoint, t);
407 INHERIT (to_can_use_hw_breakpoint, t);
408 INHERIT (to_insert_hw_breakpoint, t);
409 INHERIT (to_remove_hw_breakpoint, t);
410 INHERIT (to_insert_watchpoint, t);
411 INHERIT (to_remove_watchpoint, t);
412 INHERIT (to_stopped_data_address, t);
413 INHERIT (to_stopped_by_watchpoint, t);
414 INHERIT (to_have_steppable_watchpoint, t);
415 INHERIT (to_have_continuable_watchpoint, t);
416 INHERIT (to_region_ok_for_hw_watchpoint, t);
417 INHERIT (to_terminal_init, t);
418 INHERIT (to_terminal_inferior, t);
419 INHERIT (to_terminal_ours_for_output, t);
420 INHERIT (to_terminal_ours, t);
421 INHERIT (to_terminal_save_ours, t);
422 INHERIT (to_terminal_info, t);
423 INHERIT (to_kill, t);
424 INHERIT (to_load, t);
425 INHERIT (to_lookup_symbol, t);
426 INHERIT (to_create_inferior, t);
427 INHERIT (to_post_startup_inferior, t);
428 INHERIT (to_acknowledge_created_inferior, t);
429 INHERIT (to_insert_fork_catchpoint, t);
430 INHERIT (to_remove_fork_catchpoint, t);
431 INHERIT (to_insert_vfork_catchpoint, t);
432 INHERIT (to_remove_vfork_catchpoint, t);
433 /* Do not inherit to_follow_fork. */
434 INHERIT (to_insert_exec_catchpoint, t);
435 INHERIT (to_remove_exec_catchpoint, t);
436 INHERIT (to_reported_exec_events_per_exec_call, t);
437 INHERIT (to_has_exited, t);
438 INHERIT (to_mourn_inferior, t);
439 INHERIT (to_can_run, t);
440 INHERIT (to_notice_signals, t);
441 INHERIT (to_thread_alive, t);
442 INHERIT (to_find_new_threads, t);
443 INHERIT (to_pid_to_str, t);
444 INHERIT (to_extra_thread_info, t);
445 INHERIT (to_stop, t);
446 /* Do not inherit to_xfer_partial. */
447 INHERIT (to_rcmd, t);
448 INHERIT (to_enable_exception_callback, t);
449 INHERIT (to_get_current_exception_event, t);
450 INHERIT (to_pid_to_exec_file, t);
451 INHERIT (to_stratum, t);
452 INHERIT (to_has_all_memory, t);
453 INHERIT (to_has_memory, t);
454 INHERIT (to_has_stack, t);
455 INHERIT (to_has_registers, t);
456 INHERIT (to_has_execution, t);
457 INHERIT (to_has_thread_control, t);
458 INHERIT (to_sections, t);
459 INHERIT (to_sections_end, t);
460 INHERIT (to_can_async_p, t);
461 INHERIT (to_is_async_p, t);
462 INHERIT (to_async, t);
463 INHERIT (to_async_mask_value, t);
464 INHERIT (to_find_memory_regions, t);
465 INHERIT (to_make_corefile_notes, t);
466 INHERIT (to_get_thread_local_address, t);
467 /* Do not inherit to_read_description. */
468 INHERIT (to_magic, t);
469 /* Do not inherit to_memory_map. */
470 /* Do not inherit to_flash_erase. */
471 /* Do not inherit to_flash_done. */
475 /* Clean up a target struct so it no longer has any zero pointers in
476 it. Some entries are defaulted to a method that print an error,
477 others are hard-wired to a standard recursive default. */
479 #define de_fault(field, value) \
480 if (!current_target.field) \
481 current_target.field = value
484 (void (*) (char *, int))
490 maybe_kill_then_attach);
491 de_fault (to_post_attach,
495 (void (*) (char *, int))
498 (void (*) (ptid_t, int, enum target_signal))
501 (ptid_t (*) (ptid_t, struct target_waitstatus *))
503 de_fault (to_fetch_registers,
504 (void (*) (struct regcache *, int))
506 de_fault (to_store_registers,
507 (void (*) (struct regcache *, int))
509 de_fault (to_prepare_to_store,
510 (void (*) (struct regcache *))
512 de_fault (deprecated_xfer_memory,
513 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
515 de_fault (to_files_info,
516 (void (*) (struct target_ops *))
518 de_fault (to_insert_breakpoint,
519 memory_insert_breakpoint);
520 de_fault (to_remove_breakpoint,
521 memory_remove_breakpoint);
522 de_fault (to_can_use_hw_breakpoint,
523 (int (*) (int, int, int))
525 de_fault (to_insert_hw_breakpoint,
526 (int (*) (struct bp_target_info *))
528 de_fault (to_remove_hw_breakpoint,
529 (int (*) (struct bp_target_info *))
531 de_fault (to_insert_watchpoint,
532 (int (*) (CORE_ADDR, int, int))
534 de_fault (to_remove_watchpoint,
535 (int (*) (CORE_ADDR, int, int))
537 de_fault (to_stopped_by_watchpoint,
540 de_fault (to_stopped_data_address,
541 (int (*) (struct target_ops *, CORE_ADDR *))
543 de_fault (to_region_ok_for_hw_watchpoint,
544 default_region_ok_for_hw_watchpoint);
545 de_fault (to_terminal_init,
548 de_fault (to_terminal_inferior,
551 de_fault (to_terminal_ours_for_output,
554 de_fault (to_terminal_ours,
557 de_fault (to_terminal_save_ours,
560 de_fault (to_terminal_info,
561 default_terminal_info);
566 (void (*) (char *, int))
568 de_fault (to_lookup_symbol,
569 (int (*) (char *, CORE_ADDR *))
571 de_fault (to_create_inferior,
572 maybe_kill_then_create_inferior);
573 de_fault (to_post_startup_inferior,
576 de_fault (to_acknowledge_created_inferior,
579 de_fault (to_insert_fork_catchpoint,
582 de_fault (to_remove_fork_catchpoint,
585 de_fault (to_insert_vfork_catchpoint,
588 de_fault (to_remove_vfork_catchpoint,
591 de_fault (to_insert_exec_catchpoint,
594 de_fault (to_remove_exec_catchpoint,
597 de_fault (to_reported_exec_events_per_exec_call,
600 de_fault (to_has_exited,
601 (int (*) (int, int, int *))
603 de_fault (to_mourn_inferior,
606 de_fault (to_can_run,
608 de_fault (to_notice_signals,
611 de_fault (to_thread_alive,
614 de_fault (to_find_new_threads,
617 de_fault (to_extra_thread_info,
618 (char *(*) (struct thread_info *))
623 current_target.to_xfer_partial = current_xfer_partial;
625 (void (*) (char *, struct ui_file *))
627 de_fault (to_enable_exception_callback,
628 (struct symtab_and_line * (*) (enum exception_event_kind, int))
630 de_fault (to_get_current_exception_event,
631 (struct exception_event_record * (*) (void))
633 de_fault (to_pid_to_exec_file,
636 de_fault (to_can_async_p,
639 de_fault (to_is_async_p,
643 (void (*) (void (*) (enum inferior_event_type, void*), void*))
645 current_target.to_read_description = NULL;
648 /* Finally, position the target-stack beneath the squashed
649 "current_target". That way code looking for a non-inherited
650 target method can quickly and simply find it. */
651 current_target.beneath = target_stack;
654 /* Mark OPS as a running target. This reverses the effect
655 of target_mark_exited. */
658 target_mark_running (struct target_ops *ops)
660 struct target_ops *t;
662 for (t = target_stack; t != NULL; t = t->beneath)
666 internal_error (__FILE__, __LINE__,
667 "Attempted to mark unpushed target \"%s\" as running",
670 ops->to_has_execution = 1;
671 ops->to_has_all_memory = 1;
672 ops->to_has_memory = 1;
673 ops->to_has_stack = 1;
674 ops->to_has_registers = 1;
676 update_current_target ();
679 /* Mark OPS as a non-running target. This reverses the effect
680 of target_mark_running. */
683 target_mark_exited (struct target_ops *ops)
685 struct target_ops *t;
687 for (t = target_stack; t != NULL; t = t->beneath)
691 internal_error (__FILE__, __LINE__,
692 "Attempted to mark unpushed target \"%s\" as running",
695 ops->to_has_execution = 0;
696 ops->to_has_all_memory = 0;
697 ops->to_has_memory = 0;
698 ops->to_has_stack = 0;
699 ops->to_has_registers = 0;
701 update_current_target ();
704 /* Push a new target type into the stack of the existing target accessors,
705 possibly superseding some of the existing accessors.
707 Result is zero if the pushed target ended up on top of the stack,
708 nonzero if at least one target is on top of it.
710 Rather than allow an empty stack, we always have the dummy target at
711 the bottom stratum, so we can call the function vectors without
715 push_target (struct target_ops *t)
717 struct target_ops **cur;
719 /* Check magic number. If wrong, it probably means someone changed
720 the struct definition, but not all the places that initialize one. */
721 if (t->to_magic != OPS_MAGIC)
723 fprintf_unfiltered (gdb_stderr,
724 "Magic number of %s target struct wrong\n",
726 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
729 /* Find the proper stratum to install this target in. */
730 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
732 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
736 /* If there's already targets at this stratum, remove them. */
737 /* FIXME: cagney/2003-10-15: I think this should be popping all
738 targets to CUR, and not just those at this stratum level. */
739 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
741 /* There's already something at this stratum level. Close it,
742 and un-hook it from the stack. */
743 struct target_ops *tmp = (*cur);
744 (*cur) = (*cur)->beneath;
746 target_close (tmp, 0);
749 /* We have removed all targets in our stratum, now add the new one. */
753 update_current_target ();
756 setup_target_debug ();
759 return (t != target_stack);
762 /* Remove a target_ops vector from the stack, wherever it may be.
763 Return how many times it was removed (0 or 1). */
766 unpush_target (struct target_ops *t)
768 struct target_ops **cur;
769 struct target_ops *tmp;
771 /* Look for the specified target. Note that we assume that a target
772 can only occur once in the target stack. */
774 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
781 return 0; /* Didn't find target_ops, quit now */
783 /* NOTE: cagney/2003-12-06: In '94 the close call was made
784 unconditional by moving it to before the above check that the
785 target was in the target stack (something about "Change the way
786 pushing and popping of targets work to support target overlays
787 and inheritance"). This doesn't make much sense - only open
788 targets should be closed. */
791 /* Unchain the target */
793 (*cur) = (*cur)->beneath;
796 update_current_target ();
804 target_close (¤t_target, 0); /* Let it clean up */
805 if (unpush_target (target_stack) == 1)
808 fprintf_unfiltered (gdb_stderr,
809 "pop_target couldn't find target %s\n",
810 current_target.to_shortname);
811 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
814 /* Using the objfile specified in BATON, find the address for the
815 current thread's thread-local storage with offset OFFSET. */
817 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
819 volatile CORE_ADDR addr = 0;
821 if (target_get_thread_local_address_p ()
822 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch))
824 ptid_t ptid = inferior_ptid;
825 volatile struct gdb_exception ex;
827 TRY_CATCH (ex, RETURN_MASK_ALL)
831 /* Fetch the load module address for this objfile. */
832 lm_addr = gdbarch_fetch_tls_load_module_address (current_gdbarch,
834 /* If it's 0, throw the appropriate exception. */
836 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
837 _("TLS load module not found"));
839 addr = target_get_thread_local_address (ptid, lm_addr, offset);
841 /* If an error occurred, print TLS related messages here. Otherwise,
842 throw the error to some higher catcher. */
845 int objfile_is_library = (objfile->flags & OBJF_SHARED);
849 case TLS_NO_LIBRARY_SUPPORT_ERROR:
850 error (_("Cannot find thread-local variables in this thread library."));
852 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
853 if (objfile_is_library)
854 error (_("Cannot find shared library `%s' in dynamic"
855 " linker's load module list"), objfile->name);
857 error (_("Cannot find executable file `%s' in dynamic"
858 " linker's load module list"), objfile->name);
860 case TLS_NOT_ALLOCATED_YET_ERROR:
861 if (objfile_is_library)
862 error (_("The inferior has not yet allocated storage for"
863 " thread-local variables in\n"
864 "the shared library `%s'\n"
866 objfile->name, target_pid_to_str (ptid));
868 error (_("The inferior has not yet allocated storage for"
869 " thread-local variables in\n"
870 "the executable `%s'\n"
872 objfile->name, target_pid_to_str (ptid));
874 case TLS_GENERIC_ERROR:
875 if (objfile_is_library)
876 error (_("Cannot find thread-local storage for %s, "
877 "shared library %s:\n%s"),
878 target_pid_to_str (ptid),
879 objfile->name, ex.message);
881 error (_("Cannot find thread-local storage for %s, "
882 "executable file %s:\n%s"),
883 target_pid_to_str (ptid),
884 objfile->name, ex.message);
887 throw_exception (ex);
892 /* It wouldn't be wrong here to try a gdbarch method, too; finding
893 TLS is an ABI-specific thing. But we don't do that yet. */
895 error (_("Cannot find thread-local variables on this target"));
901 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
903 /* target_read_string -- read a null terminated string, up to LEN bytes,
904 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
905 Set *STRING to a pointer to malloc'd memory containing the data; the caller
906 is responsible for freeing it. Return the number of bytes successfully
910 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
912 int tlen, origlen, offset, i;
916 int buffer_allocated;
918 unsigned int nbytes_read = 0;
922 /* Small for testing. */
923 buffer_allocated = 4;
924 buffer = xmalloc (buffer_allocated);
931 tlen = MIN (len, 4 - (memaddr & 3));
932 offset = memaddr & 3;
934 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
937 /* The transfer request might have crossed the boundary to an
938 unallocated region of memory. Retry the transfer, requesting
942 errcode = target_read_memory (memaddr, buf, 1);
947 if (bufptr - buffer + tlen > buffer_allocated)
950 bytes = bufptr - buffer;
951 buffer_allocated *= 2;
952 buffer = xrealloc (buffer, buffer_allocated);
953 bufptr = buffer + bytes;
956 for (i = 0; i < tlen; i++)
958 *bufptr++ = buf[i + offset];
959 if (buf[i + offset] == '\000')
961 nbytes_read += i + 1;
977 /* Find a section containing ADDR. */
978 struct section_table *
979 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
981 struct section_table *secp;
982 for (secp = target->to_sections;
983 secp < target->to_sections_end;
986 if (addr >= secp->addr && addr < secp->endaddr)
992 /* Perform a partial memory transfer. The arguments and return
993 value are just as for target_xfer_partial. */
996 memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
997 ULONGEST memaddr, LONGEST len)
1001 struct mem_region *region;
1003 /* Zero length requests are ok and require no work. */
1007 /* Try the executable file, if "trust-readonly-sections" is set. */
1008 if (readbuf != NULL && trust_readonly)
1010 struct section_table *secp;
1012 secp = target_section_by_addr (ops, memaddr);
1014 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1016 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1019 /* Likewise for accesses to unmapped overlay sections. */
1020 if (readbuf != NULL && overlay_debugging)
1022 asection *section = find_pc_overlay (memaddr);
1023 if (pc_in_unmapped_range (memaddr, section))
1024 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1027 /* Try GDB's internal data cache. */
1028 region = lookup_mem_region (memaddr);
1029 /* region->hi == 0 means there's no upper bound. */
1030 if (memaddr + len < region->hi || region->hi == 0)
1033 reg_len = region->hi - memaddr;
1035 switch (region->attrib.mode)
1038 if (writebuf != NULL)
1043 if (readbuf != NULL)
1048 /* We only support writing to flash during "load" for now. */
1049 if (writebuf != NULL)
1050 error (_("Writing to flash memory forbidden in this context"));
1057 if (region->attrib.cache)
1059 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1060 memory request will start back at current_target. */
1061 if (readbuf != NULL)
1062 res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
1065 /* FIXME drow/2006-08-09: If we're going to preserve const
1066 correctness dcache_xfer_memory should take readbuf and
1068 res = dcache_xfer_memory (target_dcache, memaddr,
1077 /* If none of those methods found the memory we wanted, fall back
1078 to a target partial transfer. Normally a single call to
1079 to_xfer_partial is enough; if it doesn't recognize an object
1080 it will call the to_xfer_partial of the next target down.
1081 But for memory this won't do. Memory is the only target
1082 object which can be read from more than one valid target.
1083 A core file, for instance, could have some of memory but
1084 delegate other bits to the target below it. So, we must
1085 manually try all targets. */
1089 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1090 readbuf, writebuf, memaddr, reg_len);
1094 /* We want to continue past core files to executables, but not
1095 past a running target's memory. */
1096 if (ops->to_has_all_memory)
1101 while (ops != NULL);
1103 /* If we still haven't got anything, return the last error. We
1109 target_xfer_partial (struct target_ops *ops,
1110 enum target_object object, const char *annex,
1111 void *readbuf, const void *writebuf,
1112 ULONGEST offset, LONGEST len)
1116 gdb_assert (ops->to_xfer_partial != NULL);
1118 /* If this is a memory transfer, let the memory-specific code
1119 have a look at it instead. Memory transfers are more
1121 if (object == TARGET_OBJECT_MEMORY)
1122 retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
1125 enum target_object raw_object = object;
1127 /* If this is a raw memory transfer, request the normal
1128 memory object from other layers. */
1129 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1130 raw_object = TARGET_OBJECT_MEMORY;
1132 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1133 writebuf, offset, len);
1138 const unsigned char *myaddr = NULL;
1140 fprintf_unfiltered (gdb_stdlog,
1141 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1144 (annex ? annex : "(null)"),
1145 (long) readbuf, (long) writebuf,
1146 paddr_nz (offset), paddr_d (len), paddr_d (retval));
1152 if (retval > 0 && myaddr != NULL)
1156 fputs_unfiltered (", bytes =", gdb_stdlog);
1157 for (i = 0; i < retval; i++)
1159 if ((((long) &(myaddr[i])) & 0xf) == 0)
1161 if (targetdebug < 2 && i > 0)
1163 fprintf_unfiltered (gdb_stdlog, " ...");
1166 fprintf_unfiltered (gdb_stdlog, "\n");
1169 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1173 fputc_unfiltered ('\n', gdb_stdlog);
1178 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1179 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1180 if any error occurs.
1182 If an error occurs, no guarantee is made about the contents of the data at
1183 MYADDR. In particular, the caller should not depend upon partial reads
1184 filling the buffer with good data. There is no way for the caller to know
1185 how much good data might have been transfered anyway. Callers that can
1186 deal with partial reads should call target_read (which will retry until
1187 it makes no progress, and then return how much was transferred). */
1190 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1192 if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1193 myaddr, memaddr, len) == len)
1200 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1202 if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1203 myaddr, memaddr, len) == len)
1209 /* Fetch the target's memory map. */
1212 target_memory_map (void)
1214 VEC(mem_region_s) *result;
1215 struct mem_region *last_one, *this_one;
1217 struct target_ops *t;
1220 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1222 for (t = current_target.beneath; t != NULL; t = t->beneath)
1223 if (t->to_memory_map != NULL)
1229 result = t->to_memory_map (t);
1233 qsort (VEC_address (mem_region_s, result),
1234 VEC_length (mem_region_s, result),
1235 sizeof (struct mem_region), mem_region_cmp);
1237 /* Check that regions do not overlap. Simultaneously assign
1238 a numbering for the "mem" commands to use to refer to
1241 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1243 this_one->number = ix;
1245 if (last_one && last_one->hi > this_one->lo)
1247 warning (_("Overlapping regions in memory map: ignoring"));
1248 VEC_free (mem_region_s, result);
1251 last_one = this_one;
1258 target_flash_erase (ULONGEST address, LONGEST length)
1260 struct target_ops *t;
1262 for (t = current_target.beneath; t != NULL; t = t->beneath)
1263 if (t->to_flash_erase != NULL)
1266 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1267 paddr (address), phex (length, 0));
1268 t->to_flash_erase (t, address, length);
1276 target_flash_done (void)
1278 struct target_ops *t;
1280 for (t = current_target.beneath; t != NULL; t = t->beneath)
1281 if (t->to_flash_done != NULL)
1284 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1285 t->to_flash_done (t);
1292 #ifndef target_stopped_data_address_p
1294 target_stopped_data_address_p (struct target_ops *target)
1296 if (target->to_stopped_data_address
1297 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
1299 if (target->to_stopped_data_address == debug_to_stopped_data_address
1300 && (debug_target.to_stopped_data_address
1301 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1308 show_trust_readonly (struct ui_file *file, int from_tty,
1309 struct cmd_list_element *c, const char *value)
1311 fprintf_filtered (file, _("\
1312 Mode for reading from readonly sections is %s.\n"),
1316 /* More generic transfers. */
1319 default_xfer_partial (struct target_ops *ops, enum target_object object,
1320 const char *annex, gdb_byte *readbuf,
1321 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1323 if (object == TARGET_OBJECT_MEMORY
1324 && ops->deprecated_xfer_memory != NULL)
1325 /* If available, fall back to the target's
1326 "deprecated_xfer_memory" method. */
1330 if (writebuf != NULL)
1332 void *buffer = xmalloc (len);
1333 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1334 memcpy (buffer, writebuf, len);
1335 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1336 1/*write*/, NULL, ops);
1337 do_cleanups (cleanup);
1339 if (readbuf != NULL)
1340 xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/*read*/,
1344 else if (xfered == 0 && errno == 0)
1345 /* "deprecated_xfer_memory" uses 0, cross checked against
1346 ERRNO as one indication of an error. */
1351 else if (ops->beneath != NULL)
1352 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1353 readbuf, writebuf, offset, len);
1358 /* The xfer_partial handler for the topmost target. Unlike the default,
1359 it does not need to handle memory specially; it just passes all
1360 requests down the stack. */
1363 current_xfer_partial (struct target_ops *ops, enum target_object object,
1364 const char *annex, gdb_byte *readbuf,
1365 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1367 if (ops->beneath != NULL)
1368 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1369 readbuf, writebuf, offset, len);
1374 /* Target vector read/write partial wrapper functions.
1376 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1377 (inbuf, outbuf)", instead of separate read/write methods, make life
1381 target_read_partial (struct target_ops *ops,
1382 enum target_object object,
1383 const char *annex, gdb_byte *buf,
1384 ULONGEST offset, LONGEST len)
1386 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1390 target_write_partial (struct target_ops *ops,
1391 enum target_object object,
1392 const char *annex, const gdb_byte *buf,
1393 ULONGEST offset, LONGEST len)
1395 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1398 /* Wrappers to perform the full transfer. */
1400 target_read (struct target_ops *ops,
1401 enum target_object object,
1402 const char *annex, gdb_byte *buf,
1403 ULONGEST offset, LONGEST len)
1406 while (xfered < len)
1408 LONGEST xfer = target_read_partial (ops, object, annex,
1409 (gdb_byte *) buf + xfered,
1410 offset + xfered, len - xfered);
1411 /* Call an observer, notifying them of the xfer progress? */
1422 /* An alternative to target_write with progress callbacks. */
1425 target_write_with_progress (struct target_ops *ops,
1426 enum target_object object,
1427 const char *annex, const gdb_byte *buf,
1428 ULONGEST offset, LONGEST len,
1429 void (*progress) (ULONGEST, void *), void *baton)
1433 /* Give the progress callback a chance to set up. */
1435 (*progress) (0, baton);
1437 while (xfered < len)
1439 LONGEST xfer = target_write_partial (ops, object, annex,
1440 (gdb_byte *) buf + xfered,
1441 offset + xfered, len - xfered);
1449 (*progress) (xfer, baton);
1458 target_write (struct target_ops *ops,
1459 enum target_object object,
1460 const char *annex, const gdb_byte *buf,
1461 ULONGEST offset, LONGEST len)
1463 return target_write_with_progress (ops, object, annex, buf, offset, len,
1467 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1468 the size of the transferred data. PADDING additional bytes are
1469 available in *BUF_P. This is a helper function for
1470 target_read_alloc; see the declaration of that function for more
1474 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1475 const char *annex, gdb_byte **buf_p, int padding)
1477 size_t buf_alloc, buf_pos;
1481 /* This function does not have a length parameter; it reads the
1482 entire OBJECT). Also, it doesn't support objects fetched partly
1483 from one target and partly from another (in a different stratum,
1484 e.g. a core file and an executable). Both reasons make it
1485 unsuitable for reading memory. */
1486 gdb_assert (object != TARGET_OBJECT_MEMORY);
1488 /* Start by reading up to 4K at a time. The target will throttle
1489 this number down if necessary. */
1491 buf = xmalloc (buf_alloc);
1495 n = target_read_partial (ops, object, annex, &buf[buf_pos],
1496 buf_pos, buf_alloc - buf_pos - padding);
1499 /* An error occurred. */
1505 /* Read all there was. */
1515 /* If the buffer is filling up, expand it. */
1516 if (buf_alloc < buf_pos * 2)
1519 buf = xrealloc (buf, buf_alloc);
1526 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1527 the size of the transferred data. See the declaration in "target.h"
1528 function for more information about the return value. */
1531 target_read_alloc (struct target_ops *ops, enum target_object object,
1532 const char *annex, gdb_byte **buf_p)
1534 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1537 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1538 returned as a string, allocated using xmalloc. If an error occurs
1539 or the transfer is unsupported, NULL is returned. Empty objects
1540 are returned as allocated but empty strings. A warning is issued
1541 if the result contains any embedded NUL bytes. */
1544 target_read_stralloc (struct target_ops *ops, enum target_object object,
1548 LONGEST transferred;
1550 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1552 if (transferred < 0)
1555 if (transferred == 0)
1556 return xstrdup ("");
1558 buffer[transferred] = 0;
1559 if (strlen (buffer) < transferred)
1560 warning (_("target object %d, annex %s, "
1561 "contained unexpected null characters"),
1562 (int) object, annex ? annex : "(none)");
1564 return (char *) buffer;
1567 /* Memory transfer methods. */
1570 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1573 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1575 memory_error (EIO, addr);
1579 get_target_memory_unsigned (struct target_ops *ops,
1580 CORE_ADDR addr, int len)
1582 gdb_byte buf[sizeof (ULONGEST)];
1584 gdb_assert (len <= sizeof (buf));
1585 get_target_memory (ops, addr, buf, len);
1586 return extract_unsigned_integer (buf, len);
1590 target_info (char *args, int from_tty)
1592 struct target_ops *t;
1593 int has_all_mem = 0;
1595 if (symfile_objfile != NULL)
1596 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1598 for (t = target_stack; t != NULL; t = t->beneath)
1600 if (!t->to_has_memory)
1603 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1606 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1607 printf_unfiltered ("%s:\n", t->to_longname);
1608 (t->to_files_info) (t);
1609 has_all_mem = t->to_has_all_memory;
1613 /* This function is called before any new inferior is created, e.g.
1614 by running a program, attaching, or connecting to a target.
1615 It cleans up any state from previous invocations which might
1616 change between runs. This is a subset of what target_preopen
1617 resets (things which might change between targets). */
1620 target_pre_inferior (int from_tty)
1622 invalidate_target_mem_regions ();
1624 target_clear_description ();
1627 /* This is to be called by the open routine before it does
1631 target_preopen (int from_tty)
1635 if (target_has_execution)
1638 || query (_("A program is being debugged already. Kill it? ")))
1641 error (_("Program not killed."));
1644 /* Calling target_kill may remove the target from the stack. But if
1645 it doesn't (which seems like a win for UDI), remove it now. */
1647 if (target_has_execution)
1650 target_pre_inferior (from_tty);
1653 /* Detach a target after doing deferred register stores. */
1656 target_detach (char *args, int from_tty)
1658 (current_target.to_detach) (args, from_tty);
1662 target_disconnect (char *args, int from_tty)
1664 struct target_ops *t;
1666 for (t = current_target.beneath; t != NULL; t = t->beneath)
1667 if (t->to_disconnect != NULL)
1670 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1672 t->to_disconnect (t, args, from_tty);
1680 target_async_mask (int mask)
1682 int saved_async_masked_status = target_async_mask_value;
1683 target_async_mask_value = mask;
1684 return saved_async_masked_status;
1687 /* Look through the list of possible targets for a target that can
1691 target_follow_fork (int follow_child)
1693 struct target_ops *t;
1695 for (t = current_target.beneath; t != NULL; t = t->beneath)
1697 if (t->to_follow_fork != NULL)
1699 int retval = t->to_follow_fork (t, follow_child);
1701 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1702 follow_child, retval);
1707 /* Some target returned a fork event, but did not know how to follow it. */
1708 internal_error (__FILE__, __LINE__,
1709 "could not find a target to follow fork");
1712 /* Look for a target which can describe architectural features, starting
1713 from TARGET. If we find one, return its description. */
1715 const struct target_desc *
1716 target_read_description (struct target_ops *target)
1718 struct target_ops *t;
1720 for (t = target; t != NULL; t = t->beneath)
1721 if (t->to_read_description != NULL)
1723 const struct target_desc *tdesc;
1725 tdesc = t->to_read_description (t);
1733 /* Look through the list of possible targets for a target that can
1734 execute a run or attach command without any other data. This is
1735 used to locate the default process stratum.
1737 Result is always valid (error() is called for errors). */
1739 static struct target_ops *
1740 find_default_run_target (char *do_mesg)
1742 struct target_ops **t;
1743 struct target_ops *runable = NULL;
1748 for (t = target_structs; t < target_structs + target_struct_size;
1751 if ((*t)->to_can_run && target_can_run (*t))
1759 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
1765 find_default_attach (char *args, int from_tty)
1767 struct target_ops *t;
1769 t = find_default_run_target ("attach");
1770 (t->to_attach) (args, from_tty);
1775 find_default_create_inferior (char *exec_file, char *allargs, char **env,
1778 struct target_ops *t;
1780 t = find_default_run_target ("run");
1781 (t->to_create_inferior) (exec_file, allargs, env, from_tty);
1786 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
1788 return (len <= TYPE_LENGTH (builtin_type_void_data_ptr));
1804 return_minus_one (void)
1810 * Resize the to_sections pointer. Also make sure that anyone that
1811 * was holding on to an old value of it gets updated.
1812 * Returns the old size.
1816 target_resize_to_sections (struct target_ops *target, int num_added)
1818 struct target_ops **t;
1819 struct section_table *old_value;
1822 old_value = target->to_sections;
1824 if (target->to_sections)
1826 old_count = target->to_sections_end - target->to_sections;
1827 target->to_sections = (struct section_table *)
1828 xrealloc ((char *) target->to_sections,
1829 (sizeof (struct section_table)) * (num_added + old_count));
1834 target->to_sections = (struct section_table *)
1835 xmalloc ((sizeof (struct section_table)) * num_added);
1837 target->to_sections_end = target->to_sections + (num_added + old_count);
1839 /* Check to see if anyone else was pointing to this structure.
1840 If old_value was null, then no one was. */
1844 for (t = target_structs; t < target_structs + target_struct_size;
1847 if ((*t)->to_sections == old_value)
1849 (*t)->to_sections = target->to_sections;
1850 (*t)->to_sections_end = target->to_sections_end;
1853 /* There is a flattened view of the target stack in current_target,
1854 so its to_sections pointer might also need updating. */
1855 if (current_target.to_sections == old_value)
1857 current_target.to_sections = target->to_sections;
1858 current_target.to_sections_end = target->to_sections_end;
1866 /* Remove all target sections taken from ABFD.
1868 Scan the current target stack for targets whose section tables
1869 refer to sections from BFD, and remove those sections. We use this
1870 when we notice that the inferior has unloaded a shared object, for
1873 remove_target_sections (bfd *abfd)
1875 struct target_ops **t;
1877 for (t = target_structs; t < target_structs + target_struct_size; t++)
1879 struct section_table *src, *dest;
1881 dest = (*t)->to_sections;
1882 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1883 if (src->bfd != abfd)
1885 /* Keep this section. */
1886 if (dest < src) *dest = *src;
1890 /* If we've dropped any sections, resize the section table. */
1892 target_resize_to_sections (*t, dest - src);
1899 /* Find a single runnable target in the stack and return it. If for
1900 some reason there is more than one, return NULL. */
1903 find_run_target (void)
1905 struct target_ops **t;
1906 struct target_ops *runable = NULL;
1911 for (t = target_structs; t < target_structs + target_struct_size; ++t)
1913 if ((*t)->to_can_run && target_can_run (*t))
1920 return (count == 1 ? runable : NULL);
1923 /* Find a single core_stratum target in the list of targets and return it.
1924 If for some reason there is more than one, return NULL. */
1927 find_core_target (void)
1929 struct target_ops **t;
1930 struct target_ops *runable = NULL;
1935 for (t = target_structs; t < target_structs + target_struct_size;
1938 if ((*t)->to_stratum == core_stratum)
1945 return (count == 1 ? runable : NULL);
1949 * Find the next target down the stack from the specified target.
1953 find_target_beneath (struct target_ops *t)
1959 /* The inferior process has died. Long live the inferior! */
1962 generic_mourn_inferior (void)
1964 extern int show_breakpoint_hit_counts;
1966 inferior_ptid = null_ptid;
1968 breakpoint_init_inferior (inf_exited);
1969 registers_changed ();
1971 reopen_exec_file ();
1972 reinit_frame_cache ();
1974 /* It is confusing to the user for ignore counts to stick around
1975 from previous runs of the inferior. So clear them. */
1976 /* However, it is more confusing for the ignore counts to disappear when
1977 using hit counts. So don't clear them if we're counting hits. */
1978 if (!show_breakpoint_hit_counts)
1979 breakpoint_clear_ignore_counts ();
1981 if (deprecated_detach_hook)
1982 deprecated_detach_hook ();
1985 /* Helper function for child_wait and the derivatives of child_wait.
1986 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1987 translation of that in OURSTATUS. */
1989 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
1991 if (WIFEXITED (hoststatus))
1993 ourstatus->kind = TARGET_WAITKIND_EXITED;
1994 ourstatus->value.integer = WEXITSTATUS (hoststatus);
1996 else if (!WIFSTOPPED (hoststatus))
1998 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1999 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2003 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2004 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2008 /* Returns zero to leave the inferior alone, one to interrupt it. */
2009 int (*target_activity_function) (void);
2010 int target_activity_fd;
2012 /* Convert a normal process ID to a string. Returns the string in a
2016 normal_pid_to_str (ptid_t ptid)
2018 static char buf[32];
2020 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
2024 /* Error-catcher for target_find_memory_regions */
2025 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2027 error (_("No target."));
2031 /* Error-catcher for target_make_corefile_notes */
2032 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2034 error (_("No target."));
2038 /* Set up the handful of non-empty slots needed by the dummy target
2042 init_dummy_target (void)
2044 dummy_target.to_shortname = "None";
2045 dummy_target.to_longname = "None";
2046 dummy_target.to_doc = "";
2047 dummy_target.to_attach = find_default_attach;
2048 dummy_target.to_create_inferior = find_default_create_inferior;
2049 dummy_target.to_pid_to_str = normal_pid_to_str;
2050 dummy_target.to_stratum = dummy_stratum;
2051 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2052 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
2053 dummy_target.to_xfer_partial = default_xfer_partial;
2054 dummy_target.to_magic = OPS_MAGIC;
2058 debug_to_open (char *args, int from_tty)
2060 debug_target.to_open (args, from_tty);
2062 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2066 debug_to_close (int quitting)
2068 target_close (&debug_target, quitting);
2069 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2073 target_close (struct target_ops *targ, int quitting)
2075 if (targ->to_xclose != NULL)
2076 targ->to_xclose (targ, quitting);
2077 else if (targ->to_close != NULL)
2078 targ->to_close (quitting);
2082 debug_to_attach (char *args, int from_tty)
2084 debug_target.to_attach (args, from_tty);
2086 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
2091 debug_to_post_attach (int pid)
2093 debug_target.to_post_attach (pid);
2095 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2099 debug_to_detach (char *args, int from_tty)
2101 debug_target.to_detach (args, from_tty);
2103 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
2107 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
2109 debug_target.to_resume (ptid, step, siggnal);
2111 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
2112 step ? "step" : "continue",
2113 target_signal_to_name (siggnal));
2117 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
2121 retval = debug_target.to_wait (ptid, status);
2123 fprintf_unfiltered (gdb_stdlog,
2124 "target_wait (%d, status) = %d, ", PIDGET (ptid),
2126 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
2127 switch (status->kind)
2129 case TARGET_WAITKIND_EXITED:
2130 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
2131 status->value.integer);
2133 case TARGET_WAITKIND_STOPPED:
2134 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
2135 target_signal_to_name (status->value.sig));
2137 case TARGET_WAITKIND_SIGNALLED:
2138 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
2139 target_signal_to_name (status->value.sig));
2141 case TARGET_WAITKIND_LOADED:
2142 fprintf_unfiltered (gdb_stdlog, "loaded\n");
2144 case TARGET_WAITKIND_FORKED:
2145 fprintf_unfiltered (gdb_stdlog, "forked\n");
2147 case TARGET_WAITKIND_VFORKED:
2148 fprintf_unfiltered (gdb_stdlog, "vforked\n");
2150 case TARGET_WAITKIND_EXECD:
2151 fprintf_unfiltered (gdb_stdlog, "execd\n");
2153 case TARGET_WAITKIND_SPURIOUS:
2154 fprintf_unfiltered (gdb_stdlog, "spurious\n");
2157 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
2165 debug_print_register (const char * func,
2166 struct regcache *regcache, int regno)
2168 fprintf_unfiltered (gdb_stdlog, "%s ", func);
2169 if (regno >= 0 && regno < gdbarch_num_regs (current_gdbarch)
2170 + gdbarch_num_pseudo_regs (current_gdbarch)
2171 && gdbarch_register_name (current_gdbarch, regno) != NULL
2172 && gdbarch_register_name (current_gdbarch, regno)[0] != '\0')
2173 fprintf_unfiltered (gdb_stdlog, "(%s)", gdbarch_register_name
2174 (current_gdbarch, regno));
2176 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2179 int i, size = register_size (current_gdbarch, regno);
2180 unsigned char buf[MAX_REGISTER_SIZE];
2181 regcache_cooked_read (regcache, regno, buf);
2182 fprintf_unfiltered (gdb_stdlog, " = ");
2183 for (i = 0; i < size; i++)
2185 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2187 if (size <= sizeof (LONGEST))
2189 ULONGEST val = extract_unsigned_integer (buf, size);
2190 fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
2191 paddr_nz (val), paddr_d (val));
2194 fprintf_unfiltered (gdb_stdlog, "\n");
2198 debug_to_fetch_registers (struct regcache *regcache, int regno)
2200 debug_target.to_fetch_registers (regcache, regno);
2201 debug_print_register ("target_fetch_registers", regcache, regno);
2205 debug_to_store_registers (struct regcache *regcache, int regno)
2207 debug_target.to_store_registers (regcache, regno);
2208 debug_print_register ("target_store_registers", regcache, regno);
2209 fprintf_unfiltered (gdb_stdlog, "\n");
2213 debug_to_prepare_to_store (struct regcache *regcache)
2215 debug_target.to_prepare_to_store (regcache);
2217 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2221 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2222 int write, struct mem_attrib *attrib,
2223 struct target_ops *target)
2227 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2230 fprintf_unfiltered (gdb_stdlog,
2231 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2232 (unsigned int) memaddr, /* possable truncate long long */
2233 len, write ? "write" : "read", retval);
2239 fputs_unfiltered (", bytes =", gdb_stdlog);
2240 for (i = 0; i < retval; i++)
2242 if ((((long) &(myaddr[i])) & 0xf) == 0)
2244 if (targetdebug < 2 && i > 0)
2246 fprintf_unfiltered (gdb_stdlog, " ...");
2249 fprintf_unfiltered (gdb_stdlog, "\n");
2252 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2256 fputc_unfiltered ('\n', gdb_stdlog);
2262 debug_to_files_info (struct target_ops *target)
2264 debug_target.to_files_info (target);
2266 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2270 debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
2274 retval = debug_target.to_insert_breakpoint (bp_tgt);
2276 fprintf_unfiltered (gdb_stdlog,
2277 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2278 (unsigned long) bp_tgt->placed_address,
2279 (unsigned long) retval);
2284 debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
2288 retval = debug_target.to_remove_breakpoint (bp_tgt);
2290 fprintf_unfiltered (gdb_stdlog,
2291 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2292 (unsigned long) bp_tgt->placed_address,
2293 (unsigned long) retval);
2298 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2302 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2304 fprintf_unfiltered (gdb_stdlog,
2305 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2306 (unsigned long) type,
2307 (unsigned long) cnt,
2308 (unsigned long) from_tty,
2309 (unsigned long) retval);
2314 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2318 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2320 fprintf_unfiltered (gdb_stdlog,
2321 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2322 (unsigned long) addr,
2323 (unsigned long) len,
2324 (unsigned long) retval);
2329 debug_to_stopped_by_watchpoint (void)
2333 retval = debug_target.to_stopped_by_watchpoint ();
2335 fprintf_unfiltered (gdb_stdlog,
2336 "STOPPED_BY_WATCHPOINT () = %ld\n",
2337 (unsigned long) retval);
2342 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2346 retval = debug_target.to_stopped_data_address (target, addr);
2348 fprintf_unfiltered (gdb_stdlog,
2349 "target_stopped_data_address ([0x%lx]) = %ld\n",
2350 (unsigned long)*addr,
2351 (unsigned long)retval);
2356 debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
2360 retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
2362 fprintf_unfiltered (gdb_stdlog,
2363 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2364 (unsigned long) bp_tgt->placed_address,
2365 (unsigned long) retval);
2370 debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
2374 retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
2376 fprintf_unfiltered (gdb_stdlog,
2377 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2378 (unsigned long) bp_tgt->placed_address,
2379 (unsigned long) retval);
2384 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2388 retval = debug_target.to_insert_watchpoint (addr, len, type);
2390 fprintf_unfiltered (gdb_stdlog,
2391 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2392 (unsigned long) addr, len, type, (unsigned long) retval);
2397 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2401 retval = debug_target.to_remove_watchpoint (addr, len, type);
2403 fprintf_unfiltered (gdb_stdlog,
2404 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2405 (unsigned long) addr, len, type, (unsigned long) retval);
2410 debug_to_terminal_init (void)
2412 debug_target.to_terminal_init ();
2414 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2418 debug_to_terminal_inferior (void)
2420 debug_target.to_terminal_inferior ();
2422 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2426 debug_to_terminal_ours_for_output (void)
2428 debug_target.to_terminal_ours_for_output ();
2430 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2434 debug_to_terminal_ours (void)
2436 debug_target.to_terminal_ours ();
2438 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2442 debug_to_terminal_save_ours (void)
2444 debug_target.to_terminal_save_ours ();
2446 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2450 debug_to_terminal_info (char *arg, int from_tty)
2452 debug_target.to_terminal_info (arg, from_tty);
2454 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2459 debug_to_kill (void)
2461 debug_target.to_kill ();
2463 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2467 debug_to_load (char *args, int from_tty)
2469 debug_target.to_load (args, from_tty);
2471 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2475 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2479 retval = debug_target.to_lookup_symbol (name, addrp);
2481 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2487 debug_to_create_inferior (char *exec_file, char *args, char **env,
2490 debug_target.to_create_inferior (exec_file, args, env, from_tty);
2492 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2493 exec_file, args, from_tty);
2497 debug_to_post_startup_inferior (ptid_t ptid)
2499 debug_target.to_post_startup_inferior (ptid);
2501 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2506 debug_to_acknowledge_created_inferior (int pid)
2508 debug_target.to_acknowledge_created_inferior (pid);
2510 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2515 debug_to_insert_fork_catchpoint (int pid)
2517 debug_target.to_insert_fork_catchpoint (pid);
2519 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
2524 debug_to_remove_fork_catchpoint (int pid)
2528 retval = debug_target.to_remove_fork_catchpoint (pid);
2530 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2537 debug_to_insert_vfork_catchpoint (int pid)
2539 debug_target.to_insert_vfork_catchpoint (pid);
2541 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
2546 debug_to_remove_vfork_catchpoint (int pid)
2550 retval = debug_target.to_remove_vfork_catchpoint (pid);
2552 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2559 debug_to_insert_exec_catchpoint (int pid)
2561 debug_target.to_insert_exec_catchpoint (pid);
2563 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
2568 debug_to_remove_exec_catchpoint (int pid)
2572 retval = debug_target.to_remove_exec_catchpoint (pid);
2574 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2581 debug_to_reported_exec_events_per_exec_call (void)
2583 int reported_exec_events;
2585 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2587 fprintf_unfiltered (gdb_stdlog,
2588 "target_reported_exec_events_per_exec_call () = %d\n",
2589 reported_exec_events);
2591 return reported_exec_events;
2595 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2599 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2601 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2602 pid, wait_status, *exit_status, has_exited);
2608 debug_to_mourn_inferior (void)
2610 debug_target.to_mourn_inferior ();
2612 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2616 debug_to_can_run (void)
2620 retval = debug_target.to_can_run ();
2622 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2628 debug_to_notice_signals (ptid_t ptid)
2630 debug_target.to_notice_signals (ptid);
2632 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2637 debug_to_thread_alive (ptid_t ptid)
2641 retval = debug_target.to_thread_alive (ptid);
2643 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2644 PIDGET (ptid), retval);
2650 debug_to_find_new_threads (void)
2652 debug_target.to_find_new_threads ();
2654 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2658 debug_to_stop (void)
2660 debug_target.to_stop ();
2662 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2666 debug_to_rcmd (char *command,
2667 struct ui_file *outbuf)
2669 debug_target.to_rcmd (command, outbuf);
2670 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2673 static struct symtab_and_line *
2674 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2676 struct symtab_and_line *result;
2677 result = debug_target.to_enable_exception_callback (kind, enable);
2678 fprintf_unfiltered (gdb_stdlog,
2679 "target get_exception_callback_sal (%d, %d)\n",
2684 static struct exception_event_record *
2685 debug_to_get_current_exception_event (void)
2687 struct exception_event_record *result;
2688 result = debug_target.to_get_current_exception_event ();
2689 fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2694 debug_to_pid_to_exec_file (int pid)
2698 exec_file = debug_target.to_pid_to_exec_file (pid);
2700 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2707 setup_target_debug (void)
2709 memcpy (&debug_target, ¤t_target, sizeof debug_target);
2711 current_target.to_open = debug_to_open;
2712 current_target.to_close = debug_to_close;
2713 current_target.to_attach = debug_to_attach;
2714 current_target.to_post_attach = debug_to_post_attach;
2715 current_target.to_detach = debug_to_detach;
2716 current_target.to_resume = debug_to_resume;
2717 current_target.to_wait = debug_to_wait;
2718 current_target.to_fetch_registers = debug_to_fetch_registers;
2719 current_target.to_store_registers = debug_to_store_registers;
2720 current_target.to_prepare_to_store = debug_to_prepare_to_store;
2721 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
2722 current_target.to_files_info = debug_to_files_info;
2723 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2724 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2725 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2726 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2727 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2728 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2729 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2730 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2731 current_target.to_stopped_data_address = debug_to_stopped_data_address;
2732 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
2733 current_target.to_terminal_init = debug_to_terminal_init;
2734 current_target.to_terminal_inferior = debug_to_terminal_inferior;
2735 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2736 current_target.to_terminal_ours = debug_to_terminal_ours;
2737 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2738 current_target.to_terminal_info = debug_to_terminal_info;
2739 current_target.to_kill = debug_to_kill;
2740 current_target.to_load = debug_to_load;
2741 current_target.to_lookup_symbol = debug_to_lookup_symbol;
2742 current_target.to_create_inferior = debug_to_create_inferior;
2743 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2744 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2745 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2746 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2747 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2748 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2749 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2750 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2751 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2752 current_target.to_has_exited = debug_to_has_exited;
2753 current_target.to_mourn_inferior = debug_to_mourn_inferior;
2754 current_target.to_can_run = debug_to_can_run;
2755 current_target.to_notice_signals = debug_to_notice_signals;
2756 current_target.to_thread_alive = debug_to_thread_alive;
2757 current_target.to_find_new_threads = debug_to_find_new_threads;
2758 current_target.to_stop = debug_to_stop;
2759 current_target.to_rcmd = debug_to_rcmd;
2760 current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2761 current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2762 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2766 static char targ_desc[] =
2767 "Names of targets and files being debugged.\n\
2768 Shows the entire stack of targets currently in use (including the exec-file,\n\
2769 core-file, and process, if any), as well as the symbol file name.";
2772 do_monitor_command (char *cmd,
2775 if ((current_target.to_rcmd
2776 == (void (*) (char *, struct ui_file *)) tcomplain)
2777 || (current_target.to_rcmd == debug_to_rcmd
2778 && (debug_target.to_rcmd
2779 == (void (*) (char *, struct ui_file *)) tcomplain)))
2780 error (_("\"monitor\" command not supported by this target."));
2781 target_rcmd (cmd, gdb_stdtarg);
2784 /* Print the name of each layers of our target stack. */
2787 maintenance_print_target_stack (char *cmd, int from_tty)
2789 struct target_ops *t;
2791 printf_filtered (_("The current target stack is:\n"));
2793 for (t = target_stack; t != NULL; t = t->beneath)
2795 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
2800 initialize_targets (void)
2802 init_dummy_target ();
2803 push_target (&dummy_target);
2805 add_info ("target", target_info, targ_desc);
2806 add_info ("files", target_info, targ_desc);
2808 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
2809 Set target debugging."), _("\
2810 Show target debugging."), _("\
2811 When non-zero, target debugging is enabled. Higher numbers are more\n\
2812 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2816 &setdebuglist, &showdebuglist);
2818 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
2819 &trust_readonly, _("\
2820 Set mode for reading from readonly sections."), _("\
2821 Show mode for reading from readonly sections."), _("\
2822 When this mode is on, memory reads from readonly sections (such as .text)\n\
2823 will be read from the object file instead of from the target. This will\n\
2824 result in significant performance improvement for remote targets."),
2826 show_trust_readonly,
2827 &setlist, &showlist);
2829 add_com ("monitor", class_obscure, do_monitor_command,
2830 _("Send a command to the remote monitor (remote targets only)."));
2832 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
2833 _("Print the name of each layer of the internal target stack."),
2834 &maintenanceprintlist);
2836 target_dcache = dcache_init ();