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, 2009
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 (struct target_ops *ops, char *, int);
104 static void debug_to_detach (struct target_ops *ops, 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 (struct target_ops *);
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);
284 void target_create_inferior (char *exec_file, char *args,
285 char **env, int from_tty)
287 struct target_ops *t;
288 for (t = current_target.beneath; t != NULL; t = t->beneath)
290 if (t->to_create_inferior != NULL)
292 t->to_create_inferior (t, exec_file, args, env, from_tty);
297 internal_error (__FILE__, __LINE__,
298 "could not find a target to create inferior");
303 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
304 struct target_ops *t)
306 errno = EIO; /* Can't read/write this location */
307 return 0; /* No bytes handled */
313 error (_("You can't do that when your target is `%s'"),
314 current_target.to_shortname);
320 error (_("You can't do that without a process to debug."));
324 nosymbol (char *name, CORE_ADDR *addrp)
326 return 1; /* Symbol does not exist in target env */
330 nosupport_runtime (void)
332 if (ptid_equal (inferior_ptid, null_ptid))
335 error (_("No run-time support for this"));
340 default_terminal_info (char *args, int from_tty)
342 printf_unfiltered (_("No saved terminal information.\n"));
345 /* This is the default target_create_inferior and target_attach function.
346 If the current target is executing, it asks whether to kill it off.
347 If this function returns without calling error(), it has killed off
348 the target, and the operation should be attempted. */
351 kill_or_be_killed (int from_tty)
353 if (target_has_execution)
355 printf_unfiltered (_("You are already running a program:\n"));
356 target_files_info ();
357 if (query ("Kill it? "))
360 if (target_has_execution)
361 error (_("Killing the program did not help."));
366 error (_("Program not killed."));
372 /* A default implementation for the to_get_ada_task_ptid target method.
374 This function builds the PTID by using both LWP and TID as part of
375 the PTID lwp and tid elements. The pid used is the pid of the
379 default_get_ada_task_ptid (long lwp, long tid)
381 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
384 /* Go through the target stack from top to bottom, copying over zero
385 entries in current_target, then filling in still empty entries. In
386 effect, we are doing class inheritance through the pushed target
389 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
390 is currently implemented, is that it discards any knowledge of
391 which target an inherited method originally belonged to.
392 Consequently, new new target methods should instead explicitly and
393 locally search the target stack for the target that can handle the
397 update_current_target (void)
399 struct target_ops *t;
401 /* First, reset current's contents. */
402 memset (¤t_target, 0, sizeof (current_target));
404 #define INHERIT(FIELD, TARGET) \
405 if (!current_target.FIELD) \
406 current_target.FIELD = (TARGET)->FIELD
408 for (t = target_stack; t; t = t->beneath)
410 INHERIT (to_shortname, t);
411 INHERIT (to_longname, t);
413 /* Do not inherit to_open. */
414 /* Do not inherit to_close. */
415 /* Do not inherit to_attach. */
416 INHERIT (to_post_attach, t);
417 INHERIT (to_attach_no_wait, t);
418 /* Do not inherit to_detach. */
419 /* Do not inherit to_disconnect. */
420 INHERIT (to_resume, t);
421 INHERIT (to_wait, t);
422 INHERIT (to_fetch_registers, t);
423 INHERIT (to_store_registers, t);
424 INHERIT (to_prepare_to_store, t);
425 INHERIT (deprecated_xfer_memory, t);
426 INHERIT (to_files_info, t);
427 INHERIT (to_insert_breakpoint, t);
428 INHERIT (to_remove_breakpoint, t);
429 INHERIT (to_can_use_hw_breakpoint, t);
430 INHERIT (to_insert_hw_breakpoint, t);
431 INHERIT (to_remove_hw_breakpoint, t);
432 INHERIT (to_insert_watchpoint, t);
433 INHERIT (to_remove_watchpoint, t);
434 INHERIT (to_stopped_data_address, t);
435 INHERIT (to_have_steppable_watchpoint, t);
436 INHERIT (to_have_continuable_watchpoint, t);
437 INHERIT (to_stopped_by_watchpoint, t);
438 INHERIT (to_watchpoint_addr_within_range, t);
439 INHERIT (to_region_ok_for_hw_watchpoint, t);
440 INHERIT (to_terminal_init, t);
441 INHERIT (to_terminal_inferior, t);
442 INHERIT (to_terminal_ours_for_output, t);
443 INHERIT (to_terminal_ours, t);
444 INHERIT (to_terminal_save_ours, t);
445 INHERIT (to_terminal_info, t);
446 INHERIT (to_kill, t);
447 INHERIT (to_load, t);
448 INHERIT (to_lookup_symbol, t);
449 /* Do no inherit to_create_inferior. */
450 INHERIT (to_post_startup_inferior, t);
451 INHERIT (to_acknowledge_created_inferior, t);
452 INHERIT (to_insert_fork_catchpoint, t);
453 INHERIT (to_remove_fork_catchpoint, t);
454 INHERIT (to_insert_vfork_catchpoint, t);
455 INHERIT (to_remove_vfork_catchpoint, t);
456 /* Do not inherit to_follow_fork. */
457 INHERIT (to_insert_exec_catchpoint, t);
458 INHERIT (to_remove_exec_catchpoint, t);
459 INHERIT (to_has_exited, t);
460 /* Do no inherit to_mourn_inferiour. */
461 INHERIT (to_can_run, t);
462 INHERIT (to_notice_signals, t);
463 INHERIT (to_thread_alive, t);
464 INHERIT (to_find_new_threads, t);
465 INHERIT (to_pid_to_str, t);
466 INHERIT (to_extra_thread_info, t);
467 INHERIT (to_stop, t);
468 /* Do not inherit to_xfer_partial. */
469 INHERIT (to_rcmd, t);
470 INHERIT (to_pid_to_exec_file, t);
471 INHERIT (to_log_command, t);
472 INHERIT (to_stratum, t);
473 INHERIT (to_has_all_memory, t);
474 INHERIT (to_has_memory, t);
475 INHERIT (to_has_stack, t);
476 INHERIT (to_has_registers, t);
477 INHERIT (to_has_execution, t);
478 INHERIT (to_has_thread_control, t);
479 INHERIT (to_sections, t);
480 INHERIT (to_sections_end, t);
481 INHERIT (to_can_async_p, t);
482 INHERIT (to_is_async_p, t);
483 INHERIT (to_async, t);
484 INHERIT (to_async_mask, t);
485 INHERIT (to_find_memory_regions, t);
486 INHERIT (to_make_corefile_notes, t);
487 INHERIT (to_get_thread_local_address, t);
488 INHERIT (to_can_execute_reverse, t);
489 /* Do not inherit to_read_description. */
490 INHERIT (to_get_ada_task_ptid, t);
491 /* Do not inherit to_search_memory. */
492 INHERIT (to_supports_multi_process, t);
493 INHERIT (to_magic, t);
494 /* Do not inherit to_memory_map. */
495 /* Do not inherit to_flash_erase. */
496 /* Do not inherit to_flash_done. */
500 /* Clean up a target struct so it no longer has any zero pointers in
501 it. Some entries are defaulted to a method that print an error,
502 others are hard-wired to a standard recursive default. */
504 #define de_fault(field, value) \
505 if (!current_target.field) \
506 current_target.field = value
509 (void (*) (char *, int))
514 de_fault (to_post_attach,
518 (void (*) (ptid_t, int, enum target_signal))
521 (ptid_t (*) (ptid_t, struct target_waitstatus *))
523 de_fault (to_fetch_registers,
524 (void (*) (struct regcache *, int))
526 de_fault (to_store_registers,
527 (void (*) (struct regcache *, int))
529 de_fault (to_prepare_to_store,
530 (void (*) (struct regcache *))
532 de_fault (deprecated_xfer_memory,
533 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
535 de_fault (to_files_info,
536 (void (*) (struct target_ops *))
538 de_fault (to_insert_breakpoint,
539 memory_insert_breakpoint);
540 de_fault (to_remove_breakpoint,
541 memory_remove_breakpoint);
542 de_fault (to_can_use_hw_breakpoint,
543 (int (*) (int, int, int))
545 de_fault (to_insert_hw_breakpoint,
546 (int (*) (struct bp_target_info *))
548 de_fault (to_remove_hw_breakpoint,
549 (int (*) (struct bp_target_info *))
551 de_fault (to_insert_watchpoint,
552 (int (*) (CORE_ADDR, int, int))
554 de_fault (to_remove_watchpoint,
555 (int (*) (CORE_ADDR, int, int))
557 de_fault (to_stopped_by_watchpoint,
560 de_fault (to_stopped_data_address,
561 (int (*) (struct target_ops *, CORE_ADDR *))
563 de_fault (to_watchpoint_addr_within_range,
564 default_watchpoint_addr_within_range);
565 de_fault (to_region_ok_for_hw_watchpoint,
566 default_region_ok_for_hw_watchpoint);
567 de_fault (to_terminal_init,
570 de_fault (to_terminal_inferior,
573 de_fault (to_terminal_ours_for_output,
576 de_fault (to_terminal_ours,
579 de_fault (to_terminal_save_ours,
582 de_fault (to_terminal_info,
583 default_terminal_info);
588 (void (*) (char *, int))
590 de_fault (to_lookup_symbol,
591 (int (*) (char *, CORE_ADDR *))
593 de_fault (to_post_startup_inferior,
596 de_fault (to_acknowledge_created_inferior,
599 de_fault (to_insert_fork_catchpoint,
602 de_fault (to_remove_fork_catchpoint,
605 de_fault (to_insert_vfork_catchpoint,
608 de_fault (to_remove_vfork_catchpoint,
611 de_fault (to_insert_exec_catchpoint,
614 de_fault (to_remove_exec_catchpoint,
617 de_fault (to_has_exited,
618 (int (*) (int, int, int *))
620 de_fault (to_can_run,
622 de_fault (to_notice_signals,
625 de_fault (to_thread_alive,
628 de_fault (to_find_new_threads,
631 de_fault (to_extra_thread_info,
632 (char *(*) (struct thread_info *))
637 current_target.to_xfer_partial = current_xfer_partial;
639 (void (*) (char *, struct ui_file *))
641 de_fault (to_pid_to_exec_file,
645 (void (*) (void (*) (enum inferior_event_type, void*), void*))
647 de_fault (to_async_mask,
650 current_target.to_read_description = NULL;
651 de_fault (to_get_ada_task_ptid,
652 (ptid_t (*) (long, long))
653 default_get_ada_task_ptid);
654 de_fault (to_supports_multi_process,
659 /* Finally, position the target-stack beneath the squashed
660 "current_target". That way code looking for a non-inherited
661 target method can quickly and simply find it. */
662 current_target.beneath = target_stack;
665 setup_target_debug ();
668 /* Mark OPS as a running target. This reverses the effect
669 of target_mark_exited. */
672 target_mark_running (struct target_ops *ops)
674 struct target_ops *t;
676 for (t = target_stack; t != NULL; t = t->beneath)
680 internal_error (__FILE__, __LINE__,
681 "Attempted to mark unpushed target \"%s\" as running",
684 ops->to_has_execution = 1;
685 ops->to_has_all_memory = 1;
686 ops->to_has_memory = 1;
687 ops->to_has_stack = 1;
688 ops->to_has_registers = 1;
690 update_current_target ();
693 /* Mark OPS as a non-running target. This reverses the effect
694 of target_mark_running. */
697 target_mark_exited (struct target_ops *ops)
699 struct target_ops *t;
701 for (t = target_stack; t != NULL; t = t->beneath)
705 internal_error (__FILE__, __LINE__,
706 "Attempted to mark unpushed target \"%s\" as running",
709 ops->to_has_execution = 0;
710 ops->to_has_all_memory = 0;
711 ops->to_has_memory = 0;
712 ops->to_has_stack = 0;
713 ops->to_has_registers = 0;
715 update_current_target ();
718 /* Push a new target type into the stack of the existing target accessors,
719 possibly superseding some of the existing accessors.
721 Result is zero if the pushed target ended up on top of the stack,
722 nonzero if at least one target is on top of it.
724 Rather than allow an empty stack, we always have the dummy target at
725 the bottom stratum, so we can call the function vectors without
729 push_target (struct target_ops *t)
731 struct target_ops **cur;
733 /* Check magic number. If wrong, it probably means someone changed
734 the struct definition, but not all the places that initialize one. */
735 if (t->to_magic != OPS_MAGIC)
737 fprintf_unfiltered (gdb_stderr,
738 "Magic number of %s target struct wrong\n",
740 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
743 /* Find the proper stratum to install this target in. */
744 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
746 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
750 /* If there's already targets at this stratum, remove them. */
751 /* FIXME: cagney/2003-10-15: I think this should be popping all
752 targets to CUR, and not just those at this stratum level. */
753 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
755 /* There's already something at this stratum level. Close it,
756 and un-hook it from the stack. */
757 struct target_ops *tmp = (*cur);
758 (*cur) = (*cur)->beneath;
760 target_close (tmp, 0);
763 /* We have removed all targets in our stratum, now add the new one. */
767 update_current_target ();
770 return (t != target_stack);
773 /* Remove a target_ops vector from the stack, wherever it may be.
774 Return how many times it was removed (0 or 1). */
777 unpush_target (struct target_ops *t)
779 struct target_ops **cur;
780 struct target_ops *tmp;
782 if (t->to_stratum == dummy_stratum)
783 internal_error (__FILE__, __LINE__,
784 "Attempt to unpush the dummy target");
786 /* Look for the specified target. Note that we assume that a target
787 can only occur once in the target stack. */
789 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
796 return 0; /* Didn't find target_ops, quit now */
798 /* NOTE: cagney/2003-12-06: In '94 the close call was made
799 unconditional by moving it to before the above check that the
800 target was in the target stack (something about "Change the way
801 pushing and popping of targets work to support target overlays
802 and inheritance"). This doesn't make much sense - only open
803 targets should be closed. */
806 /* Unchain the target */
808 (*cur) = (*cur)->beneath;
811 update_current_target ();
819 target_close (target_stack, 0); /* Let it clean up */
820 if (unpush_target (target_stack) == 1)
823 fprintf_unfiltered (gdb_stderr,
824 "pop_target couldn't find target %s\n",
825 current_target.to_shortname);
826 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
830 pop_all_targets_above (enum strata above_stratum, int quitting)
832 while ((int) (current_target.to_stratum) > (int) above_stratum)
834 target_close (target_stack, quitting);
835 if (!unpush_target (target_stack))
837 fprintf_unfiltered (gdb_stderr,
838 "pop_all_targets couldn't find target %s\n",
839 target_stack->to_shortname);
840 internal_error (__FILE__, __LINE__,
841 _("failed internal consistency check"));
848 pop_all_targets (int quitting)
850 pop_all_targets_above (dummy_stratum, quitting);
853 /* Using the objfile specified in OBJFILE, find the address for the
854 current thread's thread-local storage with offset OFFSET. */
856 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
858 volatile CORE_ADDR addr = 0;
860 if (target_get_thread_local_address_p ()
861 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
863 ptid_t ptid = inferior_ptid;
864 volatile struct gdb_exception ex;
866 TRY_CATCH (ex, RETURN_MASK_ALL)
870 /* Fetch the load module address for this objfile. */
871 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
873 /* If it's 0, throw the appropriate exception. */
875 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
876 _("TLS load module not found"));
878 addr = target_get_thread_local_address (ptid, lm_addr, offset);
880 /* If an error occurred, print TLS related messages here. Otherwise,
881 throw the error to some higher catcher. */
884 int objfile_is_library = (objfile->flags & OBJF_SHARED);
888 case TLS_NO_LIBRARY_SUPPORT_ERROR:
889 error (_("Cannot find thread-local variables in this thread library."));
891 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
892 if (objfile_is_library)
893 error (_("Cannot find shared library `%s' in dynamic"
894 " linker's load module list"), objfile->name);
896 error (_("Cannot find executable file `%s' in dynamic"
897 " linker's load module list"), objfile->name);
899 case TLS_NOT_ALLOCATED_YET_ERROR:
900 if (objfile_is_library)
901 error (_("The inferior has not yet allocated storage for"
902 " thread-local variables in\n"
903 "the shared library `%s'\n"
905 objfile->name, target_pid_to_str (ptid));
907 error (_("The inferior has not yet allocated storage for"
908 " thread-local variables in\n"
909 "the executable `%s'\n"
911 objfile->name, target_pid_to_str (ptid));
913 case TLS_GENERIC_ERROR:
914 if (objfile_is_library)
915 error (_("Cannot find thread-local storage for %s, "
916 "shared library %s:\n%s"),
917 target_pid_to_str (ptid),
918 objfile->name, ex.message);
920 error (_("Cannot find thread-local storage for %s, "
921 "executable file %s:\n%s"),
922 target_pid_to_str (ptid),
923 objfile->name, ex.message);
926 throw_exception (ex);
931 /* It wouldn't be wrong here to try a gdbarch method, too; finding
932 TLS is an ABI-specific thing. But we don't do that yet. */
934 error (_("Cannot find thread-local variables on this target"));
940 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
942 /* target_read_string -- read a null terminated string, up to LEN bytes,
943 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
944 Set *STRING to a pointer to malloc'd memory containing the data; the caller
945 is responsible for freeing it. Return the number of bytes successfully
949 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
951 int tlen, origlen, offset, i;
955 int buffer_allocated;
957 unsigned int nbytes_read = 0;
961 /* Small for testing. */
962 buffer_allocated = 4;
963 buffer = xmalloc (buffer_allocated);
970 tlen = MIN (len, 4 - (memaddr & 3));
971 offset = memaddr & 3;
973 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
976 /* The transfer request might have crossed the boundary to an
977 unallocated region of memory. Retry the transfer, requesting
981 errcode = target_read_memory (memaddr, buf, 1);
986 if (bufptr - buffer + tlen > buffer_allocated)
989 bytes = bufptr - buffer;
990 buffer_allocated *= 2;
991 buffer = xrealloc (buffer, buffer_allocated);
992 bufptr = buffer + bytes;
995 for (i = 0; i < tlen; i++)
997 *bufptr++ = buf[i + offset];
998 if (buf[i + offset] == '\000')
1000 nbytes_read += i + 1;
1007 nbytes_read += tlen;
1016 /* Find a section containing ADDR. */
1017 struct section_table *
1018 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1020 struct section_table *secp;
1021 for (secp = target->to_sections;
1022 secp < target->to_sections_end;
1025 if (addr >= secp->addr && addr < secp->endaddr)
1031 /* Perform a partial memory transfer. The arguments and return
1032 value are just as for target_xfer_partial. */
1035 memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
1036 ULONGEST memaddr, LONGEST len)
1040 struct mem_region *region;
1042 /* Zero length requests are ok and require no work. */
1046 /* Try the executable file, if "trust-readonly-sections" is set. */
1047 if (readbuf != NULL && trust_readonly)
1049 struct section_table *secp;
1051 secp = target_section_by_addr (ops, memaddr);
1053 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1055 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1058 /* Likewise for accesses to unmapped overlay sections. */
1059 if (readbuf != NULL && overlay_debugging)
1061 struct obj_section *section = find_pc_overlay (memaddr);
1062 if (pc_in_unmapped_range (memaddr, section))
1063 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1066 /* Try GDB's internal data cache. */
1067 region = lookup_mem_region (memaddr);
1068 /* region->hi == 0 means there's no upper bound. */
1069 if (memaddr + len < region->hi || region->hi == 0)
1072 reg_len = region->hi - memaddr;
1074 switch (region->attrib.mode)
1077 if (writebuf != NULL)
1082 if (readbuf != NULL)
1087 /* We only support writing to flash during "load" for now. */
1088 if (writebuf != NULL)
1089 error (_("Writing to flash memory forbidden in this context"));
1096 if (region->attrib.cache)
1098 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1099 memory request will start back at current_target. */
1100 if (readbuf != NULL)
1101 res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
1104 /* FIXME drow/2006-08-09: If we're going to preserve const
1105 correctness dcache_xfer_memory should take readbuf and
1107 res = dcache_xfer_memory (target_dcache, memaddr,
1114 if (readbuf && !show_memory_breakpoints)
1115 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1120 /* If none of those methods found the memory we wanted, fall back
1121 to a target partial transfer. Normally a single call to
1122 to_xfer_partial is enough; if it doesn't recognize an object
1123 it will call the to_xfer_partial of the next target down.
1124 But for memory this won't do. Memory is the only target
1125 object which can be read from more than one valid target.
1126 A core file, for instance, could have some of memory but
1127 delegate other bits to the target below it. So, we must
1128 manually try all targets. */
1132 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1133 readbuf, writebuf, memaddr, reg_len);
1137 /* We want to continue past core files to executables, but not
1138 past a running target's memory. */
1139 if (ops->to_has_all_memory)
1144 while (ops != NULL);
1146 if (readbuf && !show_memory_breakpoints)
1147 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1149 /* If we still haven't got anything, return the last error. We
1155 restore_show_memory_breakpoints (void *arg)
1157 show_memory_breakpoints = (uintptr_t) arg;
1161 make_show_memory_breakpoints_cleanup (int show)
1163 int current = show_memory_breakpoints;
1164 show_memory_breakpoints = show;
1166 return make_cleanup (restore_show_memory_breakpoints,
1167 (void *) (uintptr_t) current);
1171 target_xfer_partial (struct target_ops *ops,
1172 enum target_object object, const char *annex,
1173 void *readbuf, const void *writebuf,
1174 ULONGEST offset, LONGEST len)
1178 gdb_assert (ops->to_xfer_partial != NULL);
1180 /* If this is a memory transfer, let the memory-specific code
1181 have a look at it instead. Memory transfers are more
1183 if (object == TARGET_OBJECT_MEMORY)
1184 retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
1187 enum target_object raw_object = object;
1189 /* If this is a raw memory transfer, request the normal
1190 memory object from other layers. */
1191 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1192 raw_object = TARGET_OBJECT_MEMORY;
1194 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1195 writebuf, offset, len);
1200 const unsigned char *myaddr = NULL;
1202 fprintf_unfiltered (gdb_stdlog,
1203 "%s:target_xfer_partial (%d, %s, %s, %s, %s, %s) = %s",
1206 (annex ? annex : "(null)"),
1207 host_address_to_string (readbuf),
1208 host_address_to_string (writebuf),
1209 core_addr_to_string_nz (offset),
1210 plongest (len), plongest (retval));
1216 if (retval > 0 && myaddr != NULL)
1220 fputs_unfiltered (", bytes =", gdb_stdlog);
1221 for (i = 0; i < retval; i++)
1223 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1225 if (targetdebug < 2 && i > 0)
1227 fprintf_unfiltered (gdb_stdlog, " ...");
1230 fprintf_unfiltered (gdb_stdlog, "\n");
1233 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1237 fputc_unfiltered ('\n', gdb_stdlog);
1242 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1243 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1244 if any error occurs.
1246 If an error occurs, no guarantee is made about the contents of the data at
1247 MYADDR. In particular, the caller should not depend upon partial reads
1248 filling the buffer with good data. There is no way for the caller to know
1249 how much good data might have been transfered anyway. Callers that can
1250 deal with partial reads should call target_read (which will retry until
1251 it makes no progress, and then return how much was transferred). */
1254 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1256 if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1257 myaddr, memaddr, len) == len)
1264 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1266 if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1267 myaddr, memaddr, len) == len)
1273 /* Fetch the target's memory map. */
1276 target_memory_map (void)
1278 VEC(mem_region_s) *result;
1279 struct mem_region *last_one, *this_one;
1281 struct target_ops *t;
1284 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1286 for (t = current_target.beneath; t != NULL; t = t->beneath)
1287 if (t->to_memory_map != NULL)
1293 result = t->to_memory_map (t);
1297 qsort (VEC_address (mem_region_s, result),
1298 VEC_length (mem_region_s, result),
1299 sizeof (struct mem_region), mem_region_cmp);
1301 /* Check that regions do not overlap. Simultaneously assign
1302 a numbering for the "mem" commands to use to refer to
1305 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1307 this_one->number = ix;
1309 if (last_one && last_one->hi > this_one->lo)
1311 warning (_("Overlapping regions in memory map: ignoring"));
1312 VEC_free (mem_region_s, result);
1315 last_one = this_one;
1322 target_flash_erase (ULONGEST address, LONGEST length)
1324 struct target_ops *t;
1326 for (t = current_target.beneath; t != NULL; t = t->beneath)
1327 if (t->to_flash_erase != NULL)
1330 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1331 paddr (address), phex (length, 0));
1332 t->to_flash_erase (t, address, length);
1340 target_flash_done (void)
1342 struct target_ops *t;
1344 for (t = current_target.beneath; t != NULL; t = t->beneath)
1345 if (t->to_flash_done != NULL)
1348 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1349 t->to_flash_done (t);
1356 #ifndef target_stopped_data_address_p
1358 target_stopped_data_address_p (struct target_ops *target)
1360 if (target->to_stopped_data_address
1361 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
1363 if (target->to_stopped_data_address == debug_to_stopped_data_address
1364 && (debug_target.to_stopped_data_address
1365 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1372 show_trust_readonly (struct ui_file *file, int from_tty,
1373 struct cmd_list_element *c, const char *value)
1375 fprintf_filtered (file, _("\
1376 Mode for reading from readonly sections is %s.\n"),
1380 /* More generic transfers. */
1383 default_xfer_partial (struct target_ops *ops, enum target_object object,
1384 const char *annex, gdb_byte *readbuf,
1385 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1387 if (object == TARGET_OBJECT_MEMORY
1388 && ops->deprecated_xfer_memory != NULL)
1389 /* If available, fall back to the target's
1390 "deprecated_xfer_memory" method. */
1394 if (writebuf != NULL)
1396 void *buffer = xmalloc (len);
1397 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1398 memcpy (buffer, writebuf, len);
1399 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1400 1/*write*/, NULL, ops);
1401 do_cleanups (cleanup);
1403 if (readbuf != NULL)
1404 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1405 0/*read*/, NULL, ops);
1408 else if (xfered == 0 && errno == 0)
1409 /* "deprecated_xfer_memory" uses 0, cross checked against
1410 ERRNO as one indication of an error. */
1415 else if (ops->beneath != NULL)
1416 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1417 readbuf, writebuf, offset, len);
1422 /* The xfer_partial handler for the topmost target. Unlike the default,
1423 it does not need to handle memory specially; it just passes all
1424 requests down the stack. */
1427 current_xfer_partial (struct target_ops *ops, enum target_object object,
1428 const char *annex, gdb_byte *readbuf,
1429 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1431 if (ops->beneath != NULL)
1432 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1433 readbuf, writebuf, offset, len);
1438 /* Target vector read/write partial wrapper functions.
1440 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1441 (inbuf, outbuf)", instead of separate read/write methods, make life
1445 target_read_partial (struct target_ops *ops,
1446 enum target_object object,
1447 const char *annex, gdb_byte *buf,
1448 ULONGEST offset, LONGEST len)
1450 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1454 target_write_partial (struct target_ops *ops,
1455 enum target_object object,
1456 const char *annex, const gdb_byte *buf,
1457 ULONGEST offset, LONGEST len)
1459 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1462 /* Wrappers to perform the full transfer. */
1464 target_read (struct target_ops *ops,
1465 enum target_object object,
1466 const char *annex, gdb_byte *buf,
1467 ULONGEST offset, LONGEST len)
1470 while (xfered < len)
1472 LONGEST xfer = target_read_partial (ops, object, annex,
1473 (gdb_byte *) buf + xfered,
1474 offset + xfered, len - xfered);
1475 /* Call an observer, notifying them of the xfer progress? */
1487 target_read_until_error (struct target_ops *ops,
1488 enum target_object object,
1489 const char *annex, gdb_byte *buf,
1490 ULONGEST offset, LONGEST len)
1493 while (xfered < len)
1495 LONGEST xfer = target_read_partial (ops, object, annex,
1496 (gdb_byte *) buf + xfered,
1497 offset + xfered, len - xfered);
1498 /* Call an observer, notifying them of the xfer progress? */
1503 /* We've got an error. Try to read in smaller blocks. */
1504 ULONGEST start = offset + xfered;
1505 ULONGEST remaining = len - xfered;
1508 /* If an attempt was made to read a random memory address,
1509 it's likely that the very first byte is not accessible.
1510 Try reading the first byte, to avoid doing log N tries
1512 xfer = target_read_partial (ops, object, annex,
1513 (gdb_byte *) buf + xfered, start, 1);
1522 xfer = target_read_partial (ops, object, annex,
1523 (gdb_byte *) buf + xfered,
1533 /* We have successfully read the first half. So, the
1534 error must be in the second half. Adjust start and
1535 remaining to point at the second half. */
1552 /* An alternative to target_write with progress callbacks. */
1555 target_write_with_progress (struct target_ops *ops,
1556 enum target_object object,
1557 const char *annex, const gdb_byte *buf,
1558 ULONGEST offset, LONGEST len,
1559 void (*progress) (ULONGEST, void *), void *baton)
1563 /* Give the progress callback a chance to set up. */
1565 (*progress) (0, baton);
1567 while (xfered < len)
1569 LONGEST xfer = target_write_partial (ops, object, annex,
1570 (gdb_byte *) buf + xfered,
1571 offset + xfered, len - xfered);
1579 (*progress) (xfer, baton);
1588 target_write (struct target_ops *ops,
1589 enum target_object object,
1590 const char *annex, const gdb_byte *buf,
1591 ULONGEST offset, LONGEST len)
1593 return target_write_with_progress (ops, object, annex, buf, offset, len,
1597 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1598 the size of the transferred data. PADDING additional bytes are
1599 available in *BUF_P. This is a helper function for
1600 target_read_alloc; see the declaration of that function for more
1604 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1605 const char *annex, gdb_byte **buf_p, int padding)
1607 size_t buf_alloc, buf_pos;
1611 /* This function does not have a length parameter; it reads the
1612 entire OBJECT). Also, it doesn't support objects fetched partly
1613 from one target and partly from another (in a different stratum,
1614 e.g. a core file and an executable). Both reasons make it
1615 unsuitable for reading memory. */
1616 gdb_assert (object != TARGET_OBJECT_MEMORY);
1618 /* Start by reading up to 4K at a time. The target will throttle
1619 this number down if necessary. */
1621 buf = xmalloc (buf_alloc);
1625 n = target_read_partial (ops, object, annex, &buf[buf_pos],
1626 buf_pos, buf_alloc - buf_pos - padding);
1629 /* An error occurred. */
1635 /* Read all there was. */
1645 /* If the buffer is filling up, expand it. */
1646 if (buf_alloc < buf_pos * 2)
1649 buf = xrealloc (buf, buf_alloc);
1656 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1657 the size of the transferred data. See the declaration in "target.h"
1658 function for more information about the return value. */
1661 target_read_alloc (struct target_ops *ops, enum target_object object,
1662 const char *annex, gdb_byte **buf_p)
1664 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1667 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1668 returned as a string, allocated using xmalloc. If an error occurs
1669 or the transfer is unsupported, NULL is returned. Empty objects
1670 are returned as allocated but empty strings. A warning is issued
1671 if the result contains any embedded NUL bytes. */
1674 target_read_stralloc (struct target_ops *ops, enum target_object object,
1678 LONGEST transferred;
1680 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1682 if (transferred < 0)
1685 if (transferred == 0)
1686 return xstrdup ("");
1688 buffer[transferred] = 0;
1689 if (strlen (buffer) < transferred)
1690 warning (_("target object %d, annex %s, "
1691 "contained unexpected null characters"),
1692 (int) object, annex ? annex : "(none)");
1694 return (char *) buffer;
1697 /* Memory transfer methods. */
1700 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1703 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1705 memory_error (EIO, addr);
1709 get_target_memory_unsigned (struct target_ops *ops,
1710 CORE_ADDR addr, int len)
1712 gdb_byte buf[sizeof (ULONGEST)];
1714 gdb_assert (len <= sizeof (buf));
1715 get_target_memory (ops, addr, buf, len);
1716 return extract_unsigned_integer (buf, len);
1720 target_info (char *args, int from_tty)
1722 struct target_ops *t;
1723 int has_all_mem = 0;
1725 if (symfile_objfile != NULL)
1726 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1728 for (t = target_stack; t != NULL; t = t->beneath)
1730 if (!t->to_has_memory)
1733 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1736 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1737 printf_unfiltered ("%s:\n", t->to_longname);
1738 (t->to_files_info) (t);
1739 has_all_mem = t->to_has_all_memory;
1743 /* This function is called before any new inferior is created, e.g.
1744 by running a program, attaching, or connecting to a target.
1745 It cleans up any state from previous invocations which might
1746 change between runs. This is a subset of what target_preopen
1747 resets (things which might change between targets). */
1750 target_pre_inferior (int from_tty)
1752 /* Clear out solib state. Otherwise the solib state of the previous
1753 inferior might have survived and is entirely wrong for the new
1754 target. This has been observed on GNU/Linux using glibc 2.3. How
1766 Cannot access memory at address 0xdeadbeef
1769 /* In some OSs, the shared library list is the same/global/shared
1770 across inferiors. If code is shared between processes, so are
1771 memory regions and features. */
1772 if (!gdbarch_has_global_solist (target_gdbarch))
1774 no_shared_libraries (NULL, from_tty);
1776 invalidate_target_mem_regions ();
1778 target_clear_description ();
1782 /* This is to be called by the open routine before it does
1786 target_preopen (int from_tty)
1790 if (target_has_execution)
1793 || query (_("A program is being debugged already. Kill it? ")))
1796 error (_("Program not killed."));
1799 /* Calling target_kill may remove the target from the stack. But if
1800 it doesn't (which seems like a win for UDI), remove it now. */
1801 /* Leave the exec target, though. The user may be switching from a
1802 live process to a core of the same program. */
1803 pop_all_targets_above (file_stratum, 0);
1805 target_pre_inferior (from_tty);
1808 /* Detach a target after doing deferred register stores. */
1811 target_detach (char *args, int from_tty)
1813 struct target_ops* t;
1815 if (gdbarch_has_global_solist (target_gdbarch))
1816 /* Don't remove global breakpoints here. They're removed on
1817 disconnection from the target. */
1820 /* If we're in breakpoints-always-inserted mode, have to remove
1821 them before detaching. */
1822 remove_breakpoints ();
1824 for (t = current_target.beneath; t != NULL; t = t->beneath)
1826 if (t->to_detach != NULL)
1828 t->to_detach (t, args, from_tty);
1833 internal_error (__FILE__, __LINE__, "could not find a target to detach");
1837 target_disconnect (char *args, int from_tty)
1839 struct target_ops *t;
1841 /* If we're in breakpoints-always-inserted mode or if breakpoints
1842 are global across processes, we have to remove them before
1844 remove_breakpoints ();
1846 for (t = current_target.beneath; t != NULL; t = t->beneath)
1847 if (t->to_disconnect != NULL)
1850 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1852 t->to_disconnect (t, args, from_tty);
1860 target_resume (ptid_t ptid, int step, enum target_signal signal)
1862 dcache_invalidate (target_dcache);
1863 (*current_target.to_resume) (ptid, step, signal);
1864 set_executing (ptid, 1);
1865 set_running (ptid, 1);
1867 /* Look through the list of possible targets for a target that can
1871 target_follow_fork (int follow_child)
1873 struct target_ops *t;
1875 for (t = current_target.beneath; t != NULL; t = t->beneath)
1877 if (t->to_follow_fork != NULL)
1879 int retval = t->to_follow_fork (t, follow_child);
1881 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1882 follow_child, retval);
1887 /* Some target returned a fork event, but did not know how to follow it. */
1888 internal_error (__FILE__, __LINE__,
1889 "could not find a target to follow fork");
1893 target_mourn_inferior (void)
1895 struct target_ops *t;
1896 for (t = current_target.beneath; t != NULL; t = t->beneath)
1898 if (t->to_mourn_inferior != NULL)
1900 t->to_mourn_inferior (t);
1905 internal_error (__FILE__, __LINE__,
1906 "could not find a target to follow mourn inferiour");
1909 /* Look for a target which can describe architectural features, starting
1910 from TARGET. If we find one, return its description. */
1912 const struct target_desc *
1913 target_read_description (struct target_ops *target)
1915 struct target_ops *t;
1917 for (t = target; t != NULL; t = t->beneath)
1918 if (t->to_read_description != NULL)
1920 const struct target_desc *tdesc;
1922 tdesc = t->to_read_description (t);
1930 /* The default implementation of to_search_memory.
1931 This implements a basic search of memory, reading target memory and
1932 performing the search here (as opposed to performing the search in on the
1933 target side with, for example, gdbserver). */
1936 simple_search_memory (struct target_ops *ops,
1937 CORE_ADDR start_addr, ULONGEST search_space_len,
1938 const gdb_byte *pattern, ULONGEST pattern_len,
1939 CORE_ADDR *found_addrp)
1941 /* NOTE: also defined in find.c testcase. */
1942 #define SEARCH_CHUNK_SIZE 16000
1943 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1944 /* Buffer to hold memory contents for searching. */
1945 gdb_byte *search_buf;
1946 unsigned search_buf_size;
1947 struct cleanup *old_cleanups;
1949 search_buf_size = chunk_size + pattern_len - 1;
1951 /* No point in trying to allocate a buffer larger than the search space. */
1952 if (search_space_len < search_buf_size)
1953 search_buf_size = search_space_len;
1955 search_buf = malloc (search_buf_size);
1956 if (search_buf == NULL)
1957 error (_("Unable to allocate memory to perform the search."));
1958 old_cleanups = make_cleanup (free_current_contents, &search_buf);
1960 /* Prime the search buffer. */
1962 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1963 search_buf, start_addr, search_buf_size) != search_buf_size)
1965 warning (_("Unable to access target memory at %s, halting search."),
1966 hex_string (start_addr));
1967 do_cleanups (old_cleanups);
1971 /* Perform the search.
1973 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1974 When we've scanned N bytes we copy the trailing bytes to the start and
1975 read in another N bytes. */
1977 while (search_space_len >= pattern_len)
1979 gdb_byte *found_ptr;
1980 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
1982 found_ptr = memmem (search_buf, nr_search_bytes,
1983 pattern, pattern_len);
1985 if (found_ptr != NULL)
1987 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
1988 *found_addrp = found_addr;
1989 do_cleanups (old_cleanups);
1993 /* Not found in this chunk, skip to next chunk. */
1995 /* Don't let search_space_len wrap here, it's unsigned. */
1996 if (search_space_len >= chunk_size)
1997 search_space_len -= chunk_size;
1999 search_space_len = 0;
2001 if (search_space_len >= pattern_len)
2003 unsigned keep_len = search_buf_size - chunk_size;
2004 CORE_ADDR read_addr = start_addr + keep_len;
2007 /* Copy the trailing part of the previous iteration to the front
2008 of the buffer for the next iteration. */
2009 gdb_assert (keep_len == pattern_len - 1);
2010 memcpy (search_buf, search_buf + chunk_size, keep_len);
2012 nr_to_read = min (search_space_len - keep_len, chunk_size);
2014 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2015 search_buf + keep_len, read_addr,
2016 nr_to_read) != nr_to_read)
2018 warning (_("Unable to access target memory at %s, halting search."),
2019 hex_string (read_addr));
2020 do_cleanups (old_cleanups);
2024 start_addr += chunk_size;
2030 do_cleanups (old_cleanups);
2034 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2035 sequence of bytes in PATTERN with length PATTERN_LEN.
2037 The result is 1 if found, 0 if not found, and -1 if there was an error
2038 requiring halting of the search (e.g. memory read error).
2039 If the pattern is found the address is recorded in FOUND_ADDRP. */
2042 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2043 const gdb_byte *pattern, ULONGEST pattern_len,
2044 CORE_ADDR *found_addrp)
2046 struct target_ops *t;
2049 /* We don't use INHERIT to set current_target.to_search_memory,
2050 so we have to scan the target stack and handle targetdebug
2054 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2055 hex_string (start_addr));
2057 for (t = current_target.beneath; t != NULL; t = t->beneath)
2058 if (t->to_search_memory != NULL)
2063 found = t->to_search_memory (t, start_addr, search_space_len,
2064 pattern, pattern_len, found_addrp);
2068 /* If a special version of to_search_memory isn't available, use the
2070 found = simple_search_memory (¤t_target,
2071 start_addr, search_space_len,
2072 pattern, pattern_len, found_addrp);
2076 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2081 /* Look through the currently pushed targets. If none of them will
2082 be able to restart the currently running process, issue an error
2086 target_require_runnable (void)
2088 struct target_ops *t;
2090 for (t = target_stack; t != NULL; t = t->beneath)
2092 /* If this target knows how to create a new program, then
2093 assume we will still be able to after killing the current
2094 one. Either killing and mourning will not pop T, or else
2095 find_default_run_target will find it again. */
2096 if (t->to_create_inferior != NULL)
2099 /* Do not worry about thread_stratum targets that can not
2100 create inferiors. Assume they will be pushed again if
2101 necessary, and continue to the process_stratum. */
2102 if (t->to_stratum == thread_stratum)
2106 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2110 /* This function is only called if the target is running. In that
2111 case there should have been a process_stratum target and it
2112 should either know how to create inferiors, or not... */
2113 internal_error (__FILE__, __LINE__, "No targets found");
2116 /* Look through the list of possible targets for a target that can
2117 execute a run or attach command without any other data. This is
2118 used to locate the default process stratum.
2120 If DO_MESG is not NULL, the result is always valid (error() is
2121 called for errors); else, return NULL on error. */
2123 static struct target_ops *
2124 find_default_run_target (char *do_mesg)
2126 struct target_ops **t;
2127 struct target_ops *runable = NULL;
2132 for (t = target_structs; t < target_structs + target_struct_size;
2135 if ((*t)->to_can_run && target_can_run (*t))
2145 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2154 find_default_attach (struct target_ops *ops, char *args, int from_tty)
2156 struct target_ops *t;
2158 t = find_default_run_target ("attach");
2159 (t->to_attach) (t, args, from_tty);
2164 find_default_create_inferior (struct target_ops *ops,
2165 char *exec_file, char *allargs, char **env,
2168 struct target_ops *t;
2170 t = find_default_run_target ("run");
2171 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
2176 find_default_can_async_p (void)
2178 struct target_ops *t;
2180 /* This may be called before the target is pushed on the stack;
2181 look for the default process stratum. If there's none, gdb isn't
2182 configured with a native debugger, and target remote isn't
2184 t = find_default_run_target (NULL);
2185 if (t && t->to_can_async_p)
2186 return (t->to_can_async_p) ();
2191 find_default_is_async_p (void)
2193 struct target_ops *t;
2195 /* This may be called before the target is pushed on the stack;
2196 look for the default process stratum. If there's none, gdb isn't
2197 configured with a native debugger, and target remote isn't
2199 t = find_default_run_target (NULL);
2200 if (t && t->to_is_async_p)
2201 return (t->to_is_async_p) ();
2206 find_default_supports_non_stop (void)
2208 struct target_ops *t;
2210 t = find_default_run_target (NULL);
2211 if (t && t->to_supports_non_stop)
2212 return (t->to_supports_non_stop) ();
2217 target_supports_non_stop ()
2219 struct target_ops *t;
2220 for (t = ¤t_target; t != NULL; t = t->beneath)
2221 if (t->to_supports_non_stop)
2222 return t->to_supports_non_stop ();
2229 target_get_osdata (const char *type)
2232 struct target_ops *t;
2234 if (target_can_run (¤t_target))
2235 t = ¤t_target;
2237 t = find_default_run_target ("get OS data");
2242 document = target_read_stralloc (t,
2243 TARGET_OBJECT_OSDATA,
2249 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2251 return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
2255 default_watchpoint_addr_within_range (struct target_ops *target,
2257 CORE_ADDR start, int length)
2259 return addr >= start && addr < start + length;
2275 return_minus_one (void)
2281 * Resize the to_sections pointer. Also make sure that anyone that
2282 * was holding on to an old value of it gets updated.
2283 * Returns the old size.
2287 target_resize_to_sections (struct target_ops *target, int num_added)
2289 struct target_ops **t;
2290 struct section_table *old_value;
2293 old_value = target->to_sections;
2295 if (target->to_sections)
2297 old_count = target->to_sections_end - target->to_sections;
2298 target->to_sections = (struct section_table *)
2299 xrealloc ((char *) target->to_sections,
2300 (sizeof (struct section_table)) * (num_added + old_count));
2305 target->to_sections = (struct section_table *)
2306 xmalloc ((sizeof (struct section_table)) * num_added);
2308 target->to_sections_end = target->to_sections + (num_added + old_count);
2310 /* Check to see if anyone else was pointing to this structure.
2311 If old_value was null, then no one was. */
2315 for (t = target_structs; t < target_structs + target_struct_size;
2318 if ((*t)->to_sections == old_value)
2320 (*t)->to_sections = target->to_sections;
2321 (*t)->to_sections_end = target->to_sections_end;
2324 /* There is a flattened view of the target stack in current_target,
2325 so its to_sections pointer might also need updating. */
2326 if (current_target.to_sections == old_value)
2328 current_target.to_sections = target->to_sections;
2329 current_target.to_sections_end = target->to_sections_end;
2337 /* Remove all target sections taken from ABFD.
2339 Scan the current target stack for targets whose section tables
2340 refer to sections from BFD, and remove those sections. We use this
2341 when we notice that the inferior has unloaded a shared object, for
2344 remove_target_sections (bfd *abfd)
2346 struct target_ops **t;
2348 for (t = target_structs; t < target_structs + target_struct_size; t++)
2350 struct section_table *src, *dest;
2352 dest = (*t)->to_sections;
2353 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
2354 if (src->bfd != abfd)
2356 /* Keep this section. */
2357 if (dest < src) *dest = *src;
2361 /* If we've dropped any sections, resize the section table. */
2363 target_resize_to_sections (*t, dest - src);
2370 /* Find a single runnable target in the stack and return it. If for
2371 some reason there is more than one, return NULL. */
2374 find_run_target (void)
2376 struct target_ops **t;
2377 struct target_ops *runable = NULL;
2382 for (t = target_structs; t < target_structs + target_struct_size; ++t)
2384 if ((*t)->to_can_run && target_can_run (*t))
2391 return (count == 1 ? runable : NULL);
2394 /* Find a single core_stratum target in the list of targets and return it.
2395 If for some reason there is more than one, return NULL. */
2398 find_core_target (void)
2400 struct target_ops **t;
2401 struct target_ops *runable = NULL;
2406 for (t = target_structs; t < target_structs + target_struct_size;
2409 if ((*t)->to_stratum == core_stratum)
2416 return (count == 1 ? runable : NULL);
2420 * Find the next target down the stack from the specified target.
2424 find_target_beneath (struct target_ops *t)
2430 /* The inferior process has died. Long live the inferior! */
2433 generic_mourn_inferior (void)
2437 ptid = inferior_ptid;
2438 inferior_ptid = null_ptid;
2440 if (!ptid_equal (ptid, null_ptid))
2442 int pid = ptid_get_pid (ptid);
2443 delete_inferior (pid);
2446 breakpoint_init_inferior (inf_exited);
2447 registers_changed ();
2449 reopen_exec_file ();
2450 reinit_frame_cache ();
2452 if (deprecated_detach_hook)
2453 deprecated_detach_hook ();
2456 /* Helper function for child_wait and the derivatives of child_wait.
2457 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2458 translation of that in OURSTATUS. */
2460 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2462 if (WIFEXITED (hoststatus))
2464 ourstatus->kind = TARGET_WAITKIND_EXITED;
2465 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2467 else if (!WIFSTOPPED (hoststatus))
2469 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2470 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2474 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2475 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2479 /* Convert a normal process ID to a string. Returns the string in a
2483 normal_pid_to_str (ptid_t ptid)
2485 static char buf[32];
2487 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
2491 /* Error-catcher for target_find_memory_regions */
2492 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2494 error (_("No target."));
2498 /* Error-catcher for target_make_corefile_notes */
2499 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2501 error (_("No target."));
2505 /* Set up the handful of non-empty slots needed by the dummy target
2509 init_dummy_target (void)
2511 dummy_target.to_shortname = "None";
2512 dummy_target.to_longname = "None";
2513 dummy_target.to_doc = "";
2514 dummy_target.to_attach = find_default_attach;
2515 dummy_target.to_detach =
2516 (void (*)(struct target_ops *, char *, int))target_ignore;
2517 dummy_target.to_create_inferior = find_default_create_inferior;
2518 dummy_target.to_can_async_p = find_default_can_async_p;
2519 dummy_target.to_is_async_p = find_default_is_async_p;
2520 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
2521 dummy_target.to_pid_to_str = normal_pid_to_str;
2522 dummy_target.to_stratum = dummy_stratum;
2523 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2524 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
2525 dummy_target.to_xfer_partial = default_xfer_partial;
2526 dummy_target.to_magic = OPS_MAGIC;
2530 debug_to_open (char *args, int from_tty)
2532 debug_target.to_open (args, from_tty);
2534 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2538 debug_to_close (int quitting)
2540 target_close (&debug_target, quitting);
2541 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2545 target_close (struct target_ops *targ, int quitting)
2547 if (targ->to_xclose != NULL)
2548 targ->to_xclose (targ, quitting);
2549 else if (targ->to_close != NULL)
2550 targ->to_close (quitting);
2554 target_attach (char *args, int from_tty)
2556 struct target_ops *t;
2557 for (t = current_target.beneath; t != NULL; t = t->beneath)
2559 if (t->to_attach != NULL)
2561 t->to_attach (t, args, from_tty);
2566 internal_error (__FILE__, __LINE__,
2567 "could not find a target to attach");
2572 debug_to_attach (struct target_ops *ops, char *args, int from_tty)
2574 debug_target.to_attach (&debug_target, args, from_tty);
2576 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
2581 debug_to_post_attach (int pid)
2583 debug_target.to_post_attach (pid);
2585 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2589 debug_to_detach (struct target_ops *ops, char *args, int from_tty)
2591 debug_target.to_detach (&debug_target, args, from_tty);
2593 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
2597 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
2599 debug_target.to_resume (ptid, step, siggnal);
2601 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
2602 step ? "step" : "continue",
2603 target_signal_to_name (siggnal));
2606 /* Return a pretty printed form of target_waitstatus.
2607 Space for the result is malloc'd, caller must free. */
2610 target_waitstatus_to_string (const struct target_waitstatus *ws)
2612 const char *kind_str = "status->kind = ";
2616 case TARGET_WAITKIND_EXITED:
2617 return xstrprintf ("%sexited, status = %d",
2618 kind_str, ws->value.integer);
2619 case TARGET_WAITKIND_STOPPED:
2620 return xstrprintf ("%sstopped, signal = %s",
2621 kind_str, target_signal_to_name (ws->value.sig));
2622 case TARGET_WAITKIND_SIGNALLED:
2623 return xstrprintf ("%ssignalled, signal = %s",
2624 kind_str, target_signal_to_name (ws->value.sig));
2625 case TARGET_WAITKIND_LOADED:
2626 return xstrprintf ("%sloaded", kind_str);
2627 case TARGET_WAITKIND_FORKED:
2628 return xstrprintf ("%sforked", kind_str);
2629 case TARGET_WAITKIND_VFORKED:
2630 return xstrprintf ("%svforked", kind_str);
2631 case TARGET_WAITKIND_EXECD:
2632 return xstrprintf ("%sexecd", kind_str);
2633 case TARGET_WAITKIND_SYSCALL_ENTRY:
2634 return xstrprintf ("%ssyscall-entry", kind_str);
2635 case TARGET_WAITKIND_SYSCALL_RETURN:
2636 return xstrprintf ("%ssyscall-return", kind_str);
2637 case TARGET_WAITKIND_SPURIOUS:
2638 return xstrprintf ("%sspurious", kind_str);
2639 case TARGET_WAITKIND_IGNORE:
2640 return xstrprintf ("%signore", kind_str);
2641 case TARGET_WAITKIND_NO_HISTORY:
2642 return xstrprintf ("%sno-history", kind_str);
2644 return xstrprintf ("%sunknown???", kind_str);
2649 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
2652 char *status_string;
2654 retval = debug_target.to_wait (ptid, status);
2656 fprintf_unfiltered (gdb_stdlog,
2657 "target_wait (%d, status) = %d, ", PIDGET (ptid),
2660 status_string = target_waitstatus_to_string (status);
2661 fprintf_unfiltered (gdb_stdlog, "%s\n", status_string);
2662 xfree (status_string);
2668 debug_print_register (const char * func,
2669 struct regcache *regcache, int regno)
2671 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2672 fprintf_unfiltered (gdb_stdlog, "%s ", func);
2673 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
2674 && gdbarch_register_name (gdbarch, regno) != NULL
2675 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
2676 fprintf_unfiltered (gdb_stdlog, "(%s)",
2677 gdbarch_register_name (gdbarch, regno));
2679 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2680 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
2682 int i, size = register_size (gdbarch, regno);
2683 unsigned char buf[MAX_REGISTER_SIZE];
2684 regcache_raw_collect (regcache, regno, buf);
2685 fprintf_unfiltered (gdb_stdlog, " = ");
2686 for (i = 0; i < size; i++)
2688 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2690 if (size <= sizeof (LONGEST))
2692 ULONGEST val = extract_unsigned_integer (buf, size);
2693 fprintf_unfiltered (gdb_stdlog, " %s %s",
2694 core_addr_to_string_nz (val), plongest (val));
2697 fprintf_unfiltered (gdb_stdlog, "\n");
2701 debug_to_fetch_registers (struct regcache *regcache, int regno)
2703 debug_target.to_fetch_registers (regcache, regno);
2704 debug_print_register ("target_fetch_registers", regcache, regno);
2708 debug_to_store_registers (struct regcache *regcache, int regno)
2710 debug_target.to_store_registers (regcache, regno);
2711 debug_print_register ("target_store_registers", regcache, regno);
2712 fprintf_unfiltered (gdb_stdlog, "\n");
2716 debug_to_prepare_to_store (struct regcache *regcache)
2718 debug_target.to_prepare_to_store (regcache);
2720 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2724 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2725 int write, struct mem_attrib *attrib,
2726 struct target_ops *target)
2730 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2733 fprintf_unfiltered (gdb_stdlog,
2734 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
2735 paddress (memaddr), len, write ? "write" : "read",
2742 fputs_unfiltered (", bytes =", gdb_stdlog);
2743 for (i = 0; i < retval; i++)
2745 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
2747 if (targetdebug < 2 && i > 0)
2749 fprintf_unfiltered (gdb_stdlog, " ...");
2752 fprintf_unfiltered (gdb_stdlog, "\n");
2755 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2759 fputc_unfiltered ('\n', gdb_stdlog);
2765 debug_to_files_info (struct target_ops *target)
2767 debug_target.to_files_info (target);
2769 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2773 debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
2777 retval = debug_target.to_insert_breakpoint (bp_tgt);
2779 fprintf_unfiltered (gdb_stdlog,
2780 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2781 (unsigned long) bp_tgt->placed_address,
2782 (unsigned long) retval);
2787 debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
2791 retval = debug_target.to_remove_breakpoint (bp_tgt);
2793 fprintf_unfiltered (gdb_stdlog,
2794 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2795 (unsigned long) bp_tgt->placed_address,
2796 (unsigned long) retval);
2801 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2805 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2807 fprintf_unfiltered (gdb_stdlog,
2808 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2809 (unsigned long) type,
2810 (unsigned long) cnt,
2811 (unsigned long) from_tty,
2812 (unsigned long) retval);
2817 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2821 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2823 fprintf_unfiltered (gdb_stdlog,
2824 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2825 (unsigned long) addr,
2826 (unsigned long) len,
2827 (unsigned long) retval);
2832 debug_to_stopped_by_watchpoint (void)
2836 retval = debug_target.to_stopped_by_watchpoint ();
2838 fprintf_unfiltered (gdb_stdlog,
2839 "STOPPED_BY_WATCHPOINT () = %ld\n",
2840 (unsigned long) retval);
2845 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2849 retval = debug_target.to_stopped_data_address (target, addr);
2851 fprintf_unfiltered (gdb_stdlog,
2852 "target_stopped_data_address ([0x%lx]) = %ld\n",
2853 (unsigned long)*addr,
2854 (unsigned long)retval);
2859 debug_to_watchpoint_addr_within_range (struct target_ops *target,
2861 CORE_ADDR start, int length)
2865 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
2868 fprintf_filtered (gdb_stdlog,
2869 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2870 (unsigned long) addr, (unsigned long) start, length,
2876 debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
2880 retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
2882 fprintf_unfiltered (gdb_stdlog,
2883 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2884 (unsigned long) bp_tgt->placed_address,
2885 (unsigned long) retval);
2890 debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
2894 retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
2896 fprintf_unfiltered (gdb_stdlog,
2897 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2898 (unsigned long) bp_tgt->placed_address,
2899 (unsigned long) retval);
2904 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2908 retval = debug_target.to_insert_watchpoint (addr, len, type);
2910 fprintf_unfiltered (gdb_stdlog,
2911 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2912 (unsigned long) addr, len, type, (unsigned long) retval);
2917 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2921 retval = debug_target.to_remove_watchpoint (addr, len, type);
2923 fprintf_unfiltered (gdb_stdlog,
2924 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2925 (unsigned long) addr, len, type, (unsigned long) retval);
2930 debug_to_terminal_init (void)
2932 debug_target.to_terminal_init ();
2934 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2938 debug_to_terminal_inferior (void)
2940 debug_target.to_terminal_inferior ();
2942 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2946 debug_to_terminal_ours_for_output (void)
2948 debug_target.to_terminal_ours_for_output ();
2950 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2954 debug_to_terminal_ours (void)
2956 debug_target.to_terminal_ours ();
2958 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2962 debug_to_terminal_save_ours (void)
2964 debug_target.to_terminal_save_ours ();
2966 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2970 debug_to_terminal_info (char *arg, int from_tty)
2972 debug_target.to_terminal_info (arg, from_tty);
2974 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2979 debug_to_kill (void)
2981 debug_target.to_kill ();
2983 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2987 debug_to_load (char *args, int from_tty)
2989 debug_target.to_load (args, from_tty);
2991 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2995 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2999 retval = debug_target.to_lookup_symbol (name, addrp);
3001 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
3007 debug_to_create_inferior (struct target_ops *ops,
3008 char *exec_file, char *args, char **env,
3011 debug_target.to_create_inferior (ops, exec_file, args, env, from_tty);
3013 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
3014 exec_file, args, from_tty);
3018 debug_to_post_startup_inferior (ptid_t ptid)
3020 debug_target.to_post_startup_inferior (ptid);
3022 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
3027 debug_to_acknowledge_created_inferior (int pid)
3029 debug_target.to_acknowledge_created_inferior (pid);
3031 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
3036 debug_to_insert_fork_catchpoint (int pid)
3038 debug_target.to_insert_fork_catchpoint (pid);
3040 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
3045 debug_to_remove_fork_catchpoint (int pid)
3049 retval = debug_target.to_remove_fork_catchpoint (pid);
3051 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
3058 debug_to_insert_vfork_catchpoint (int pid)
3060 debug_target.to_insert_vfork_catchpoint (pid);
3062 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
3067 debug_to_remove_vfork_catchpoint (int pid)
3071 retval = debug_target.to_remove_vfork_catchpoint (pid);
3073 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
3080 debug_to_insert_exec_catchpoint (int pid)
3082 debug_target.to_insert_exec_catchpoint (pid);
3084 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
3089 debug_to_remove_exec_catchpoint (int pid)
3093 retval = debug_target.to_remove_exec_catchpoint (pid);
3095 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
3102 debug_to_has_exited (int pid, int wait_status, int *exit_status)
3106 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
3108 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
3109 pid, wait_status, *exit_status, has_exited);
3115 debug_to_mourn_inferior (struct target_ops *ops)
3117 debug_target.to_mourn_inferior (&debug_target);
3119 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
3123 debug_to_can_run (void)
3127 retval = debug_target.to_can_run ();
3129 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
3135 debug_to_notice_signals (ptid_t ptid)
3137 debug_target.to_notice_signals (ptid);
3139 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
3144 debug_to_thread_alive (ptid_t ptid)
3148 retval = debug_target.to_thread_alive (ptid);
3150 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3151 PIDGET (ptid), retval);
3157 debug_to_find_new_threads (void)
3159 debug_target.to_find_new_threads ();
3161 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
3165 debug_to_stop (ptid_t ptid)
3167 debug_target.to_stop (ptid);
3169 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
3170 target_pid_to_str (ptid));
3174 debug_to_rcmd (char *command,
3175 struct ui_file *outbuf)
3177 debug_target.to_rcmd (command, outbuf);
3178 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
3182 debug_to_pid_to_exec_file (int pid)
3186 exec_file = debug_target.to_pid_to_exec_file (pid);
3188 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
3195 setup_target_debug (void)
3197 memcpy (&debug_target, ¤t_target, sizeof debug_target);
3199 current_target.to_open = debug_to_open;
3200 current_target.to_close = debug_to_close;
3201 current_target.to_attach = debug_to_attach;
3202 current_target.to_post_attach = debug_to_post_attach;
3203 current_target.to_detach = debug_to_detach;
3204 current_target.to_resume = debug_to_resume;
3205 current_target.to_wait = debug_to_wait;
3206 current_target.to_fetch_registers = debug_to_fetch_registers;
3207 current_target.to_store_registers = debug_to_store_registers;
3208 current_target.to_prepare_to_store = debug_to_prepare_to_store;
3209 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
3210 current_target.to_files_info = debug_to_files_info;
3211 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
3212 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
3213 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
3214 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
3215 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
3216 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
3217 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
3218 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
3219 current_target.to_stopped_data_address = debug_to_stopped_data_address;
3220 current_target.to_watchpoint_addr_within_range = debug_to_watchpoint_addr_within_range;
3221 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
3222 current_target.to_terminal_init = debug_to_terminal_init;
3223 current_target.to_terminal_inferior = debug_to_terminal_inferior;
3224 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
3225 current_target.to_terminal_ours = debug_to_terminal_ours;
3226 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
3227 current_target.to_terminal_info = debug_to_terminal_info;
3228 current_target.to_kill = debug_to_kill;
3229 current_target.to_load = debug_to_load;
3230 current_target.to_lookup_symbol = debug_to_lookup_symbol;
3231 current_target.to_create_inferior = debug_to_create_inferior;
3232 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
3233 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
3234 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
3235 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
3236 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
3237 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
3238 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
3239 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
3240 current_target.to_has_exited = debug_to_has_exited;
3241 current_target.to_mourn_inferior = debug_to_mourn_inferior;
3242 current_target.to_can_run = debug_to_can_run;
3243 current_target.to_notice_signals = debug_to_notice_signals;
3244 current_target.to_thread_alive = debug_to_thread_alive;
3245 current_target.to_find_new_threads = debug_to_find_new_threads;
3246 current_target.to_stop = debug_to_stop;
3247 current_target.to_rcmd = debug_to_rcmd;
3248 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
3252 static char targ_desc[] =
3253 "Names of targets and files being debugged.\n\
3254 Shows the entire stack of targets currently in use (including the exec-file,\n\
3255 core-file, and process, if any), as well as the symbol file name.";
3258 do_monitor_command (char *cmd,
3261 if ((current_target.to_rcmd
3262 == (void (*) (char *, struct ui_file *)) tcomplain)
3263 || (current_target.to_rcmd == debug_to_rcmd
3264 && (debug_target.to_rcmd
3265 == (void (*) (char *, struct ui_file *)) tcomplain)))
3266 error (_("\"monitor\" command not supported by this target."));
3267 target_rcmd (cmd, gdb_stdtarg);
3270 /* Print the name of each layers of our target stack. */
3273 maintenance_print_target_stack (char *cmd, int from_tty)
3275 struct target_ops *t;
3277 printf_filtered (_("The current target stack is:\n"));
3279 for (t = target_stack; t != NULL; t = t->beneath)
3281 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3285 /* Controls if async mode is permitted. */
3286 int target_async_permitted = 0;
3288 /* The set command writes to this variable. If the inferior is
3289 executing, linux_nat_async_permitted is *not* updated. */
3290 static int target_async_permitted_1 = 0;
3293 set_maintenance_target_async_permitted (char *args, int from_tty,
3294 struct cmd_list_element *c)
3296 if (target_has_execution)
3298 target_async_permitted_1 = target_async_permitted;
3299 error (_("Cannot change this setting while the inferior is running."));
3302 target_async_permitted = target_async_permitted_1;
3306 show_maintenance_target_async_permitted (struct ui_file *file, int from_tty,
3307 struct cmd_list_element *c,
3310 fprintf_filtered (file, _("\
3311 Controlling the inferior in asynchronous mode is %s.\n"), value);
3315 initialize_targets (void)
3317 init_dummy_target ();
3318 push_target (&dummy_target);
3320 add_info ("target", target_info, targ_desc);
3321 add_info ("files", target_info, targ_desc);
3323 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3324 Set target debugging."), _("\
3325 Show target debugging."), _("\
3326 When non-zero, target debugging is enabled. Higher numbers are more\n\
3327 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3331 &setdebuglist, &showdebuglist);
3333 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
3334 &trust_readonly, _("\
3335 Set mode for reading from readonly sections."), _("\
3336 Show mode for reading from readonly sections."), _("\
3337 When this mode is on, memory reads from readonly sections (such as .text)\n\
3338 will be read from the object file instead of from the target. This will\n\
3339 result in significant performance improvement for remote targets."),
3341 show_trust_readonly,
3342 &setlist, &showlist);
3344 add_com ("monitor", class_obscure, do_monitor_command,
3345 _("Send a command to the remote monitor (remote targets only)."));
3347 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3348 _("Print the name of each layer of the internal target stack."),
3349 &maintenanceprintlist);
3351 add_setshow_boolean_cmd ("target-async", no_class,
3352 &target_async_permitted_1, _("\
3353 Set whether gdb controls the inferior in asynchronous mode."), _("\
3354 Show whether gdb controls the inferior in asynchronous mode."), _("\
3355 Tells gdb whether to control the inferior in asynchronous mode."),
3356 set_maintenance_target_async_permitted,
3357 show_maintenance_target_async_permitted,
3361 target_dcache = dcache_init ();