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 "gdbthread.h"
45 static void target_info (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_watchpoint_addr_within_range (struct target_ops *,
52 CORE_ADDR, CORE_ADDR, int);
54 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
56 static int nosymbol (char *, CORE_ADDR *);
58 static void tcomplain (void) ATTR_NORETURN;
60 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
62 static int return_zero (void);
64 static int return_one (void);
66 static int return_minus_one (void);
68 void target_ignore (void);
70 static void target_command (char *, int);
72 static struct target_ops *find_default_run_target (char *);
74 static void nosupport_runtime (void);
76 static LONGEST default_xfer_partial (struct target_ops *ops,
77 enum target_object object,
78 const char *annex, gdb_byte *readbuf,
79 const gdb_byte *writebuf,
80 ULONGEST offset, LONGEST len);
82 static LONGEST current_xfer_partial (struct target_ops *ops,
83 enum target_object object,
84 const char *annex, gdb_byte *readbuf,
85 const gdb_byte *writebuf,
86 ULONGEST offset, LONGEST len);
88 static LONGEST target_xfer_partial (struct target_ops *ops,
89 enum target_object object,
91 void *readbuf, const void *writebuf,
92 ULONGEST offset, LONGEST len);
94 static void init_dummy_target (void);
96 static struct target_ops debug_target;
98 static void debug_to_open (char *, int);
100 static void debug_to_close (int);
102 static void debug_to_attach (char *, int);
104 static void debug_to_detach (char *, int);
106 static void debug_to_resume (ptid_t, int, enum target_signal);
108 static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
110 static void debug_to_fetch_registers (struct regcache *, int);
112 static void debug_to_store_registers (struct regcache *, int);
114 static void debug_to_prepare_to_store (struct regcache *);
116 static void debug_to_files_info (struct target_ops *);
118 static int debug_to_insert_breakpoint (struct bp_target_info *);
120 static int debug_to_remove_breakpoint (struct bp_target_info *);
122 static int debug_to_can_use_hw_breakpoint (int, int, int);
124 static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
126 static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
128 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
130 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
132 static int debug_to_stopped_by_watchpoint (void);
134 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
136 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
137 CORE_ADDR, CORE_ADDR, int);
139 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
141 static void debug_to_terminal_init (void);
143 static void debug_to_terminal_inferior (void);
145 static void debug_to_terminal_ours_for_output (void);
147 static void debug_to_terminal_save_ours (void);
149 static void debug_to_terminal_ours (void);
151 static void debug_to_terminal_info (char *, int);
153 static void debug_to_kill (void);
155 static void debug_to_load (char *, int);
157 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
159 static void debug_to_mourn_inferior (void);
161 static int debug_to_can_run (void);
163 static void debug_to_notice_signals (ptid_t);
165 static int debug_to_thread_alive (ptid_t);
167 static void debug_to_stop (ptid_t);
169 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
170 wierd and mysterious ways. Putting the variable here lets those
171 wierd and mysterious ways keep building while they are being
172 converted to the inferior inheritance structure. */
173 struct target_ops deprecated_child_ops;
175 /* Pointer to array of target architecture structures; the size of the
176 array; the current index into the array; the allocated size of the
178 struct target_ops **target_structs;
179 unsigned target_struct_size;
180 unsigned target_struct_index;
181 unsigned target_struct_allocsize;
182 #define DEFAULT_ALLOCSIZE 10
184 /* The initial current target, so that there is always a semi-valid
187 static struct target_ops dummy_target;
189 /* Top of target stack. */
191 static struct target_ops *target_stack;
193 /* The target structure we are currently using to talk to a process
194 or file or whatever "inferior" we have. */
196 struct target_ops current_target;
198 /* Command list for target. */
200 static struct cmd_list_element *targetlist = NULL;
202 /* Nonzero if we should trust readonly sections from the
203 executable when reading memory. */
205 static int trust_readonly = 0;
207 /* Nonzero if we should show true memory content including
208 memory breakpoint inserted by gdb. */
210 static int show_memory_breakpoints = 0;
212 /* Non-zero if we want to see trace of target level stuff. */
214 static int targetdebug = 0;
216 show_targetdebug (struct ui_file *file, int from_tty,
217 struct cmd_list_element *c, const char *value)
219 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
222 static void setup_target_debug (void);
224 DCACHE *target_dcache;
226 /* The user just typed 'target' without the name of a target. */
229 target_command (char *arg, int from_tty)
231 fputs_filtered ("Argument required (target name). Try `help target'\n",
235 /* Add a possible target architecture to the list. */
238 add_target (struct target_ops *t)
240 /* Provide default values for all "must have" methods. */
241 if (t->to_xfer_partial == NULL)
242 t->to_xfer_partial = default_xfer_partial;
246 target_struct_allocsize = DEFAULT_ALLOCSIZE;
247 target_structs = (struct target_ops **) xmalloc
248 (target_struct_allocsize * sizeof (*target_structs));
250 if (target_struct_size >= target_struct_allocsize)
252 target_struct_allocsize *= 2;
253 target_structs = (struct target_ops **)
254 xrealloc ((char *) target_structs,
255 target_struct_allocsize * sizeof (*target_structs));
257 target_structs[target_struct_size++] = t;
259 if (targetlist == NULL)
260 add_prefix_cmd ("target", class_run, target_command, _("\
261 Connect to a target machine or process.\n\
262 The first argument is the type or protocol of the target machine.\n\
263 Remaining arguments are interpreted by the target protocol. For more\n\
264 information on the arguments for a particular protocol, type\n\
265 `help target ' followed by the protocol name."),
266 &targetlist, "target ", 0, &cmdlist);
267 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
278 target_load (char *arg, int from_tty)
280 dcache_invalidate (target_dcache);
281 (*current_target.to_load) (arg, from_tty);
285 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
286 struct target_ops *t)
288 errno = EIO; /* Can't read/write this location */
289 return 0; /* No bytes handled */
295 error (_("You can't do that when your target is `%s'"),
296 current_target.to_shortname);
302 error (_("You can't do that without a process to debug."));
306 nosymbol (char *name, CORE_ADDR *addrp)
308 return 1; /* Symbol does not exist in target env */
312 nosupport_runtime (void)
314 if (ptid_equal (inferior_ptid, null_ptid))
317 error (_("No run-time support for this"));
322 default_terminal_info (char *args, int from_tty)
324 printf_unfiltered (_("No saved terminal information.\n"));
327 /* This is the default target_create_inferior and target_attach function.
328 If the current target is executing, it asks whether to kill it off.
329 If this function returns without calling error(), it has killed off
330 the target, and the operation should be attempted. */
333 kill_or_be_killed (int from_tty)
335 if (target_has_execution)
337 printf_unfiltered (_("You are already running a program:\n"));
338 target_files_info ();
339 if (query ("Kill it? "))
342 if (target_has_execution)
343 error (_("Killing the program did not help."));
348 error (_("Program not killed."));
354 /* A default implementation for the to_get_ada_task_ptid target method.
356 This function builds the PTID by using both LWP and TID as part of
357 the PTID lwp and tid elements. The pid used is the pid of the
361 default_get_ada_task_ptid (long lwp, long tid)
363 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
366 /* Go through the target stack from top to bottom, copying over zero
367 entries in current_target, then filling in still empty entries. In
368 effect, we are doing class inheritance through the pushed target
371 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
372 is currently implemented, is that it discards any knowledge of
373 which target an inherited method originally belonged to.
374 Consequently, new new target methods should instead explicitly and
375 locally search the target stack for the target that can handle the
379 update_current_target (void)
381 struct target_ops *t;
383 /* First, reset current's contents. */
384 memset (¤t_target, 0, sizeof (current_target));
386 #define INHERIT(FIELD, TARGET) \
387 if (!current_target.FIELD) \
388 current_target.FIELD = (TARGET)->FIELD
390 for (t = target_stack; t; t = t->beneath)
392 INHERIT (to_shortname, t);
393 INHERIT (to_longname, t);
395 /* Do not inherit to_open. */
396 /* Do not inherit to_close. */
397 INHERIT (to_attach, t);
398 INHERIT (to_post_attach, t);
399 INHERIT (to_attach_no_wait, t);
400 INHERIT (to_detach, t);
401 /* Do not inherit to_disconnect. */
402 INHERIT (to_resume, t);
403 INHERIT (to_wait, t);
404 INHERIT (to_fetch_registers, t);
405 INHERIT (to_store_registers, t);
406 INHERIT (to_prepare_to_store, t);
407 INHERIT (deprecated_xfer_memory, t);
408 INHERIT (to_files_info, t);
409 INHERIT (to_insert_breakpoint, t);
410 INHERIT (to_remove_breakpoint, t);
411 INHERIT (to_can_use_hw_breakpoint, t);
412 INHERIT (to_insert_hw_breakpoint, t);
413 INHERIT (to_remove_hw_breakpoint, t);
414 INHERIT (to_insert_watchpoint, t);
415 INHERIT (to_remove_watchpoint, t);
416 INHERIT (to_stopped_data_address, t);
417 INHERIT (to_have_steppable_watchpoint, t);
418 INHERIT (to_have_continuable_watchpoint, t);
419 INHERIT (to_stopped_by_watchpoint, t);
420 INHERIT (to_watchpoint_addr_within_range, t);
421 INHERIT (to_region_ok_for_hw_watchpoint, t);
422 INHERIT (to_terminal_init, t);
423 INHERIT (to_terminal_inferior, t);
424 INHERIT (to_terminal_ours_for_output, t);
425 INHERIT (to_terminal_ours, t);
426 INHERIT (to_terminal_save_ours, t);
427 INHERIT (to_terminal_info, t);
428 INHERIT (to_kill, t);
429 INHERIT (to_load, t);
430 INHERIT (to_lookup_symbol, t);
431 INHERIT (to_create_inferior, t);
432 INHERIT (to_post_startup_inferior, t);
433 INHERIT (to_acknowledge_created_inferior, t);
434 INHERIT (to_insert_fork_catchpoint, t);
435 INHERIT (to_remove_fork_catchpoint, t);
436 INHERIT (to_insert_vfork_catchpoint, t);
437 INHERIT (to_remove_vfork_catchpoint, t);
438 /* Do not inherit to_follow_fork. */
439 INHERIT (to_insert_exec_catchpoint, t);
440 INHERIT (to_remove_exec_catchpoint, t);
441 INHERIT (to_has_exited, t);
442 INHERIT (to_mourn_inferior, t);
443 INHERIT (to_can_run, t);
444 INHERIT (to_notice_signals, t);
445 INHERIT (to_thread_alive, t);
446 INHERIT (to_find_new_threads, t);
447 INHERIT (to_pid_to_str, t);
448 INHERIT (to_extra_thread_info, t);
449 INHERIT (to_stop, t);
450 /* Do not inherit to_xfer_partial. */
451 INHERIT (to_rcmd, t);
452 INHERIT (to_pid_to_exec_file, t);
453 INHERIT (to_log_command, t);
454 INHERIT (to_stratum, t);
455 INHERIT (to_has_all_memory, t);
456 INHERIT (to_has_memory, t);
457 INHERIT (to_has_stack, t);
458 INHERIT (to_has_registers, t);
459 INHERIT (to_has_execution, t);
460 INHERIT (to_has_thread_control, t);
461 INHERIT (to_sections, t);
462 INHERIT (to_sections_end, t);
463 INHERIT (to_can_async_p, t);
464 INHERIT (to_is_async_p, t);
465 INHERIT (to_async, t);
466 INHERIT (to_async_mask, t);
467 INHERIT (to_find_memory_regions, t);
468 INHERIT (to_make_corefile_notes, t);
469 INHERIT (to_get_thread_local_address, t);
470 INHERIT (to_can_execute_reverse, t);
471 /* Do not inherit to_read_description. */
472 INHERIT (to_get_ada_task_ptid, t);
473 /* Do not inherit to_search_memory. */
474 INHERIT (to_supports_multi_process, t);
475 INHERIT (to_magic, t);
476 /* Do not inherit to_memory_map. */
477 /* Do not inherit to_flash_erase. */
478 /* Do not inherit to_flash_done. */
482 /* Clean up a target struct so it no longer has any zero pointers in
483 it. Some entries are defaulted to a method that print an error,
484 others are hard-wired to a standard recursive default. */
486 #define de_fault(field, value) \
487 if (!current_target.field) \
488 current_target.field = value
491 (void (*) (char *, int))
496 de_fault (to_post_attach,
500 (void (*) (char *, int))
503 (void (*) (ptid_t, int, enum target_signal))
506 (ptid_t (*) (ptid_t, struct target_waitstatus *))
508 de_fault (to_fetch_registers,
509 (void (*) (struct regcache *, int))
511 de_fault (to_store_registers,
512 (void (*) (struct regcache *, int))
514 de_fault (to_prepare_to_store,
515 (void (*) (struct regcache *))
517 de_fault (deprecated_xfer_memory,
518 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
520 de_fault (to_files_info,
521 (void (*) (struct target_ops *))
523 de_fault (to_insert_breakpoint,
524 memory_insert_breakpoint);
525 de_fault (to_remove_breakpoint,
526 memory_remove_breakpoint);
527 de_fault (to_can_use_hw_breakpoint,
528 (int (*) (int, int, int))
530 de_fault (to_insert_hw_breakpoint,
531 (int (*) (struct bp_target_info *))
533 de_fault (to_remove_hw_breakpoint,
534 (int (*) (struct bp_target_info *))
536 de_fault (to_insert_watchpoint,
537 (int (*) (CORE_ADDR, int, int))
539 de_fault (to_remove_watchpoint,
540 (int (*) (CORE_ADDR, int, int))
542 de_fault (to_stopped_by_watchpoint,
545 de_fault (to_stopped_data_address,
546 (int (*) (struct target_ops *, CORE_ADDR *))
548 de_fault (to_watchpoint_addr_within_range,
549 default_watchpoint_addr_within_range);
550 de_fault (to_region_ok_for_hw_watchpoint,
551 default_region_ok_for_hw_watchpoint);
552 de_fault (to_terminal_init,
555 de_fault (to_terminal_inferior,
558 de_fault (to_terminal_ours_for_output,
561 de_fault (to_terminal_ours,
564 de_fault (to_terminal_save_ours,
567 de_fault (to_terminal_info,
568 default_terminal_info);
573 (void (*) (char *, int))
575 de_fault (to_lookup_symbol,
576 (int (*) (char *, CORE_ADDR *))
578 de_fault (to_post_startup_inferior,
581 de_fault (to_acknowledge_created_inferior,
584 de_fault (to_insert_fork_catchpoint,
587 de_fault (to_remove_fork_catchpoint,
590 de_fault (to_insert_vfork_catchpoint,
593 de_fault (to_remove_vfork_catchpoint,
596 de_fault (to_insert_exec_catchpoint,
599 de_fault (to_remove_exec_catchpoint,
602 de_fault (to_has_exited,
603 (int (*) (int, int, int *))
605 de_fault (to_mourn_inferior,
608 de_fault (to_can_run,
610 de_fault (to_notice_signals,
613 de_fault (to_thread_alive,
616 de_fault (to_find_new_threads,
619 de_fault (to_extra_thread_info,
620 (char *(*) (struct thread_info *))
625 current_target.to_xfer_partial = current_xfer_partial;
627 (void (*) (char *, struct ui_file *))
629 de_fault (to_pid_to_exec_file,
633 (void (*) (void (*) (enum inferior_event_type, void*), void*))
635 de_fault (to_async_mask,
638 current_target.to_read_description = NULL;
639 de_fault (to_get_ada_task_ptid,
640 (ptid_t (*) (long, long))
641 default_get_ada_task_ptid);
642 de_fault (to_supports_multi_process,
647 /* Finally, position the target-stack beneath the squashed
648 "current_target". That way code looking for a non-inherited
649 target method can quickly and simply find it. */
650 current_target.beneath = target_stack;
653 setup_target_debug ();
656 /* Mark OPS as a running target. This reverses the effect
657 of target_mark_exited. */
660 target_mark_running (struct target_ops *ops)
662 struct target_ops *t;
664 for (t = target_stack; t != NULL; t = t->beneath)
668 internal_error (__FILE__, __LINE__,
669 "Attempted to mark unpushed target \"%s\" as running",
672 ops->to_has_execution = 1;
673 ops->to_has_all_memory = 1;
674 ops->to_has_memory = 1;
675 ops->to_has_stack = 1;
676 ops->to_has_registers = 1;
678 update_current_target ();
681 /* Mark OPS as a non-running target. This reverses the effect
682 of target_mark_running. */
685 target_mark_exited (struct target_ops *ops)
687 struct target_ops *t;
689 for (t = target_stack; t != NULL; t = t->beneath)
693 internal_error (__FILE__, __LINE__,
694 "Attempted to mark unpushed target \"%s\" as running",
697 ops->to_has_execution = 0;
698 ops->to_has_all_memory = 0;
699 ops->to_has_memory = 0;
700 ops->to_has_stack = 0;
701 ops->to_has_registers = 0;
703 update_current_target ();
706 /* Push a new target type into the stack of the existing target accessors,
707 possibly superseding some of the existing accessors.
709 Result is zero if the pushed target ended up on top of the stack,
710 nonzero if at least one target is on top of it.
712 Rather than allow an empty stack, we always have the dummy target at
713 the bottom stratum, so we can call the function vectors without
717 push_target (struct target_ops *t)
719 struct target_ops **cur;
721 /* Check magic number. If wrong, it probably means someone changed
722 the struct definition, but not all the places that initialize one. */
723 if (t->to_magic != OPS_MAGIC)
725 fprintf_unfiltered (gdb_stderr,
726 "Magic number of %s target struct wrong\n",
728 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
731 /* Find the proper stratum to install this target in. */
732 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
734 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
738 /* If there's already targets at this stratum, remove them. */
739 /* FIXME: cagney/2003-10-15: I think this should be popping all
740 targets to CUR, and not just those at this stratum level. */
741 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
743 /* There's already something at this stratum level. Close it,
744 and un-hook it from the stack. */
745 struct target_ops *tmp = (*cur);
746 (*cur) = (*cur)->beneath;
748 target_close (tmp, 0);
751 /* We have removed all targets in our stratum, now add the new one. */
755 update_current_target ();
758 return (t != target_stack);
761 /* Remove a target_ops vector from the stack, wherever it may be.
762 Return how many times it was removed (0 or 1). */
765 unpush_target (struct target_ops *t)
767 struct target_ops **cur;
768 struct target_ops *tmp;
770 if (t->to_stratum == dummy_stratum)
771 internal_error (__FILE__, __LINE__,
772 "Attempt to unpush the dummy target");
774 /* Look for the specified target. Note that we assume that a target
775 can only occur once in the target stack. */
777 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
784 return 0; /* Didn't find target_ops, quit now */
786 /* NOTE: cagney/2003-12-06: In '94 the close call was made
787 unconditional by moving it to before the above check that the
788 target was in the target stack (something about "Change the way
789 pushing and popping of targets work to support target overlays
790 and inheritance"). This doesn't make much sense - only open
791 targets should be closed. */
794 /* Unchain the target */
796 (*cur) = (*cur)->beneath;
799 update_current_target ();
807 target_close (target_stack, 0); /* Let it clean up */
808 if (unpush_target (target_stack) == 1)
811 fprintf_unfiltered (gdb_stderr,
812 "pop_target couldn't find target %s\n",
813 current_target.to_shortname);
814 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
818 pop_all_targets_above (enum strata above_stratum, int quitting)
820 while ((int) (current_target.to_stratum) > (int) above_stratum)
822 target_close (target_stack, quitting);
823 if (!unpush_target (target_stack))
825 fprintf_unfiltered (gdb_stderr,
826 "pop_all_targets couldn't find target %s\n",
827 target_stack->to_shortname);
828 internal_error (__FILE__, __LINE__,
829 _("failed internal consistency check"));
836 pop_all_targets (int quitting)
838 pop_all_targets_above (dummy_stratum, quitting);
841 /* Using the objfile specified in OBJFILE, find the address for the
842 current thread's thread-local storage with offset OFFSET. */
844 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
846 volatile CORE_ADDR addr = 0;
848 if (target_get_thread_local_address_p ()
849 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
851 ptid_t ptid = inferior_ptid;
852 volatile struct gdb_exception ex;
854 TRY_CATCH (ex, RETURN_MASK_ALL)
858 /* Fetch the load module address for this objfile. */
859 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
861 /* If it's 0, throw the appropriate exception. */
863 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
864 _("TLS load module not found"));
866 addr = target_get_thread_local_address (ptid, lm_addr, offset);
868 /* If an error occurred, print TLS related messages here. Otherwise,
869 throw the error to some higher catcher. */
872 int objfile_is_library = (objfile->flags & OBJF_SHARED);
876 case TLS_NO_LIBRARY_SUPPORT_ERROR:
877 error (_("Cannot find thread-local variables in this thread library."));
879 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
880 if (objfile_is_library)
881 error (_("Cannot find shared library `%s' in dynamic"
882 " linker's load module list"), objfile->name);
884 error (_("Cannot find executable file `%s' in dynamic"
885 " linker's load module list"), objfile->name);
887 case TLS_NOT_ALLOCATED_YET_ERROR:
888 if (objfile_is_library)
889 error (_("The inferior has not yet allocated storage for"
890 " thread-local variables in\n"
891 "the shared library `%s'\n"
893 objfile->name, target_pid_to_str (ptid));
895 error (_("The inferior has not yet allocated storage for"
896 " thread-local variables in\n"
897 "the executable `%s'\n"
899 objfile->name, target_pid_to_str (ptid));
901 case TLS_GENERIC_ERROR:
902 if (objfile_is_library)
903 error (_("Cannot find thread-local storage for %s, "
904 "shared library %s:\n%s"),
905 target_pid_to_str (ptid),
906 objfile->name, ex.message);
908 error (_("Cannot find thread-local storage for %s, "
909 "executable file %s:\n%s"),
910 target_pid_to_str (ptid),
911 objfile->name, ex.message);
914 throw_exception (ex);
919 /* It wouldn't be wrong here to try a gdbarch method, too; finding
920 TLS is an ABI-specific thing. But we don't do that yet. */
922 error (_("Cannot find thread-local variables on this target"));
928 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
930 /* target_read_string -- read a null terminated string, up to LEN bytes,
931 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
932 Set *STRING to a pointer to malloc'd memory containing the data; the caller
933 is responsible for freeing it. Return the number of bytes successfully
937 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
939 int tlen, origlen, offset, i;
943 int buffer_allocated;
945 unsigned int nbytes_read = 0;
949 /* Small for testing. */
950 buffer_allocated = 4;
951 buffer = xmalloc (buffer_allocated);
958 tlen = MIN (len, 4 - (memaddr & 3));
959 offset = memaddr & 3;
961 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
964 /* The transfer request might have crossed the boundary to an
965 unallocated region of memory. Retry the transfer, requesting
969 errcode = target_read_memory (memaddr, buf, 1);
974 if (bufptr - buffer + tlen > buffer_allocated)
977 bytes = bufptr - buffer;
978 buffer_allocated *= 2;
979 buffer = xrealloc (buffer, buffer_allocated);
980 bufptr = buffer + bytes;
983 for (i = 0; i < tlen; i++)
985 *bufptr++ = buf[i + offset];
986 if (buf[i + offset] == '\000')
988 nbytes_read += i + 1;
1004 /* Find a section containing ADDR. */
1005 struct section_table *
1006 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1008 struct section_table *secp;
1009 for (secp = target->to_sections;
1010 secp < target->to_sections_end;
1013 if (addr >= secp->addr && addr < secp->endaddr)
1019 /* Perform a partial memory transfer. The arguments and return
1020 value are just as for target_xfer_partial. */
1023 memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
1024 ULONGEST memaddr, LONGEST len)
1028 struct mem_region *region;
1030 /* Zero length requests are ok and require no work. */
1034 /* Try the executable file, if "trust-readonly-sections" is set. */
1035 if (readbuf != NULL && trust_readonly)
1037 struct section_table *secp;
1039 secp = target_section_by_addr (ops, memaddr);
1041 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1043 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1046 /* Likewise for accesses to unmapped overlay sections. */
1047 if (readbuf != NULL && overlay_debugging)
1049 struct obj_section *section = find_pc_overlay (memaddr);
1050 if (pc_in_unmapped_range (memaddr, section))
1051 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1054 /* Try GDB's internal data cache. */
1055 region = lookup_mem_region (memaddr);
1056 /* region->hi == 0 means there's no upper bound. */
1057 if (memaddr + len < region->hi || region->hi == 0)
1060 reg_len = region->hi - memaddr;
1062 switch (region->attrib.mode)
1065 if (writebuf != NULL)
1070 if (readbuf != NULL)
1075 /* We only support writing to flash during "load" for now. */
1076 if (writebuf != NULL)
1077 error (_("Writing to flash memory forbidden in this context"));
1084 if (region->attrib.cache)
1086 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1087 memory request will start back at current_target. */
1088 if (readbuf != NULL)
1089 res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
1092 /* FIXME drow/2006-08-09: If we're going to preserve const
1093 correctness dcache_xfer_memory should take readbuf and
1095 res = dcache_xfer_memory (target_dcache, memaddr,
1102 if (readbuf && !show_memory_breakpoints)
1103 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1108 /* If none of those methods found the memory we wanted, fall back
1109 to a target partial transfer. Normally a single call to
1110 to_xfer_partial is enough; if it doesn't recognize an object
1111 it will call the to_xfer_partial of the next target down.
1112 But for memory this won't do. Memory is the only target
1113 object which can be read from more than one valid target.
1114 A core file, for instance, could have some of memory but
1115 delegate other bits to the target below it. So, we must
1116 manually try all targets. */
1120 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1121 readbuf, writebuf, memaddr, reg_len);
1125 /* We want to continue past core files to executables, but not
1126 past a running target's memory. */
1127 if (ops->to_has_all_memory)
1132 while (ops != NULL);
1134 if (readbuf && !show_memory_breakpoints)
1135 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1137 /* If we still haven't got anything, return the last error. We
1143 restore_show_memory_breakpoints (void *arg)
1145 show_memory_breakpoints = (uintptr_t) arg;
1149 make_show_memory_breakpoints_cleanup (int show)
1151 int current = show_memory_breakpoints;
1152 show_memory_breakpoints = show;
1154 return make_cleanup (restore_show_memory_breakpoints,
1155 (void *) (uintptr_t) current);
1159 target_xfer_partial (struct target_ops *ops,
1160 enum target_object object, const char *annex,
1161 void *readbuf, const void *writebuf,
1162 ULONGEST offset, LONGEST len)
1166 gdb_assert (ops->to_xfer_partial != NULL);
1168 /* If this is a memory transfer, let the memory-specific code
1169 have a look at it instead. Memory transfers are more
1171 if (object == TARGET_OBJECT_MEMORY)
1172 retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
1175 enum target_object raw_object = object;
1177 /* If this is a raw memory transfer, request the normal
1178 memory object from other layers. */
1179 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1180 raw_object = TARGET_OBJECT_MEMORY;
1182 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1183 writebuf, offset, len);
1188 const unsigned char *myaddr = NULL;
1190 fprintf_unfiltered (gdb_stdlog,
1191 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
1194 (annex ? annex : "(null)"),
1195 (long) readbuf, (long) writebuf,
1196 core_addr_to_string_nz (offset),
1197 plongest (len), plongest (retval));
1203 if (retval > 0 && myaddr != NULL)
1207 fputs_unfiltered (", bytes =", gdb_stdlog);
1208 for (i = 0; i < retval; i++)
1210 if ((((long) &(myaddr[i])) & 0xf) == 0)
1212 if (targetdebug < 2 && i > 0)
1214 fprintf_unfiltered (gdb_stdlog, " ...");
1217 fprintf_unfiltered (gdb_stdlog, "\n");
1220 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1224 fputc_unfiltered ('\n', gdb_stdlog);
1229 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1230 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1231 if any error occurs.
1233 If an error occurs, no guarantee is made about the contents of the data at
1234 MYADDR. In particular, the caller should not depend upon partial reads
1235 filling the buffer with good data. There is no way for the caller to know
1236 how much good data might have been transfered anyway. Callers that can
1237 deal with partial reads should call target_read (which will retry until
1238 it makes no progress, and then return how much was transferred). */
1241 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1243 if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1244 myaddr, memaddr, len) == len)
1251 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1253 if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1254 myaddr, memaddr, len) == len)
1260 /* Fetch the target's memory map. */
1263 target_memory_map (void)
1265 VEC(mem_region_s) *result;
1266 struct mem_region *last_one, *this_one;
1268 struct target_ops *t;
1271 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1273 for (t = current_target.beneath; t != NULL; t = t->beneath)
1274 if (t->to_memory_map != NULL)
1280 result = t->to_memory_map (t);
1284 qsort (VEC_address (mem_region_s, result),
1285 VEC_length (mem_region_s, result),
1286 sizeof (struct mem_region), mem_region_cmp);
1288 /* Check that regions do not overlap. Simultaneously assign
1289 a numbering for the "mem" commands to use to refer to
1292 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1294 this_one->number = ix;
1296 if (last_one && last_one->hi > this_one->lo)
1298 warning (_("Overlapping regions in memory map: ignoring"));
1299 VEC_free (mem_region_s, result);
1302 last_one = this_one;
1309 target_flash_erase (ULONGEST address, LONGEST length)
1311 struct target_ops *t;
1313 for (t = current_target.beneath; t != NULL; t = t->beneath)
1314 if (t->to_flash_erase != NULL)
1317 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1318 paddr (address), phex (length, 0));
1319 t->to_flash_erase (t, address, length);
1327 target_flash_done (void)
1329 struct target_ops *t;
1331 for (t = current_target.beneath; t != NULL; t = t->beneath)
1332 if (t->to_flash_done != NULL)
1335 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1336 t->to_flash_done (t);
1343 #ifndef target_stopped_data_address_p
1345 target_stopped_data_address_p (struct target_ops *target)
1347 if (target->to_stopped_data_address
1348 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
1350 if (target->to_stopped_data_address == debug_to_stopped_data_address
1351 && (debug_target.to_stopped_data_address
1352 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1359 show_trust_readonly (struct ui_file *file, int from_tty,
1360 struct cmd_list_element *c, const char *value)
1362 fprintf_filtered (file, _("\
1363 Mode for reading from readonly sections is %s.\n"),
1367 /* More generic transfers. */
1370 default_xfer_partial (struct target_ops *ops, enum target_object object,
1371 const char *annex, gdb_byte *readbuf,
1372 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1374 if (object == TARGET_OBJECT_MEMORY
1375 && ops->deprecated_xfer_memory != NULL)
1376 /* If available, fall back to the target's
1377 "deprecated_xfer_memory" method. */
1381 if (writebuf != NULL)
1383 void *buffer = xmalloc (len);
1384 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1385 memcpy (buffer, writebuf, len);
1386 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1387 1/*write*/, NULL, ops);
1388 do_cleanups (cleanup);
1390 if (readbuf != NULL)
1391 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1392 0/*read*/, NULL, ops);
1395 else if (xfered == 0 && errno == 0)
1396 /* "deprecated_xfer_memory" uses 0, cross checked against
1397 ERRNO as one indication of an error. */
1402 else if (ops->beneath != NULL)
1403 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1404 readbuf, writebuf, offset, len);
1409 /* The xfer_partial handler for the topmost target. Unlike the default,
1410 it does not need to handle memory specially; it just passes all
1411 requests down the stack. */
1414 current_xfer_partial (struct target_ops *ops, enum target_object object,
1415 const char *annex, gdb_byte *readbuf,
1416 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1418 if (ops->beneath != NULL)
1419 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1420 readbuf, writebuf, offset, len);
1425 /* Target vector read/write partial wrapper functions.
1427 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1428 (inbuf, outbuf)", instead of separate read/write methods, make life
1432 target_read_partial (struct target_ops *ops,
1433 enum target_object object,
1434 const char *annex, gdb_byte *buf,
1435 ULONGEST offset, LONGEST len)
1437 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1441 target_write_partial (struct target_ops *ops,
1442 enum target_object object,
1443 const char *annex, const gdb_byte *buf,
1444 ULONGEST offset, LONGEST len)
1446 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1449 /* Wrappers to perform the full transfer. */
1451 target_read (struct target_ops *ops,
1452 enum target_object object,
1453 const char *annex, gdb_byte *buf,
1454 ULONGEST offset, LONGEST len)
1457 while (xfered < len)
1459 LONGEST xfer = target_read_partial (ops, object, annex,
1460 (gdb_byte *) buf + xfered,
1461 offset + xfered, len - xfered);
1462 /* Call an observer, notifying them of the xfer progress? */
1474 target_read_until_error (struct target_ops *ops,
1475 enum target_object object,
1476 const char *annex, gdb_byte *buf,
1477 ULONGEST offset, LONGEST len)
1480 while (xfered < len)
1482 LONGEST xfer = target_read_partial (ops, object, annex,
1483 (gdb_byte *) buf + xfered,
1484 offset + xfered, len - xfered);
1485 /* Call an observer, notifying them of the xfer progress? */
1490 /* We've got an error. Try to read in smaller blocks. */
1491 ULONGEST start = offset + xfered;
1492 ULONGEST remaining = len - xfered;
1495 /* If an attempt was made to read a random memory address,
1496 it's likely that the very first byte is not accessible.
1497 Try reading the first byte, to avoid doing log N tries
1499 xfer = target_read_partial (ops, object, annex,
1500 (gdb_byte *) buf + xfered, start, 1);
1509 xfer = target_read_partial (ops, object, annex,
1510 (gdb_byte *) buf + xfered,
1520 /* We have successfully read the first half. So, the
1521 error must be in the second half. Adjust start and
1522 remaining to point at the second half. */
1539 /* An alternative to target_write with progress callbacks. */
1542 target_write_with_progress (struct target_ops *ops,
1543 enum target_object object,
1544 const char *annex, const gdb_byte *buf,
1545 ULONGEST offset, LONGEST len,
1546 void (*progress) (ULONGEST, void *), void *baton)
1550 /* Give the progress callback a chance to set up. */
1552 (*progress) (0, baton);
1554 while (xfered < len)
1556 LONGEST xfer = target_write_partial (ops, object, annex,
1557 (gdb_byte *) buf + xfered,
1558 offset + xfered, len - xfered);
1566 (*progress) (xfer, baton);
1575 target_write (struct target_ops *ops,
1576 enum target_object object,
1577 const char *annex, const gdb_byte *buf,
1578 ULONGEST offset, LONGEST len)
1580 return target_write_with_progress (ops, object, annex, buf, offset, len,
1584 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1585 the size of the transferred data. PADDING additional bytes are
1586 available in *BUF_P. This is a helper function for
1587 target_read_alloc; see the declaration of that function for more
1591 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1592 const char *annex, gdb_byte **buf_p, int padding)
1594 size_t buf_alloc, buf_pos;
1598 /* This function does not have a length parameter; it reads the
1599 entire OBJECT). Also, it doesn't support objects fetched partly
1600 from one target and partly from another (in a different stratum,
1601 e.g. a core file and an executable). Both reasons make it
1602 unsuitable for reading memory. */
1603 gdb_assert (object != TARGET_OBJECT_MEMORY);
1605 /* Start by reading up to 4K at a time. The target will throttle
1606 this number down if necessary. */
1608 buf = xmalloc (buf_alloc);
1612 n = target_read_partial (ops, object, annex, &buf[buf_pos],
1613 buf_pos, buf_alloc - buf_pos - padding);
1616 /* An error occurred. */
1622 /* Read all there was. */
1632 /* If the buffer is filling up, expand it. */
1633 if (buf_alloc < buf_pos * 2)
1636 buf = xrealloc (buf, buf_alloc);
1643 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1644 the size of the transferred data. See the declaration in "target.h"
1645 function for more information about the return value. */
1648 target_read_alloc (struct target_ops *ops, enum target_object object,
1649 const char *annex, gdb_byte **buf_p)
1651 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1654 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1655 returned as a string, allocated using xmalloc. If an error occurs
1656 or the transfer is unsupported, NULL is returned. Empty objects
1657 are returned as allocated but empty strings. A warning is issued
1658 if the result contains any embedded NUL bytes. */
1661 target_read_stralloc (struct target_ops *ops, enum target_object object,
1665 LONGEST transferred;
1667 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1669 if (transferred < 0)
1672 if (transferred == 0)
1673 return xstrdup ("");
1675 buffer[transferred] = 0;
1676 if (strlen (buffer) < transferred)
1677 warning (_("target object %d, annex %s, "
1678 "contained unexpected null characters"),
1679 (int) object, annex ? annex : "(none)");
1681 return (char *) buffer;
1684 /* Memory transfer methods. */
1687 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1690 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1692 memory_error (EIO, addr);
1696 get_target_memory_unsigned (struct target_ops *ops,
1697 CORE_ADDR addr, int len)
1699 gdb_byte buf[sizeof (ULONGEST)];
1701 gdb_assert (len <= sizeof (buf));
1702 get_target_memory (ops, addr, buf, len);
1703 return extract_unsigned_integer (buf, len);
1707 target_info (char *args, int from_tty)
1709 struct target_ops *t;
1710 int has_all_mem = 0;
1712 if (symfile_objfile != NULL)
1713 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1715 for (t = target_stack; t != NULL; t = t->beneath)
1717 if (!t->to_has_memory)
1720 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1723 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1724 printf_unfiltered ("%s:\n", t->to_longname);
1725 (t->to_files_info) (t);
1726 has_all_mem = t->to_has_all_memory;
1730 /* This function is called before any new inferior is created, e.g.
1731 by running a program, attaching, or connecting to a target.
1732 It cleans up any state from previous invocations which might
1733 change between runs. This is a subset of what target_preopen
1734 resets (things which might change between targets). */
1737 target_pre_inferior (int from_tty)
1739 /* Clear out solib state. Otherwise the solib state of the previous
1740 inferior might have survived and is entirely wrong for the new
1741 target. This has been observed on GNU/Linux using glibc 2.3. How
1753 Cannot access memory at address 0xdeadbeef
1755 no_shared_libraries (NULL, from_tty);
1757 invalidate_target_mem_regions ();
1759 target_clear_description ();
1762 /* This is to be called by the open routine before it does
1766 target_preopen (int from_tty)
1770 if (target_has_execution)
1773 || query (_("A program is being debugged already. Kill it? ")))
1776 error (_("Program not killed."));
1779 /* Calling target_kill may remove the target from the stack. But if
1780 it doesn't (which seems like a win for UDI), remove it now. */
1781 /* Leave the exec target, though. The user may be switching from a
1782 live process to a core of the same program. */
1783 pop_all_targets_above (file_stratum, 0);
1785 target_pre_inferior (from_tty);
1788 /* Detach a target after doing deferred register stores. */
1791 target_detach (char *args, int from_tty)
1793 /* If we're in breakpoints-always-inserted mode, have to
1794 remove them before detaching. */
1795 remove_breakpoints ();
1797 (current_target.to_detach) (args, from_tty);
1801 target_disconnect (char *args, int from_tty)
1803 struct target_ops *t;
1805 /* If we're in breakpoints-always-inserted mode, have to
1806 remove them before disconnecting. */
1807 remove_breakpoints ();
1809 for (t = current_target.beneath; t != NULL; t = t->beneath)
1810 if (t->to_disconnect != NULL)
1813 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1815 t->to_disconnect (t, args, from_tty);
1823 target_resume (ptid_t ptid, int step, enum target_signal signal)
1825 dcache_invalidate (target_dcache);
1826 (*current_target.to_resume) (ptid, step, signal);
1827 set_executing (ptid, 1);
1828 set_running (ptid, 1);
1830 /* Look through the list of possible targets for a target that can
1834 target_follow_fork (int follow_child)
1836 struct target_ops *t;
1838 for (t = current_target.beneath; t != NULL; t = t->beneath)
1840 if (t->to_follow_fork != NULL)
1842 int retval = t->to_follow_fork (t, follow_child);
1844 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1845 follow_child, retval);
1850 /* Some target returned a fork event, but did not know how to follow it. */
1851 internal_error (__FILE__, __LINE__,
1852 "could not find a target to follow fork");
1855 /* Look for a target which can describe architectural features, starting
1856 from TARGET. If we find one, return its description. */
1858 const struct target_desc *
1859 target_read_description (struct target_ops *target)
1861 struct target_ops *t;
1863 for (t = target; t != NULL; t = t->beneath)
1864 if (t->to_read_description != NULL)
1866 const struct target_desc *tdesc;
1868 tdesc = t->to_read_description (t);
1876 /* The default implementation of to_search_memory.
1877 This implements a basic search of memory, reading target memory and
1878 performing the search here (as opposed to performing the search in on the
1879 target side with, for example, gdbserver). */
1882 simple_search_memory (struct target_ops *ops,
1883 CORE_ADDR start_addr, ULONGEST search_space_len,
1884 const gdb_byte *pattern, ULONGEST pattern_len,
1885 CORE_ADDR *found_addrp)
1887 /* NOTE: also defined in find.c testcase. */
1888 #define SEARCH_CHUNK_SIZE 16000
1889 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1890 /* Buffer to hold memory contents for searching. */
1891 gdb_byte *search_buf;
1892 unsigned search_buf_size;
1893 struct cleanup *old_cleanups;
1895 search_buf_size = chunk_size + pattern_len - 1;
1897 /* No point in trying to allocate a buffer larger than the search space. */
1898 if (search_space_len < search_buf_size)
1899 search_buf_size = search_space_len;
1901 search_buf = malloc (search_buf_size);
1902 if (search_buf == NULL)
1903 error (_("Unable to allocate memory to perform the search."));
1904 old_cleanups = make_cleanup (free_current_contents, &search_buf);
1906 /* Prime the search buffer. */
1908 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1909 search_buf, start_addr, search_buf_size) != search_buf_size)
1911 warning (_("Unable to access target memory at %s, halting search."),
1912 hex_string (start_addr));
1913 do_cleanups (old_cleanups);
1917 /* Perform the search.
1919 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1920 When we've scanned N bytes we copy the trailing bytes to the start and
1921 read in another N bytes. */
1923 while (search_space_len >= pattern_len)
1925 gdb_byte *found_ptr;
1926 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
1928 found_ptr = memmem (search_buf, nr_search_bytes,
1929 pattern, pattern_len);
1931 if (found_ptr != NULL)
1933 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
1934 *found_addrp = found_addr;
1935 do_cleanups (old_cleanups);
1939 /* Not found in this chunk, skip to next chunk. */
1941 /* Don't let search_space_len wrap here, it's unsigned. */
1942 if (search_space_len >= chunk_size)
1943 search_space_len -= chunk_size;
1945 search_space_len = 0;
1947 if (search_space_len >= pattern_len)
1949 unsigned keep_len = search_buf_size - chunk_size;
1950 CORE_ADDR read_addr = start_addr + keep_len;
1953 /* Copy the trailing part of the previous iteration to the front
1954 of the buffer for the next iteration. */
1955 gdb_assert (keep_len == pattern_len - 1);
1956 memcpy (search_buf, search_buf + chunk_size, keep_len);
1958 nr_to_read = min (search_space_len - keep_len, chunk_size);
1960 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1961 search_buf + keep_len, read_addr,
1962 nr_to_read) != nr_to_read)
1964 warning (_("Unable to access target memory at %s, halting search."),
1965 hex_string (read_addr));
1966 do_cleanups (old_cleanups);
1970 start_addr += chunk_size;
1976 do_cleanups (old_cleanups);
1980 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1981 sequence of bytes in PATTERN with length PATTERN_LEN.
1983 The result is 1 if found, 0 if not found, and -1 if there was an error
1984 requiring halting of the search (e.g. memory read error).
1985 If the pattern is found the address is recorded in FOUND_ADDRP. */
1988 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
1989 const gdb_byte *pattern, ULONGEST pattern_len,
1990 CORE_ADDR *found_addrp)
1992 struct target_ops *t;
1995 /* We don't use INHERIT to set current_target.to_search_memory,
1996 so we have to scan the target stack and handle targetdebug
2000 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2001 hex_string (start_addr));
2003 for (t = current_target.beneath; t != NULL; t = t->beneath)
2004 if (t->to_search_memory != NULL)
2009 found = t->to_search_memory (t, start_addr, search_space_len,
2010 pattern, pattern_len, found_addrp);
2014 /* If a special version of to_search_memory isn't available, use the
2016 found = simple_search_memory (¤t_target,
2017 start_addr, search_space_len,
2018 pattern, pattern_len, found_addrp);
2022 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2027 /* Look through the currently pushed targets. If none of them will
2028 be able to restart the currently running process, issue an error
2032 target_require_runnable (void)
2034 struct target_ops *t;
2036 for (t = target_stack; t != NULL; t = t->beneath)
2038 /* If this target knows how to create a new program, then
2039 assume we will still be able to after killing the current
2040 one. Either killing and mourning will not pop T, or else
2041 find_default_run_target will find it again. */
2042 if (t->to_create_inferior != NULL)
2045 /* Do not worry about thread_stratum targets that can not
2046 create inferiors. Assume they will be pushed again if
2047 necessary, and continue to the process_stratum. */
2048 if (t->to_stratum == thread_stratum)
2052 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2056 /* This function is only called if the target is running. In that
2057 case there should have been a process_stratum target and it
2058 should either know how to create inferiors, or not... */
2059 internal_error (__FILE__, __LINE__, "No targets found");
2062 /* Look through the list of possible targets for a target that can
2063 execute a run or attach command without any other data. This is
2064 used to locate the default process stratum.
2066 If DO_MESG is not NULL, the result is always valid (error() is
2067 called for errors); else, return NULL on error. */
2069 static struct target_ops *
2070 find_default_run_target (char *do_mesg)
2072 struct target_ops **t;
2073 struct target_ops *runable = NULL;
2078 for (t = target_structs; t < target_structs + target_struct_size;
2081 if ((*t)->to_can_run && target_can_run (*t))
2091 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2100 find_default_attach (char *args, int from_tty)
2102 struct target_ops *t;
2104 t = find_default_run_target ("attach");
2105 (t->to_attach) (args, from_tty);
2110 find_default_create_inferior (char *exec_file, char *allargs, char **env,
2113 struct target_ops *t;
2115 t = find_default_run_target ("run");
2116 (t->to_create_inferior) (exec_file, allargs, env, from_tty);
2121 find_default_can_async_p (void)
2123 struct target_ops *t;
2125 /* This may be called before the target is pushed on the stack;
2126 look for the default process stratum. If there's none, gdb isn't
2127 configured with a native debugger, and target remote isn't
2129 t = find_default_run_target (NULL);
2130 if (t && t->to_can_async_p)
2131 return (t->to_can_async_p) ();
2136 find_default_is_async_p (void)
2138 struct target_ops *t;
2140 /* This may be called before the target is pushed on the stack;
2141 look for the default process stratum. If there's none, gdb isn't
2142 configured with a native debugger, and target remote isn't
2144 t = find_default_run_target (NULL);
2145 if (t && t->to_is_async_p)
2146 return (t->to_is_async_p) ();
2151 find_default_supports_non_stop (void)
2153 struct target_ops *t;
2155 t = find_default_run_target (NULL);
2156 if (t && t->to_supports_non_stop)
2157 return (t->to_supports_non_stop) ();
2162 target_supports_non_stop ()
2164 struct target_ops *t;
2165 for (t = ¤t_target; t != NULL; t = t->beneath)
2166 if (t->to_supports_non_stop)
2167 return t->to_supports_non_stop ();
2174 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2176 return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
2180 default_watchpoint_addr_within_range (struct target_ops *target,
2182 CORE_ADDR start, int length)
2184 return addr >= start && addr < start + length;
2200 return_minus_one (void)
2206 * Resize the to_sections pointer. Also make sure that anyone that
2207 * was holding on to an old value of it gets updated.
2208 * Returns the old size.
2212 target_resize_to_sections (struct target_ops *target, int num_added)
2214 struct target_ops **t;
2215 struct section_table *old_value;
2218 old_value = target->to_sections;
2220 if (target->to_sections)
2222 old_count = target->to_sections_end - target->to_sections;
2223 target->to_sections = (struct section_table *)
2224 xrealloc ((char *) target->to_sections,
2225 (sizeof (struct section_table)) * (num_added + old_count));
2230 target->to_sections = (struct section_table *)
2231 xmalloc ((sizeof (struct section_table)) * num_added);
2233 target->to_sections_end = target->to_sections + (num_added + old_count);
2235 /* Check to see if anyone else was pointing to this structure.
2236 If old_value was null, then no one was. */
2240 for (t = target_structs; t < target_structs + target_struct_size;
2243 if ((*t)->to_sections == old_value)
2245 (*t)->to_sections = target->to_sections;
2246 (*t)->to_sections_end = target->to_sections_end;
2249 /* There is a flattened view of the target stack in current_target,
2250 so its to_sections pointer might also need updating. */
2251 if (current_target.to_sections == old_value)
2253 current_target.to_sections = target->to_sections;
2254 current_target.to_sections_end = target->to_sections_end;
2262 /* Remove all target sections taken from ABFD.
2264 Scan the current target stack for targets whose section tables
2265 refer to sections from BFD, and remove those sections. We use this
2266 when we notice that the inferior has unloaded a shared object, for
2269 remove_target_sections (bfd *abfd)
2271 struct target_ops **t;
2273 for (t = target_structs; t < target_structs + target_struct_size; t++)
2275 struct section_table *src, *dest;
2277 dest = (*t)->to_sections;
2278 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
2279 if (src->bfd != abfd)
2281 /* Keep this section. */
2282 if (dest < src) *dest = *src;
2286 /* If we've dropped any sections, resize the section table. */
2288 target_resize_to_sections (*t, dest - src);
2295 /* Find a single runnable target in the stack and return it. If for
2296 some reason there is more than one, return NULL. */
2299 find_run_target (void)
2301 struct target_ops **t;
2302 struct target_ops *runable = NULL;
2307 for (t = target_structs; t < target_structs + target_struct_size; ++t)
2309 if ((*t)->to_can_run && target_can_run (*t))
2316 return (count == 1 ? runable : NULL);
2319 /* Find a single core_stratum target in the list of targets and return it.
2320 If for some reason there is more than one, return NULL. */
2323 find_core_target (void)
2325 struct target_ops **t;
2326 struct target_ops *runable = NULL;
2331 for (t = target_structs; t < target_structs + target_struct_size;
2334 if ((*t)->to_stratum == core_stratum)
2341 return (count == 1 ? runable : NULL);
2345 * Find the next target down the stack from the specified target.
2349 find_target_beneath (struct target_ops *t)
2355 /* The inferior process has died. Long live the inferior! */
2358 generic_mourn_inferior (void)
2362 ptid = inferior_ptid;
2363 inferior_ptid = null_ptid;
2365 if (!ptid_equal (ptid, null_ptid))
2367 int pid = ptid_get_pid (ptid);
2368 delete_inferior (pid);
2371 breakpoint_init_inferior (inf_exited);
2372 registers_changed ();
2374 reopen_exec_file ();
2375 reinit_frame_cache ();
2377 if (deprecated_detach_hook)
2378 deprecated_detach_hook ();
2381 /* Helper function for child_wait and the derivatives of child_wait.
2382 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2383 translation of that in OURSTATUS. */
2385 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2387 if (WIFEXITED (hoststatus))
2389 ourstatus->kind = TARGET_WAITKIND_EXITED;
2390 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2392 else if (!WIFSTOPPED (hoststatus))
2394 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2395 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2399 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2400 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2404 /* Returns zero to leave the inferior alone, one to interrupt it. */
2405 int (*target_activity_function) (void);
2406 int target_activity_fd;
2408 /* Convert a normal process ID to a string. Returns the string in a
2412 normal_pid_to_str (ptid_t ptid)
2414 static char buf[32];
2416 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
2420 /* Error-catcher for target_find_memory_regions */
2421 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2423 error (_("No target."));
2427 /* Error-catcher for target_make_corefile_notes */
2428 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2430 error (_("No target."));
2434 /* Set up the handful of non-empty slots needed by the dummy target
2438 init_dummy_target (void)
2440 dummy_target.to_shortname = "None";
2441 dummy_target.to_longname = "None";
2442 dummy_target.to_doc = "";
2443 dummy_target.to_attach = find_default_attach;
2444 dummy_target.to_create_inferior = find_default_create_inferior;
2445 dummy_target.to_can_async_p = find_default_can_async_p;
2446 dummy_target.to_is_async_p = find_default_is_async_p;
2447 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
2448 dummy_target.to_pid_to_str = normal_pid_to_str;
2449 dummy_target.to_stratum = dummy_stratum;
2450 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2451 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
2452 dummy_target.to_xfer_partial = default_xfer_partial;
2453 dummy_target.to_magic = OPS_MAGIC;
2457 debug_to_open (char *args, int from_tty)
2459 debug_target.to_open (args, from_tty);
2461 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2465 debug_to_close (int quitting)
2467 target_close (&debug_target, quitting);
2468 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2472 target_close (struct target_ops *targ, int quitting)
2474 if (targ->to_xclose != NULL)
2475 targ->to_xclose (targ, quitting);
2476 else if (targ->to_close != NULL)
2477 targ->to_close (quitting);
2481 debug_to_attach (char *args, int from_tty)
2483 debug_target.to_attach (args, from_tty);
2485 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
2490 debug_to_post_attach (int pid)
2492 debug_target.to_post_attach (pid);
2494 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2498 debug_to_detach (char *args, int from_tty)
2500 debug_target.to_detach (args, from_tty);
2502 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
2506 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
2508 debug_target.to_resume (ptid, step, siggnal);
2510 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
2511 step ? "step" : "continue",
2512 target_signal_to_name (siggnal));
2516 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
2520 retval = debug_target.to_wait (ptid, status);
2522 fprintf_unfiltered (gdb_stdlog,
2523 "target_wait (%d, status) = %d, ", PIDGET (ptid),
2525 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
2526 switch (status->kind)
2528 case TARGET_WAITKIND_EXITED:
2529 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
2530 status->value.integer);
2532 case TARGET_WAITKIND_STOPPED:
2533 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
2534 target_signal_to_name (status->value.sig));
2536 case TARGET_WAITKIND_SIGNALLED:
2537 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
2538 target_signal_to_name (status->value.sig));
2540 case TARGET_WAITKIND_LOADED:
2541 fprintf_unfiltered (gdb_stdlog, "loaded\n");
2543 case TARGET_WAITKIND_FORKED:
2544 fprintf_unfiltered (gdb_stdlog, "forked\n");
2546 case TARGET_WAITKIND_VFORKED:
2547 fprintf_unfiltered (gdb_stdlog, "vforked\n");
2549 case TARGET_WAITKIND_EXECD:
2550 fprintf_unfiltered (gdb_stdlog, "execd\n");
2552 case TARGET_WAITKIND_SPURIOUS:
2553 fprintf_unfiltered (gdb_stdlog, "spurious\n");
2556 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
2564 debug_print_register (const char * func,
2565 struct regcache *regcache, int regno)
2567 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2568 fprintf_unfiltered (gdb_stdlog, "%s ", func);
2569 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
2570 && gdbarch_register_name (gdbarch, regno) != NULL
2571 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
2572 fprintf_unfiltered (gdb_stdlog, "(%s)",
2573 gdbarch_register_name (gdbarch, regno));
2575 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2576 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
2578 int i, size = register_size (gdbarch, regno);
2579 unsigned char buf[MAX_REGISTER_SIZE];
2580 regcache_raw_collect (regcache, regno, buf);
2581 fprintf_unfiltered (gdb_stdlog, " = ");
2582 for (i = 0; i < size; i++)
2584 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2586 if (size <= sizeof (LONGEST))
2588 ULONGEST val = extract_unsigned_integer (buf, size);
2589 fprintf_unfiltered (gdb_stdlog, " %s %s",
2590 core_addr_to_string_nz (val), plongest (val));
2593 fprintf_unfiltered (gdb_stdlog, "\n");
2597 debug_to_fetch_registers (struct regcache *regcache, int regno)
2599 debug_target.to_fetch_registers (regcache, regno);
2600 debug_print_register ("target_fetch_registers", regcache, regno);
2604 debug_to_store_registers (struct regcache *regcache, int regno)
2606 debug_target.to_store_registers (regcache, regno);
2607 debug_print_register ("target_store_registers", regcache, regno);
2608 fprintf_unfiltered (gdb_stdlog, "\n");
2612 debug_to_prepare_to_store (struct regcache *regcache)
2614 debug_target.to_prepare_to_store (regcache);
2616 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2620 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2621 int write, struct mem_attrib *attrib,
2622 struct target_ops *target)
2626 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2629 fprintf_unfiltered (gdb_stdlog,
2630 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2631 (unsigned int) memaddr, /* possable truncate long long */
2632 len, write ? "write" : "read", retval);
2638 fputs_unfiltered (", bytes =", gdb_stdlog);
2639 for (i = 0; i < retval; i++)
2641 if ((((long) &(myaddr[i])) & 0xf) == 0)
2643 if (targetdebug < 2 && i > 0)
2645 fprintf_unfiltered (gdb_stdlog, " ...");
2648 fprintf_unfiltered (gdb_stdlog, "\n");
2651 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2655 fputc_unfiltered ('\n', gdb_stdlog);
2661 debug_to_files_info (struct target_ops *target)
2663 debug_target.to_files_info (target);
2665 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2669 debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
2673 retval = debug_target.to_insert_breakpoint (bp_tgt);
2675 fprintf_unfiltered (gdb_stdlog,
2676 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2677 (unsigned long) bp_tgt->placed_address,
2678 (unsigned long) retval);
2683 debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
2687 retval = debug_target.to_remove_breakpoint (bp_tgt);
2689 fprintf_unfiltered (gdb_stdlog,
2690 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2691 (unsigned long) bp_tgt->placed_address,
2692 (unsigned long) retval);
2697 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2701 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2703 fprintf_unfiltered (gdb_stdlog,
2704 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2705 (unsigned long) type,
2706 (unsigned long) cnt,
2707 (unsigned long) from_tty,
2708 (unsigned long) retval);
2713 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2717 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2719 fprintf_unfiltered (gdb_stdlog,
2720 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2721 (unsigned long) addr,
2722 (unsigned long) len,
2723 (unsigned long) retval);
2728 debug_to_stopped_by_watchpoint (void)
2732 retval = debug_target.to_stopped_by_watchpoint ();
2734 fprintf_unfiltered (gdb_stdlog,
2735 "STOPPED_BY_WATCHPOINT () = %ld\n",
2736 (unsigned long) retval);
2741 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2745 retval = debug_target.to_stopped_data_address (target, addr);
2747 fprintf_unfiltered (gdb_stdlog,
2748 "target_stopped_data_address ([0x%lx]) = %ld\n",
2749 (unsigned long)*addr,
2750 (unsigned long)retval);
2755 debug_to_watchpoint_addr_within_range (struct target_ops *target,
2757 CORE_ADDR start, int length)
2761 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
2764 fprintf_filtered (gdb_stdlog,
2765 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2766 (unsigned long) addr, (unsigned long) start, length,
2772 debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
2776 retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
2778 fprintf_unfiltered (gdb_stdlog,
2779 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2780 (unsigned long) bp_tgt->placed_address,
2781 (unsigned long) retval);
2786 debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
2790 retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
2792 fprintf_unfiltered (gdb_stdlog,
2793 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2794 (unsigned long) bp_tgt->placed_address,
2795 (unsigned long) retval);
2800 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2804 retval = debug_target.to_insert_watchpoint (addr, len, type);
2806 fprintf_unfiltered (gdb_stdlog,
2807 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2808 (unsigned long) addr, len, type, (unsigned long) retval);
2813 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2817 retval = debug_target.to_remove_watchpoint (addr, len, type);
2819 fprintf_unfiltered (gdb_stdlog,
2820 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2821 (unsigned long) addr, len, type, (unsigned long) retval);
2826 debug_to_terminal_init (void)
2828 debug_target.to_terminal_init ();
2830 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2834 debug_to_terminal_inferior (void)
2836 debug_target.to_terminal_inferior ();
2838 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2842 debug_to_terminal_ours_for_output (void)
2844 debug_target.to_terminal_ours_for_output ();
2846 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2850 debug_to_terminal_ours (void)
2852 debug_target.to_terminal_ours ();
2854 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2858 debug_to_terminal_save_ours (void)
2860 debug_target.to_terminal_save_ours ();
2862 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2866 debug_to_terminal_info (char *arg, int from_tty)
2868 debug_target.to_terminal_info (arg, from_tty);
2870 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2875 debug_to_kill (void)
2877 debug_target.to_kill ();
2879 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2883 debug_to_load (char *args, int from_tty)
2885 debug_target.to_load (args, from_tty);
2887 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2891 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2895 retval = debug_target.to_lookup_symbol (name, addrp);
2897 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2903 debug_to_create_inferior (char *exec_file, char *args, char **env,
2906 debug_target.to_create_inferior (exec_file, args, env, from_tty);
2908 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2909 exec_file, args, from_tty);
2913 debug_to_post_startup_inferior (ptid_t ptid)
2915 debug_target.to_post_startup_inferior (ptid);
2917 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2922 debug_to_acknowledge_created_inferior (int pid)
2924 debug_target.to_acknowledge_created_inferior (pid);
2926 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2931 debug_to_insert_fork_catchpoint (int pid)
2933 debug_target.to_insert_fork_catchpoint (pid);
2935 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
2940 debug_to_remove_fork_catchpoint (int pid)
2944 retval = debug_target.to_remove_fork_catchpoint (pid);
2946 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2953 debug_to_insert_vfork_catchpoint (int pid)
2955 debug_target.to_insert_vfork_catchpoint (pid);
2957 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
2962 debug_to_remove_vfork_catchpoint (int pid)
2966 retval = debug_target.to_remove_vfork_catchpoint (pid);
2968 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2975 debug_to_insert_exec_catchpoint (int pid)
2977 debug_target.to_insert_exec_catchpoint (pid);
2979 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
2984 debug_to_remove_exec_catchpoint (int pid)
2988 retval = debug_target.to_remove_exec_catchpoint (pid);
2990 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2997 debug_to_has_exited (int pid, int wait_status, int *exit_status)
3001 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
3003 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
3004 pid, wait_status, *exit_status, has_exited);
3010 debug_to_mourn_inferior (void)
3012 debug_target.to_mourn_inferior ();
3014 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
3018 debug_to_can_run (void)
3022 retval = debug_target.to_can_run ();
3024 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
3030 debug_to_notice_signals (ptid_t ptid)
3032 debug_target.to_notice_signals (ptid);
3034 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
3039 debug_to_thread_alive (ptid_t ptid)
3043 retval = debug_target.to_thread_alive (ptid);
3045 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3046 PIDGET (ptid), retval);
3052 debug_to_find_new_threads (void)
3054 debug_target.to_find_new_threads ();
3056 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
3060 debug_to_stop (ptid_t ptid)
3062 debug_target.to_stop (ptid);
3064 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
3065 target_pid_to_str (ptid));
3069 debug_to_rcmd (char *command,
3070 struct ui_file *outbuf)
3072 debug_target.to_rcmd (command, outbuf);
3073 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
3077 debug_to_pid_to_exec_file (int pid)
3081 exec_file = debug_target.to_pid_to_exec_file (pid);
3083 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
3090 setup_target_debug (void)
3092 memcpy (&debug_target, ¤t_target, sizeof debug_target);
3094 current_target.to_open = debug_to_open;
3095 current_target.to_close = debug_to_close;
3096 current_target.to_attach = debug_to_attach;
3097 current_target.to_post_attach = debug_to_post_attach;
3098 current_target.to_detach = debug_to_detach;
3099 current_target.to_resume = debug_to_resume;
3100 current_target.to_wait = debug_to_wait;
3101 current_target.to_fetch_registers = debug_to_fetch_registers;
3102 current_target.to_store_registers = debug_to_store_registers;
3103 current_target.to_prepare_to_store = debug_to_prepare_to_store;
3104 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
3105 current_target.to_files_info = debug_to_files_info;
3106 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
3107 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
3108 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
3109 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
3110 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
3111 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
3112 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
3113 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
3114 current_target.to_stopped_data_address = debug_to_stopped_data_address;
3115 current_target.to_watchpoint_addr_within_range = debug_to_watchpoint_addr_within_range;
3116 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
3117 current_target.to_terminal_init = debug_to_terminal_init;
3118 current_target.to_terminal_inferior = debug_to_terminal_inferior;
3119 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
3120 current_target.to_terminal_ours = debug_to_terminal_ours;
3121 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
3122 current_target.to_terminal_info = debug_to_terminal_info;
3123 current_target.to_kill = debug_to_kill;
3124 current_target.to_load = debug_to_load;
3125 current_target.to_lookup_symbol = debug_to_lookup_symbol;
3126 current_target.to_create_inferior = debug_to_create_inferior;
3127 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
3128 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
3129 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
3130 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
3131 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
3132 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
3133 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
3134 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
3135 current_target.to_has_exited = debug_to_has_exited;
3136 current_target.to_mourn_inferior = debug_to_mourn_inferior;
3137 current_target.to_can_run = debug_to_can_run;
3138 current_target.to_notice_signals = debug_to_notice_signals;
3139 current_target.to_thread_alive = debug_to_thread_alive;
3140 current_target.to_find_new_threads = debug_to_find_new_threads;
3141 current_target.to_stop = debug_to_stop;
3142 current_target.to_rcmd = debug_to_rcmd;
3143 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
3147 static char targ_desc[] =
3148 "Names of targets and files being debugged.\n\
3149 Shows the entire stack of targets currently in use (including the exec-file,\n\
3150 core-file, and process, if any), as well as the symbol file name.";
3153 do_monitor_command (char *cmd,
3156 if ((current_target.to_rcmd
3157 == (void (*) (char *, struct ui_file *)) tcomplain)
3158 || (current_target.to_rcmd == debug_to_rcmd
3159 && (debug_target.to_rcmd
3160 == (void (*) (char *, struct ui_file *)) tcomplain)))
3161 error (_("\"monitor\" command not supported by this target."));
3162 target_rcmd (cmd, gdb_stdtarg);
3165 /* Print the name of each layers of our target stack. */
3168 maintenance_print_target_stack (char *cmd, int from_tty)
3170 struct target_ops *t;
3172 printf_filtered (_("The current target stack is:\n"));
3174 for (t = target_stack; t != NULL; t = t->beneath)
3176 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3180 /* Controls if async mode is permitted. */
3181 int target_async_permitted = 0;
3183 /* The set command writes to this variable. If the inferior is
3184 executing, linux_nat_async_permitted is *not* updated. */
3185 static int target_async_permitted_1 = 0;
3188 set_maintenance_target_async_permitted (char *args, int from_tty,
3189 struct cmd_list_element *c)
3191 if (target_has_execution)
3193 target_async_permitted_1 = target_async_permitted;
3194 error (_("Cannot change this setting while the inferior is running."));
3197 target_async_permitted = target_async_permitted_1;
3201 show_maintenance_target_async_permitted (struct ui_file *file, int from_tty,
3202 struct cmd_list_element *c,
3205 fprintf_filtered (file, _("\
3206 Controlling the inferior in asynchronous mode is %s.\n"), value);
3210 initialize_targets (void)
3212 init_dummy_target ();
3213 push_target (&dummy_target);
3215 add_info ("target", target_info, targ_desc);
3216 add_info ("files", target_info, targ_desc);
3218 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3219 Set target debugging."), _("\
3220 Show target debugging."), _("\
3221 When non-zero, target debugging is enabled. Higher numbers are more\n\
3222 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3226 &setdebuglist, &showdebuglist);
3228 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
3229 &trust_readonly, _("\
3230 Set mode for reading from readonly sections."), _("\
3231 Show mode for reading from readonly sections."), _("\
3232 When this mode is on, memory reads from readonly sections (such as .text)\n\
3233 will be read from the object file instead of from the target. This will\n\
3234 result in significant performance improvement for remote targets."),
3236 show_trust_readonly,
3237 &setlist, &showlist);
3239 add_com ("monitor", class_obscure, do_monitor_command,
3240 _("Send a command to the remote monitor (remote targets only)."));
3242 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3243 _("Print the name of each layer of the internal target stack."),
3244 &maintenanceprintlist);
3246 add_setshow_boolean_cmd ("target-async", no_class,
3247 &target_async_permitted_1, _("\
3248 Set whether gdb controls the inferior in asynchronous mode."), _("\
3249 Show whether gdb controls the inferior in asynchronous mode."), _("\
3250 Tells gdb whether to control the inferior in asynchronous mode."),
3251 set_maintenance_target_async_permitted,
3252 show_maintenance_target_async_permitted,
3256 target_dcache = dcache_init ();