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 #include "inline-frame.h"
47 static void target_info (char *, int);
49 static void kill_or_be_killed (int);
51 static void default_terminal_info (char *, int);
53 static int default_watchpoint_addr_within_range (struct target_ops *,
54 CORE_ADDR, CORE_ADDR, int);
56 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
58 static int nosymbol (char *, CORE_ADDR *);
60 static void tcomplain (void) ATTR_NORETURN;
62 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
64 static int return_zero (void);
66 static int return_one (void);
68 static int return_minus_one (void);
70 void target_ignore (void);
72 static void target_command (char *, int);
74 static struct target_ops *find_default_run_target (char *);
76 static void nosupport_runtime (void);
78 static LONGEST default_xfer_partial (struct target_ops *ops,
79 enum target_object object,
80 const char *annex, gdb_byte *readbuf,
81 const gdb_byte *writebuf,
82 ULONGEST offset, LONGEST len);
84 static LONGEST current_xfer_partial (struct target_ops *ops,
85 enum target_object object,
86 const char *annex, gdb_byte *readbuf,
87 const gdb_byte *writebuf,
88 ULONGEST offset, LONGEST len);
90 static LONGEST target_xfer_partial (struct target_ops *ops,
91 enum target_object object,
93 void *readbuf, const void *writebuf,
94 ULONGEST offset, LONGEST len);
96 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
99 static void init_dummy_target (void);
101 static struct target_ops debug_target;
103 static void debug_to_open (char *, int);
105 static void debug_to_prepare_to_store (struct regcache *);
107 static void debug_to_files_info (struct target_ops *);
109 static int debug_to_insert_breakpoint (struct gdbarch *,
110 struct bp_target_info *);
112 static int debug_to_remove_breakpoint (struct gdbarch *,
113 struct bp_target_info *);
115 static int debug_to_can_use_hw_breakpoint (int, int, int);
117 static int debug_to_insert_hw_breakpoint (struct gdbarch *,
118 struct bp_target_info *);
120 static int debug_to_remove_hw_breakpoint (struct gdbarch *,
121 struct bp_target_info *);
123 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
125 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
127 static int debug_to_stopped_by_watchpoint (void);
129 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
131 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
132 CORE_ADDR, CORE_ADDR, int);
134 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
136 static void debug_to_terminal_init (void);
138 static void debug_to_terminal_inferior (void);
140 static void debug_to_terminal_ours_for_output (void);
142 static void debug_to_terminal_save_ours (void);
144 static void debug_to_terminal_ours (void);
146 static void debug_to_terminal_info (char *, int);
148 static void debug_to_load (char *, int);
150 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
152 static int debug_to_can_run (void);
154 static void debug_to_notice_signals (ptid_t);
156 static void debug_to_stop (ptid_t);
158 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
159 wierd and mysterious ways. Putting the variable here lets those
160 wierd and mysterious ways keep building while they are being
161 converted to the inferior inheritance structure. */
162 struct target_ops deprecated_child_ops;
164 /* Pointer to array of target architecture structures; the size of the
165 array; the current index into the array; the allocated size of the
167 struct target_ops **target_structs;
168 unsigned target_struct_size;
169 unsigned target_struct_index;
170 unsigned target_struct_allocsize;
171 #define DEFAULT_ALLOCSIZE 10
173 /* The initial current target, so that there is always a semi-valid
176 static struct target_ops dummy_target;
178 /* Top of target stack. */
180 static struct target_ops *target_stack;
182 /* The target structure we are currently using to talk to a process
183 or file or whatever "inferior" we have. */
185 struct target_ops current_target;
187 /* Command list for target. */
189 static struct cmd_list_element *targetlist = NULL;
191 /* Nonzero if we should trust readonly sections from the
192 executable when reading memory. */
194 static int trust_readonly = 0;
196 /* Nonzero if we should show true memory content including
197 memory breakpoint inserted by gdb. */
199 static int show_memory_breakpoints = 0;
201 /* Non-zero if we want to see trace of target level stuff. */
203 static int targetdebug = 0;
205 show_targetdebug (struct ui_file *file, int from_tty,
206 struct cmd_list_element *c, const char *value)
208 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
211 static void setup_target_debug (void);
213 /* The option sets this. */
214 static int stack_cache_enabled_p_1 = 1;
215 /* And set_stack_cache_enabled_p updates this.
216 The reason for the separation is so that we don't flush the cache for
217 on->on transitions. */
218 static int stack_cache_enabled_p = 1;
220 /* This is called *after* the stack-cache has been set.
221 Flush the cache for off->on and on->off transitions.
222 There's no real need to flush the cache for on->off transitions,
223 except cleanliness. */
226 set_stack_cache_enabled_p (char *args, int from_tty,
227 struct cmd_list_element *c)
229 if (stack_cache_enabled_p != stack_cache_enabled_p_1)
230 target_dcache_invalidate ();
232 stack_cache_enabled_p = stack_cache_enabled_p_1;
236 show_stack_cache_enabled_p (struct ui_file *file, int from_tty,
237 struct cmd_list_element *c, const char *value)
239 fprintf_filtered (file, _("Cache use for stack accesses is %s.\n"), value);
242 /* Cache of memory operations, to speed up remote access. */
243 static DCACHE *target_dcache;
245 /* Invalidate the target dcache. */
248 target_dcache_invalidate (void)
250 dcache_invalidate (target_dcache);
253 /* The user just typed 'target' without the name of a target. */
256 target_command (char *arg, int from_tty)
258 fputs_filtered ("Argument required (target name). Try `help target'\n",
262 /* Default target_has_* methods for process_stratum targets. */
265 default_child_has_all_memory (struct target_ops *ops)
267 /* If no inferior selected, then we can't read memory here. */
268 if (ptid_equal (inferior_ptid, null_ptid))
275 default_child_has_memory (struct target_ops *ops)
277 /* If no inferior selected, then we can't read memory here. */
278 if (ptid_equal (inferior_ptid, null_ptid))
285 default_child_has_stack (struct target_ops *ops)
287 /* If no inferior selected, there's no stack. */
288 if (ptid_equal (inferior_ptid, null_ptid))
295 default_child_has_registers (struct target_ops *ops)
297 /* Can't read registers from no inferior. */
298 if (ptid_equal (inferior_ptid, null_ptid))
305 default_child_has_execution (struct target_ops *ops)
307 /* If there's no thread selected, then we can't make it run through
309 if (ptid_equal (inferior_ptid, null_ptid))
317 target_has_all_memory_1 (void)
319 struct target_ops *t;
321 for (t = current_target.beneath; t != NULL; t = t->beneath)
322 if (t->to_has_all_memory (t))
329 target_has_memory_1 (void)
331 struct target_ops *t;
333 for (t = current_target.beneath; t != NULL; t = t->beneath)
334 if (t->to_has_memory (t))
341 target_has_stack_1 (void)
343 struct target_ops *t;
345 for (t = current_target.beneath; t != NULL; t = t->beneath)
346 if (t->to_has_stack (t))
353 target_has_registers_1 (void)
355 struct target_ops *t;
357 for (t = current_target.beneath; t != NULL; t = t->beneath)
358 if (t->to_has_registers (t))
365 target_has_execution_1 (void)
367 struct target_ops *t;
369 for (t = current_target.beneath; t != NULL; t = t->beneath)
370 if (t->to_has_execution (t))
376 /* Add a possible target architecture to the list. */
379 add_target (struct target_ops *t)
381 /* Provide default values for all "must have" methods. */
382 if (t->to_xfer_partial == NULL)
383 t->to_xfer_partial = default_xfer_partial;
385 if (t->to_has_all_memory == NULL)
386 t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
388 if (t->to_has_memory == NULL)
389 t->to_has_memory = (int (*) (struct target_ops *)) return_zero;
391 if (t->to_has_stack == NULL)
392 t->to_has_stack = (int (*) (struct target_ops *)) return_zero;
394 if (t->to_has_registers == NULL)
395 t->to_has_registers = (int (*) (struct target_ops *)) return_zero;
397 if (t->to_has_execution == NULL)
398 t->to_has_execution = (int (*) (struct target_ops *)) return_zero;
402 target_struct_allocsize = DEFAULT_ALLOCSIZE;
403 target_structs = (struct target_ops **) xmalloc
404 (target_struct_allocsize * sizeof (*target_structs));
406 if (target_struct_size >= target_struct_allocsize)
408 target_struct_allocsize *= 2;
409 target_structs = (struct target_ops **)
410 xrealloc ((char *) target_structs,
411 target_struct_allocsize * sizeof (*target_structs));
413 target_structs[target_struct_size++] = t;
415 if (targetlist == NULL)
416 add_prefix_cmd ("target", class_run, target_command, _("\
417 Connect to a target machine or process.\n\
418 The first argument is the type or protocol of the target machine.\n\
419 Remaining arguments are interpreted by the target protocol. For more\n\
420 information on the arguments for a particular protocol, type\n\
421 `help target ' followed by the protocol name."),
422 &targetlist, "target ", 0, &cmdlist);
423 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
436 struct target_ops *t;
438 for (t = current_target.beneath; t != NULL; t = t->beneath)
439 if (t->to_kill != NULL)
442 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
452 target_load (char *arg, int from_tty)
454 target_dcache_invalidate ();
455 (*current_target.to_load) (arg, from_tty);
459 target_create_inferior (char *exec_file, char *args,
460 char **env, int from_tty)
462 struct target_ops *t;
463 for (t = current_target.beneath; t != NULL; t = t->beneath)
465 if (t->to_create_inferior != NULL)
467 t->to_create_inferior (t, exec_file, args, env, from_tty);
469 fprintf_unfiltered (gdb_stdlog,
470 "target_create_inferior (%s, %s, xxx, %d)\n",
471 exec_file, args, from_tty);
476 internal_error (__FILE__, __LINE__,
477 "could not find a target to create inferior");
481 target_terminal_inferior (void)
483 /* A background resume (``run&'') should leave GDB in control of the
485 if (target_is_async_p () && !sync_execution)
488 /* If GDB is resuming the inferior in the foreground, install
489 inferior's terminal modes. */
490 (*current_target.to_terminal_inferior) ();
494 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
495 struct target_ops *t)
497 errno = EIO; /* Can't read/write this location */
498 return 0; /* No bytes handled */
504 error (_("You can't do that when your target is `%s'"),
505 current_target.to_shortname);
511 error (_("You can't do that without a process to debug."));
515 nosymbol (char *name, CORE_ADDR *addrp)
517 return 1; /* Symbol does not exist in target env */
521 nosupport_runtime (void)
523 if (ptid_equal (inferior_ptid, null_ptid))
526 error (_("No run-time support for this"));
531 default_terminal_info (char *args, int from_tty)
533 printf_unfiltered (_("No saved terminal information.\n"));
536 /* This is the default target_create_inferior and target_attach function.
537 If the current target is executing, it asks whether to kill it off.
538 If this function returns without calling error(), it has killed off
539 the target, and the operation should be attempted. */
542 kill_or_be_killed (int from_tty)
544 if (target_has_execution)
546 printf_unfiltered (_("You are already running a program:\n"));
547 target_files_info ();
548 if (query (_("Kill it? ")))
551 if (target_has_execution)
552 error (_("Killing the program did not help."));
557 error (_("Program not killed."));
563 /* A default implementation for the to_get_ada_task_ptid target method.
565 This function builds the PTID by using both LWP and TID as part of
566 the PTID lwp and tid elements. The pid used is the pid of the
570 default_get_ada_task_ptid (long lwp, long tid)
572 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
575 /* Go through the target stack from top to bottom, copying over zero
576 entries in current_target, then filling in still empty entries. In
577 effect, we are doing class inheritance through the pushed target
580 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
581 is currently implemented, is that it discards any knowledge of
582 which target an inherited method originally belonged to.
583 Consequently, new new target methods should instead explicitly and
584 locally search the target stack for the target that can handle the
588 update_current_target (void)
590 struct target_ops *t;
592 /* First, reset current's contents. */
593 memset (¤t_target, 0, sizeof (current_target));
595 #define INHERIT(FIELD, TARGET) \
596 if (!current_target.FIELD) \
597 current_target.FIELD = (TARGET)->FIELD
599 for (t = target_stack; t; t = t->beneath)
601 INHERIT (to_shortname, t);
602 INHERIT (to_longname, t);
604 /* Do not inherit to_open. */
605 /* Do not inherit to_close. */
606 /* Do not inherit to_attach. */
607 INHERIT (to_post_attach, t);
608 INHERIT (to_attach_no_wait, t);
609 /* Do not inherit to_detach. */
610 /* Do not inherit to_disconnect. */
611 /* Do not inherit to_resume. */
612 /* Do not inherit to_wait. */
613 /* Do not inherit to_fetch_registers. */
614 /* Do not inherit to_store_registers. */
615 INHERIT (to_prepare_to_store, t);
616 INHERIT (deprecated_xfer_memory, t);
617 INHERIT (to_files_info, t);
618 INHERIT (to_insert_breakpoint, t);
619 INHERIT (to_remove_breakpoint, t);
620 INHERIT (to_can_use_hw_breakpoint, t);
621 INHERIT (to_insert_hw_breakpoint, t);
622 INHERIT (to_remove_hw_breakpoint, t);
623 INHERIT (to_insert_watchpoint, t);
624 INHERIT (to_remove_watchpoint, t);
625 INHERIT (to_stopped_data_address, t);
626 INHERIT (to_have_steppable_watchpoint, t);
627 INHERIT (to_have_continuable_watchpoint, t);
628 INHERIT (to_stopped_by_watchpoint, t);
629 INHERIT (to_watchpoint_addr_within_range, t);
630 INHERIT (to_region_ok_for_hw_watchpoint, t);
631 INHERIT (to_terminal_init, t);
632 INHERIT (to_terminal_inferior, t);
633 INHERIT (to_terminal_ours_for_output, t);
634 INHERIT (to_terminal_ours, t);
635 INHERIT (to_terminal_save_ours, t);
636 INHERIT (to_terminal_info, t);
637 /* Do not inherit to_kill. */
638 INHERIT (to_load, t);
639 INHERIT (to_lookup_symbol, t);
640 /* Do no inherit to_create_inferior. */
641 INHERIT (to_post_startup_inferior, t);
642 INHERIT (to_acknowledge_created_inferior, t);
643 INHERIT (to_insert_fork_catchpoint, t);
644 INHERIT (to_remove_fork_catchpoint, t);
645 INHERIT (to_insert_vfork_catchpoint, t);
646 INHERIT (to_remove_vfork_catchpoint, t);
647 /* Do not inherit to_follow_fork. */
648 INHERIT (to_insert_exec_catchpoint, t);
649 INHERIT (to_remove_exec_catchpoint, t);
650 INHERIT (to_has_exited, t);
651 /* Do not inherit to_mourn_inferiour. */
652 INHERIT (to_can_run, t);
653 INHERIT (to_notice_signals, t);
654 /* Do not inherit to_thread_alive. */
655 /* Do not inherit to_find_new_threads. */
656 /* Do not inherit to_pid_to_str. */
657 INHERIT (to_extra_thread_info, t);
658 INHERIT (to_stop, t);
659 /* Do not inherit to_xfer_partial. */
660 INHERIT (to_rcmd, t);
661 INHERIT (to_pid_to_exec_file, t);
662 INHERIT (to_log_command, t);
663 INHERIT (to_stratum, t);
664 /* Do not inherit to_has_all_memory */
665 /* Do not inherit to_has_memory */
666 /* Do not inherit to_has_stack */
667 /* Do not inherit to_has_registers */
668 /* Do not inherit to_has_execution */
669 INHERIT (to_has_thread_control, t);
670 INHERIT (to_can_async_p, t);
671 INHERIT (to_is_async_p, t);
672 INHERIT (to_async, t);
673 INHERIT (to_async_mask, t);
674 INHERIT (to_find_memory_regions, t);
675 INHERIT (to_make_corefile_notes, t);
676 /* Do not inherit to_get_thread_local_address. */
677 INHERIT (to_can_execute_reverse, t);
678 INHERIT (to_thread_architecture, t);
679 /* Do not inherit to_read_description. */
680 INHERIT (to_get_ada_task_ptid, t);
681 /* Do not inherit to_search_memory. */
682 INHERIT (to_supports_multi_process, t);
683 INHERIT (to_magic, t);
684 /* Do not inherit to_memory_map. */
685 /* Do not inherit to_flash_erase. */
686 /* Do not inherit to_flash_done. */
690 /* Clean up a target struct so it no longer has any zero pointers in
691 it. Some entries are defaulted to a method that print an error,
692 others are hard-wired to a standard recursive default. */
694 #define de_fault(field, value) \
695 if (!current_target.field) \
696 current_target.field = value
699 (void (*) (char *, int))
704 de_fault (to_post_attach,
707 de_fault (to_prepare_to_store,
708 (void (*) (struct regcache *))
710 de_fault (deprecated_xfer_memory,
711 (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
713 de_fault (to_files_info,
714 (void (*) (struct target_ops *))
716 de_fault (to_insert_breakpoint,
717 memory_insert_breakpoint);
718 de_fault (to_remove_breakpoint,
719 memory_remove_breakpoint);
720 de_fault (to_can_use_hw_breakpoint,
721 (int (*) (int, int, int))
723 de_fault (to_insert_hw_breakpoint,
724 (int (*) (struct gdbarch *, struct bp_target_info *))
726 de_fault (to_remove_hw_breakpoint,
727 (int (*) (struct gdbarch *, struct bp_target_info *))
729 de_fault (to_insert_watchpoint,
730 (int (*) (CORE_ADDR, int, int))
732 de_fault (to_remove_watchpoint,
733 (int (*) (CORE_ADDR, int, int))
735 de_fault (to_stopped_by_watchpoint,
738 de_fault (to_stopped_data_address,
739 (int (*) (struct target_ops *, CORE_ADDR *))
741 de_fault (to_watchpoint_addr_within_range,
742 default_watchpoint_addr_within_range);
743 de_fault (to_region_ok_for_hw_watchpoint,
744 default_region_ok_for_hw_watchpoint);
745 de_fault (to_terminal_init,
748 de_fault (to_terminal_inferior,
751 de_fault (to_terminal_ours_for_output,
754 de_fault (to_terminal_ours,
757 de_fault (to_terminal_save_ours,
760 de_fault (to_terminal_info,
761 default_terminal_info);
763 (void (*) (char *, int))
765 de_fault (to_lookup_symbol,
766 (int (*) (char *, CORE_ADDR *))
768 de_fault (to_post_startup_inferior,
771 de_fault (to_acknowledge_created_inferior,
774 de_fault (to_insert_fork_catchpoint,
777 de_fault (to_remove_fork_catchpoint,
780 de_fault (to_insert_vfork_catchpoint,
783 de_fault (to_remove_vfork_catchpoint,
786 de_fault (to_insert_exec_catchpoint,
789 de_fault (to_remove_exec_catchpoint,
792 de_fault (to_has_exited,
793 (int (*) (int, int, int *))
795 de_fault (to_can_run,
797 de_fault (to_notice_signals,
800 de_fault (to_extra_thread_info,
801 (char *(*) (struct thread_info *))
806 current_target.to_xfer_partial = current_xfer_partial;
808 (void (*) (char *, struct ui_file *))
810 de_fault (to_pid_to_exec_file,
814 (void (*) (void (*) (enum inferior_event_type, void*), void*))
816 de_fault (to_async_mask,
819 de_fault (to_thread_architecture,
820 default_thread_architecture);
821 current_target.to_read_description = NULL;
822 de_fault (to_get_ada_task_ptid,
823 (ptid_t (*) (long, long))
824 default_get_ada_task_ptid);
825 de_fault (to_supports_multi_process,
830 /* Finally, position the target-stack beneath the squashed
831 "current_target". That way code looking for a non-inherited
832 target method can quickly and simply find it. */
833 current_target.beneath = target_stack;
836 setup_target_debug ();
839 /* Push a new target type into the stack of the existing target accessors,
840 possibly superseding some of the existing accessors.
842 Result is zero if the pushed target ended up on top of the stack,
843 nonzero if at least one target is on top of it.
845 Rather than allow an empty stack, we always have the dummy target at
846 the bottom stratum, so we can call the function vectors without
850 push_target (struct target_ops *t)
852 struct target_ops **cur;
854 /* Check magic number. If wrong, it probably means someone changed
855 the struct definition, but not all the places that initialize one. */
856 if (t->to_magic != OPS_MAGIC)
858 fprintf_unfiltered (gdb_stderr,
859 "Magic number of %s target struct wrong\n",
861 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
864 /* Find the proper stratum to install this target in. */
865 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
867 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
871 /* If there's already targets at this stratum, remove them. */
872 /* FIXME: cagney/2003-10-15: I think this should be popping all
873 targets to CUR, and not just those at this stratum level. */
874 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
876 /* There's already something at this stratum level. Close it,
877 and un-hook it from the stack. */
878 struct target_ops *tmp = (*cur);
879 (*cur) = (*cur)->beneath;
881 target_close (tmp, 0);
884 /* We have removed all targets in our stratum, now add the new one. */
888 update_current_target ();
891 return (t != target_stack);
894 /* Remove a target_ops vector from the stack, wherever it may be.
895 Return how many times it was removed (0 or 1). */
898 unpush_target (struct target_ops *t)
900 struct target_ops **cur;
901 struct target_ops *tmp;
903 if (t->to_stratum == dummy_stratum)
904 internal_error (__FILE__, __LINE__,
905 "Attempt to unpush the dummy target");
907 /* Look for the specified target. Note that we assume that a target
908 can only occur once in the target stack. */
910 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
917 return 0; /* Didn't find target_ops, quit now */
919 /* NOTE: cagney/2003-12-06: In '94 the close call was made
920 unconditional by moving it to before the above check that the
921 target was in the target stack (something about "Change the way
922 pushing and popping of targets work to support target overlays
923 and inheritance"). This doesn't make much sense - only open
924 targets should be closed. */
927 /* Unchain the target */
929 (*cur) = (*cur)->beneath;
932 update_current_target ();
940 target_close (target_stack, 0); /* Let it clean up */
941 if (unpush_target (target_stack) == 1)
944 fprintf_unfiltered (gdb_stderr,
945 "pop_target couldn't find target %s\n",
946 current_target.to_shortname);
947 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
951 pop_all_targets_above (enum strata above_stratum, int quitting)
953 while ((int) (current_target.to_stratum) > (int) above_stratum)
955 target_close (target_stack, quitting);
956 if (!unpush_target (target_stack))
958 fprintf_unfiltered (gdb_stderr,
959 "pop_all_targets couldn't find target %s\n",
960 target_stack->to_shortname);
961 internal_error (__FILE__, __LINE__,
962 _("failed internal consistency check"));
969 pop_all_targets (int quitting)
971 pop_all_targets_above (dummy_stratum, quitting);
974 /* Using the objfile specified in OBJFILE, find the address for the
975 current thread's thread-local storage with offset OFFSET. */
977 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
979 volatile CORE_ADDR addr = 0;
980 struct target_ops *target;
982 for (target = current_target.beneath;
984 target = target->beneath)
986 if (target->to_get_thread_local_address != NULL)
991 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
993 ptid_t ptid = inferior_ptid;
994 volatile struct gdb_exception ex;
996 TRY_CATCH (ex, RETURN_MASK_ALL)
1000 /* Fetch the load module address for this objfile. */
1001 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
1003 /* If it's 0, throw the appropriate exception. */
1005 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
1006 _("TLS load module not found"));
1008 addr = target->to_get_thread_local_address (target, ptid, lm_addr, offset);
1010 /* If an error occurred, print TLS related messages here. Otherwise,
1011 throw the error to some higher catcher. */
1014 int objfile_is_library = (objfile->flags & OBJF_SHARED);
1018 case TLS_NO_LIBRARY_SUPPORT_ERROR:
1019 error (_("Cannot find thread-local variables in this thread library."));
1021 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
1022 if (objfile_is_library)
1023 error (_("Cannot find shared library `%s' in dynamic"
1024 " linker's load module list"), objfile->name);
1026 error (_("Cannot find executable file `%s' in dynamic"
1027 " linker's load module list"), objfile->name);
1029 case TLS_NOT_ALLOCATED_YET_ERROR:
1030 if (objfile_is_library)
1031 error (_("The inferior has not yet allocated storage for"
1032 " thread-local variables in\n"
1033 "the shared library `%s'\n"
1035 objfile->name, target_pid_to_str (ptid));
1037 error (_("The inferior has not yet allocated storage for"
1038 " thread-local variables in\n"
1039 "the executable `%s'\n"
1041 objfile->name, target_pid_to_str (ptid));
1043 case TLS_GENERIC_ERROR:
1044 if (objfile_is_library)
1045 error (_("Cannot find thread-local storage for %s, "
1046 "shared library %s:\n%s"),
1047 target_pid_to_str (ptid),
1048 objfile->name, ex.message);
1050 error (_("Cannot find thread-local storage for %s, "
1051 "executable file %s:\n%s"),
1052 target_pid_to_str (ptid),
1053 objfile->name, ex.message);
1056 throw_exception (ex);
1061 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1062 TLS is an ABI-specific thing. But we don't do that yet. */
1064 error (_("Cannot find thread-local variables on this target"));
1070 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1072 /* target_read_string -- read a null terminated string, up to LEN bytes,
1073 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1074 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1075 is responsible for freeing it. Return the number of bytes successfully
1079 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
1081 int tlen, origlen, offset, i;
1085 int buffer_allocated;
1087 unsigned int nbytes_read = 0;
1089 gdb_assert (string);
1091 /* Small for testing. */
1092 buffer_allocated = 4;
1093 buffer = xmalloc (buffer_allocated);
1100 tlen = MIN (len, 4 - (memaddr & 3));
1101 offset = memaddr & 3;
1103 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
1106 /* The transfer request might have crossed the boundary to an
1107 unallocated region of memory. Retry the transfer, requesting
1111 errcode = target_read_memory (memaddr, buf, 1);
1116 if (bufptr - buffer + tlen > buffer_allocated)
1119 bytes = bufptr - buffer;
1120 buffer_allocated *= 2;
1121 buffer = xrealloc (buffer, buffer_allocated);
1122 bufptr = buffer + bytes;
1125 for (i = 0; i < tlen; i++)
1127 *bufptr++ = buf[i + offset];
1128 if (buf[i + offset] == '\000')
1130 nbytes_read += i + 1;
1137 nbytes_read += tlen;
1146 struct target_section_table *
1147 target_get_section_table (struct target_ops *target)
1149 struct target_ops *t;
1152 fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
1154 for (t = target; t != NULL; t = t->beneath)
1155 if (t->to_get_section_table != NULL)
1156 return (*t->to_get_section_table) (t);
1161 /* Find a section containing ADDR. */
1163 struct target_section *
1164 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1166 struct target_section_table *table = target_get_section_table (target);
1167 struct target_section *secp;
1172 for (secp = table->sections; secp < table->sections_end; secp++)
1174 if (addr >= secp->addr && addr < secp->endaddr)
1180 /* Perform a partial memory transfer. The arguments and return
1181 value are just as for target_xfer_partial. */
1184 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1185 void *readbuf, const void *writebuf, ULONGEST memaddr,
1190 struct mem_region *region;
1191 struct inferior *inf;
1193 /* Zero length requests are ok and require no work. */
1197 /* For accesses to unmapped overlay sections, read directly from
1198 files. Must do this first, as MEMADDR may need adjustment. */
1199 if (readbuf != NULL && overlay_debugging)
1201 struct obj_section *section = find_pc_overlay (memaddr);
1202 if (pc_in_unmapped_range (memaddr, section))
1204 struct target_section_table *table
1205 = target_get_section_table (ops);
1206 const char *section_name = section->the_bfd_section->name;
1207 memaddr = overlay_mapped_address (memaddr, section);
1208 return section_table_xfer_memory_partial (readbuf, writebuf,
1211 table->sections_end,
1216 /* Try the executable files, if "trust-readonly-sections" is set. */
1217 if (readbuf != NULL && trust_readonly)
1219 struct target_section *secp;
1220 struct target_section_table *table;
1222 secp = target_section_by_addr (ops, memaddr);
1224 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1227 table = target_get_section_table (ops);
1228 return section_table_xfer_memory_partial (readbuf, writebuf,
1231 table->sections_end,
1236 /* Try GDB's internal data cache. */
1237 region = lookup_mem_region (memaddr);
1238 /* region->hi == 0 means there's no upper bound. */
1239 if (memaddr + len < region->hi || region->hi == 0)
1242 reg_len = region->hi - memaddr;
1244 switch (region->attrib.mode)
1247 if (writebuf != NULL)
1252 if (readbuf != NULL)
1257 /* We only support writing to flash during "load" for now. */
1258 if (writebuf != NULL)
1259 error (_("Writing to flash memory forbidden in this context"));
1266 inf = find_inferior_pid (ptid_get_pid (inferior_ptid));
1269 && (region->attrib.cache
1270 || (stack_cache_enabled_p && object == TARGET_OBJECT_STACK_MEMORY)))
1272 if (readbuf != NULL)
1273 res = dcache_xfer_memory (ops, target_dcache, memaddr, readbuf,
1276 /* FIXME drow/2006-08-09: If we're going to preserve const
1277 correctness dcache_xfer_memory should take readbuf and
1279 res = dcache_xfer_memory (ops, target_dcache, memaddr,
1286 if (readbuf && !show_memory_breakpoints)
1287 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1292 /* Make sure the cache gets updated no matter what - if we are writing
1293 to the stack, even if this write is not tagged as such, we still need
1294 to update the cache. */
1298 && !region->attrib.cache
1299 && stack_cache_enabled_p
1300 && object != TARGET_OBJECT_STACK_MEMORY)
1302 dcache_update (target_dcache, memaddr, (void *) writebuf, reg_len);
1305 /* If none of those methods found the memory we wanted, fall back
1306 to a target partial transfer. Normally a single call to
1307 to_xfer_partial is enough; if it doesn't recognize an object
1308 it will call the to_xfer_partial of the next target down.
1309 But for memory this won't do. Memory is the only target
1310 object which can be read from more than one valid target.
1311 A core file, for instance, could have some of memory but
1312 delegate other bits to the target below it. So, we must
1313 manually try all targets. */
1317 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1318 readbuf, writebuf, memaddr, reg_len);
1322 /* We want to continue past core files to executables, but not
1323 past a running target's memory. */
1324 if (ops->to_has_all_memory (ops))
1329 while (ops != NULL);
1331 if (readbuf && !show_memory_breakpoints)
1332 breakpoint_restore_shadows (readbuf, memaddr, reg_len);
1334 /* If we still haven't got anything, return the last error. We
1340 restore_show_memory_breakpoints (void *arg)
1342 show_memory_breakpoints = (uintptr_t) arg;
1346 make_show_memory_breakpoints_cleanup (int show)
1348 int current = show_memory_breakpoints;
1349 show_memory_breakpoints = show;
1351 return make_cleanup (restore_show_memory_breakpoints,
1352 (void *) (uintptr_t) current);
1356 target_xfer_partial (struct target_ops *ops,
1357 enum target_object object, const char *annex,
1358 void *readbuf, const void *writebuf,
1359 ULONGEST offset, LONGEST len)
1363 gdb_assert (ops->to_xfer_partial != NULL);
1365 /* If this is a memory transfer, let the memory-specific code
1366 have a look at it instead. Memory transfers are more
1368 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY)
1369 retval = memory_xfer_partial (ops, object, readbuf,
1370 writebuf, offset, len);
1373 enum target_object raw_object = object;
1375 /* If this is a raw memory transfer, request the normal
1376 memory object from other layers. */
1377 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1378 raw_object = TARGET_OBJECT_MEMORY;
1380 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1381 writebuf, offset, len);
1386 const unsigned char *myaddr = NULL;
1388 fprintf_unfiltered (gdb_stdlog,
1389 "%s:target_xfer_partial (%d, %s, %s, %s, %s, %s) = %s",
1392 (annex ? annex : "(null)"),
1393 host_address_to_string (readbuf),
1394 host_address_to_string (writebuf),
1395 core_addr_to_string_nz (offset),
1396 plongest (len), plongest (retval));
1402 if (retval > 0 && myaddr != NULL)
1406 fputs_unfiltered (", bytes =", gdb_stdlog);
1407 for (i = 0; i < retval; i++)
1409 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1411 if (targetdebug < 2 && i > 0)
1413 fprintf_unfiltered (gdb_stdlog, " ...");
1416 fprintf_unfiltered (gdb_stdlog, "\n");
1419 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1423 fputc_unfiltered ('\n', gdb_stdlog);
1428 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1429 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1430 if any error occurs.
1432 If an error occurs, no guarantee is made about the contents of the data at
1433 MYADDR. In particular, the caller should not depend upon partial reads
1434 filling the buffer with good data. There is no way for the caller to know
1435 how much good data might have been transfered anyway. Callers that can
1436 deal with partial reads should call target_read (which will retry until
1437 it makes no progress, and then return how much was transferred). */
1440 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1442 /* Dispatch to the topmost target, not the flattened current_target.
1443 Memory accesses check target->to_has_(all_)memory, and the
1444 flattened target doesn't inherit those. */
1445 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1446 myaddr, memaddr, len) == len)
1452 /* Like target_read_memory, but specify explicitly that this is a read from
1453 the target's stack. This may trigger different cache behavior. */
1456 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1458 /* Dispatch to the topmost target, not the flattened current_target.
1459 Memory accesses check target->to_has_(all_)memory, and the
1460 flattened target doesn't inherit those. */
1462 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1463 myaddr, memaddr, len) == len)
1470 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1472 /* Dispatch to the topmost target, not the flattened current_target.
1473 Memory accesses check target->to_has_(all_)memory, and the
1474 flattened target doesn't inherit those. */
1475 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1476 myaddr, memaddr, len) == len)
1482 /* Fetch the target's memory map. */
1485 target_memory_map (void)
1487 VEC(mem_region_s) *result;
1488 struct mem_region *last_one, *this_one;
1490 struct target_ops *t;
1493 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1495 for (t = current_target.beneath; t != NULL; t = t->beneath)
1496 if (t->to_memory_map != NULL)
1502 result = t->to_memory_map (t);
1506 qsort (VEC_address (mem_region_s, result),
1507 VEC_length (mem_region_s, result),
1508 sizeof (struct mem_region), mem_region_cmp);
1510 /* Check that regions do not overlap. Simultaneously assign
1511 a numbering for the "mem" commands to use to refer to
1514 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1516 this_one->number = ix;
1518 if (last_one && last_one->hi > this_one->lo)
1520 warning (_("Overlapping regions in memory map: ignoring"));
1521 VEC_free (mem_region_s, result);
1524 last_one = this_one;
1531 target_flash_erase (ULONGEST address, LONGEST length)
1533 struct target_ops *t;
1535 for (t = current_target.beneath; t != NULL; t = t->beneath)
1536 if (t->to_flash_erase != NULL)
1539 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1540 hex_string (address), phex (length, 0));
1541 t->to_flash_erase (t, address, length);
1549 target_flash_done (void)
1551 struct target_ops *t;
1553 for (t = current_target.beneath; t != NULL; t = t->beneath)
1554 if (t->to_flash_done != NULL)
1557 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1558 t->to_flash_done (t);
1566 show_trust_readonly (struct ui_file *file, int from_tty,
1567 struct cmd_list_element *c, const char *value)
1569 fprintf_filtered (file, _("\
1570 Mode for reading from readonly sections is %s.\n"),
1574 /* More generic transfers. */
1577 default_xfer_partial (struct target_ops *ops, enum target_object object,
1578 const char *annex, gdb_byte *readbuf,
1579 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1581 if (object == TARGET_OBJECT_MEMORY
1582 && ops->deprecated_xfer_memory != NULL)
1583 /* If available, fall back to the target's
1584 "deprecated_xfer_memory" method. */
1588 if (writebuf != NULL)
1590 void *buffer = xmalloc (len);
1591 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1592 memcpy (buffer, writebuf, len);
1593 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1594 1/*write*/, NULL, ops);
1595 do_cleanups (cleanup);
1597 if (readbuf != NULL)
1598 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1599 0/*read*/, NULL, ops);
1602 else if (xfered == 0 && errno == 0)
1603 /* "deprecated_xfer_memory" uses 0, cross checked against
1604 ERRNO as one indication of an error. */
1609 else if (ops->beneath != NULL)
1610 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1611 readbuf, writebuf, offset, len);
1616 /* The xfer_partial handler for the topmost target. Unlike the default,
1617 it does not need to handle memory specially; it just passes all
1618 requests down the stack. */
1621 current_xfer_partial (struct target_ops *ops, enum target_object object,
1622 const char *annex, gdb_byte *readbuf,
1623 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1625 if (ops->beneath != NULL)
1626 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1627 readbuf, writebuf, offset, len);
1632 /* Target vector read/write partial wrapper functions.
1634 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1635 (inbuf, outbuf)", instead of separate read/write methods, make life
1639 target_read_partial (struct target_ops *ops,
1640 enum target_object object,
1641 const char *annex, gdb_byte *buf,
1642 ULONGEST offset, LONGEST len)
1644 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1648 target_write_partial (struct target_ops *ops,
1649 enum target_object object,
1650 const char *annex, const gdb_byte *buf,
1651 ULONGEST offset, LONGEST len)
1653 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1656 /* Wrappers to perform the full transfer. */
1658 target_read (struct target_ops *ops,
1659 enum target_object object,
1660 const char *annex, gdb_byte *buf,
1661 ULONGEST offset, LONGEST len)
1664 while (xfered < len)
1666 LONGEST xfer = target_read_partial (ops, object, annex,
1667 (gdb_byte *) buf + xfered,
1668 offset + xfered, len - xfered);
1669 /* Call an observer, notifying them of the xfer progress? */
1681 target_read_until_error (struct target_ops *ops,
1682 enum target_object object,
1683 const char *annex, gdb_byte *buf,
1684 ULONGEST offset, LONGEST len)
1687 while (xfered < len)
1689 LONGEST xfer = target_read_partial (ops, object, annex,
1690 (gdb_byte *) buf + xfered,
1691 offset + xfered, len - xfered);
1692 /* Call an observer, notifying them of the xfer progress? */
1697 /* We've got an error. Try to read in smaller blocks. */
1698 ULONGEST start = offset + xfered;
1699 ULONGEST remaining = len - xfered;
1702 /* If an attempt was made to read a random memory address,
1703 it's likely that the very first byte is not accessible.
1704 Try reading the first byte, to avoid doing log N tries
1706 xfer = target_read_partial (ops, object, annex,
1707 (gdb_byte *) buf + xfered, start, 1);
1716 xfer = target_read_partial (ops, object, annex,
1717 (gdb_byte *) buf + xfered,
1727 /* We have successfully read the first half. So, the
1728 error must be in the second half. Adjust start and
1729 remaining to point at the second half. */
1746 /* An alternative to target_write with progress callbacks. */
1749 target_write_with_progress (struct target_ops *ops,
1750 enum target_object object,
1751 const char *annex, const gdb_byte *buf,
1752 ULONGEST offset, LONGEST len,
1753 void (*progress) (ULONGEST, void *), void *baton)
1757 /* Give the progress callback a chance to set up. */
1759 (*progress) (0, baton);
1761 while (xfered < len)
1763 LONGEST xfer = target_write_partial (ops, object, annex,
1764 (gdb_byte *) buf + xfered,
1765 offset + xfered, len - xfered);
1773 (*progress) (xfer, baton);
1782 target_write (struct target_ops *ops,
1783 enum target_object object,
1784 const char *annex, const gdb_byte *buf,
1785 ULONGEST offset, LONGEST len)
1787 return target_write_with_progress (ops, object, annex, buf, offset, len,
1791 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1792 the size of the transferred data. PADDING additional bytes are
1793 available in *BUF_P. This is a helper function for
1794 target_read_alloc; see the declaration of that function for more
1798 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1799 const char *annex, gdb_byte **buf_p, int padding)
1801 size_t buf_alloc, buf_pos;
1805 /* This function does not have a length parameter; it reads the
1806 entire OBJECT). Also, it doesn't support objects fetched partly
1807 from one target and partly from another (in a different stratum,
1808 e.g. a core file and an executable). Both reasons make it
1809 unsuitable for reading memory. */
1810 gdb_assert (object != TARGET_OBJECT_MEMORY);
1812 /* Start by reading up to 4K at a time. The target will throttle
1813 this number down if necessary. */
1815 buf = xmalloc (buf_alloc);
1819 n = target_read_partial (ops, object, annex, &buf[buf_pos],
1820 buf_pos, buf_alloc - buf_pos - padding);
1823 /* An error occurred. */
1829 /* Read all there was. */
1839 /* If the buffer is filling up, expand it. */
1840 if (buf_alloc < buf_pos * 2)
1843 buf = xrealloc (buf, buf_alloc);
1850 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1851 the size of the transferred data. See the declaration in "target.h"
1852 function for more information about the return value. */
1855 target_read_alloc (struct target_ops *ops, enum target_object object,
1856 const char *annex, gdb_byte **buf_p)
1858 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1861 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1862 returned as a string, allocated using xmalloc. If an error occurs
1863 or the transfer is unsupported, NULL is returned. Empty objects
1864 are returned as allocated but empty strings. A warning is issued
1865 if the result contains any embedded NUL bytes. */
1868 target_read_stralloc (struct target_ops *ops, enum target_object object,
1872 LONGEST transferred;
1874 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1876 if (transferred < 0)
1879 if (transferred == 0)
1880 return xstrdup ("");
1882 buffer[transferred] = 0;
1883 if (strlen (buffer) < transferred)
1884 warning (_("target object %d, annex %s, "
1885 "contained unexpected null characters"),
1886 (int) object, annex ? annex : "(none)");
1888 return (char *) buffer;
1891 /* Memory transfer methods. */
1894 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1897 /* This method is used to read from an alternate, non-current
1898 target. This read must bypass the overlay support (as symbols
1899 don't match this target), and GDB's internal cache (wrong cache
1900 for this target). */
1901 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
1903 memory_error (EIO, addr);
1907 get_target_memory_unsigned (struct target_ops *ops,
1908 CORE_ADDR addr, int len, enum bfd_endian byte_order)
1910 gdb_byte buf[sizeof (ULONGEST)];
1912 gdb_assert (len <= sizeof (buf));
1913 get_target_memory (ops, addr, buf, len);
1914 return extract_unsigned_integer (buf, len, byte_order);
1918 target_info (char *args, int from_tty)
1920 struct target_ops *t;
1921 int has_all_mem = 0;
1923 if (symfile_objfile != NULL)
1924 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1926 for (t = target_stack; t != NULL; t = t->beneath)
1928 if (!(*t->to_has_memory) (t))
1931 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1934 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1935 printf_unfiltered ("%s:\n", t->to_longname);
1936 (t->to_files_info) (t);
1937 has_all_mem = (*t->to_has_all_memory) (t);
1941 /* This function is called before any new inferior is created, e.g.
1942 by running a program, attaching, or connecting to a target.
1943 It cleans up any state from previous invocations which might
1944 change between runs. This is a subset of what target_preopen
1945 resets (things which might change between targets). */
1948 target_pre_inferior (int from_tty)
1950 /* Clear out solib state. Otherwise the solib state of the previous
1951 inferior might have survived and is entirely wrong for the new
1952 target. This has been observed on GNU/Linux using glibc 2.3. How
1964 Cannot access memory at address 0xdeadbeef
1967 /* In some OSs, the shared library list is the same/global/shared
1968 across inferiors. If code is shared between processes, so are
1969 memory regions and features. */
1970 if (!gdbarch_has_global_solist (target_gdbarch))
1972 no_shared_libraries (NULL, from_tty);
1974 invalidate_target_mem_regions ();
1976 target_clear_description ();
1980 /* Callback for iterate_over_inferiors. Gets rid of the given
1984 dispose_inferior (struct inferior *inf, void *args)
1986 struct thread_info *thread;
1988 thread = any_thread_of_process (inf->pid);
1991 switch_to_thread (thread->ptid);
1993 /* Core inferiors actually should be detached, not killed. */
1994 if (target_has_execution)
1997 target_detach (NULL, 0);
2003 /* This is to be called by the open routine before it does
2007 target_preopen (int from_tty)
2011 if (have_inferiors ())
2014 || !have_live_inferiors ()
2015 || query (_("A program is being debugged already. Kill it? ")))
2016 iterate_over_inferiors (dispose_inferior, NULL);
2018 error (_("Program not killed."));
2021 /* Calling target_kill may remove the target from the stack. But if
2022 it doesn't (which seems like a win for UDI), remove it now. */
2023 /* Leave the exec target, though. The user may be switching from a
2024 live process to a core of the same program. */
2025 pop_all_targets_above (file_stratum, 0);
2027 target_pre_inferior (from_tty);
2030 /* Detach a target after doing deferred register stores. */
2033 target_detach (char *args, int from_tty)
2035 struct target_ops* t;
2037 if (gdbarch_has_global_breakpoints (target_gdbarch))
2038 /* Don't remove global breakpoints here. They're removed on
2039 disconnection from the target. */
2042 /* If we're in breakpoints-always-inserted mode, have to remove
2043 them before detaching. */
2044 remove_breakpoints ();
2046 for (t = current_target.beneath; t != NULL; t = t->beneath)
2048 if (t->to_detach != NULL)
2050 t->to_detach (t, args, from_tty);
2052 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
2058 internal_error (__FILE__, __LINE__, "could not find a target to detach");
2062 target_disconnect (char *args, int from_tty)
2064 struct target_ops *t;
2066 /* If we're in breakpoints-always-inserted mode or if breakpoints
2067 are global across processes, we have to remove them before
2069 remove_breakpoints ();
2071 for (t = current_target.beneath; t != NULL; t = t->beneath)
2072 if (t->to_disconnect != NULL)
2075 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
2077 t->to_disconnect (t, args, from_tty);
2085 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2087 struct target_ops *t;
2089 for (t = current_target.beneath; t != NULL; t = t->beneath)
2091 if (t->to_wait != NULL)
2093 ptid_t retval = (*t->to_wait) (t, ptid, status, options);
2097 char *status_string;
2099 status_string = target_waitstatus_to_string (status);
2100 fprintf_unfiltered (gdb_stdlog,
2101 "target_wait (%d, status) = %d, %s\n",
2102 PIDGET (ptid), PIDGET (retval),
2104 xfree (status_string);
2115 target_pid_to_str (ptid_t ptid)
2117 struct target_ops *t;
2119 for (t = current_target.beneath; t != NULL; t = t->beneath)
2121 if (t->to_pid_to_str != NULL)
2122 return (*t->to_pid_to_str) (t, ptid);
2125 return normal_pid_to_str (ptid);
2129 target_resume (ptid_t ptid, int step, enum target_signal signal)
2131 struct target_ops *t;
2133 target_dcache_invalidate ();
2135 for (t = current_target.beneath; t != NULL; t = t->beneath)
2137 if (t->to_resume != NULL)
2139 t->to_resume (t, ptid, step, signal);
2141 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
2143 step ? "step" : "continue",
2144 target_signal_to_name (signal));
2146 set_executing (ptid, 1);
2147 set_running (ptid, 1);
2148 clear_inline_frame_state (ptid);
2155 /* Look through the list of possible targets for a target that can
2159 target_follow_fork (int follow_child)
2161 struct target_ops *t;
2163 for (t = current_target.beneath; t != NULL; t = t->beneath)
2165 if (t->to_follow_fork != NULL)
2167 int retval = t->to_follow_fork (t, follow_child);
2169 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2170 follow_child, retval);
2175 /* Some target returned a fork event, but did not know how to follow it. */
2176 internal_error (__FILE__, __LINE__,
2177 "could not find a target to follow fork");
2181 target_mourn_inferior (void)
2183 struct target_ops *t;
2184 for (t = current_target.beneath; t != NULL; t = t->beneath)
2186 if (t->to_mourn_inferior != NULL)
2188 t->to_mourn_inferior (t);
2190 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2192 /* We no longer need to keep handles on any of the object files.
2193 Make sure to release them to avoid unnecessarily locking any
2194 of them while we're not actually debugging. */
2195 bfd_cache_close_all ();
2201 internal_error (__FILE__, __LINE__,
2202 "could not find a target to follow mourn inferiour");
2205 /* Look for a target which can describe architectural features, starting
2206 from TARGET. If we find one, return its description. */
2208 const struct target_desc *
2209 target_read_description (struct target_ops *target)
2211 struct target_ops *t;
2213 for (t = target; t != NULL; t = t->beneath)
2214 if (t->to_read_description != NULL)
2216 const struct target_desc *tdesc;
2218 tdesc = t->to_read_description (t);
2226 /* The default implementation of to_search_memory.
2227 This implements a basic search of memory, reading target memory and
2228 performing the search here (as opposed to performing the search in on the
2229 target side with, for example, gdbserver). */
2232 simple_search_memory (struct target_ops *ops,
2233 CORE_ADDR start_addr, ULONGEST search_space_len,
2234 const gdb_byte *pattern, ULONGEST pattern_len,
2235 CORE_ADDR *found_addrp)
2237 /* NOTE: also defined in find.c testcase. */
2238 #define SEARCH_CHUNK_SIZE 16000
2239 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2240 /* Buffer to hold memory contents for searching. */
2241 gdb_byte *search_buf;
2242 unsigned search_buf_size;
2243 struct cleanup *old_cleanups;
2245 search_buf_size = chunk_size + pattern_len - 1;
2247 /* No point in trying to allocate a buffer larger than the search space. */
2248 if (search_space_len < search_buf_size)
2249 search_buf_size = search_space_len;
2251 search_buf = malloc (search_buf_size);
2252 if (search_buf == NULL)
2253 error (_("Unable to allocate memory to perform the search."));
2254 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2256 /* Prime the search buffer. */
2258 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2259 search_buf, start_addr, search_buf_size) != search_buf_size)
2261 warning (_("Unable to access target memory at %s, halting search."),
2262 hex_string (start_addr));
2263 do_cleanups (old_cleanups);
2267 /* Perform the search.
2269 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2270 When we've scanned N bytes we copy the trailing bytes to the start and
2271 read in another N bytes. */
2273 while (search_space_len >= pattern_len)
2275 gdb_byte *found_ptr;
2276 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2278 found_ptr = memmem (search_buf, nr_search_bytes,
2279 pattern, pattern_len);
2281 if (found_ptr != NULL)
2283 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2284 *found_addrp = found_addr;
2285 do_cleanups (old_cleanups);
2289 /* Not found in this chunk, skip to next chunk. */
2291 /* Don't let search_space_len wrap here, it's unsigned. */
2292 if (search_space_len >= chunk_size)
2293 search_space_len -= chunk_size;
2295 search_space_len = 0;
2297 if (search_space_len >= pattern_len)
2299 unsigned keep_len = search_buf_size - chunk_size;
2300 CORE_ADDR read_addr = start_addr + keep_len;
2303 /* Copy the trailing part of the previous iteration to the front
2304 of the buffer for the next iteration. */
2305 gdb_assert (keep_len == pattern_len - 1);
2306 memcpy (search_buf, search_buf + chunk_size, keep_len);
2308 nr_to_read = min (search_space_len - keep_len, chunk_size);
2310 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2311 search_buf + keep_len, read_addr,
2312 nr_to_read) != nr_to_read)
2314 warning (_("Unable to access target memory at %s, halting search."),
2315 hex_string (read_addr));
2316 do_cleanups (old_cleanups);
2320 start_addr += chunk_size;
2326 do_cleanups (old_cleanups);
2330 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2331 sequence of bytes in PATTERN with length PATTERN_LEN.
2333 The result is 1 if found, 0 if not found, and -1 if there was an error
2334 requiring halting of the search (e.g. memory read error).
2335 If the pattern is found the address is recorded in FOUND_ADDRP. */
2338 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2339 const gdb_byte *pattern, ULONGEST pattern_len,
2340 CORE_ADDR *found_addrp)
2342 struct target_ops *t;
2345 /* We don't use INHERIT to set current_target.to_search_memory,
2346 so we have to scan the target stack and handle targetdebug
2350 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2351 hex_string (start_addr));
2353 for (t = current_target.beneath; t != NULL; t = t->beneath)
2354 if (t->to_search_memory != NULL)
2359 found = t->to_search_memory (t, start_addr, search_space_len,
2360 pattern, pattern_len, found_addrp);
2364 /* If a special version of to_search_memory isn't available, use the
2366 found = simple_search_memory (current_target.beneath,
2367 start_addr, search_space_len,
2368 pattern, pattern_len, found_addrp);
2372 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2377 /* Look through the currently pushed targets. If none of them will
2378 be able to restart the currently running process, issue an error
2382 target_require_runnable (void)
2384 struct target_ops *t;
2386 for (t = target_stack; t != NULL; t = t->beneath)
2388 /* If this target knows how to create a new program, then
2389 assume we will still be able to after killing the current
2390 one. Either killing and mourning will not pop T, or else
2391 find_default_run_target will find it again. */
2392 if (t->to_create_inferior != NULL)
2395 /* Do not worry about thread_stratum targets that can not
2396 create inferiors. Assume they will be pushed again if
2397 necessary, and continue to the process_stratum. */
2398 if (t->to_stratum == thread_stratum
2399 || t->to_stratum == arch_stratum)
2403 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2407 /* This function is only called if the target is running. In that
2408 case there should have been a process_stratum target and it
2409 should either know how to create inferiors, or not... */
2410 internal_error (__FILE__, __LINE__, "No targets found");
2413 /* Look through the list of possible targets for a target that can
2414 execute a run or attach command without any other data. This is
2415 used to locate the default process stratum.
2417 If DO_MESG is not NULL, the result is always valid (error() is
2418 called for errors); else, return NULL on error. */
2420 static struct target_ops *
2421 find_default_run_target (char *do_mesg)
2423 struct target_ops **t;
2424 struct target_ops *runable = NULL;
2429 for (t = target_structs; t < target_structs + target_struct_size;
2432 if ((*t)->to_can_run && target_can_run (*t))
2442 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2451 find_default_attach (struct target_ops *ops, char *args, int from_tty)
2453 struct target_ops *t;
2455 t = find_default_run_target ("attach");
2456 (t->to_attach) (t, args, from_tty);
2461 find_default_create_inferior (struct target_ops *ops,
2462 char *exec_file, char *allargs, char **env,
2465 struct target_ops *t;
2467 t = find_default_run_target ("run");
2468 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
2473 find_default_can_async_p (void)
2475 struct target_ops *t;
2477 /* This may be called before the target is pushed on the stack;
2478 look for the default process stratum. If there's none, gdb isn't
2479 configured with a native debugger, and target remote isn't
2481 t = find_default_run_target (NULL);
2482 if (t && t->to_can_async_p)
2483 return (t->to_can_async_p) ();
2488 find_default_is_async_p (void)
2490 struct target_ops *t;
2492 /* This may be called before the target is pushed on the stack;
2493 look for the default process stratum. If there's none, gdb isn't
2494 configured with a native debugger, and target remote isn't
2496 t = find_default_run_target (NULL);
2497 if (t && t->to_is_async_p)
2498 return (t->to_is_async_p) ();
2503 find_default_supports_non_stop (void)
2505 struct target_ops *t;
2507 t = find_default_run_target (NULL);
2508 if (t && t->to_supports_non_stop)
2509 return (t->to_supports_non_stop) ();
2514 target_supports_non_stop (void)
2516 struct target_ops *t;
2517 for (t = ¤t_target; t != NULL; t = t->beneath)
2518 if (t->to_supports_non_stop)
2519 return t->to_supports_non_stop ();
2526 target_get_osdata (const char *type)
2529 struct target_ops *t;
2531 /* If we're already connected to something that can get us OS
2532 related data, use it. Otherwise, try using the native
2534 if (current_target.to_stratum >= process_stratum)
2535 t = current_target.beneath;
2537 t = find_default_run_target ("get OS data");
2542 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
2546 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2548 return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
2552 default_watchpoint_addr_within_range (struct target_ops *target,
2554 CORE_ADDR start, int length)
2556 return addr >= start && addr < start + length;
2559 static struct gdbarch *
2560 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
2562 return target_gdbarch;
2578 return_minus_one (void)
2583 /* Find a single runnable target in the stack and return it. If for
2584 some reason there is more than one, return NULL. */
2587 find_run_target (void)
2589 struct target_ops **t;
2590 struct target_ops *runable = NULL;
2595 for (t = target_structs; t < target_structs + target_struct_size; ++t)
2597 if ((*t)->to_can_run && target_can_run (*t))
2604 return (count == 1 ? runable : NULL);
2607 /* Find a single core_stratum target in the list of targets and return it.
2608 If for some reason there is more than one, return NULL. */
2611 find_core_target (void)
2613 struct target_ops **t;
2614 struct target_ops *runable = NULL;
2619 for (t = target_structs; t < target_structs + target_struct_size;
2622 if ((*t)->to_stratum == core_stratum)
2629 return (count == 1 ? runable : NULL);
2633 * Find the next target down the stack from the specified target.
2637 find_target_beneath (struct target_ops *t)
2643 /* The inferior process has died. Long live the inferior! */
2646 generic_mourn_inferior (void)
2650 ptid = inferior_ptid;
2651 inferior_ptid = null_ptid;
2653 if (!ptid_equal (ptid, null_ptid))
2655 int pid = ptid_get_pid (ptid);
2656 delete_inferior (pid);
2659 breakpoint_init_inferior (inf_exited);
2660 registers_changed ();
2662 reopen_exec_file ();
2663 reinit_frame_cache ();
2665 if (deprecated_detach_hook)
2666 deprecated_detach_hook ();
2669 /* Helper function for child_wait and the derivatives of child_wait.
2670 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2671 translation of that in OURSTATUS. */
2673 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2675 if (WIFEXITED (hoststatus))
2677 ourstatus->kind = TARGET_WAITKIND_EXITED;
2678 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2680 else if (!WIFSTOPPED (hoststatus))
2682 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2683 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2687 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2688 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2692 /* Convert a normal process ID to a string. Returns the string in a
2696 normal_pid_to_str (ptid_t ptid)
2698 static char buf[32];
2700 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
2705 dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
2707 return normal_pid_to_str (ptid);
2710 /* Error-catcher for target_find_memory_regions */
2711 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
2713 error (_("No target."));
2717 /* Error-catcher for target_make_corefile_notes */
2718 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
2720 error (_("No target."));
2724 /* Set up the handful of non-empty slots needed by the dummy target
2728 init_dummy_target (void)
2730 dummy_target.to_shortname = "None";
2731 dummy_target.to_longname = "None";
2732 dummy_target.to_doc = "";
2733 dummy_target.to_attach = find_default_attach;
2734 dummy_target.to_detach =
2735 (void (*)(struct target_ops *, char *, int))target_ignore;
2736 dummy_target.to_create_inferior = find_default_create_inferior;
2737 dummy_target.to_can_async_p = find_default_can_async_p;
2738 dummy_target.to_is_async_p = find_default_is_async_p;
2739 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
2740 dummy_target.to_pid_to_str = dummy_pid_to_str;
2741 dummy_target.to_stratum = dummy_stratum;
2742 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
2743 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
2744 dummy_target.to_xfer_partial = default_xfer_partial;
2745 dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
2746 dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero;
2747 dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero;
2748 dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero;
2749 dummy_target.to_has_execution = (int (*) (struct target_ops *)) return_zero;
2750 dummy_target.to_magic = OPS_MAGIC;
2754 debug_to_open (char *args, int from_tty)
2756 debug_target.to_open (args, from_tty);
2758 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2762 target_close (struct target_ops *targ, int quitting)
2764 if (targ->to_xclose != NULL)
2765 targ->to_xclose (targ, quitting);
2766 else if (targ->to_close != NULL)
2767 targ->to_close (quitting);
2770 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2774 target_attach (char *args, int from_tty)
2776 struct target_ops *t;
2777 for (t = current_target.beneath; t != NULL; t = t->beneath)
2779 if (t->to_attach != NULL)
2781 t->to_attach (t, args, from_tty);
2783 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
2789 internal_error (__FILE__, __LINE__,
2790 "could not find a target to attach");
2794 target_thread_alive (ptid_t ptid)
2796 struct target_ops *t;
2797 for (t = current_target.beneath; t != NULL; t = t->beneath)
2799 if (t->to_thread_alive != NULL)
2803 retval = t->to_thread_alive (t, ptid);
2805 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2806 PIDGET (ptid), retval);
2816 target_find_new_threads (void)
2818 struct target_ops *t;
2819 for (t = current_target.beneath; t != NULL; t = t->beneath)
2821 if (t->to_find_new_threads != NULL)
2823 t->to_find_new_threads (t);
2825 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
2833 debug_to_post_attach (int pid)
2835 debug_target.to_post_attach (pid);
2837 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2840 /* Return a pretty printed form of target_waitstatus.
2841 Space for the result is malloc'd, caller must free. */
2844 target_waitstatus_to_string (const struct target_waitstatus *ws)
2846 const char *kind_str = "status->kind = ";
2850 case TARGET_WAITKIND_EXITED:
2851 return xstrprintf ("%sexited, status = %d",
2852 kind_str, ws->value.integer);
2853 case TARGET_WAITKIND_STOPPED:
2854 return xstrprintf ("%sstopped, signal = %s",
2855 kind_str, target_signal_to_name (ws->value.sig));
2856 case TARGET_WAITKIND_SIGNALLED:
2857 return xstrprintf ("%ssignalled, signal = %s",
2858 kind_str, target_signal_to_name (ws->value.sig));
2859 case TARGET_WAITKIND_LOADED:
2860 return xstrprintf ("%sloaded", kind_str);
2861 case TARGET_WAITKIND_FORKED:
2862 return xstrprintf ("%sforked", kind_str);
2863 case TARGET_WAITKIND_VFORKED:
2864 return xstrprintf ("%svforked", kind_str);
2865 case TARGET_WAITKIND_EXECD:
2866 return xstrprintf ("%sexecd", kind_str);
2867 case TARGET_WAITKIND_SYSCALL_ENTRY:
2868 return xstrprintf ("%ssyscall-entry", kind_str);
2869 case TARGET_WAITKIND_SYSCALL_RETURN:
2870 return xstrprintf ("%ssyscall-return", kind_str);
2871 case TARGET_WAITKIND_SPURIOUS:
2872 return xstrprintf ("%sspurious", kind_str);
2873 case TARGET_WAITKIND_IGNORE:
2874 return xstrprintf ("%signore", kind_str);
2875 case TARGET_WAITKIND_NO_HISTORY:
2876 return xstrprintf ("%sno-history", kind_str);
2878 return xstrprintf ("%sunknown???", kind_str);
2883 debug_print_register (const char * func,
2884 struct regcache *regcache, int regno)
2886 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2887 fprintf_unfiltered (gdb_stdlog, "%s ", func);
2888 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
2889 && gdbarch_register_name (gdbarch, regno) != NULL
2890 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
2891 fprintf_unfiltered (gdb_stdlog, "(%s)",
2892 gdbarch_register_name (gdbarch, regno));
2894 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2895 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
2897 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2898 int i, size = register_size (gdbarch, regno);
2899 unsigned char buf[MAX_REGISTER_SIZE];
2900 regcache_raw_collect (regcache, regno, buf);
2901 fprintf_unfiltered (gdb_stdlog, " = ");
2902 for (i = 0; i < size; i++)
2904 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2906 if (size <= sizeof (LONGEST))
2908 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
2909 fprintf_unfiltered (gdb_stdlog, " %s %s",
2910 core_addr_to_string_nz (val), plongest (val));
2913 fprintf_unfiltered (gdb_stdlog, "\n");
2917 target_fetch_registers (struct regcache *regcache, int regno)
2919 struct target_ops *t;
2920 for (t = current_target.beneath; t != NULL; t = t->beneath)
2922 if (t->to_fetch_registers != NULL)
2924 t->to_fetch_registers (t, regcache, regno);
2926 debug_print_register ("target_fetch_registers", regcache, regno);
2933 target_store_registers (struct regcache *regcache, int regno)
2936 struct target_ops *t;
2937 for (t = current_target.beneath; t != NULL; t = t->beneath)
2939 if (t->to_store_registers != NULL)
2941 t->to_store_registers (t, regcache, regno);
2944 debug_print_register ("target_store_registers", regcache, regno);
2954 debug_to_prepare_to_store (struct regcache *regcache)
2956 debug_target.to_prepare_to_store (regcache);
2958 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2962 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2963 int write, struct mem_attrib *attrib,
2964 struct target_ops *target)
2968 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2971 fprintf_unfiltered (gdb_stdlog,
2972 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
2973 paddress (target_gdbarch, memaddr), len,
2974 write ? "write" : "read", retval);
2980 fputs_unfiltered (", bytes =", gdb_stdlog);
2981 for (i = 0; i < retval; i++)
2983 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
2985 if (targetdebug < 2 && i > 0)
2987 fprintf_unfiltered (gdb_stdlog, " ...");
2990 fprintf_unfiltered (gdb_stdlog, "\n");
2993 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2997 fputc_unfiltered ('\n', gdb_stdlog);
3003 debug_to_files_info (struct target_ops *target)
3005 debug_target.to_files_info (target);
3007 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
3011 debug_to_insert_breakpoint (struct gdbarch *gdbarch,
3012 struct bp_target_info *bp_tgt)
3016 retval = debug_target.to_insert_breakpoint (gdbarch, bp_tgt);
3018 fprintf_unfiltered (gdb_stdlog,
3019 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
3020 (unsigned long) bp_tgt->placed_address,
3021 (unsigned long) retval);
3026 debug_to_remove_breakpoint (struct gdbarch *gdbarch,
3027 struct bp_target_info *bp_tgt)
3031 retval = debug_target.to_remove_breakpoint (gdbarch, bp_tgt);
3033 fprintf_unfiltered (gdb_stdlog,
3034 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
3035 (unsigned long) bp_tgt->placed_address,
3036 (unsigned long) retval);
3041 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
3045 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
3047 fprintf_unfiltered (gdb_stdlog,
3048 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
3049 (unsigned long) type,
3050 (unsigned long) cnt,
3051 (unsigned long) from_tty,
3052 (unsigned long) retval);
3057 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
3061 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
3063 fprintf_unfiltered (gdb_stdlog,
3064 "target_region_ok_for_hw_watchpoint (%ld, %ld) = 0x%lx\n",
3065 (unsigned long) addr,
3066 (unsigned long) len,
3067 (unsigned long) retval);
3072 debug_to_stopped_by_watchpoint (void)
3076 retval = debug_target.to_stopped_by_watchpoint ();
3078 fprintf_unfiltered (gdb_stdlog,
3079 "target_stopped_by_watchpoint () = %ld\n",
3080 (unsigned long) retval);
3085 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
3089 retval = debug_target.to_stopped_data_address (target, addr);
3091 fprintf_unfiltered (gdb_stdlog,
3092 "target_stopped_data_address ([0x%lx]) = %ld\n",
3093 (unsigned long)*addr,
3094 (unsigned long)retval);
3099 debug_to_watchpoint_addr_within_range (struct target_ops *target,
3101 CORE_ADDR start, int length)
3105 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
3108 fprintf_filtered (gdb_stdlog,
3109 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
3110 (unsigned long) addr, (unsigned long) start, length,
3116 debug_to_insert_hw_breakpoint (struct gdbarch *gdbarch,
3117 struct bp_target_info *bp_tgt)
3121 retval = debug_target.to_insert_hw_breakpoint (gdbarch, bp_tgt);
3123 fprintf_unfiltered (gdb_stdlog,
3124 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
3125 (unsigned long) bp_tgt->placed_address,
3126 (unsigned long) retval);
3131 debug_to_remove_hw_breakpoint (struct gdbarch *gdbarch,
3132 struct bp_target_info *bp_tgt)
3136 retval = debug_target.to_remove_hw_breakpoint (gdbarch, bp_tgt);
3138 fprintf_unfiltered (gdb_stdlog,
3139 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
3140 (unsigned long) bp_tgt->placed_address,
3141 (unsigned long) retval);
3146 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
3150 retval = debug_target.to_insert_watchpoint (addr, len, type);
3152 fprintf_unfiltered (gdb_stdlog,
3153 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
3154 (unsigned long) addr, len, type, (unsigned long) retval);
3159 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
3163 retval = debug_target.to_remove_watchpoint (addr, len, type);
3165 fprintf_unfiltered (gdb_stdlog,
3166 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
3167 (unsigned long) addr, len, type, (unsigned long) retval);
3172 debug_to_terminal_init (void)
3174 debug_target.to_terminal_init ();
3176 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
3180 debug_to_terminal_inferior (void)
3182 debug_target.to_terminal_inferior ();
3184 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
3188 debug_to_terminal_ours_for_output (void)
3190 debug_target.to_terminal_ours_for_output ();
3192 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
3196 debug_to_terminal_ours (void)
3198 debug_target.to_terminal_ours ();
3200 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
3204 debug_to_terminal_save_ours (void)
3206 debug_target.to_terminal_save_ours ();
3208 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
3212 debug_to_terminal_info (char *arg, int from_tty)
3214 debug_target.to_terminal_info (arg, from_tty);
3216 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
3221 debug_to_load (char *args, int from_tty)
3223 debug_target.to_load (args, from_tty);
3225 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
3229 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
3233 retval = debug_target.to_lookup_symbol (name, addrp);
3235 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
3241 debug_to_post_startup_inferior (ptid_t ptid)
3243 debug_target.to_post_startup_inferior (ptid);
3245 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
3250 debug_to_acknowledge_created_inferior (int pid)
3252 debug_target.to_acknowledge_created_inferior (pid);
3254 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
3259 debug_to_insert_fork_catchpoint (int pid)
3261 debug_target.to_insert_fork_catchpoint (pid);
3263 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
3268 debug_to_remove_fork_catchpoint (int pid)
3272 retval = debug_target.to_remove_fork_catchpoint (pid);
3274 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
3281 debug_to_insert_vfork_catchpoint (int pid)
3283 debug_target.to_insert_vfork_catchpoint (pid);
3285 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
3290 debug_to_remove_vfork_catchpoint (int pid)
3294 retval = debug_target.to_remove_vfork_catchpoint (pid);
3296 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
3303 debug_to_insert_exec_catchpoint (int pid)
3305 debug_target.to_insert_exec_catchpoint (pid);
3307 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
3312 debug_to_remove_exec_catchpoint (int pid)
3316 retval = debug_target.to_remove_exec_catchpoint (pid);
3318 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
3325 debug_to_has_exited (int pid, int wait_status, int *exit_status)
3329 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
3331 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
3332 pid, wait_status, *exit_status, has_exited);
3338 debug_to_can_run (void)
3342 retval = debug_target.to_can_run ();
3344 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
3350 debug_to_notice_signals (ptid_t ptid)
3352 debug_target.to_notice_signals (ptid);
3354 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
3358 static struct gdbarch *
3359 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
3361 struct gdbarch *retval;
3363 retval = debug_target.to_thread_architecture (ops, ptid);
3365 fprintf_unfiltered (gdb_stdlog, "target_thread_architecture (%s) = %p [%s]\n",
3366 target_pid_to_str (ptid), retval,
3367 gdbarch_bfd_arch_info (retval)->printable_name);
3372 debug_to_stop (ptid_t ptid)
3374 debug_target.to_stop (ptid);
3376 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
3377 target_pid_to_str (ptid));
3381 debug_to_rcmd (char *command,
3382 struct ui_file *outbuf)
3384 debug_target.to_rcmd (command, outbuf);
3385 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
3389 debug_to_pid_to_exec_file (int pid)
3393 exec_file = debug_target.to_pid_to_exec_file (pid);
3395 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
3402 setup_target_debug (void)
3404 memcpy (&debug_target, ¤t_target, sizeof debug_target);
3406 current_target.to_open = debug_to_open;
3407 current_target.to_post_attach = debug_to_post_attach;
3408 current_target.to_prepare_to_store = debug_to_prepare_to_store;
3409 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
3410 current_target.to_files_info = debug_to_files_info;
3411 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
3412 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
3413 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
3414 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
3415 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
3416 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
3417 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
3418 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
3419 current_target.to_stopped_data_address = debug_to_stopped_data_address;
3420 current_target.to_watchpoint_addr_within_range = debug_to_watchpoint_addr_within_range;
3421 current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
3422 current_target.to_terminal_init = debug_to_terminal_init;
3423 current_target.to_terminal_inferior = debug_to_terminal_inferior;
3424 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
3425 current_target.to_terminal_ours = debug_to_terminal_ours;
3426 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
3427 current_target.to_terminal_info = debug_to_terminal_info;
3428 current_target.to_load = debug_to_load;
3429 current_target.to_lookup_symbol = debug_to_lookup_symbol;
3430 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
3431 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
3432 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
3433 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
3434 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
3435 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
3436 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
3437 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
3438 current_target.to_has_exited = debug_to_has_exited;
3439 current_target.to_can_run = debug_to_can_run;
3440 current_target.to_notice_signals = debug_to_notice_signals;
3441 current_target.to_stop = debug_to_stop;
3442 current_target.to_rcmd = debug_to_rcmd;
3443 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
3444 current_target.to_thread_architecture = debug_to_thread_architecture;
3448 static char targ_desc[] =
3449 "Names of targets and files being debugged.\n\
3450 Shows the entire stack of targets currently in use (including the exec-file,\n\
3451 core-file, and process, if any), as well as the symbol file name.";
3454 do_monitor_command (char *cmd,
3457 if ((current_target.to_rcmd
3458 == (void (*) (char *, struct ui_file *)) tcomplain)
3459 || (current_target.to_rcmd == debug_to_rcmd
3460 && (debug_target.to_rcmd
3461 == (void (*) (char *, struct ui_file *)) tcomplain)))
3462 error (_("\"monitor\" command not supported by this target."));
3463 target_rcmd (cmd, gdb_stdtarg);
3466 /* Print the name of each layers of our target stack. */
3469 maintenance_print_target_stack (char *cmd, int from_tty)
3471 struct target_ops *t;
3473 printf_filtered (_("The current target stack is:\n"));
3475 for (t = target_stack; t != NULL; t = t->beneath)
3477 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3481 /* Controls if async mode is permitted. */
3482 int target_async_permitted = 0;
3484 /* The set command writes to this variable. If the inferior is
3485 executing, linux_nat_async_permitted is *not* updated. */
3486 static int target_async_permitted_1 = 0;
3489 set_maintenance_target_async_permitted (char *args, int from_tty,
3490 struct cmd_list_element *c)
3492 if (have_live_inferiors ())
3494 target_async_permitted_1 = target_async_permitted;
3495 error (_("Cannot change this setting while the inferior is running."));
3498 target_async_permitted = target_async_permitted_1;
3502 show_maintenance_target_async_permitted (struct ui_file *file, int from_tty,
3503 struct cmd_list_element *c,
3506 fprintf_filtered (file, _("\
3507 Controlling the inferior in asynchronous mode is %s.\n"), value);
3511 initialize_targets (void)
3513 init_dummy_target ();
3514 push_target (&dummy_target);
3516 add_info ("target", target_info, targ_desc);
3517 add_info ("files", target_info, targ_desc);
3519 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3520 Set target debugging."), _("\
3521 Show target debugging."), _("\
3522 When non-zero, target debugging is enabled. Higher numbers are more\n\
3523 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3527 &setdebuglist, &showdebuglist);
3529 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
3530 &trust_readonly, _("\
3531 Set mode for reading from readonly sections."), _("\
3532 Show mode for reading from readonly sections."), _("\
3533 When this mode is on, memory reads from readonly sections (such as .text)\n\
3534 will be read from the object file instead of from the target. This will\n\
3535 result in significant performance improvement for remote targets."),
3537 show_trust_readonly,
3538 &setlist, &showlist);
3540 add_com ("monitor", class_obscure, do_monitor_command,
3541 _("Send a command to the remote monitor (remote targets only)."));
3543 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3544 _("Print the name of each layer of the internal target stack."),
3545 &maintenanceprintlist);
3547 add_setshow_boolean_cmd ("target-async", no_class,
3548 &target_async_permitted_1, _("\
3549 Set whether gdb controls the inferior in asynchronous mode."), _("\
3550 Show whether gdb controls the inferior in asynchronous mode."), _("\
3551 Tells gdb whether to control the inferior in asynchronous mode."),
3552 set_maintenance_target_async_permitted,
3553 show_maintenance_target_async_permitted,
3557 add_setshow_boolean_cmd ("stack-cache", class_support,
3558 &stack_cache_enabled_p_1, _("\
3559 Set cache use for stack access."), _("\
3560 Show cache use for stack access."), _("\
3561 When on, use the data cache for all stack access, regardless of any\n\
3562 configured memory regions. This improves remote performance significantly.\n\
3563 By default, caching for stack access is on."),
3564 set_stack_cache_enabled_p,
3565 show_stack_cache_enabled_p,
3566 &setlist, &showlist);
3568 target_dcache = dcache_init ();