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_prepare_to_store (struct regcache *);
102 static void debug_to_files_info (struct target_ops *);
104 static int debug_to_insert_breakpoint (struct bp_target_info *);
106 static int debug_to_remove_breakpoint (struct bp_target_info *);
108 static int debug_to_can_use_hw_breakpoint (int, int, int);
110 static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
112 static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
114 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
116 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
118 static int debug_to_stopped_by_watchpoint (void);
120 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
122 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
123 CORE_ADDR, CORE_ADDR, int);
125 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
127 static void debug_to_terminal_init (void);
129 static void debug_to_terminal_inferior (void);
131 static void debug_to_terminal_ours_for_output (void);
133 static void debug_to_terminal_save_ours (void);
135 static void debug_to_terminal_ours (void);
137 static void debug_to_terminal_info (char *, int);
139 static void debug_to_load (char *, int);
141 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
143 static int debug_to_can_run (void);
145 static void debug_to_notice_signals (ptid_t);
147 static void debug_to_stop (ptid_t);
149 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
150 wierd and mysterious ways. Putting the variable here lets those
151 wierd and mysterious ways keep building while they are being
152 converted to the inferior inheritance structure. */
153 struct target_ops deprecated_child_ops;
155 /* Pointer to array of target architecture structures; the size of the
156 array; the current index into the array; the allocated size of the
158 struct target_ops **target_structs;
159 unsigned target_struct_size;
160 unsigned target_struct_index;
161 unsigned target_struct_allocsize;
162 #define DEFAULT_ALLOCSIZE 10
164 /* The initial current target, so that there is always a semi-valid
167 static struct target_ops dummy_target;
169 /* Top of target stack. */
171 static struct target_ops *target_stack;
173 /* The target structure we are currently using to talk to a process
174 or file or whatever "inferior" we have. */
176 struct target_ops current_target;
178 /* Command list for target. */
180 static struct cmd_list_element *targetlist = NULL;
182 /* Nonzero if we should trust readonly sections from the
183 executable when reading memory. */
185 static int trust_readonly = 0;
187 /* Nonzero if we should show true memory content including
188 memory breakpoint inserted by gdb. */
190 static int show_memory_breakpoints = 0;
192 /* Non-zero if we want to see trace of target level stuff. */
194 static int targetdebug = 0;
196 show_targetdebug (struct ui_file *file, int from_tty,
197 struct cmd_list_element *c, const char *value)
199 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
202 static void setup_target_debug (void);
204 DCACHE *target_dcache;
206 /* The user just typed 'target' without the name of a target. */
209 target_command (char *arg, int from_tty)
211 fputs_filtered ("Argument required (target name). Try `help target'\n",
215 /* Add a possible target architecture to the list. */
218 add_target (struct target_ops *t)
220 /* Provide default values for all "must have" methods. */
221 if (t->to_xfer_partial == NULL)
222 t->to_xfer_partial = default_xfer_partial;
226 target_struct_allocsize = DEFAULT_ALLOCSIZE;
227 target_structs = (struct target_ops **) xmalloc
228 (target_struct_allocsize * sizeof (*target_structs));
230 if (target_struct_size >= target_struct_allocsize)
232 target_struct_allocsize *= 2;
233 target_structs = (struct target_ops **)
234 xrealloc ((char *) target_structs,
235 target_struct_allocsize * sizeof (*target_structs));
237 target_structs[target_struct_size++] = t;
239 if (targetlist == NULL)
240 add_prefix_cmd ("target", class_run, target_command, _("\
241 Connect to a target machine or process.\n\
242 The first argument is the type or protocol of the target machine.\n\
243 Remaining arguments are interpreted by the target protocol. For more\n\
244 information on the arguments for a particular protocol, type\n\
245 `help target ' followed by the protocol name."),
246 &targetlist, "target ", 0, &cmdlist);
247 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
260 struct target_ops *t;
262 for (t = current_target.beneath; t != NULL; t = t->beneath)
263 if (t->to_kill != NULL)
266 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
276 target_load (char *arg, int from_tty)
278 dcache_invalidate (target_dcache);
279 (*current_target.to_load) (arg, from_tty);
283 target_create_inferior (char *exec_file, char *args,
284 char **env, int from_tty)
286 struct target_ops *t;
287 for (t = current_target.beneath; t != NULL; t = t->beneath)
289 if (t->to_create_inferior != NULL)
291 t->to_create_inferior (t, exec_file, args, env, from_tty);
293 fprintf_unfiltered (gdb_stdlog,
294 "target_create_inferior (%s, %s, xxx, %d)\n",
295 exec_file, args, from_tty);
300 internal_error (__FILE__, __LINE__,
301 "could not find a target to create inferior");
306 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
307 struct target_ops *t)
309 errno = EIO; /* Can't read/write this location */
310 return 0; /* No bytes handled */
316 error (_("You can't do that when your target is `%s'"),
317 current_target.to_shortname);
323 error (_("You can't do that without a process to debug."));
327 nosymbol (char *name, CORE_ADDR *addrp)
329 return 1; /* Symbol does not exist in target env */
333 nosupport_runtime (void)
335 if (ptid_equal (inferior_ptid, null_ptid))
338 error (_("No run-time support for this"));
343 default_terminal_info (char *args, int from_tty)
345 printf_unfiltered (_("No saved terminal information.\n"));
348 /* This is the default target_create_inferior and target_attach function.
349 If the current target is executing, it asks whether to kill it off.
350 If this function returns without calling error(), it has killed off
351 the target, and the operation should be attempted. */
354 kill_or_be_killed (int from_tty)
356 if (target_has_execution)
358 printf_unfiltered (_("You are already running a program:\n"));
359 target_files_info ();
360 if (query (_("Kill it? ")))
363 if (target_has_execution)
364 error (_("Killing the program did not help."));
369 error (_("Program not killed."));
375 /* A default implementation for the to_get_ada_task_ptid target method.
377 This function builds the PTID by using both LWP and TID as part of
378 the PTID lwp and tid elements. The pid used is the pid of the
382 default_get_ada_task_ptid (long lwp, long tid)
384 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
387 /* Go through the target stack from top to bottom, copying over zero
388 entries in current_target, then filling in still empty entries. In
389 effect, we are doing class inheritance through the pushed target
392 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
393 is currently implemented, is that it discards any knowledge of
394 which target an inherited method originally belonged to.
395 Consequently, new new target methods should instead explicitly and
396 locally search the target stack for the target that can handle the
400 update_current_target (void)
402 struct target_ops *t;
404 /* First, reset current's contents. */
405 memset (¤t_target, 0, sizeof (current_target));
407 #define INHERIT(FIELD, TARGET) \
408 if (!current_target.FIELD) \
409 current_target.FIELD = (TARGET)->FIELD
411 for (t = target_stack; t; t = t->beneath)
413 INHERIT (to_shortname, t);
414 INHERIT (to_longname, t);
416 /* Do not inherit to_open. */
417 /* Do not inherit to_close. */
418 /* Do not inherit to_attach. */
419 INHERIT (to_post_attach, t);
420 INHERIT (to_attach_no_wait, t);
421 /* Do not inherit to_detach. */
422 /* Do not inherit to_disconnect. */
423 /* Do not inherit to_resume. */
424 /* Do not inherit to_wait. */
425 /* Do not inherit to_fetch_registers. */
426 /* Do not inherit to_store_registers. */
427 INHERIT (to_prepare_to_store, t);
428 INHERIT (deprecated_xfer_memory, t);
429 INHERIT (to_files_info, t);
430 INHERIT (to_insert_breakpoint, t);
431 INHERIT (to_remove_breakpoint, t);
432 INHERIT (to_can_use_hw_breakpoint, t);
433 INHERIT (to_insert_hw_breakpoint, t);
434 INHERIT (to_remove_hw_breakpoint, t);
435 INHERIT (to_insert_watchpoint, t);
436 INHERIT (to_remove_watchpoint, t);
437 INHERIT (to_stopped_data_address, t);
438 INHERIT (to_have_steppable_watchpoint, t);
439 INHERIT (to_have_continuable_watchpoint, t);
440 INHERIT (to_stopped_by_watchpoint, t);
441 INHERIT (to_watchpoint_addr_within_range, t);
442 INHERIT (to_region_ok_for_hw_watchpoint, t);
443 INHERIT (to_terminal_init, t);
444 INHERIT (to_terminal_inferior, t);
445 INHERIT (to_terminal_ours_for_output, t);
446 INHERIT (to_terminal_ours, t);
447 INHERIT (to_terminal_save_ours, t);
448 INHERIT (to_terminal_info, t);
449 /* Do not inherit to_kill. */
450 INHERIT (to_load, t);
451 INHERIT (to_lookup_symbol, t);
452 /* Do no inherit to_create_inferior. */
453 INHERIT (to_post_startup_inferior, t);
454 INHERIT (to_acknowledge_created_inferior, t);
455 INHERIT (to_insert_fork_catchpoint, t);
456 INHERIT (to_remove_fork_catchpoint, t);
457 INHERIT (to_insert_vfork_catchpoint, t);
458 INHERIT (to_remove_vfork_catchpoint, t);
459 /* Do not inherit to_follow_fork. */
460 INHERIT (to_insert_exec_catchpoint, t);
461 INHERIT (to_remove_exec_catchpoint, t);
462 INHERIT (to_has_exited, t);
463 /* Do not inherit to_mourn_inferiour. */
464 INHERIT (to_can_run, t);
465 INHERIT (to_notice_signals, t);
466 /* Do not inherit to_thread_alive. */
467 /* Do not inherit to_find_new_threads. */
468 /* Do not inherit to_pid_to_str. */
469 INHERIT (to_extra_thread_info, t);
470 INHERIT (to_stop, t);
471 /* Do not inherit to_xfer_partial. */
472 INHERIT (to_rcmd, t);
473 INHERIT (to_pid_to_exec_file, t);
474 INHERIT (to_log_command, t);
475 INHERIT (to_stratum, t);
476 INHERIT (to_has_all_memory, t);
477 INHERIT (to_has_memory, t);
478 INHERIT (to_has_stack, t);
479 INHERIT (to_has_registers, t);
480 INHERIT (to_has_execution, t);
481 INHERIT (to_has_thread_control, t);
482 INHERIT (to_sections, t);
483 INHERIT (to_sections_end, t);
484 INHERIT (to_can_async_p, t);
485 INHERIT (to_is_async_p, t);
486 INHERIT (to_async, t);
487 INHERIT (to_async_mask, t);
488 INHERIT (to_find_memory_regions, t);
489 INHERIT (to_make_corefile_notes, t);
490 /* Do not inherit to_get_thread_local_address. */
491 INHERIT (to_can_execute_reverse, t);
492 /* Do not inherit to_read_description. */
493 INHERIT (to_get_ada_task_ptid, t);
494 /* Do not inherit to_search_memory. */
495 INHERIT (to_supports_multi_process, t);
496 INHERIT (to_magic, t);
497 /* Do not inherit to_memory_map. */
498 /* Do not inherit to_flash_erase. */
499 /* Do not inherit to_flash_done. */
503 /* Clean up a target struct so it no longer has any zero pointers in
504 it. Some entries are defaulted to a method that print an error,
505 others are hard-wired to a standard recursive default. */
507 #define de_fault(field, value) \
508 if (!current_target.field) \
509 current_target.field = value
512 (void (*) (char *, int))
517 de_fault (to_post_attach,
520 de_fault (to_prepare_to_store,
521 (void (*) (struct regcache *))
523 de_fault (deprecated_xfer_memory,
524 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
526 de_fault (to_files_info,
527 (void (*) (struct target_ops *))
529 de_fault (to_insert_breakpoint,
530 memory_insert_breakpoint);
531 de_fault (to_remove_breakpoint,
532 memory_remove_breakpoint);
533 de_fault (to_can_use_hw_breakpoint,
534 (int (*) (int, int, int))
536 de_fault (to_insert_hw_breakpoint,
537 (int (*) (struct bp_target_info *))
539 de_fault (to_remove_hw_breakpoint,
540 (int (*) (struct bp_target_info *))
542 de_fault (to_insert_watchpoint,
543 (int (*) (CORE_ADDR, int, int))
545 de_fault (to_remove_watchpoint,
546 (int (*) (CORE_ADDR, int, int))
548 de_fault (to_stopped_by_watchpoint,
551 de_fault (to_stopped_data_address,
552 (int (*) (struct target_ops *, CORE_ADDR *))
554 de_fault (to_watchpoint_addr_within_range,
555 default_watchpoint_addr_within_range);
556 de_fault (to_region_ok_for_hw_watchpoint,
557 default_region_ok_for_hw_watchpoint);
558 de_fault (to_terminal_init,
561 de_fault (to_terminal_inferior,
564 de_fault (to_terminal_ours_for_output,
567 de_fault (to_terminal_ours,
570 de_fault (to_terminal_save_ours,
573 de_fault (to_terminal_info,
574 default_terminal_info);
576 (void (*) (char *, int))
578 de_fault (to_lookup_symbol,
579 (int (*) (char *, CORE_ADDR *))
581 de_fault (to_post_startup_inferior,
584 de_fault (to_acknowledge_created_inferior,
587 de_fault (to_insert_fork_catchpoint,
590 de_fault (to_remove_fork_catchpoint,
593 de_fault (to_insert_vfork_catchpoint,
596 de_fault (to_remove_vfork_catchpoint,
599 de_fault (to_insert_exec_catchpoint,
602 de_fault (to_remove_exec_catchpoint,
605 de_fault (to_has_exited,
606 (int (*) (int, int, int *))
608 de_fault (to_can_run,
610 de_fault (to_notice_signals,
613 de_fault (to_extra_thread_info,
614 (char *(*) (struct thread_info *))
619 current_target.to_xfer_partial = current_xfer_partial;
621 (void (*) (char *, struct ui_file *))
623 de_fault (to_pid_to_exec_file,
627 (void (*) (void (*) (enum inferior_event_type, void*), void*))
629 de_fault (to_async_mask,
632 current_target.to_read_description = NULL;
633 de_fault (to_get_ada_task_ptid,
634 (ptid_t (*) (long, long))
635 default_get_ada_task_ptid);
636 de_fault (to_supports_multi_process,
641 /* Finally, position the target-stack beneath the squashed
642 "current_target". That way code looking for a non-inherited
643 target method can quickly and simply find it. */
644 current_target.beneath = target_stack;
647 setup_target_debug ();
650 /* Mark OPS as a running target. This reverses the effect
651 of target_mark_exited. */
654 target_mark_running (struct target_ops *ops)
656 struct target_ops *t;
658 for (t = target_stack; t != NULL; t = t->beneath)
662 internal_error (__FILE__, __LINE__,
663 "Attempted to mark unpushed target \"%s\" as running",
666 ops->to_has_execution = 1;
667 ops->to_has_all_memory = 1;
668 ops->to_has_memory = 1;
669 ops->to_has_stack = 1;
670 ops->to_has_registers = 1;
672 update_current_target ();
675 /* Mark OPS as a non-running target. This reverses the effect
676 of target_mark_running. */
679 target_mark_exited (struct target_ops *ops)
681 struct target_ops *t;
683 for (t = target_stack; t != NULL; t = t->beneath)
687 internal_error (__FILE__, __LINE__,
688 "Attempted to mark unpushed target \"%s\" as running",
691 ops->to_has_execution = 0;
692 ops->to_has_all_memory = 0;
693 ops->to_has_memory = 0;
694 ops->to_has_stack = 0;
695 ops->to_has_registers = 0;
697 update_current_target ();
700 /* Push a new target type into the stack of the existing target accessors,
701 possibly superseding some of the existing accessors.
703 Result is zero if the pushed target ended up on top of the stack,
704 nonzero if at least one target is on top of it.
706 Rather than allow an empty stack, we always have the dummy target at
707 the bottom stratum, so we can call the function vectors without
711 push_target (struct target_ops *t)
713 struct target_ops **cur;
715 /* Check magic number. If wrong, it probably means someone changed
716 the struct definition, but not all the places that initialize one. */
717 if (t->to_magic != OPS_MAGIC)
719 fprintf_unfiltered (gdb_stderr,
720 "Magic number of %s target struct wrong\n",
722 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
725 /* Find the proper stratum to install this target in. */
726 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
728 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
732 /* If there's already targets at this stratum, remove them. */
733 /* FIXME: cagney/2003-10-15: I think this should be popping all
734 targets to CUR, and not just those at this stratum level. */
735 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
737 /* There's already something at this stratum level. Close it,
738 and un-hook it from the stack. */
739 struct target_ops *tmp = (*cur);
740 (*cur) = (*cur)->beneath;
742 target_close (tmp, 0);
745 /* We have removed all targets in our stratum, now add the new one. */
749 update_current_target ();
752 return (t != target_stack);
755 /* Remove a target_ops vector from the stack, wherever it may be.
756 Return how many times it was removed (0 or 1). */
759 unpush_target (struct target_ops *t)
761 struct target_ops **cur;
762 struct target_ops *tmp;
764 if (t->to_stratum == dummy_stratum)
765 internal_error (__FILE__, __LINE__,
766 "Attempt to unpush the dummy target");
768 /* Look for the specified target. Note that we assume that a target
769 can only occur once in the target stack. */
771 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
778 return 0; /* Didn't find target_ops, quit now */
780 /* NOTE: cagney/2003-12-06: In '94 the close call was made
781 unconditional by moving it to before the above check that the
782 target was in the target stack (something about "Change the way
783 pushing and popping of targets work to support target overlays
784 and inheritance"). This doesn't make much sense - only open
785 targets should be closed. */
788 /* Unchain the target */
790 (*cur) = (*cur)->beneath;
793 update_current_target ();
801 target_close (target_stack, 0); /* Let it clean up */
802 if (unpush_target (target_stack) == 1)
805 fprintf_unfiltered (gdb_stderr,
806 "pop_target couldn't find target %s\n",
807 current_target.to_shortname);
808 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
812 pop_all_targets_above (enum strata above_stratum, int quitting)
814 while ((int) (current_target.to_stratum) > (int) above_stratum)
816 target_close (target_stack, quitting);
817 if (!unpush_target (target_stack))
819 fprintf_unfiltered (gdb_stderr,
820 "pop_all_targets couldn't find target %s\n",
821 target_stack->to_shortname);
822 internal_error (__FILE__, __LINE__,
823 _("failed internal consistency check"));
830 pop_all_targets (int quitting)
832 pop_all_targets_above (dummy_stratum, quitting);
835 /* Using the objfile specified in OBJFILE, find the address for the
836 current thread's thread-local storage with offset OFFSET. */
838 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
840 volatile CORE_ADDR addr = 0;
841 struct target_ops *target;
843 for (target = current_target.beneath;
845 target = target->beneath)
847 if (target->to_get_thread_local_address != NULL)
852 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
854 ptid_t ptid = inferior_ptid;
855 volatile struct gdb_exception ex;
857 TRY_CATCH (ex, RETURN_MASK_ALL)
861 /* Fetch the load module address for this objfile. */
862 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
864 /* If it's 0, throw the appropriate exception. */
866 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
867 _("TLS load module not found"));
869 addr = target->to_get_thread_local_address (target, ptid, lm_addr, offset);
871 /* If an error occurred, print TLS related messages here. Otherwise,
872 throw the error to some higher catcher. */
875 int objfile_is_library = (objfile->flags & OBJF_SHARED);
879 case TLS_NO_LIBRARY_SUPPORT_ERROR:
880 error (_("Cannot find thread-local variables in this thread library."));
882 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
883 if (objfile_is_library)
884 error (_("Cannot find shared library `%s' in dynamic"
885 " linker's load module list"), objfile->name);
887 error (_("Cannot find executable file `%s' in dynamic"
888 " linker's load module list"), objfile->name);
890 case TLS_NOT_ALLOCATED_YET_ERROR:
891 if (objfile_is_library)
892 error (_("The inferior has not yet allocated storage for"
893 " thread-local variables in\n"
894 "the shared library `%s'\n"
896 objfile->name, target_pid_to_str (ptid));
898 error (_("The inferior has not yet allocated storage for"
899 " thread-local variables in\n"
900 "the executable `%s'\n"
902 objfile->name, target_pid_to_str (ptid));
904 case TLS_GENERIC_ERROR:
905 if (objfile_is_library)
906 error (_("Cannot find thread-local storage for %s, "
907 "shared library %s:\n%s"),
908 target_pid_to_str (ptid),
909 objfile->name, ex.message);
911 error (_("Cannot find thread-local storage for %s, "
912 "executable file %s:\n%s"),
913 target_pid_to_str (ptid),
914 objfile->name, ex.message);
917 throw_exception (ex);
922 /* It wouldn't be wrong here to try a gdbarch method, too; finding
923 TLS is an ABI-specific thing. But we don't do that yet. */
925 error (_("Cannot find thread-local variables on this target"));
931 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
933 /* target_read_string -- read a null terminated string, up to LEN bytes,
934 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
935 Set *STRING to a pointer to malloc'd memory containing the data; the caller
936 is responsible for freeing it. Return the number of bytes successfully
940 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
942 int tlen, origlen, offset, i;
946 int buffer_allocated;
948 unsigned int nbytes_read = 0;
952 /* Small for testing. */
953 buffer_allocated = 4;
954 buffer = xmalloc (buffer_allocated);
961 tlen = MIN (len, 4 - (memaddr & 3));
962 offset = memaddr & 3;
964 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
967 /* The transfer request might have crossed the boundary to an
968 unallocated region of memory. Retry the transfer, requesting
972 errcode = target_read_memory (memaddr, buf, 1);
977 if (bufptr - buffer + tlen > buffer_allocated)
980 bytes = bufptr - buffer;
981 buffer_allocated *= 2;
982 buffer = xrealloc (buffer, buffer_allocated);
983 bufptr = buffer + bytes;
986 for (i = 0; i < tlen; i++)
988 *bufptr++ = buf[i + offset];
989 if (buf[i + offset] == '\000')
991 nbytes_read += i + 1;
1007 /* Find a section containing ADDR. */
1008 struct section_table *
1009 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1011 struct section_table *secp;
1012 for (secp = target->to_sections;
1013 secp < target->to_sections_end;
1016 if (addr >= secp->addr && addr < secp->endaddr)
1022 /* Perform a partial memory transfer. The arguments and return
1023 value are just as for target_xfer_partial. */
1026 memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
1027 ULONGEST memaddr, LONGEST len)
1031 struct mem_region *region;
1033 /* Zero length requests are ok and require no work. */
1037 /* Try the executable file, if "trust-readonly-sections" is set. */
1038 if (readbuf != NULL && trust_readonly)
1040 struct section_table *secp;
1042 secp = target_section_by_addr (ops, memaddr);
1044 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1046 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1049 /* Likewise for accesses to unmapped overlay sections. */
1050 if (readbuf != NULL && overlay_debugging)
1052 struct obj_section *section = find_pc_overlay (memaddr);
1053 if (pc_in_unmapped_range (memaddr, section))
1054 return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
1057 /* Try GDB's internal data cache. */
1058 region = lookup_mem_region (memaddr);
1059 /* region->hi == 0 means there's no upper bound. */
1060 if (memaddr + len < region->hi || region->hi == 0)
1063 reg_len = region->hi - memaddr;
1065 switch (region->attrib.mode)
1068 if (writebuf != NULL)
1073 if (readbuf != NULL)
1078 /* We only support writing to flash during "load" for now. */
1079 if (writebuf != NULL)
1080 error (_("Writing to flash memory forbidden in this context"));
1087 if (region->attrib.cache)
1089 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1090 memory request will start back at current_target. */
1091 if (readbuf != NULL)
1092 res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
1095 /* FIXME drow/2006-08-09: If we're going to preserve const
1096 correctness dcache_xfer_memory should take readbuf and
1098 res = dcache_xfer_memory (target_dcache, memaddr,
1105 if (readbuf && !show_memory_breakpoints)
1106 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1111 /* If none of those methods found the memory we wanted, fall back
1112 to a target partial transfer. Normally a single call to
1113 to_xfer_partial is enough; if it doesn't recognize an object
1114 it will call the to_xfer_partial of the next target down.
1115 But for memory this won't do. Memory is the only target
1116 object which can be read from more than one valid target.
1117 A core file, for instance, could have some of memory but
1118 delegate other bits to the target below it. So, we must
1119 manually try all targets. */
1123 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1124 readbuf, writebuf, memaddr, reg_len);
1128 /* We want to continue past core files to executables, but not
1129 past a running target's memory. */
1130 if (ops->to_has_all_memory)
1135 while (ops != NULL);
1137 if (readbuf && !show_memory_breakpoints)
1138 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1140 /* If we still haven't got anything, return the last error. We
1146 restore_show_memory_breakpoints (void *arg)
1148 show_memory_breakpoints = (uintptr_t) arg;
1152 make_show_memory_breakpoints_cleanup (int show)
1154 int current = show_memory_breakpoints;
1155 show_memory_breakpoints = show;
1157 return make_cleanup (restore_show_memory_breakpoints,
1158 (void *) (uintptr_t) current);
1162 target_xfer_partial (struct target_ops *ops,
1163 enum target_object object, const char *annex,
1164 void *readbuf, const void *writebuf,
1165 ULONGEST offset, LONGEST len)
1169 gdb_assert (ops->to_xfer_partial != NULL);
1171 /* If this is a memory transfer, let the memory-specific code
1172 have a look at it instead. Memory transfers are more
1174 if (object == TARGET_OBJECT_MEMORY)
1175 retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
1178 enum target_object raw_object = object;
1180 /* If this is a raw memory transfer, request the normal
1181 memory object from other layers. */
1182 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1183 raw_object = TARGET_OBJECT_MEMORY;
1185 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1186 writebuf, offset, len);
1191 const unsigned char *myaddr = NULL;
1193 fprintf_unfiltered (gdb_stdlog,
1194 "%s:target_xfer_partial (%d, %s, %s, %s, %s, %s) = %s",
1197 (annex ? annex : "(null)"),
1198 host_address_to_string (readbuf),
1199 host_address_to_string (writebuf),
1200 core_addr_to_string_nz (offset),
1201 plongest (len), plongest (retval));
1207 if (retval > 0 && myaddr != NULL)
1211 fputs_unfiltered (", bytes =", gdb_stdlog);
1212 for (i = 0; i < retval; i++)
1214 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1216 if (targetdebug < 2 && i > 0)
1218 fprintf_unfiltered (gdb_stdlog, " ...");
1221 fprintf_unfiltered (gdb_stdlog, "\n");
1224 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1228 fputc_unfiltered ('\n', gdb_stdlog);
1233 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1234 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1235 if any error occurs.
1237 If an error occurs, no guarantee is made about the contents of the data at
1238 MYADDR. In particular, the caller should not depend upon partial reads
1239 filling the buffer with good data. There is no way for the caller to know
1240 how much good data might have been transfered anyway. Callers that can
1241 deal with partial reads should call target_read (which will retry until
1242 it makes no progress, and then return how much was transferred). */
1245 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1247 if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1248 myaddr, memaddr, len) == len)
1255 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1257 if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
1258 myaddr, memaddr, len) == len)
1264 /* Fetch the target's memory map. */
1267 target_memory_map (void)
1269 VEC(mem_region_s) *result;
1270 struct mem_region *last_one, *this_one;
1272 struct target_ops *t;
1275 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1277 for (t = current_target.beneath; t != NULL; t = t->beneath)
1278 if (t->to_memory_map != NULL)
1284 result = t->to_memory_map (t);
1288 qsort (VEC_address (mem_region_s, result),
1289 VEC_length (mem_region_s, result),
1290 sizeof (struct mem_region), mem_region_cmp);
1292 /* Check that regions do not overlap. Simultaneously assign
1293 a numbering for the "mem" commands to use to refer to
1296 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1298 this_one->number = ix;
1300 if (last_one && last_one->hi > this_one->lo)
1302 warning (_("Overlapping regions in memory map: ignoring"));
1303 VEC_free (mem_region_s, result);
1306 last_one = this_one;
1313 target_flash_erase (ULONGEST address, LONGEST length)
1315 struct target_ops *t;
1317 for (t = current_target.beneath; t != NULL; t = t->beneath)
1318 if (t->to_flash_erase != NULL)
1321 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1322 paddr (address), phex (length, 0));
1323 t->to_flash_erase (t, address, length);
1331 target_flash_done (void)
1333 struct target_ops *t;
1335 for (t = current_target.beneath; t != NULL; t = t->beneath)
1336 if (t->to_flash_done != NULL)
1339 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1340 t->to_flash_done (t);
1348 show_trust_readonly (struct ui_file *file, int from_tty,
1349 struct cmd_list_element *c, const char *value)
1351 fprintf_filtered (file, _("\
1352 Mode for reading from readonly sections is %s.\n"),
1356 /* More generic transfers. */
1359 default_xfer_partial (struct target_ops *ops, enum target_object object,
1360 const char *annex, gdb_byte *readbuf,
1361 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1363 if (object == TARGET_OBJECT_MEMORY
1364 && ops->deprecated_xfer_memory != NULL)
1365 /* If available, fall back to the target's
1366 "deprecated_xfer_memory" method. */
1370 if (writebuf != NULL)
1372 void *buffer = xmalloc (len);
1373 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1374 memcpy (buffer, writebuf, len);
1375 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1376 1/*write*/, NULL, ops);
1377 do_cleanups (cleanup);
1379 if (readbuf != NULL)
1380 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1381 0/*read*/, NULL, ops);
1384 else if (xfered == 0 && errno == 0)
1385 /* "deprecated_xfer_memory" uses 0, cross checked against
1386 ERRNO as one indication of an error. */
1391 else if (ops->beneath != NULL)
1392 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1393 readbuf, writebuf, offset, len);
1398 /* The xfer_partial handler for the topmost target. Unlike the default,
1399 it does not need to handle memory specially; it just passes all
1400 requests down the stack. */
1403 current_xfer_partial (struct target_ops *ops, enum target_object object,
1404 const char *annex, gdb_byte *readbuf,
1405 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1407 if (ops->beneath != NULL)
1408 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1409 readbuf, writebuf, offset, len);
1414 /* Target vector read/write partial wrapper functions.
1416 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1417 (inbuf, outbuf)", instead of separate read/write methods, make life
1421 target_read_partial (struct target_ops *ops,
1422 enum target_object object,
1423 const char *annex, gdb_byte *buf,
1424 ULONGEST offset, LONGEST len)
1426 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1430 target_write_partial (struct target_ops *ops,
1431 enum target_object object,
1432 const char *annex, const gdb_byte *buf,
1433 ULONGEST offset, LONGEST len)
1435 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1438 /* Wrappers to perform the full transfer. */
1440 target_read (struct target_ops *ops,
1441 enum target_object object,
1442 const char *annex, gdb_byte *buf,
1443 ULONGEST offset, LONGEST len)
1446 while (xfered < len)
1448 LONGEST xfer = target_read_partial (ops, object, annex,
1449 (gdb_byte *) buf + xfered,
1450 offset + xfered, len - xfered);
1451 /* Call an observer, notifying them of the xfer progress? */
1463 target_read_until_error (struct target_ops *ops,
1464 enum target_object object,
1465 const char *annex, gdb_byte *buf,
1466 ULONGEST offset, LONGEST len)
1469 while (xfered < len)
1471 LONGEST xfer = target_read_partial (ops, object, annex,
1472 (gdb_byte *) buf + xfered,
1473 offset + xfered, len - xfered);
1474 /* Call an observer, notifying them of the xfer progress? */
1479 /* We've got an error. Try to read in smaller blocks. */
1480 ULONGEST start = offset + xfered;
1481 ULONGEST remaining = len - xfered;
1484 /* If an attempt was made to read a random memory address,
1485 it's likely that the very first byte is not accessible.
1486 Try reading the first byte, to avoid doing log N tries
1488 xfer = target_read_partial (ops, object, annex,
1489 (gdb_byte *) buf + xfered, start, 1);
1498 xfer = target_read_partial (ops, object, annex,
1499 (gdb_byte *) buf + xfered,
1509 /* We have successfully read the first half. So, the
1510 error must be in the second half. Adjust start and
1511 remaining to point at the second half. */
1528 /* An alternative to target_write with progress callbacks. */
1531 target_write_with_progress (struct target_ops *ops,
1532 enum target_object object,
1533 const char *annex, const gdb_byte *buf,
1534 ULONGEST offset, LONGEST len,
1535 void (*progress) (ULONGEST, void *), void *baton)
1539 /* Give the progress callback a chance to set up. */
1541 (*progress) (0, baton);
1543 while (xfered < len)
1545 LONGEST xfer = target_write_partial (ops, object, annex,
1546 (gdb_byte *) buf + xfered,
1547 offset + xfered, len - xfered);
1555 (*progress) (xfer, baton);
1564 target_write (struct target_ops *ops,
1565 enum target_object object,
1566 const char *annex, const gdb_byte *buf,
1567 ULONGEST offset, LONGEST len)
1569 return target_write_with_progress (ops, object, annex, buf, offset, len,
1573 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1574 the size of the transferred data. PADDING additional bytes are
1575 available in *BUF_P. This is a helper function for
1576 target_read_alloc; see the declaration of that function for more
1580 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1581 const char *annex, gdb_byte **buf_p, int padding)
1583 size_t buf_alloc, buf_pos;
1587 /* This function does not have a length parameter; it reads the
1588 entire OBJECT). Also, it doesn't support objects fetched partly
1589 from one target and partly from another (in a different stratum,
1590 e.g. a core file and an executable). Both reasons make it
1591 unsuitable for reading memory. */
1592 gdb_assert (object != TARGET_OBJECT_MEMORY);
1594 /* Start by reading up to 4K at a time. The target will throttle
1595 this number down if necessary. */
1597 buf = xmalloc (buf_alloc);
1601 n = target_read_partial (ops, object, annex, &buf[buf_pos],
1602 buf_pos, buf_alloc - buf_pos - padding);
1605 /* An error occurred. */
1611 /* Read all there was. */
1621 /* If the buffer is filling up, expand it. */
1622 if (buf_alloc < buf_pos * 2)
1625 buf = xrealloc (buf, buf_alloc);
1632 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1633 the size of the transferred data. See the declaration in "target.h"
1634 function for more information about the return value. */
1637 target_read_alloc (struct target_ops *ops, enum target_object object,
1638 const char *annex, gdb_byte **buf_p)
1640 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1643 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1644 returned as a string, allocated using xmalloc. If an error occurs
1645 or the transfer is unsupported, NULL is returned. Empty objects
1646 are returned as allocated but empty strings. A warning is issued
1647 if the result contains any embedded NUL bytes. */
1650 target_read_stralloc (struct target_ops *ops, enum target_object object,
1654 LONGEST transferred;
1656 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1658 if (transferred < 0)
1661 if (transferred == 0)
1662 return xstrdup ("");
1664 buffer[transferred] = 0;
1665 if (strlen (buffer) < transferred)
1666 warning (_("target object %d, annex %s, "
1667 "contained unexpected null characters"),
1668 (int) object, annex ? annex : "(none)");
1670 return (char *) buffer;
1673 /* Memory transfer methods. */
1676 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1679 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1681 memory_error (EIO, addr);
1685 get_target_memory_unsigned (struct target_ops *ops,
1686 CORE_ADDR addr, int len)
1688 gdb_byte buf[sizeof (ULONGEST)];
1690 gdb_assert (len <= sizeof (buf));
1691 get_target_memory (ops, addr, buf, len);
1692 return extract_unsigned_integer (buf, len);
1696 target_info (char *args, int from_tty)
1698 struct target_ops *t;
1699 int has_all_mem = 0;
1701 if (symfile_objfile != NULL)
1702 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1704 for (t = target_stack; t != NULL; t = t->beneath)
1706 if (!t->to_has_memory)
1709 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1712 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1713 printf_unfiltered ("%s:\n", t->to_longname);
1714 (t->to_files_info) (t);
1715 has_all_mem = t->to_has_all_memory;
1719 /* This function is called before any new inferior is created, e.g.
1720 by running a program, attaching, or connecting to a target.
1721 It cleans up any state from previous invocations which might
1722 change between runs. This is a subset of what target_preopen
1723 resets (things which might change between targets). */
1726 target_pre_inferior (int from_tty)
1728 /* Clear out solib state. Otherwise the solib state of the previous
1729 inferior might have survived and is entirely wrong for the new
1730 target. This has been observed on GNU/Linux using glibc 2.3. How
1742 Cannot access memory at address 0xdeadbeef
1745 /* In some OSs, the shared library list is the same/global/shared
1746 across inferiors. If code is shared between processes, so are
1747 memory regions and features. */
1748 if (!gdbarch_has_global_solist (target_gdbarch))
1750 no_shared_libraries (NULL, from_tty);
1752 invalidate_target_mem_regions ();
1754 target_clear_description ();
1758 /* This is to be called by the open routine before it does
1762 target_preopen (int from_tty)
1766 if (target_has_execution)
1769 || query (_("A program is being debugged already. Kill it? ")))
1772 error (_("Program not killed."));
1775 /* Calling target_kill may remove the target from the stack. But if
1776 it doesn't (which seems like a win for UDI), remove it now. */
1777 /* Leave the exec target, though. The user may be switching from a
1778 live process to a core of the same program. */
1779 pop_all_targets_above (file_stratum, 0);
1781 target_pre_inferior (from_tty);
1784 /* Detach a target after doing deferred register stores. */
1787 target_detach (char *args, int from_tty)
1789 struct target_ops* t;
1791 if (gdbarch_has_global_solist (target_gdbarch))
1792 /* Don't remove global breakpoints here. They're removed on
1793 disconnection from the target. */
1796 /* If we're in breakpoints-always-inserted mode, have to remove
1797 them before detaching. */
1798 remove_breakpoints ();
1800 for (t = current_target.beneath; t != NULL; t = t->beneath)
1802 if (t->to_detach != NULL)
1804 t->to_detach (t, args, from_tty);
1806 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
1812 internal_error (__FILE__, __LINE__, "could not find a target to detach");
1816 target_disconnect (char *args, int from_tty)
1818 struct target_ops *t;
1820 /* If we're in breakpoints-always-inserted mode or if breakpoints
1821 are global across processes, we have to remove them before
1823 remove_breakpoints ();
1825 for (t = current_target.beneath; t != NULL; t = t->beneath)
1826 if (t->to_disconnect != NULL)
1829 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1831 t->to_disconnect (t, args, from_tty);
1839 target_wait (ptid_t ptid, struct target_waitstatus *status)
1841 struct target_ops *t;
1843 for (t = current_target.beneath; t != NULL; t = t->beneath)
1845 if (t->to_wait != NULL)
1847 ptid_t retval = (*t->to_wait) (t, ptid, status);
1851 char *status_string;
1853 status_string = target_waitstatus_to_string (status);
1854 fprintf_unfiltered (gdb_stdlog,
1855 "target_wait (%d, status) = %d, %s\n",
1856 PIDGET (ptid), PIDGET (retval),
1858 xfree (status_string);
1869 target_pid_to_str (ptid_t ptid)
1871 struct target_ops *t;
1873 for (t = current_target.beneath; t != NULL; t = t->beneath)
1875 if (t->to_pid_to_str != NULL)
1876 return (*t->to_pid_to_str) (t, ptid);
1879 return normal_pid_to_str (ptid);
1883 target_resume (ptid_t ptid, int step, enum target_signal signal)
1885 struct target_ops *t;
1887 dcache_invalidate (target_dcache);
1889 for (t = current_target.beneath; t != NULL; t = t->beneath)
1891 if (t->to_resume != NULL)
1893 t->to_resume (t, ptid, step, signal);
1895 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
1897 step ? "step" : "continue",
1898 target_signal_to_name (signal));
1900 set_executing (ptid, 1);
1901 set_running (ptid, 1);
1908 /* Look through the list of possible targets for a target that can
1912 target_follow_fork (int follow_child)
1914 struct target_ops *t;
1916 for (t = current_target.beneath; t != NULL; t = t->beneath)
1918 if (t->to_follow_fork != NULL)
1920 int retval = t->to_follow_fork (t, follow_child);
1922 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1923 follow_child, retval);
1928 /* Some target returned a fork event, but did not know how to follow it. */
1929 internal_error (__FILE__, __LINE__,
1930 "could not find a target to follow fork");
1934 target_mourn_inferior (void)
1936 struct target_ops *t;
1937 for (t = current_target.beneath; t != NULL; t = t->beneath)
1939 if (t->to_mourn_inferior != NULL)
1941 t->to_mourn_inferior (t);
1943 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
1945 /* We no longer need to keep handles on any of the object files.
1946 Make sure to release them to avoid unnecessarily locking any
1947 of them while we're not actually debugging. */
1948 bfd_cache_close_all ();
1954 internal_error (__FILE__, __LINE__,
1955 "could not find a target to follow mourn inferiour");
1958 /* Look for a target which can describe architectural features, starting
1959 from TARGET. If we find one, return its description. */
1961 const struct target_desc *
1962 target_read_description (struct target_ops *target)
1964 struct target_ops *t;
1966 for (t = target; t != NULL; t = t->beneath)
1967 if (t->to_read_description != NULL)
1969 const struct target_desc *tdesc;
1971 tdesc = t->to_read_description (t);
1979 /* The default implementation of to_search_memory.
1980 This implements a basic search of memory, reading target memory and
1981 performing the search here (as opposed to performing the search in on the
1982 target side with, for example, gdbserver). */
1985 simple_search_memory (struct target_ops *ops,
1986 CORE_ADDR start_addr, ULONGEST search_space_len,
1987 const gdb_byte *pattern, ULONGEST pattern_len,
1988 CORE_ADDR *found_addrp)
1990 /* NOTE: also defined in find.c testcase. */
1991 #define SEARCH_CHUNK_SIZE 16000
1992 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1993 /* Buffer to hold memory contents for searching. */
1994 gdb_byte *search_buf;
1995 unsigned search_buf_size;
1996 struct cleanup *old_cleanups;
1998 search_buf_size = chunk_size + pattern_len - 1;
2000 /* No point in trying to allocate a buffer larger than the search space. */
2001 if (search_space_len < search_buf_size)
2002 search_buf_size = search_space_len;
2004 search_buf = malloc (search_buf_size);
2005 if (search_buf == NULL)
2006 error (_("Unable to allocate memory to perform the search."));
2007 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2009 /* Prime the search buffer. */
2011 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2012 search_buf, start_addr, search_buf_size) != search_buf_size)
2014 warning (_("Unable to access target memory at %s, halting search."),
2015 hex_string (start_addr));
2016 do_cleanups (old_cleanups);
2020 /* Perform the search.
2022 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2023 When we've scanned N bytes we copy the trailing bytes to the start and
2024 read in another N bytes. */
2026 while (search_space_len >= pattern_len)
2028 gdb_byte *found_ptr;
2029 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2031 found_ptr = memmem (search_buf, nr_search_bytes,
2032 pattern, pattern_len);
2034 if (found_ptr != NULL)
2036 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2037 *found_addrp = found_addr;
2038 do_cleanups (old_cleanups);
2042 /* Not found in this chunk, skip to next chunk. */
2044 /* Don't let search_space_len wrap here, it's unsigned. */
2045 if (search_space_len >= chunk_size)
2046 search_space_len -= chunk_size;
2048 search_space_len = 0;
2050 if (search_space_len >= pattern_len)
2052 unsigned keep_len = search_buf_size - chunk_size;
2053 CORE_ADDR read_addr = start_addr + keep_len;
2056 /* Copy the trailing part of the previous iteration to the front
2057 of the buffer for the next iteration. */
2058 gdb_assert (keep_len == pattern_len - 1);
2059 memcpy (search_buf, search_buf + chunk_size, keep_len);
2061 nr_to_read = min (search_space_len - keep_len, chunk_size);
2063 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2064 search_buf + keep_len, read_addr,
2065 nr_to_read) != nr_to_read)
2067 warning (_("Unable to access target memory at %s, halting search."),
2068 hex_string (read_addr));
2069 do_cleanups (old_cleanups);
2073 start_addr += chunk_size;
2079 do_cleanups (old_cleanups);
2083 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2084 sequence of bytes in PATTERN with length PATTERN_LEN.
2086 The result is 1 if found, 0 if not found, and -1 if there was an error
2087 requiring halting of the search (e.g. memory read error).
2088 If the pattern is found the address is recorded in FOUND_ADDRP. */
2091 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2092 const gdb_byte *pattern, ULONGEST pattern_len,
2093 CORE_ADDR *found_addrp)
2095 struct target_ops *t;
2098 /* We don't use INHERIT to set current_target.to_search_memory,
2099 so we have to scan the target stack and handle targetdebug
2103 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2104 hex_string (start_addr));
2106 for (t = current_target.beneath; t != NULL; t = t->beneath)
2107 if (t->to_search_memory != NULL)
2112 found = t->to_search_memory (t, start_addr, search_space_len,
2113 pattern, pattern_len, found_addrp);
2117 /* If a special version of to_search_memory isn't available, use the
2119 found = simple_search_memory (¤t_target,
2120 start_addr, search_space_len,
2121 pattern, pattern_len, found_addrp);
2125 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2130 /* Look through the currently pushed targets. If none of them will
2131 be able to restart the currently running process, issue an error
2135 target_require_runnable (void)
2137 struct target_ops *t;
2139 for (t = target_stack; t != NULL; t = t->beneath)
2141 /* If this target knows how to create a new program, then
2142 assume we will still be able to after killing the current
2143 one. Either killing and mourning will not pop T, or else
2144 find_default_run_target will find it again. */
2145 if (t->to_create_inferior != NULL)
2148 /* Do not worry about thread_stratum targets that can not
2149 create inferiors. Assume they will be pushed again if
2150 necessary, and continue to the process_stratum. */
2151 if (t->to_stratum == thread_stratum)
2155 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2159 /* This function is only called if the target is running. In that
2160 case there should have been a process_stratum target and it
2161 should either know how to create inferiors, or not... */
2162 internal_error (__FILE__, __LINE__, "No targets found");
2165 /* Look through the list of possible targets for a target that can
2166 execute a run or attach command without any other data. This is
2167 used to locate the default process stratum.
2169 If DO_MESG is not NULL, the result is always valid (error() is
2170 called for errors); else, return NULL on error. */
2172 static struct target_ops *
2173 find_default_run_target (char *do_mesg)
2175 struct target_ops **t;
2176 struct target_ops *runable = NULL;
2181 for (t = target_structs; t < target_structs + target_struct_size;
2184 if ((*t)->to_can_run && target_can_run (*t))
2194 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2203 find_default_attach (struct target_ops *ops, char *args, int from_tty)
2205 struct target_ops *t;
2207 t = find_default_run_target ("attach");
2208 (t->to_attach) (t, args, from_tty);
2213 find_default_create_inferior (struct target_ops *ops,
2214 char *exec_file, char *allargs, char **env,
2217 struct target_ops *t;
2219 t = find_default_run_target ("run");
2220 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
2225 find_default_can_async_p (void)
2227 struct target_ops *t;
2229 /* This may be called before the target is pushed on the stack;
2230 look for the default process stratum. If there's none, gdb isn't
2231 configured with a native debugger, and target remote isn't
2233 t = find_default_run_target (NULL);
2234 if (t && t->to_can_async_p)
2235 return (t->to_can_async_p) ();
2240 find_default_is_async_p (void)
2242 struct target_ops *t;
2244 /* This may be called before the target is pushed on the stack;
2245 look for the default process stratum. If there's none, gdb isn't
2246 configured with a native debugger, and target remote isn't
2248 t = find_default_run_target (NULL);
2249 if (t && t->to_is_async_p)
2250 return (t->to_is_async_p) ();
2255 find_default_supports_non_stop (void)
2257 struct target_ops *t;
2259 t = find_default_run_target (NULL);
2260 if (t && t->to_supports_non_stop)
2261 return (t->to_supports_non_stop) ();
2266 target_supports_non_stop (void)
2268 struct target_ops *t;
2269 for (t = ¤t_target; t != NULL; t = t->beneath)
2270 if (t->to_supports_non_stop)
2271 return t->to_supports_non_stop ();
2278 target_get_osdata (const char *type)
2281 struct target_ops *t;
2283 /* If we're already connected to something that can get us OS
2284 related data, use it. Otherwise, try using the native
2286 if (current_target.to_stratum >= process_stratum)
2287 t = current_target.beneath;
2289 t = find_default_run_target ("get OS data");
2294 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
2298 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2300 return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
2304 default_watchpoint_addr_within_range (struct target_ops *target,
2306 CORE_ADDR start, int length)
2308 return addr >= start && addr < start + length;
2324 return_minus_one (void)
2330 * Resize the to_sections pointer. Also make sure that anyone that
2331 * was holding on to an old value of it gets updated.
2332 * Returns the old size.
2336 target_resize_to_sections (struct target_ops *target, int num_added)
2338 struct target_ops **t;
2339 struct section_table *old_value;
2342 old_value = target->to_sections;
2344 if (target->to_sections)
2346 old_count = target->to_sections_end - target->to_sections;
2347 target->to_sections = (struct section_table *)
2348 xrealloc ((char *) target->to_sections,
2349 (sizeof (struct section_table)) * (num_added + old_count));
2354 target->to_sections = (struct section_table *)
2355 xmalloc ((sizeof (struct section_table)) * num_added);
2357 target->to_sections_end = target->to_sections + (num_added + old_count);
2359 /* Check to see if anyone else was pointing to this structure.
2360 If old_value was null, then no one was. */
2364 for (t = target_structs; t < target_structs + target_struct_size;
2367 if ((*t)->to_sections == old_value)
2369 (*t)->to_sections = target->to_sections;
2370 (*t)->to_sections_end = target->to_sections_end;
2373 /* There is a flattened view of the target stack in current_target,
2374 so its to_sections pointer might also need updating. */
2375 if (current_target.to_sections == old_value)
2377 current_target.to_sections = target->to_sections;
2378 current_target.to_sections_end = target->to_sections_end;
2386 /* Remove all target sections taken from ABFD.
2388 Scan the current target stack for targets whose section tables
2389 refer to sections from BFD, and remove those sections. We use this
2390 when we notice that the inferior has unloaded a shared object, for
2393 remove_target_sections (bfd *abfd)
2395 struct target_ops **t;
2397 for (t = target_structs; t < target_structs + target_struct_size; t++)
2399 struct section_table *src, *dest;
2401 dest = (*t)->to_sections;
2402 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
2403 if (src->bfd != abfd)
2405 /* Keep this section. */
2406 if (dest < src) *dest = *src;
2410 /* If we've dropped any sections, resize the section table. */
2412 target_resize_to_sections (*t, dest - src);
2419 /* Find a single runnable target in the stack and return it. If for
2420 some reason there is more than one, return NULL. */
2423 find_run_target (void)
2425 struct target_ops **t;
2426 struct target_ops *runable = NULL;
2431 for (t = target_structs; t < target_structs + target_struct_size; ++t)
2433 if ((*t)->to_can_run && target_can_run (*t))
2440 return (count == 1 ? runable : NULL);
2443 /* Find a single core_stratum target in the list of targets and return it.
2444 If for some reason there is more than one, return NULL. */
2447 find_core_target (void)
2449 struct target_ops **t;
2450 struct target_ops *runable = NULL;
2455 for (t = target_structs; t < target_structs + target_struct_size;
2458 if ((*t)->to_stratum == core_stratum)
2465 return (count == 1 ? runable : NULL);
2469 * Find the next target down the stack from the specified target.
2473 find_target_beneath (struct target_ops *t)
2479 /* The inferior process has died. Long live the inferior! */
2482 generic_mourn_inferior (void)
2486 ptid = inferior_ptid;
2487 inferior_ptid = null_ptid;
2489 if (!ptid_equal (ptid, null_ptid))
2491 int pid = ptid_get_pid (ptid);
2492 delete_inferior (pid);
2495 breakpoint_init_inferior (inf_exited);
2496 registers_changed ();
2498 reopen_exec_file ();
2499 reinit_frame_cache ();
2501 if (deprecated_detach_hook)
2502 deprecated_detach_hook ();
2505 /* Helper function for child_wait and the derivatives of child_wait.
2506 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2507 translation of that in OURSTATUS. */
2509 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2511 if (WIFEXITED (hoststatus))
2513 ourstatus->kind = TARGET_WAITKIND_EXITED;
2514 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2516 else if (!WIFSTOPPED (hoststatus))
2518 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2519 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2523 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2524 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2528 /* Convert a normal process ID to a string. Returns the string in a
2532 normal_pid_to_str (ptid_t ptid)
2534 static char buf[32];
2536 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
2541 dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
2543 return normal_pid_to_str (ptid);
2546 /* Error-catcher for target_find_memory_regions */
2547 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2549 error (_("No target."));
2553 /* Error-catcher for target_make_corefile_notes */
2554 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2556 error (_("No target."));
2560 /* Set up the handful of non-empty slots needed by the dummy target
2564 init_dummy_target (void)
2566 dummy_target.to_shortname = "None";
2567 dummy_target.to_longname = "None";
2568 dummy_target.to_doc = "";
2569 dummy_target.to_attach = find_default_attach;
2570 dummy_target.to_detach =
2571 (void (*)(struct target_ops *, char *, int))target_ignore;
2572 dummy_target.to_create_inferior = find_default_create_inferior;
2573 dummy_target.to_can_async_p = find_default_can_async_p;
2574 dummy_target.to_is_async_p = find_default_is_async_p;
2575 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
2576 dummy_target.to_pid_to_str = dummy_pid_to_str;
2577 dummy_target.to_stratum = dummy_stratum;
2578 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2579 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
2580 dummy_target.to_xfer_partial = default_xfer_partial;
2581 dummy_target.to_magic = OPS_MAGIC;
2585 debug_to_open (char *args, int from_tty)
2587 debug_target.to_open (args, from_tty);
2589 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2593 target_close (struct target_ops *targ, int quitting)
2595 if (targ->to_xclose != NULL)
2596 targ->to_xclose (targ, quitting);
2597 else if (targ->to_close != NULL)
2598 targ->to_close (quitting);
2601 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2605 target_attach (char *args, int from_tty)
2607 struct target_ops *t;
2608 for (t = current_target.beneath; t != NULL; t = t->beneath)
2610 if (t->to_attach != NULL)
2612 t->to_attach (t, args, from_tty);
2614 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
2620 internal_error (__FILE__, __LINE__,
2621 "could not find a target to attach");
2625 target_thread_alive (ptid_t ptid)
2627 struct target_ops *t;
2628 for (t = current_target.beneath; t != NULL; t = t->beneath)
2630 if (t->to_thread_alive != NULL)
2634 retval = t->to_thread_alive (t, ptid);
2636 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2637 PIDGET (ptid), retval);
2647 target_find_new_threads (void)
2649 struct target_ops *t;
2650 for (t = current_target.beneath; t != NULL; t = t->beneath)
2652 if (t->to_find_new_threads != NULL)
2654 t->to_find_new_threads (t);
2656 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
2664 debug_to_post_attach (int pid)
2666 debug_target.to_post_attach (pid);
2668 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2671 /* Return a pretty printed form of target_waitstatus.
2672 Space for the result is malloc'd, caller must free. */
2675 target_waitstatus_to_string (const struct target_waitstatus *ws)
2677 const char *kind_str = "status->kind = ";
2681 case TARGET_WAITKIND_EXITED:
2682 return xstrprintf ("%sexited, status = %d",
2683 kind_str, ws->value.integer);
2684 case TARGET_WAITKIND_STOPPED:
2685 return xstrprintf ("%sstopped, signal = %s",
2686 kind_str, target_signal_to_name (ws->value.sig));
2687 case TARGET_WAITKIND_SIGNALLED:
2688 return xstrprintf ("%ssignalled, signal = %s",
2689 kind_str, target_signal_to_name (ws->value.sig));
2690 case TARGET_WAITKIND_LOADED:
2691 return xstrprintf ("%sloaded", kind_str);
2692 case TARGET_WAITKIND_FORKED:
2693 return xstrprintf ("%sforked", kind_str);
2694 case TARGET_WAITKIND_VFORKED:
2695 return xstrprintf ("%svforked", kind_str);
2696 case TARGET_WAITKIND_EXECD:
2697 return xstrprintf ("%sexecd", kind_str);
2698 case TARGET_WAITKIND_SYSCALL_ENTRY:
2699 return xstrprintf ("%ssyscall-entry", kind_str);
2700 case TARGET_WAITKIND_SYSCALL_RETURN:
2701 return xstrprintf ("%ssyscall-return", kind_str);
2702 case TARGET_WAITKIND_SPURIOUS:
2703 return xstrprintf ("%sspurious", kind_str);
2704 case TARGET_WAITKIND_IGNORE:
2705 return xstrprintf ("%signore", kind_str);
2706 case TARGET_WAITKIND_NO_HISTORY:
2707 return xstrprintf ("%sno-history", kind_str);
2709 return xstrprintf ("%sunknown???", kind_str);
2714 debug_print_register (const char * func,
2715 struct regcache *regcache, int regno)
2717 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2718 fprintf_unfiltered (gdb_stdlog, "%s ", func);
2719 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
2720 && gdbarch_register_name (gdbarch, regno) != NULL
2721 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
2722 fprintf_unfiltered (gdb_stdlog, "(%s)",
2723 gdbarch_register_name (gdbarch, regno));
2725 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2726 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
2728 int i, size = register_size (gdbarch, regno);
2729 unsigned char buf[MAX_REGISTER_SIZE];
2730 regcache_raw_collect (regcache, regno, buf);
2731 fprintf_unfiltered (gdb_stdlog, " = ");
2732 for (i = 0; i < size; i++)
2734 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2736 if (size <= sizeof (LONGEST))
2738 ULONGEST val = extract_unsigned_integer (buf, size);
2739 fprintf_unfiltered (gdb_stdlog, " %s %s",
2740 core_addr_to_string_nz (val), plongest (val));
2743 fprintf_unfiltered (gdb_stdlog, "\n");
2747 target_fetch_registers (struct regcache *regcache, int regno)
2749 struct target_ops *t;
2750 for (t = current_target.beneath; t != NULL; t = t->beneath)
2752 if (t->to_fetch_registers != NULL)
2754 t->to_fetch_registers (t, regcache, regno);
2756 debug_print_register ("target_fetch_registers", regcache, regno);
2763 target_store_registers (struct regcache *regcache, int regno)
2766 struct target_ops *t;
2767 for (t = current_target.beneath; t != NULL; t = t->beneath)
2769 if (t->to_store_registers != NULL)
2771 t->to_store_registers (t, regcache, regno);
2774 debug_print_register ("target_store_registers", regcache, regno);
2784 debug_to_prepare_to_store (struct regcache *regcache)
2786 debug_target.to_prepare_to_store (regcache);
2788 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2792 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2793 int write, struct mem_attrib *attrib,
2794 struct target_ops *target)
2798 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2801 fprintf_unfiltered (gdb_stdlog,
2802 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
2803 paddress (memaddr), len, write ? "write" : "read",
2810 fputs_unfiltered (", bytes =", gdb_stdlog);
2811 for (i = 0; i < retval; i++)
2813 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
2815 if (targetdebug < 2 && i > 0)
2817 fprintf_unfiltered (gdb_stdlog, " ...");
2820 fprintf_unfiltered (gdb_stdlog, "\n");
2823 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2827 fputc_unfiltered ('\n', gdb_stdlog);
2833 debug_to_files_info (struct target_ops *target)
2835 debug_target.to_files_info (target);
2837 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2841 debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
2845 retval = debug_target.to_insert_breakpoint (bp_tgt);
2847 fprintf_unfiltered (gdb_stdlog,
2848 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2849 (unsigned long) bp_tgt->placed_address,
2850 (unsigned long) retval);
2855 debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
2859 retval = debug_target.to_remove_breakpoint (bp_tgt);
2861 fprintf_unfiltered (gdb_stdlog,
2862 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2863 (unsigned long) bp_tgt->placed_address,
2864 (unsigned long) retval);
2869 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2873 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2875 fprintf_unfiltered (gdb_stdlog,
2876 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2877 (unsigned long) type,
2878 (unsigned long) cnt,
2879 (unsigned long) from_tty,
2880 (unsigned long) retval);
2885 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2889 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2891 fprintf_unfiltered (gdb_stdlog,
2892 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2893 (unsigned long) addr,
2894 (unsigned long) len,
2895 (unsigned long) retval);
2900 debug_to_stopped_by_watchpoint (void)
2904 retval = debug_target.to_stopped_by_watchpoint ();
2906 fprintf_unfiltered (gdb_stdlog,
2907 "STOPPED_BY_WATCHPOINT () = %ld\n",
2908 (unsigned long) retval);
2913 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2917 retval = debug_target.to_stopped_data_address (target, addr);
2919 fprintf_unfiltered (gdb_stdlog,
2920 "target_stopped_data_address ([0x%lx]) = %ld\n",
2921 (unsigned long)*addr,
2922 (unsigned long)retval);
2927 debug_to_watchpoint_addr_within_range (struct target_ops *target,
2929 CORE_ADDR start, int length)
2933 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
2936 fprintf_filtered (gdb_stdlog,
2937 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2938 (unsigned long) addr, (unsigned long) start, length,
2944 debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
2948 retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
2950 fprintf_unfiltered (gdb_stdlog,
2951 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2952 (unsigned long) bp_tgt->placed_address,
2953 (unsigned long) retval);
2958 debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
2962 retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
2964 fprintf_unfiltered (gdb_stdlog,
2965 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2966 (unsigned long) bp_tgt->placed_address,
2967 (unsigned long) retval);
2972 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2976 retval = debug_target.to_insert_watchpoint (addr, len, type);
2978 fprintf_unfiltered (gdb_stdlog,
2979 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2980 (unsigned long) addr, len, type, (unsigned long) retval);
2985 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2989 retval = debug_target.to_remove_watchpoint (addr, len, type);
2991 fprintf_unfiltered (gdb_stdlog,
2992 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2993 (unsigned long) addr, len, type, (unsigned long) retval);
2998 debug_to_terminal_init (void)
3000 debug_target.to_terminal_init ();
3002 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
3006 debug_to_terminal_inferior (void)
3008 debug_target.to_terminal_inferior ();
3010 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
3014 debug_to_terminal_ours_for_output (void)
3016 debug_target.to_terminal_ours_for_output ();
3018 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
3022 debug_to_terminal_ours (void)
3024 debug_target.to_terminal_ours ();
3026 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
3030 debug_to_terminal_save_ours (void)
3032 debug_target.to_terminal_save_ours ();
3034 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
3038 debug_to_terminal_info (char *arg, int from_tty)
3040 debug_target.to_terminal_info (arg, from_tty);
3042 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
3047 debug_to_load (char *args, int from_tty)
3049 debug_target.to_load (args, from_tty);
3051 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
3055 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
3059 retval = debug_target.to_lookup_symbol (name, addrp);
3061 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
3067 debug_to_post_startup_inferior (ptid_t ptid)
3069 debug_target.to_post_startup_inferior (ptid);
3071 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
3076 debug_to_acknowledge_created_inferior (int pid)
3078 debug_target.to_acknowledge_created_inferior (pid);
3080 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
3085 debug_to_insert_fork_catchpoint (int pid)
3087 debug_target.to_insert_fork_catchpoint (pid);
3089 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
3094 debug_to_remove_fork_catchpoint (int pid)
3098 retval = debug_target.to_remove_fork_catchpoint (pid);
3100 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
3107 debug_to_insert_vfork_catchpoint (int pid)
3109 debug_target.to_insert_vfork_catchpoint (pid);
3111 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
3116 debug_to_remove_vfork_catchpoint (int pid)
3120 retval = debug_target.to_remove_vfork_catchpoint (pid);
3122 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
3129 debug_to_insert_exec_catchpoint (int pid)
3131 debug_target.to_insert_exec_catchpoint (pid);
3133 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
3138 debug_to_remove_exec_catchpoint (int pid)
3142 retval = debug_target.to_remove_exec_catchpoint (pid);
3144 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
3151 debug_to_has_exited (int pid, int wait_status, int *exit_status)
3155 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
3157 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
3158 pid, wait_status, *exit_status, has_exited);
3164 debug_to_can_run (void)
3168 retval = debug_target.to_can_run ();
3170 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
3176 debug_to_notice_signals (ptid_t ptid)
3178 debug_target.to_notice_signals (ptid);
3180 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
3185 debug_to_stop (ptid_t ptid)
3187 debug_target.to_stop (ptid);
3189 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
3190 target_pid_to_str (ptid));
3194 debug_to_rcmd (char *command,
3195 struct ui_file *outbuf)
3197 debug_target.to_rcmd (command, outbuf);
3198 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
3202 debug_to_pid_to_exec_file (int pid)
3206 exec_file = debug_target.to_pid_to_exec_file (pid);
3208 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
3215 setup_target_debug (void)
3217 memcpy (&debug_target, ¤t_target, sizeof debug_target);
3219 current_target.to_open = debug_to_open;
3220 current_target.to_post_attach = debug_to_post_attach;
3221 current_target.to_prepare_to_store = debug_to_prepare_to_store;
3222 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
3223 current_target.to_files_info = debug_to_files_info;
3224 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
3225 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
3226 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
3227 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
3228 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
3229 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
3230 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
3231 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
3232 current_target.to_stopped_data_address = debug_to_stopped_data_address;
3233 current_target.to_watchpoint_addr_within_range = debug_to_watchpoint_addr_within_range;
3234 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
3235 current_target.to_terminal_init = debug_to_terminal_init;
3236 current_target.to_terminal_inferior = debug_to_terminal_inferior;
3237 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
3238 current_target.to_terminal_ours = debug_to_terminal_ours;
3239 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
3240 current_target.to_terminal_info = debug_to_terminal_info;
3241 current_target.to_load = debug_to_load;
3242 current_target.to_lookup_symbol = debug_to_lookup_symbol;
3243 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
3244 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
3245 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
3246 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
3247 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
3248 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
3249 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
3250 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
3251 current_target.to_has_exited = debug_to_has_exited;
3252 current_target.to_can_run = debug_to_can_run;
3253 current_target.to_notice_signals = debug_to_notice_signals;
3254 current_target.to_stop = debug_to_stop;
3255 current_target.to_rcmd = debug_to_rcmd;
3256 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
3260 static char targ_desc[] =
3261 "Names of targets and files being debugged.\n\
3262 Shows the entire stack of targets currently in use (including the exec-file,\n\
3263 core-file, and process, if any), as well as the symbol file name.";
3266 do_monitor_command (char *cmd,
3269 if ((current_target.to_rcmd
3270 == (void (*) (char *, struct ui_file *)) tcomplain)
3271 || (current_target.to_rcmd == debug_to_rcmd
3272 && (debug_target.to_rcmd
3273 == (void (*) (char *, struct ui_file *)) tcomplain)))
3274 error (_("\"monitor\" command not supported by this target."));
3275 target_rcmd (cmd, gdb_stdtarg);
3278 /* Print the name of each layers of our target stack. */
3281 maintenance_print_target_stack (char *cmd, int from_tty)
3283 struct target_ops *t;
3285 printf_filtered (_("The current target stack is:\n"));
3287 for (t = target_stack; t != NULL; t = t->beneath)
3289 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3293 /* Controls if async mode is permitted. */
3294 int target_async_permitted = 0;
3296 /* The set command writes to this variable. If the inferior is
3297 executing, linux_nat_async_permitted is *not* updated. */
3298 static int target_async_permitted_1 = 0;
3301 set_maintenance_target_async_permitted (char *args, int from_tty,
3302 struct cmd_list_element *c)
3304 if (target_has_execution)
3306 target_async_permitted_1 = target_async_permitted;
3307 error (_("Cannot change this setting while the inferior is running."));
3310 target_async_permitted = target_async_permitted_1;
3314 show_maintenance_target_async_permitted (struct ui_file *file, int from_tty,
3315 struct cmd_list_element *c,
3318 fprintf_filtered (file, _("\
3319 Controlling the inferior in asynchronous mode is %s.\n"), value);
3323 initialize_targets (void)
3325 init_dummy_target ();
3326 push_target (&dummy_target);
3328 add_info ("target", target_info, targ_desc);
3329 add_info ("files", target_info, targ_desc);
3331 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3332 Set target debugging."), _("\
3333 Show target debugging."), _("\
3334 When non-zero, target debugging is enabled. Higher numbers are more\n\
3335 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3339 &setdebuglist, &showdebuglist);
3341 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
3342 &trust_readonly, _("\
3343 Set mode for reading from readonly sections."), _("\
3344 Show mode for reading from readonly sections."), _("\
3345 When this mode is on, memory reads from readonly sections (such as .text)\n\
3346 will be read from the object file instead of from the target. This will\n\
3347 result in significant performance improvement for remote targets."),
3349 show_trust_readonly,
3350 &setlist, &showlist);
3352 add_com ("monitor", class_obscure, do_monitor_command,
3353 _("Send a command to the remote monitor (remote targets only)."));
3355 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3356 _("Print the name of each layer of the internal target stack."),
3357 &maintenanceprintlist);
3359 add_setshow_boolean_cmd ("target-async", no_class,
3360 &target_async_permitted_1, _("\
3361 Set whether gdb controls the inferior in asynchronous mode."), _("\
3362 Show whether gdb controls the inferior in asynchronous mode."), _("\
3363 Tells gdb whether to control the inferior in asynchronous mode."),
3364 set_maintenance_target_async_permitted,
3365 show_maintenance_target_async_permitted,
3369 target_dcache = dcache_init ();