1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "target-dcache.h"
36 #include "gdb_assert.h"
38 #include "exceptions.h"
39 #include "target-descriptions.h"
40 #include "gdbthread.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
45 #include "gdb/fileio.h"
49 static void target_info (char *, int);
51 static void default_terminal_info (struct target_ops *, const 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 (struct target_ops *,
59 static void default_rcmd (struct target_ops *, char *, struct ui_file *);
61 static ptid_t default_get_ada_task_ptid (struct target_ops *self,
64 static int default_follow_fork (struct target_ops *self, int follow_child,
67 static void default_mourn_inferior (struct target_ops *self);
69 static int default_search_memory (struct target_ops *ops,
71 ULONGEST search_space_len,
72 const gdb_byte *pattern,
74 CORE_ADDR *found_addrp);
76 static void tcomplain (void) ATTRIBUTE_NORETURN;
78 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
80 static int return_zero (struct target_ops *);
82 static int return_zero_has_execution (struct target_ops *, ptid_t);
84 void target_ignore (void);
86 static void target_command (char *, int);
88 static struct target_ops *find_default_run_target (char *);
90 static target_xfer_partial_ftype default_xfer_partial;
92 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
95 static int dummy_find_memory_regions (struct target_ops *self,
96 find_memory_region_ftype ignore1,
99 static char *dummy_make_corefile_notes (struct target_ops *self,
100 bfd *ignore1, int *ignore2);
102 static char *default_pid_to_str (struct target_ops *ops, ptid_t ptid);
104 static int find_default_can_async_p (struct target_ops *ignore);
106 static int find_default_is_async_p (struct target_ops *ignore);
108 static enum exec_direction_kind default_execution_direction
109 (struct target_ops *self);
111 static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops,
112 struct gdbarch *gdbarch);
114 #include "target-delegates.c"
116 static void init_dummy_target (void);
118 static struct target_ops debug_target;
120 static void debug_to_open (char *, int);
122 static void debug_to_prepare_to_store (struct target_ops *self,
125 static void debug_to_files_info (struct target_ops *);
127 static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
128 struct bp_target_info *);
130 static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
131 struct bp_target_info *);
133 static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
136 static int debug_to_insert_hw_breakpoint (struct target_ops *self,
138 struct bp_target_info *);
140 static int debug_to_remove_hw_breakpoint (struct target_ops *self,
142 struct bp_target_info *);
144 static int debug_to_insert_watchpoint (struct target_ops *self,
146 struct expression *);
148 static int debug_to_remove_watchpoint (struct target_ops *self,
150 struct expression *);
152 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
154 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
155 CORE_ADDR, CORE_ADDR, int);
157 static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
160 static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
162 struct expression *);
164 static void debug_to_terminal_init (struct target_ops *self);
166 static void debug_to_terminal_inferior (struct target_ops *self);
168 static void debug_to_terminal_ours_for_output (struct target_ops *self);
170 static void debug_to_terminal_save_ours (struct target_ops *self);
172 static void debug_to_terminal_ours (struct target_ops *self);
174 static void debug_to_load (struct target_ops *self, char *, int);
176 static int debug_to_can_run (struct target_ops *self);
178 static void debug_to_stop (struct target_ops *self, ptid_t);
180 /* Pointer to array of target architecture structures; the size of the
181 array; the current index into the array; the allocated size of the
183 struct target_ops **target_structs;
184 unsigned target_struct_size;
185 unsigned target_struct_allocsize;
186 #define DEFAULT_ALLOCSIZE 10
188 /* The initial current target, so that there is always a semi-valid
191 static struct target_ops dummy_target;
193 /* Top of target stack. */
195 static struct target_ops *target_stack;
197 /* The target structure we are currently using to talk to a process
198 or file or whatever "inferior" we have. */
200 struct target_ops current_target;
202 /* Command list for target. */
204 static struct cmd_list_element *targetlist = NULL;
206 /* Nonzero if we should trust readonly sections from the
207 executable when reading memory. */
209 static int trust_readonly = 0;
211 /* Nonzero if we should show true memory content including
212 memory breakpoint inserted by gdb. */
214 static int show_memory_breakpoints = 0;
216 /* These globals control whether GDB attempts to perform these
217 operations; they are useful for targets that need to prevent
218 inadvertant disruption, such as in non-stop mode. */
220 int may_write_registers = 1;
222 int may_write_memory = 1;
224 int may_insert_breakpoints = 1;
226 int may_insert_tracepoints = 1;
228 int may_insert_fast_tracepoints = 1;
232 /* Non-zero if we want to see trace of target level stuff. */
234 static unsigned int targetdebug = 0;
236 show_targetdebug (struct ui_file *file, int from_tty,
237 struct cmd_list_element *c, const char *value)
239 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
242 static void setup_target_debug (void);
244 /* The user just typed 'target' without the name of a target. */
247 target_command (char *arg, int from_tty)
249 fputs_filtered ("Argument required (target name). Try `help target'\n",
253 /* Default target_has_* methods for process_stratum targets. */
256 default_child_has_all_memory (struct target_ops *ops)
258 /* If no inferior selected, then we can't read memory here. */
259 if (ptid_equal (inferior_ptid, null_ptid))
266 default_child_has_memory (struct target_ops *ops)
268 /* If no inferior selected, then we can't read memory here. */
269 if (ptid_equal (inferior_ptid, null_ptid))
276 default_child_has_stack (struct target_ops *ops)
278 /* If no inferior selected, there's no stack. */
279 if (ptid_equal (inferior_ptid, null_ptid))
286 default_child_has_registers (struct target_ops *ops)
288 /* Can't read registers from no inferior. */
289 if (ptid_equal (inferior_ptid, null_ptid))
296 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
298 /* If there's no thread selected, then we can't make it run through
300 if (ptid_equal (the_ptid, null_ptid))
308 target_has_all_memory_1 (void)
310 struct target_ops *t;
312 for (t = current_target.beneath; t != NULL; t = t->beneath)
313 if (t->to_has_all_memory (t))
320 target_has_memory_1 (void)
322 struct target_ops *t;
324 for (t = current_target.beneath; t != NULL; t = t->beneath)
325 if (t->to_has_memory (t))
332 target_has_stack_1 (void)
334 struct target_ops *t;
336 for (t = current_target.beneath; t != NULL; t = t->beneath)
337 if (t->to_has_stack (t))
344 target_has_registers_1 (void)
346 struct target_ops *t;
348 for (t = current_target.beneath; t != NULL; t = t->beneath)
349 if (t->to_has_registers (t))
356 target_has_execution_1 (ptid_t the_ptid)
358 struct target_ops *t;
360 for (t = current_target.beneath; t != NULL; t = t->beneath)
361 if (t->to_has_execution (t, the_ptid))
368 target_has_execution_current (void)
370 return target_has_execution_1 (inferior_ptid);
373 /* Complete initialization of T. This ensures that various fields in
374 T are set, if needed by the target implementation. */
377 complete_target_initialization (struct target_ops *t)
379 /* Provide default values for all "must have" methods. */
380 if (t->to_xfer_partial == NULL)
381 t->to_xfer_partial = default_xfer_partial;
383 if (t->to_has_all_memory == NULL)
384 t->to_has_all_memory = return_zero;
386 if (t->to_has_memory == NULL)
387 t->to_has_memory = return_zero;
389 if (t->to_has_stack == NULL)
390 t->to_has_stack = return_zero;
392 if (t->to_has_registers == NULL)
393 t->to_has_registers = return_zero;
395 if (t->to_has_execution == NULL)
396 t->to_has_execution = return_zero_has_execution;
398 install_delegators (t);
401 /* Add possible target architecture T to the list and add a new
402 command 'target T->to_shortname'. Set COMPLETER as the command's
403 completer if not NULL. */
406 add_target_with_completer (struct target_ops *t,
407 completer_ftype *completer)
409 struct cmd_list_element *c;
411 complete_target_initialization (t);
415 target_struct_allocsize = DEFAULT_ALLOCSIZE;
416 target_structs = (struct target_ops **) xmalloc
417 (target_struct_allocsize * sizeof (*target_structs));
419 if (target_struct_size >= target_struct_allocsize)
421 target_struct_allocsize *= 2;
422 target_structs = (struct target_ops **)
423 xrealloc ((char *) target_structs,
424 target_struct_allocsize * sizeof (*target_structs));
426 target_structs[target_struct_size++] = t;
428 if (targetlist == NULL)
429 add_prefix_cmd ("target", class_run, target_command, _("\
430 Connect to a target machine or process.\n\
431 The first argument is the type or protocol of the target machine.\n\
432 Remaining arguments are interpreted by the target protocol. For more\n\
433 information on the arguments for a particular protocol, type\n\
434 `help target ' followed by the protocol name."),
435 &targetlist, "target ", 0, &cmdlist);
436 c = add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc,
438 if (completer != NULL)
439 set_cmd_completer (c, completer);
442 /* Add a possible target architecture to the list. */
445 add_target (struct target_ops *t)
447 add_target_with_completer (t, NULL);
453 add_deprecated_target_alias (struct target_ops *t, char *alias)
455 struct cmd_list_element *c;
458 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
460 c = add_cmd (alias, no_class, t->to_open, t->to_doc, &targetlist);
461 alt = xstrprintf ("target %s", t->to_shortname);
462 deprecate_cmd (c, alt);
476 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
478 current_target.to_kill (¤t_target);
482 target_load (char *arg, int from_tty)
484 target_dcache_invalidate ();
485 (*current_target.to_load) (¤t_target, arg, from_tty);
489 target_create_inferior (char *exec_file, char *args,
490 char **env, int from_tty)
492 struct target_ops *t;
494 for (t = current_target.beneath; t != NULL; t = t->beneath)
496 if (t->to_create_inferior != NULL)
498 t->to_create_inferior (t, exec_file, args, env, from_tty);
500 fprintf_unfiltered (gdb_stdlog,
501 "target_create_inferior (%s, %s, xxx, %d)\n",
502 exec_file, args, from_tty);
507 internal_error (__FILE__, __LINE__,
508 _("could not find a target to create inferior"));
512 target_terminal_inferior (void)
514 /* A background resume (``run&'') should leave GDB in control of the
515 terminal. Use target_can_async_p, not target_is_async_p, since at
516 this point the target is not async yet. However, if sync_execution
517 is not set, we know it will become async prior to resume. */
518 if (target_can_async_p () && !sync_execution)
521 /* If GDB is resuming the inferior in the foreground, install
522 inferior's terminal modes. */
523 (*current_target.to_terminal_inferior) (¤t_target);
527 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
528 struct target_ops *t)
530 errno = EIO; /* Can't read/write this location. */
531 return 0; /* No bytes handled. */
537 error (_("You can't do that when your target is `%s'"),
538 current_target.to_shortname);
544 error (_("You can't do that without a process to debug."));
548 default_terminal_info (struct target_ops *self, const char *args, int from_tty)
550 printf_unfiltered (_("No saved terminal information.\n"));
553 /* A default implementation for the to_get_ada_task_ptid target method.
555 This function builds the PTID by using both LWP and TID as part of
556 the PTID lwp and tid elements. The pid used is the pid of the
560 default_get_ada_task_ptid (struct target_ops *self, long lwp, long tid)
562 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
565 static enum exec_direction_kind
566 default_execution_direction (struct target_ops *self)
568 if (!target_can_execute_reverse)
570 else if (!target_can_async_p ())
573 gdb_assert_not_reached ("\
574 to_execution_direction must be implemented for reverse async");
577 /* Go through the target stack from top to bottom, copying over zero
578 entries in current_target, then filling in still empty entries. In
579 effect, we are doing class inheritance through the pushed target
582 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
583 is currently implemented, is that it discards any knowledge of
584 which target an inherited method originally belonged to.
585 Consequently, new new target methods should instead explicitly and
586 locally search the target stack for the target that can handle the
590 update_current_target (void)
592 struct target_ops *t;
594 /* First, reset current's contents. */
595 memset (¤t_target, 0, sizeof (current_target));
597 /* Install the delegators. */
598 install_delegators (¤t_target);
600 current_target.to_stratum = target_stack->to_stratum;
602 #define INHERIT(FIELD, TARGET) \
603 if (!current_target.FIELD) \
604 current_target.FIELD = (TARGET)->FIELD
606 /* Do not add any new INHERITs here. Instead, use the delegation
607 mechanism provided by make-target-delegates. */
608 for (t = target_stack; t; t = t->beneath)
610 INHERIT (to_shortname, t);
611 INHERIT (to_longname, t);
612 INHERIT (to_attach_no_wait, t);
613 INHERIT (deprecated_xfer_memory, t);
614 INHERIT (to_have_steppable_watchpoint, t);
615 INHERIT (to_have_continuable_watchpoint, t);
616 INHERIT (to_has_thread_control, t);
620 /* Clean up a target struct so it no longer has any zero pointers in
621 it. Do not add any new de_faults here. Instead, use the
622 delegation mechanism provided by make-target-delegates. */
624 #define de_fault(field, value) \
625 if (!current_target.field) \
626 current_target.field = value
628 de_fault (deprecated_xfer_memory,
629 (int (*) (CORE_ADDR, gdb_byte *, int, int,
630 struct mem_attrib *, struct target_ops *))
635 /* Finally, position the target-stack beneath the squashed
636 "current_target". That way code looking for a non-inherited
637 target method can quickly and simply find it. */
638 current_target.beneath = target_stack;
641 setup_target_debug ();
644 /* Push a new target type into the stack of the existing target accessors,
645 possibly superseding some of the existing accessors.
647 Rather than allow an empty stack, we always have the dummy target at
648 the bottom stratum, so we can call the function vectors without
652 push_target (struct target_ops *t)
654 struct target_ops **cur;
656 /* Check magic number. If wrong, it probably means someone changed
657 the struct definition, but not all the places that initialize one. */
658 if (t->to_magic != OPS_MAGIC)
660 fprintf_unfiltered (gdb_stderr,
661 "Magic number of %s target struct wrong\n",
663 internal_error (__FILE__, __LINE__,
664 _("failed internal consistency check"));
667 /* Find the proper stratum to install this target in. */
668 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
670 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
674 /* If there's already targets at this stratum, remove them. */
675 /* FIXME: cagney/2003-10-15: I think this should be popping all
676 targets to CUR, and not just those at this stratum level. */
677 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
679 /* There's already something at this stratum level. Close it,
680 and un-hook it from the stack. */
681 struct target_ops *tmp = (*cur);
683 (*cur) = (*cur)->beneath;
688 /* We have removed all targets in our stratum, now add the new one. */
692 update_current_target ();
695 /* Remove a target_ops vector from the stack, wherever it may be.
696 Return how many times it was removed (0 or 1). */
699 unpush_target (struct target_ops *t)
701 struct target_ops **cur;
702 struct target_ops *tmp;
704 if (t->to_stratum == dummy_stratum)
705 internal_error (__FILE__, __LINE__,
706 _("Attempt to unpush the dummy target"));
708 /* Look for the specified target. Note that we assume that a target
709 can only occur once in the target stack. */
711 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
717 /* If we don't find target_ops, quit. Only open targets should be
722 /* Unchain the target. */
724 (*cur) = (*cur)->beneath;
727 update_current_target ();
729 /* Finally close the target. Note we do this after unchaining, so
730 any target method calls from within the target_close
731 implementation don't end up in T anymore. */
738 pop_all_targets_above (enum strata above_stratum)
740 while ((int) (current_target.to_stratum) > (int) above_stratum)
742 if (!unpush_target (target_stack))
744 fprintf_unfiltered (gdb_stderr,
745 "pop_all_targets couldn't find target %s\n",
746 target_stack->to_shortname);
747 internal_error (__FILE__, __LINE__,
748 _("failed internal consistency check"));
755 pop_all_targets (void)
757 pop_all_targets_above (dummy_stratum);
760 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
763 target_is_pushed (struct target_ops *t)
765 struct target_ops **cur;
767 /* Check magic number. If wrong, it probably means someone changed
768 the struct definition, but not all the places that initialize one. */
769 if (t->to_magic != OPS_MAGIC)
771 fprintf_unfiltered (gdb_stderr,
772 "Magic number of %s target struct wrong\n",
774 internal_error (__FILE__, __LINE__,
775 _("failed internal consistency check"));
778 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
785 /* Using the objfile specified in OBJFILE, find the address for the
786 current thread's thread-local storage with offset OFFSET. */
788 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
790 volatile CORE_ADDR addr = 0;
791 struct target_ops *target;
793 for (target = current_target.beneath;
795 target = target->beneath)
797 if (target->to_get_thread_local_address != NULL)
802 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
804 ptid_t ptid = inferior_ptid;
805 volatile struct gdb_exception ex;
807 TRY_CATCH (ex, RETURN_MASK_ALL)
811 /* Fetch the load module address for this objfile. */
812 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
814 /* If it's 0, throw the appropriate exception. */
816 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
817 _("TLS load module not found"));
819 addr = target->to_get_thread_local_address (target, ptid,
822 /* If an error occurred, print TLS related messages here. Otherwise,
823 throw the error to some higher catcher. */
826 int objfile_is_library = (objfile->flags & OBJF_SHARED);
830 case TLS_NO_LIBRARY_SUPPORT_ERROR:
831 error (_("Cannot find thread-local variables "
832 "in this thread library."));
834 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
835 if (objfile_is_library)
836 error (_("Cannot find shared library `%s' in dynamic"
837 " linker's load module list"), objfile_name (objfile));
839 error (_("Cannot find executable file `%s' in dynamic"
840 " linker's load module list"), objfile_name (objfile));
842 case TLS_NOT_ALLOCATED_YET_ERROR:
843 if (objfile_is_library)
844 error (_("The inferior has not yet allocated storage for"
845 " thread-local variables in\n"
846 "the shared library `%s'\n"
848 objfile_name (objfile), target_pid_to_str (ptid));
850 error (_("The inferior has not yet allocated storage for"
851 " thread-local variables in\n"
852 "the executable `%s'\n"
854 objfile_name (objfile), target_pid_to_str (ptid));
856 case TLS_GENERIC_ERROR:
857 if (objfile_is_library)
858 error (_("Cannot find thread-local storage for %s, "
859 "shared library %s:\n%s"),
860 target_pid_to_str (ptid),
861 objfile_name (objfile), ex.message);
863 error (_("Cannot find thread-local storage for %s, "
864 "executable file %s:\n%s"),
865 target_pid_to_str (ptid),
866 objfile_name (objfile), ex.message);
869 throw_exception (ex);
874 /* It wouldn't be wrong here to try a gdbarch method, too; finding
875 TLS is an ABI-specific thing. But we don't do that yet. */
877 error (_("Cannot find thread-local variables on this target"));
883 target_xfer_status_to_string (enum target_xfer_status status)
885 #define CASE(X) case X: return #X
888 CASE(TARGET_XFER_E_IO);
889 CASE(TARGET_XFER_UNAVAILABLE);
898 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
900 /* target_read_string -- read a null terminated string, up to LEN bytes,
901 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
902 Set *STRING to a pointer to malloc'd memory containing the data; the caller
903 is responsible for freeing it. Return the number of bytes successfully
907 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
913 int buffer_allocated;
915 unsigned int nbytes_read = 0;
919 /* Small for testing. */
920 buffer_allocated = 4;
921 buffer = xmalloc (buffer_allocated);
926 tlen = MIN (len, 4 - (memaddr & 3));
927 offset = memaddr & 3;
929 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
932 /* The transfer request might have crossed the boundary to an
933 unallocated region of memory. Retry the transfer, requesting
937 errcode = target_read_memory (memaddr, buf, 1);
942 if (bufptr - buffer + tlen > buffer_allocated)
946 bytes = bufptr - buffer;
947 buffer_allocated *= 2;
948 buffer = xrealloc (buffer, buffer_allocated);
949 bufptr = buffer + bytes;
952 for (i = 0; i < tlen; i++)
954 *bufptr++ = buf[i + offset];
955 if (buf[i + offset] == '\000')
957 nbytes_read += i + 1;
973 struct target_section_table *
974 target_get_section_table (struct target_ops *target)
977 fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
979 return (*target->to_get_section_table) (target);
982 /* Find a section containing ADDR. */
984 struct target_section *
985 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
987 struct target_section_table *table = target_get_section_table (target);
988 struct target_section *secp;
993 for (secp = table->sections; secp < table->sections_end; secp++)
995 if (addr >= secp->addr && addr < secp->endaddr)
1001 /* Read memory from the live target, even if currently inspecting a
1002 traceframe. The return is the same as that of target_read. */
1004 static enum target_xfer_status
1005 target_read_live_memory (enum target_object object,
1006 ULONGEST memaddr, gdb_byte *myaddr, ULONGEST len,
1007 ULONGEST *xfered_len)
1009 enum target_xfer_status ret;
1010 struct cleanup *cleanup;
1012 /* Switch momentarily out of tfind mode so to access live memory.
1013 Note that this must not clear global state, such as the frame
1014 cache, which must still remain valid for the previous traceframe.
1015 We may be _building_ the frame cache at this point. */
1016 cleanup = make_cleanup_restore_traceframe_number ();
1017 set_traceframe_number (-1);
1019 ret = target_xfer_partial (current_target.beneath, object, NULL,
1020 myaddr, NULL, memaddr, len, xfered_len);
1022 do_cleanups (cleanup);
1026 /* Using the set of read-only target sections of OPS, read live
1027 read-only memory. Note that the actual reads start from the
1028 top-most target again.
1030 For interface/parameters/return description see target.h,
1033 static enum target_xfer_status
1034 memory_xfer_live_readonly_partial (struct target_ops *ops,
1035 enum target_object object,
1036 gdb_byte *readbuf, ULONGEST memaddr,
1037 ULONGEST len, ULONGEST *xfered_len)
1039 struct target_section *secp;
1040 struct target_section_table *table;
1042 secp = target_section_by_addr (ops, memaddr);
1044 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1045 secp->the_bfd_section)
1048 struct target_section *p;
1049 ULONGEST memend = memaddr + len;
1051 table = target_get_section_table (ops);
1053 for (p = table->sections; p < table->sections_end; p++)
1055 if (memaddr >= p->addr)
1057 if (memend <= p->endaddr)
1059 /* Entire transfer is within this section. */
1060 return target_read_live_memory (object, memaddr,
1061 readbuf, len, xfered_len);
1063 else if (memaddr >= p->endaddr)
1065 /* This section ends before the transfer starts. */
1070 /* This section overlaps the transfer. Just do half. */
1071 len = p->endaddr - memaddr;
1072 return target_read_live_memory (object, memaddr,
1073 readbuf, len, xfered_len);
1079 return TARGET_XFER_EOF;
1082 /* Read memory from more than one valid target. A core file, for
1083 instance, could have some of memory but delegate other bits to
1084 the target below it. So, we must manually try all targets. */
1086 static enum target_xfer_status
1087 raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
1088 const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
1089 ULONGEST *xfered_len)
1091 enum target_xfer_status res;
1095 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1096 readbuf, writebuf, memaddr, len,
1098 if (res == TARGET_XFER_OK)
1101 /* Stop if the target reports that the memory is not available. */
1102 if (res == TARGET_XFER_UNAVAILABLE)
1105 /* We want to continue past core files to executables, but not
1106 past a running target's memory. */
1107 if (ops->to_has_all_memory (ops))
1112 while (ops != NULL);
1117 /* Perform a partial memory transfer.
1118 For docs see target.h, to_xfer_partial. */
1120 static enum target_xfer_status
1121 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
1122 gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr,
1123 ULONGEST len, ULONGEST *xfered_len)
1125 enum target_xfer_status res;
1127 struct mem_region *region;
1128 struct inferior *inf;
1130 /* For accesses to unmapped overlay sections, read directly from
1131 files. Must do this first, as MEMADDR may need adjustment. */
1132 if (readbuf != NULL && overlay_debugging)
1134 struct obj_section *section = find_pc_overlay (memaddr);
1136 if (pc_in_unmapped_range (memaddr, section))
1138 struct target_section_table *table
1139 = target_get_section_table (ops);
1140 const char *section_name = section->the_bfd_section->name;
1142 memaddr = overlay_mapped_address (memaddr, section);
1143 return section_table_xfer_memory_partial (readbuf, writebuf,
1144 memaddr, len, xfered_len,
1146 table->sections_end,
1151 /* Try the executable files, if "trust-readonly-sections" is set. */
1152 if (readbuf != NULL && trust_readonly)
1154 struct target_section *secp;
1155 struct target_section_table *table;
1157 secp = target_section_by_addr (ops, memaddr);
1159 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1160 secp->the_bfd_section)
1163 table = target_get_section_table (ops);
1164 return section_table_xfer_memory_partial (readbuf, writebuf,
1165 memaddr, len, xfered_len,
1167 table->sections_end,
1172 /* If reading unavailable memory in the context of traceframes, and
1173 this address falls within a read-only section, fallback to
1174 reading from live memory. */
1175 if (readbuf != NULL && get_traceframe_number () != -1)
1177 VEC(mem_range_s) *available;
1179 /* If we fail to get the set of available memory, then the
1180 target does not support querying traceframe info, and so we
1181 attempt reading from the traceframe anyway (assuming the
1182 target implements the old QTro packet then). */
1183 if (traceframe_available_memory (&available, memaddr, len))
1185 struct cleanup *old_chain;
1187 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
1189 if (VEC_empty (mem_range_s, available)
1190 || VEC_index (mem_range_s, available, 0)->start != memaddr)
1192 /* Don't read into the traceframe's available
1194 if (!VEC_empty (mem_range_s, available))
1196 LONGEST oldlen = len;
1198 len = VEC_index (mem_range_s, available, 0)->start - memaddr;
1199 gdb_assert (len <= oldlen);
1202 do_cleanups (old_chain);
1204 /* This goes through the topmost target again. */
1205 res = memory_xfer_live_readonly_partial (ops, object,
1208 if (res == TARGET_XFER_OK)
1209 return TARGET_XFER_OK;
1212 /* No use trying further, we know some memory starting
1213 at MEMADDR isn't available. */
1215 return TARGET_XFER_UNAVAILABLE;
1219 /* Don't try to read more than how much is available, in
1220 case the target implements the deprecated QTro packet to
1221 cater for older GDBs (the target's knowledge of read-only
1222 sections may be outdated by now). */
1223 len = VEC_index (mem_range_s, available, 0)->length;
1225 do_cleanups (old_chain);
1229 /* Try GDB's internal data cache. */
1230 region = lookup_mem_region (memaddr);
1231 /* region->hi == 0 means there's no upper bound. */
1232 if (memaddr + len < region->hi || region->hi == 0)
1235 reg_len = region->hi - memaddr;
1237 switch (region->attrib.mode)
1240 if (writebuf != NULL)
1241 return TARGET_XFER_E_IO;
1245 if (readbuf != NULL)
1246 return TARGET_XFER_E_IO;
1250 /* We only support writing to flash during "load" for now. */
1251 if (writebuf != NULL)
1252 error (_("Writing to flash memory forbidden in this context"));
1256 return TARGET_XFER_E_IO;
1259 if (!ptid_equal (inferior_ptid, null_ptid))
1260 inf = find_inferior_pid (ptid_get_pid (inferior_ptid));
1265 /* The dcache reads whole cache lines; that doesn't play well
1266 with reading from a trace buffer, because reading outside of
1267 the collected memory range fails. */
1268 && get_traceframe_number () == -1
1269 && (region->attrib.cache
1270 || (stack_cache_enabled_p () && object == TARGET_OBJECT_STACK_MEMORY)
1271 || (code_cache_enabled_p () && object == TARGET_OBJECT_CODE_MEMORY)))
1273 DCACHE *dcache = target_dcache_get_or_init ();
1276 if (readbuf != NULL)
1277 l = dcache_xfer_memory (ops, dcache, memaddr, readbuf, reg_len, 0);
1279 /* FIXME drow/2006-08-09: If we're going to preserve const
1280 correctness dcache_xfer_memory should take readbuf and
1282 l = dcache_xfer_memory (ops, dcache, memaddr, (void *) writebuf,
1285 return TARGET_XFER_E_IO;
1288 *xfered_len = (ULONGEST) l;
1289 return TARGET_XFER_OK;
1293 /* If none of those methods found the memory we wanted, fall back
1294 to a target partial transfer. Normally a single call to
1295 to_xfer_partial is enough; if it doesn't recognize an object
1296 it will call the to_xfer_partial of the next target down.
1297 But for memory this won't do. Memory is the only target
1298 object which can be read from more than one valid target.
1299 A core file, for instance, could have some of memory but
1300 delegate other bits to the target below it. So, we must
1301 manually try all targets. */
1303 res = raw_memory_xfer_partial (ops, readbuf, writebuf, memaddr, reg_len,
1306 /* Make sure the cache gets updated no matter what - if we are writing
1307 to the stack. Even if this write is not tagged as such, we still need
1308 to update the cache. */
1310 if (res == TARGET_XFER_OK
1313 && target_dcache_init_p ()
1314 && !region->attrib.cache
1315 && ((stack_cache_enabled_p () && object != TARGET_OBJECT_STACK_MEMORY)
1316 || (code_cache_enabled_p () && object != TARGET_OBJECT_CODE_MEMORY)))
1318 DCACHE *dcache = target_dcache_get ();
1320 dcache_update (dcache, memaddr, (void *) writebuf, reg_len);
1323 /* If we still haven't got anything, return the last error. We
1328 /* Perform a partial memory transfer. For docs see target.h,
1331 static enum target_xfer_status
1332 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1333 gdb_byte *readbuf, const gdb_byte *writebuf,
1334 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1336 enum target_xfer_status res;
1338 /* Zero length requests are ok and require no work. */
1340 return TARGET_XFER_EOF;
1342 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1343 breakpoint insns, thus hiding out from higher layers whether
1344 there are software breakpoints inserted in the code stream. */
1345 if (readbuf != NULL)
1347 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len,
1350 if (res == TARGET_XFER_OK && !show_memory_breakpoints)
1351 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, *xfered_len);
1356 struct cleanup *old_chain;
1358 /* A large write request is likely to be partially satisfied
1359 by memory_xfer_partial_1. We will continually malloc
1360 and free a copy of the entire write request for breakpoint
1361 shadow handling even though we only end up writing a small
1362 subset of it. Cap writes to 4KB to mitigate this. */
1363 len = min (4096, len);
1365 buf = xmalloc (len);
1366 old_chain = make_cleanup (xfree, buf);
1367 memcpy (buf, writebuf, len);
1369 breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
1370 res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len,
1373 do_cleanups (old_chain);
1380 restore_show_memory_breakpoints (void *arg)
1382 show_memory_breakpoints = (uintptr_t) arg;
1386 make_show_memory_breakpoints_cleanup (int show)
1388 int current = show_memory_breakpoints;
1390 show_memory_breakpoints = show;
1391 return make_cleanup (restore_show_memory_breakpoints,
1392 (void *) (uintptr_t) current);
1395 /* For docs see target.h, to_xfer_partial. */
1397 enum target_xfer_status
1398 target_xfer_partial (struct target_ops *ops,
1399 enum target_object object, const char *annex,
1400 gdb_byte *readbuf, const gdb_byte *writebuf,
1401 ULONGEST offset, ULONGEST len,
1402 ULONGEST *xfered_len)
1404 enum target_xfer_status retval;
1406 gdb_assert (ops->to_xfer_partial != NULL);
1408 /* Transfer is done when LEN is zero. */
1410 return TARGET_XFER_EOF;
1412 if (writebuf && !may_write_memory)
1413 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1414 core_addr_to_string_nz (offset), plongest (len));
1418 /* If this is a memory transfer, let the memory-specific code
1419 have a look at it instead. Memory transfers are more
1421 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
1422 || object == TARGET_OBJECT_CODE_MEMORY)
1423 retval = memory_xfer_partial (ops, object, readbuf,
1424 writebuf, offset, len, xfered_len);
1425 else if (object == TARGET_OBJECT_RAW_MEMORY)
1427 /* Request the normal memory object from other layers. */
1428 retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len,
1432 retval = ops->to_xfer_partial (ops, object, annex, readbuf,
1433 writebuf, offset, len, xfered_len);
1437 const unsigned char *myaddr = NULL;
1439 fprintf_unfiltered (gdb_stdlog,
1440 "%s:target_xfer_partial "
1441 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1444 (annex ? annex : "(null)"),
1445 host_address_to_string (readbuf),
1446 host_address_to_string (writebuf),
1447 core_addr_to_string_nz (offset),
1448 pulongest (len), retval,
1449 pulongest (*xfered_len));
1455 if (retval == TARGET_XFER_OK && myaddr != NULL)
1459 fputs_unfiltered (", bytes =", gdb_stdlog);
1460 for (i = 0; i < *xfered_len; i++)
1462 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1464 if (targetdebug < 2 && i > 0)
1466 fprintf_unfiltered (gdb_stdlog, " ...");
1469 fprintf_unfiltered (gdb_stdlog, "\n");
1472 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1476 fputc_unfiltered ('\n', gdb_stdlog);
1479 /* Check implementations of to_xfer_partial update *XFERED_LEN
1480 properly. Do assertion after printing debug messages, so that we
1481 can find more clues on assertion failure from debugging messages. */
1482 if (retval == TARGET_XFER_OK || retval == TARGET_XFER_UNAVAILABLE)
1483 gdb_assert (*xfered_len > 0);
1488 /* Read LEN bytes of target memory at address MEMADDR, placing the
1489 results in GDB's memory at MYADDR. Returns either 0 for success or
1490 TARGET_XFER_E_IO if any error occurs.
1492 If an error occurs, no guarantee is made about the contents of the data at
1493 MYADDR. In particular, the caller should not depend upon partial reads
1494 filling the buffer with good data. There is no way for the caller to know
1495 how much good data might have been transfered anyway. Callers that can
1496 deal with partial reads should call target_read (which will retry until
1497 it makes no progress, and then return how much was transferred). */
1500 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1502 /* Dispatch to the topmost target, not the flattened current_target.
1503 Memory accesses check target->to_has_(all_)memory, and the
1504 flattened target doesn't inherit those. */
1505 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1506 myaddr, memaddr, len) == len)
1509 return TARGET_XFER_E_IO;
1512 /* Like target_read_memory, but specify explicitly that this is a read
1513 from the target's raw memory. That is, this read bypasses the
1514 dcache, breakpoint shadowing, etc. */
1517 target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1519 /* See comment in target_read_memory about why the request starts at
1520 current_target.beneath. */
1521 if (target_read (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1522 myaddr, memaddr, len) == len)
1525 return TARGET_XFER_E_IO;
1528 /* Like target_read_memory, but specify explicitly that this is a read from
1529 the target's stack. This may trigger different cache behavior. */
1532 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1534 /* See comment in target_read_memory about why the request starts at
1535 current_target.beneath. */
1536 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1537 myaddr, memaddr, len) == len)
1540 return TARGET_XFER_E_IO;
1543 /* Like target_read_memory, but specify explicitly that this is a read from
1544 the target's code. This may trigger different cache behavior. */
1547 target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1549 /* See comment in target_read_memory about why the request starts at
1550 current_target.beneath. */
1551 if (target_read (current_target.beneath, TARGET_OBJECT_CODE_MEMORY, NULL,
1552 myaddr, memaddr, len) == len)
1555 return TARGET_XFER_E_IO;
1558 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1559 Returns either 0 for success or TARGET_XFER_E_IO if any
1560 error occurs. If an error occurs, no guarantee is made about how
1561 much data got written. Callers that can deal with partial writes
1562 should call target_write. */
1565 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1567 /* See comment in target_read_memory about why the request starts at
1568 current_target.beneath. */
1569 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1570 myaddr, memaddr, len) == len)
1573 return TARGET_XFER_E_IO;
1576 /* Write LEN bytes from MYADDR to target raw memory at address
1577 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1578 if any error occurs. If an error occurs, no guarantee is made
1579 about how much data got written. Callers that can deal with
1580 partial writes should call target_write. */
1583 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1585 /* See comment in target_read_memory about why the request starts at
1586 current_target.beneath. */
1587 if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1588 myaddr, memaddr, len) == len)
1591 return TARGET_XFER_E_IO;
1594 /* Fetch the target's memory map. */
1597 target_memory_map (void)
1599 VEC(mem_region_s) *result;
1600 struct mem_region *last_one, *this_one;
1602 struct target_ops *t;
1605 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1607 result = current_target.to_memory_map (¤t_target);
1611 qsort (VEC_address (mem_region_s, result),
1612 VEC_length (mem_region_s, result),
1613 sizeof (struct mem_region), mem_region_cmp);
1615 /* Check that regions do not overlap. Simultaneously assign
1616 a numbering for the "mem" commands to use to refer to
1619 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1621 this_one->number = ix;
1623 if (last_one && last_one->hi > this_one->lo)
1625 warning (_("Overlapping regions in memory map: ignoring"));
1626 VEC_free (mem_region_s, result);
1629 last_one = this_one;
1636 target_flash_erase (ULONGEST address, LONGEST length)
1639 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1640 hex_string (address), phex (length, 0));
1641 current_target.to_flash_erase (¤t_target, address, length);
1645 target_flash_done (void)
1648 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1649 current_target.to_flash_done (¤t_target);
1653 show_trust_readonly (struct ui_file *file, int from_tty,
1654 struct cmd_list_element *c, const char *value)
1656 fprintf_filtered (file,
1657 _("Mode for reading from readonly sections is %s.\n"),
1661 /* More generic transfers. */
1663 static enum target_xfer_status
1664 default_xfer_partial (struct target_ops *ops, enum target_object object,
1665 const char *annex, gdb_byte *readbuf,
1666 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1667 ULONGEST *xfered_len)
1669 if (object == TARGET_OBJECT_MEMORY
1670 && ops->deprecated_xfer_memory != NULL)
1671 /* If available, fall back to the target's
1672 "deprecated_xfer_memory" method. */
1677 if (writebuf != NULL)
1679 void *buffer = xmalloc (len);
1680 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1682 memcpy (buffer, writebuf, len);
1683 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1684 1/*write*/, NULL, ops);
1685 do_cleanups (cleanup);
1687 if (readbuf != NULL)
1688 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1689 0/*read*/, NULL, ops);
1692 *xfered_len = (ULONGEST) xfered;
1693 return TARGET_XFER_E_IO;
1695 else if (xfered == 0 && errno == 0)
1696 /* "deprecated_xfer_memory" uses 0, cross checked against
1697 ERRNO as one indication of an error. */
1698 return TARGET_XFER_EOF;
1700 return TARGET_XFER_E_IO;
1704 gdb_assert (ops->beneath != NULL);
1705 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1706 readbuf, writebuf, offset, len,
1711 /* Target vector read/write partial wrapper functions. */
1713 static enum target_xfer_status
1714 target_read_partial (struct target_ops *ops,
1715 enum target_object object,
1716 const char *annex, gdb_byte *buf,
1717 ULONGEST offset, ULONGEST len,
1718 ULONGEST *xfered_len)
1720 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len,
1724 static enum target_xfer_status
1725 target_write_partial (struct target_ops *ops,
1726 enum target_object object,
1727 const char *annex, const gdb_byte *buf,
1728 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
1730 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len,
1734 /* Wrappers to perform the full transfer. */
1736 /* For docs on target_read see target.h. */
1739 target_read (struct target_ops *ops,
1740 enum target_object object,
1741 const char *annex, gdb_byte *buf,
1742 ULONGEST offset, LONGEST len)
1746 while (xfered < len)
1748 ULONGEST xfered_len;
1749 enum target_xfer_status status;
1751 status = target_read_partial (ops, object, annex,
1752 (gdb_byte *) buf + xfered,
1753 offset + xfered, len - xfered,
1756 /* Call an observer, notifying them of the xfer progress? */
1757 if (status == TARGET_XFER_EOF)
1759 else if (status == TARGET_XFER_OK)
1761 xfered += xfered_len;
1771 /* Assuming that the entire [begin, end) range of memory cannot be
1772 read, try to read whatever subrange is possible to read.
1774 The function returns, in RESULT, either zero or one memory block.
1775 If there's a readable subrange at the beginning, it is completely
1776 read and returned. Any further readable subrange will not be read.
1777 Otherwise, if there's a readable subrange at the end, it will be
1778 completely read and returned. Any readable subranges before it
1779 (obviously, not starting at the beginning), will be ignored. In
1780 other cases -- either no readable subrange, or readable subrange(s)
1781 that is neither at the beginning, or end, nothing is returned.
1783 The purpose of this function is to handle a read across a boundary
1784 of accessible memory in a case when memory map is not available.
1785 The above restrictions are fine for this case, but will give
1786 incorrect results if the memory is 'patchy'. However, supporting
1787 'patchy' memory would require trying to read every single byte,
1788 and it seems unacceptable solution. Explicit memory map is
1789 recommended for this case -- and target_read_memory_robust will
1790 take care of reading multiple ranges then. */
1793 read_whatever_is_readable (struct target_ops *ops,
1794 ULONGEST begin, ULONGEST end,
1795 VEC(memory_read_result_s) **result)
1797 gdb_byte *buf = xmalloc (end - begin);
1798 ULONGEST current_begin = begin;
1799 ULONGEST current_end = end;
1801 memory_read_result_s r;
1802 ULONGEST xfered_len;
1804 /* If we previously failed to read 1 byte, nothing can be done here. */
1805 if (end - begin <= 1)
1811 /* Check that either first or the last byte is readable, and give up
1812 if not. This heuristic is meant to permit reading accessible memory
1813 at the boundary of accessible region. */
1814 if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1815 buf, begin, 1, &xfered_len) == TARGET_XFER_OK)
1820 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1821 buf + (end-begin) - 1, end - 1, 1,
1822 &xfered_len) == TARGET_XFER_OK)
1833 /* Loop invariant is that the [current_begin, current_end) was previously
1834 found to be not readable as a whole.
1836 Note loop condition -- if the range has 1 byte, we can't divide the range
1837 so there's no point trying further. */
1838 while (current_end - current_begin > 1)
1840 ULONGEST first_half_begin, first_half_end;
1841 ULONGEST second_half_begin, second_half_end;
1843 ULONGEST middle = current_begin + (current_end - current_begin)/2;
1847 first_half_begin = current_begin;
1848 first_half_end = middle;
1849 second_half_begin = middle;
1850 second_half_end = current_end;
1854 first_half_begin = middle;
1855 first_half_end = current_end;
1856 second_half_begin = current_begin;
1857 second_half_end = middle;
1860 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1861 buf + (first_half_begin - begin),
1863 first_half_end - first_half_begin);
1865 if (xfer == first_half_end - first_half_begin)
1867 /* This half reads up fine. So, the error must be in the
1869 current_begin = second_half_begin;
1870 current_end = second_half_end;
1874 /* This half is not readable. Because we've tried one byte, we
1875 know some part of this half if actually redable. Go to the next
1876 iteration to divide again and try to read.
1878 We don't handle the other half, because this function only tries
1879 to read a single readable subrange. */
1880 current_begin = first_half_begin;
1881 current_end = first_half_end;
1887 /* The [begin, current_begin) range has been read. */
1889 r.end = current_begin;
1894 /* The [current_end, end) range has been read. */
1895 LONGEST rlen = end - current_end;
1897 r.data = xmalloc (rlen);
1898 memcpy (r.data, buf + current_end - begin, rlen);
1899 r.begin = current_end;
1903 VEC_safe_push(memory_read_result_s, (*result), &r);
1907 free_memory_read_result_vector (void *x)
1909 VEC(memory_read_result_s) *v = x;
1910 memory_read_result_s *current;
1913 for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
1915 xfree (current->data);
1917 VEC_free (memory_read_result_s, v);
1920 VEC(memory_read_result_s) *
1921 read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
1923 VEC(memory_read_result_s) *result = 0;
1926 while (xfered < len)
1928 struct mem_region *region = lookup_mem_region (offset + xfered);
1931 /* If there is no explicit region, a fake one should be created. */
1932 gdb_assert (region);
1934 if (region->hi == 0)
1935 rlen = len - xfered;
1937 rlen = region->hi - offset;
1939 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
1941 /* Cannot read this region. Note that we can end up here only
1942 if the region is explicitly marked inaccessible, or
1943 'inaccessible-by-default' is in effect. */
1948 LONGEST to_read = min (len - xfered, rlen);
1949 gdb_byte *buffer = (gdb_byte *)xmalloc (to_read);
1951 LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1952 (gdb_byte *) buffer,
1953 offset + xfered, to_read);
1954 /* Call an observer, notifying them of the xfer progress? */
1957 /* Got an error reading full chunk. See if maybe we can read
1960 read_whatever_is_readable (ops, offset + xfered,
1961 offset + xfered + to_read, &result);
1966 struct memory_read_result r;
1968 r.begin = offset + xfered;
1969 r.end = r.begin + xfer;
1970 VEC_safe_push (memory_read_result_s, result, &r);
1980 /* An alternative to target_write with progress callbacks. */
1983 target_write_with_progress (struct target_ops *ops,
1984 enum target_object object,
1985 const char *annex, const gdb_byte *buf,
1986 ULONGEST offset, LONGEST len,
1987 void (*progress) (ULONGEST, void *), void *baton)
1991 /* Give the progress callback a chance to set up. */
1993 (*progress) (0, baton);
1995 while (xfered < len)
1997 ULONGEST xfered_len;
1998 enum target_xfer_status status;
2000 status = target_write_partial (ops, object, annex,
2001 (gdb_byte *) buf + xfered,
2002 offset + xfered, len - xfered,
2005 if (status != TARGET_XFER_OK)
2006 return status == TARGET_XFER_EOF ? xfered : -1;
2009 (*progress) (xfered_len, baton);
2011 xfered += xfered_len;
2017 /* For docs on target_write see target.h. */
2020 target_write (struct target_ops *ops,
2021 enum target_object object,
2022 const char *annex, const gdb_byte *buf,
2023 ULONGEST offset, LONGEST len)
2025 return target_write_with_progress (ops, object, annex, buf, offset, len,
2029 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2030 the size of the transferred data. PADDING additional bytes are
2031 available in *BUF_P. This is a helper function for
2032 target_read_alloc; see the declaration of that function for more
2036 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
2037 const char *annex, gdb_byte **buf_p, int padding)
2039 size_t buf_alloc, buf_pos;
2042 /* This function does not have a length parameter; it reads the
2043 entire OBJECT). Also, it doesn't support objects fetched partly
2044 from one target and partly from another (in a different stratum,
2045 e.g. a core file and an executable). Both reasons make it
2046 unsuitable for reading memory. */
2047 gdb_assert (object != TARGET_OBJECT_MEMORY);
2049 /* Start by reading up to 4K at a time. The target will throttle
2050 this number down if necessary. */
2052 buf = xmalloc (buf_alloc);
2056 ULONGEST xfered_len;
2057 enum target_xfer_status status;
2059 status = target_read_partial (ops, object, annex, &buf[buf_pos],
2060 buf_pos, buf_alloc - buf_pos - padding,
2063 if (status == TARGET_XFER_EOF)
2065 /* Read all there was. */
2072 else if (status != TARGET_XFER_OK)
2074 /* An error occurred. */
2076 return TARGET_XFER_E_IO;
2079 buf_pos += xfered_len;
2081 /* If the buffer is filling up, expand it. */
2082 if (buf_alloc < buf_pos * 2)
2085 buf = xrealloc (buf, buf_alloc);
2092 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2093 the size of the transferred data. See the declaration in "target.h"
2094 function for more information about the return value. */
2097 target_read_alloc (struct target_ops *ops, enum target_object object,
2098 const char *annex, gdb_byte **buf_p)
2100 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
2103 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2104 returned as a string, allocated using xmalloc. If an error occurs
2105 or the transfer is unsupported, NULL is returned. Empty objects
2106 are returned as allocated but empty strings. A warning is issued
2107 if the result contains any embedded NUL bytes. */
2110 target_read_stralloc (struct target_ops *ops, enum target_object object,
2115 LONGEST i, transferred;
2117 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
2118 bufstr = (char *) buffer;
2120 if (transferred < 0)
2123 if (transferred == 0)
2124 return xstrdup ("");
2126 bufstr[transferred] = 0;
2128 /* Check for embedded NUL bytes; but allow trailing NULs. */
2129 for (i = strlen (bufstr); i < transferred; i++)
2132 warning (_("target object %d, annex %s, "
2133 "contained unexpected null characters"),
2134 (int) object, annex ? annex : "(none)");
2141 /* Memory transfer methods. */
2144 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2147 /* This method is used to read from an alternate, non-current
2148 target. This read must bypass the overlay support (as symbols
2149 don't match this target), and GDB's internal cache (wrong cache
2150 for this target). */
2151 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2153 memory_error (TARGET_XFER_E_IO, addr);
2157 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2158 int len, enum bfd_endian byte_order)
2160 gdb_byte buf[sizeof (ULONGEST)];
2162 gdb_assert (len <= sizeof (buf));
2163 get_target_memory (ops, addr, buf, len);
2164 return extract_unsigned_integer (buf, len, byte_order);
2170 target_insert_breakpoint (struct gdbarch *gdbarch,
2171 struct bp_target_info *bp_tgt)
2173 if (!may_insert_breakpoints)
2175 warning (_("May not insert breakpoints"));
2179 return current_target.to_insert_breakpoint (¤t_target,
2186 target_remove_breakpoint (struct gdbarch *gdbarch,
2187 struct bp_target_info *bp_tgt)
2189 /* This is kind of a weird case to handle, but the permission might
2190 have been changed after breakpoints were inserted - in which case
2191 we should just take the user literally and assume that any
2192 breakpoints should be left in place. */
2193 if (!may_insert_breakpoints)
2195 warning (_("May not remove breakpoints"));
2199 return current_target.to_remove_breakpoint (¤t_target,
2204 target_info (char *args, int from_tty)
2206 struct target_ops *t;
2207 int has_all_mem = 0;
2209 if (symfile_objfile != NULL)
2210 printf_unfiltered (_("Symbols from \"%s\".\n"),
2211 objfile_name (symfile_objfile));
2213 for (t = target_stack; t != NULL; t = t->beneath)
2215 if (!(*t->to_has_memory) (t))
2218 if ((int) (t->to_stratum) <= (int) dummy_stratum)
2221 printf_unfiltered (_("\tWhile running this, "
2222 "GDB does not access memory from...\n"));
2223 printf_unfiltered ("%s:\n", t->to_longname);
2224 (t->to_files_info) (t);
2225 has_all_mem = (*t->to_has_all_memory) (t);
2229 /* This function is called before any new inferior is created, e.g.
2230 by running a program, attaching, or connecting to a target.
2231 It cleans up any state from previous invocations which might
2232 change between runs. This is a subset of what target_preopen
2233 resets (things which might change between targets). */
2236 target_pre_inferior (int from_tty)
2238 /* Clear out solib state. Otherwise the solib state of the previous
2239 inferior might have survived and is entirely wrong for the new
2240 target. This has been observed on GNU/Linux using glibc 2.3. How
2252 Cannot access memory at address 0xdeadbeef
2255 /* In some OSs, the shared library list is the same/global/shared
2256 across inferiors. If code is shared between processes, so are
2257 memory regions and features. */
2258 if (!gdbarch_has_global_solist (target_gdbarch ()))
2260 no_shared_libraries (NULL, from_tty);
2262 invalidate_target_mem_regions ();
2264 target_clear_description ();
2267 agent_capability_invalidate ();
2270 /* Callback for iterate_over_inferiors. Gets rid of the given
2274 dispose_inferior (struct inferior *inf, void *args)
2276 struct thread_info *thread;
2278 thread = any_thread_of_process (inf->pid);
2281 switch_to_thread (thread->ptid);
2283 /* Core inferiors actually should be detached, not killed. */
2284 if (target_has_execution)
2287 target_detach (NULL, 0);
2293 /* This is to be called by the open routine before it does
2297 target_preopen (int from_tty)
2301 if (have_inferiors ())
2304 || !have_live_inferiors ()
2305 || query (_("A program is being debugged already. Kill it? ")))
2306 iterate_over_inferiors (dispose_inferior, NULL);
2308 error (_("Program not killed."));
2311 /* Calling target_kill may remove the target from the stack. But if
2312 it doesn't (which seems like a win for UDI), remove it now. */
2313 /* Leave the exec target, though. The user may be switching from a
2314 live process to a core of the same program. */
2315 pop_all_targets_above (file_stratum);
2317 target_pre_inferior (from_tty);
2320 /* Detach a target after doing deferred register stores. */
2323 target_detach (const char *args, int from_tty)
2325 struct target_ops* t;
2327 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2328 /* Don't remove global breakpoints here. They're removed on
2329 disconnection from the target. */
2332 /* If we're in breakpoints-always-inserted mode, have to remove
2333 them before detaching. */
2334 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
2336 prepare_for_detach ();
2338 current_target.to_detach (¤t_target, args, from_tty);
2340 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
2345 target_disconnect (char *args, int from_tty)
2347 /* If we're in breakpoints-always-inserted mode or if breakpoints
2348 are global across processes, we have to remove them before
2350 remove_breakpoints ();
2353 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
2355 current_target.to_disconnect (¤t_target, args, from_tty);
2359 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2361 struct target_ops *t;
2362 ptid_t retval = (current_target.to_wait) (¤t_target, ptid,
2367 char *status_string;
2368 char *options_string;
2370 status_string = target_waitstatus_to_string (status);
2371 options_string = target_options_to_string (options);
2372 fprintf_unfiltered (gdb_stdlog,
2373 "target_wait (%d, status, options={%s})"
2375 ptid_get_pid (ptid), options_string,
2376 ptid_get_pid (retval), status_string);
2377 xfree (status_string);
2378 xfree (options_string);
2385 target_pid_to_str (ptid_t ptid)
2387 return (*current_target.to_pid_to_str) (¤t_target, ptid);
2391 target_thread_name (struct thread_info *info)
2393 return current_target.to_thread_name (¤t_target, info);
2397 target_resume (ptid_t ptid, int step, enum gdb_signal signal)
2399 struct target_ops *t;
2401 target_dcache_invalidate ();
2403 current_target.to_resume (¤t_target, ptid, step, signal);
2405 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
2406 ptid_get_pid (ptid),
2407 step ? "step" : "continue",
2408 gdb_signal_to_name (signal));
2410 registers_changed_ptid (ptid);
2411 set_executing (ptid, 1);
2412 set_running (ptid, 1);
2413 clear_inline_frame_state (ptid);
2417 target_pass_signals (int numsigs, unsigned char *pass_signals)
2423 fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
2426 for (i = 0; i < numsigs; i++)
2427 if (pass_signals[i])
2428 fprintf_unfiltered (gdb_stdlog, " %s",
2429 gdb_signal_to_name (i));
2431 fprintf_unfiltered (gdb_stdlog, " })\n");
2434 (*current_target.to_pass_signals) (¤t_target, numsigs, pass_signals);
2438 target_program_signals (int numsigs, unsigned char *program_signals)
2444 fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
2447 for (i = 0; i < numsigs; i++)
2448 if (program_signals[i])
2449 fprintf_unfiltered (gdb_stdlog, " %s",
2450 gdb_signal_to_name (i));
2452 fprintf_unfiltered (gdb_stdlog, " })\n");
2455 (*current_target.to_program_signals) (¤t_target,
2456 numsigs, program_signals);
2460 default_follow_fork (struct target_ops *self, int follow_child,
2463 /* Some target returned a fork event, but did not know how to follow it. */
2464 internal_error (__FILE__, __LINE__,
2465 _("could not find a target to follow fork"));
2468 /* Look through the list of possible targets for a target that can
2472 target_follow_fork (int follow_child, int detach_fork)
2474 int retval = current_target.to_follow_fork (¤t_target,
2475 follow_child, detach_fork);
2478 fprintf_unfiltered (gdb_stdlog,
2479 "target_follow_fork (%d, %d) = %d\n",
2480 follow_child, detach_fork, retval);
2485 default_mourn_inferior (struct target_ops *self)
2487 internal_error (__FILE__, __LINE__,
2488 _("could not find a target to follow mourn inferior"));
2492 target_mourn_inferior (void)
2494 current_target.to_mourn_inferior (¤t_target);
2496 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2498 /* We no longer need to keep handles on any of the object files.
2499 Make sure to release them to avoid unnecessarily locking any
2500 of them while we're not actually debugging. */
2501 bfd_cache_close_all ();
2504 /* Look for a target which can describe architectural features, starting
2505 from TARGET. If we find one, return its description. */
2507 const struct target_desc *
2508 target_read_description (struct target_ops *target)
2510 return target->to_read_description (target);
2513 /* This implements a basic search of memory, reading target memory and
2514 performing the search here (as opposed to performing the search in on the
2515 target side with, for example, gdbserver). */
2518 simple_search_memory (struct target_ops *ops,
2519 CORE_ADDR start_addr, ULONGEST search_space_len,
2520 const gdb_byte *pattern, ULONGEST pattern_len,
2521 CORE_ADDR *found_addrp)
2523 /* NOTE: also defined in find.c testcase. */
2524 #define SEARCH_CHUNK_SIZE 16000
2525 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2526 /* Buffer to hold memory contents for searching. */
2527 gdb_byte *search_buf;
2528 unsigned search_buf_size;
2529 struct cleanup *old_cleanups;
2531 search_buf_size = chunk_size + pattern_len - 1;
2533 /* No point in trying to allocate a buffer larger than the search space. */
2534 if (search_space_len < search_buf_size)
2535 search_buf_size = search_space_len;
2537 search_buf = malloc (search_buf_size);
2538 if (search_buf == NULL)
2539 error (_("Unable to allocate memory to perform the search."));
2540 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2542 /* Prime the search buffer. */
2544 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2545 search_buf, start_addr, search_buf_size) != search_buf_size)
2547 warning (_("Unable to access %s bytes of target "
2548 "memory at %s, halting search."),
2549 pulongest (search_buf_size), hex_string (start_addr));
2550 do_cleanups (old_cleanups);
2554 /* Perform the search.
2556 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2557 When we've scanned N bytes we copy the trailing bytes to the start and
2558 read in another N bytes. */
2560 while (search_space_len >= pattern_len)
2562 gdb_byte *found_ptr;
2563 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2565 found_ptr = memmem (search_buf, nr_search_bytes,
2566 pattern, pattern_len);
2568 if (found_ptr != NULL)
2570 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2572 *found_addrp = found_addr;
2573 do_cleanups (old_cleanups);
2577 /* Not found in this chunk, skip to next chunk. */
2579 /* Don't let search_space_len wrap here, it's unsigned. */
2580 if (search_space_len >= chunk_size)
2581 search_space_len -= chunk_size;
2583 search_space_len = 0;
2585 if (search_space_len >= pattern_len)
2587 unsigned keep_len = search_buf_size - chunk_size;
2588 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
2591 /* Copy the trailing part of the previous iteration to the front
2592 of the buffer for the next iteration. */
2593 gdb_assert (keep_len == pattern_len - 1);
2594 memcpy (search_buf, search_buf + chunk_size, keep_len);
2596 nr_to_read = min (search_space_len - keep_len, chunk_size);
2598 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2599 search_buf + keep_len, read_addr,
2600 nr_to_read) != nr_to_read)
2602 warning (_("Unable to access %s bytes of target "
2603 "memory at %s, halting search."),
2604 plongest (nr_to_read),
2605 hex_string (read_addr));
2606 do_cleanups (old_cleanups);
2610 start_addr += chunk_size;
2616 do_cleanups (old_cleanups);
2620 /* Default implementation of memory-searching. */
2623 default_search_memory (struct target_ops *self,
2624 CORE_ADDR start_addr, ULONGEST search_space_len,
2625 const gdb_byte *pattern, ULONGEST pattern_len,
2626 CORE_ADDR *found_addrp)
2628 /* Start over from the top of the target stack. */
2629 return simple_search_memory (current_target.beneath,
2630 start_addr, search_space_len,
2631 pattern, pattern_len, found_addrp);
2634 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2635 sequence of bytes in PATTERN with length PATTERN_LEN.
2637 The result is 1 if found, 0 if not found, and -1 if there was an error
2638 requiring halting of the search (e.g. memory read error).
2639 If the pattern is found the address is recorded in FOUND_ADDRP. */
2642 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2643 const gdb_byte *pattern, ULONGEST pattern_len,
2644 CORE_ADDR *found_addrp)
2649 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2650 hex_string (start_addr));
2652 found = current_target.to_search_memory (¤t_target, start_addr,
2654 pattern, pattern_len, found_addrp);
2657 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2662 /* Look through the currently pushed targets. If none of them will
2663 be able to restart the currently running process, issue an error
2667 target_require_runnable (void)
2669 struct target_ops *t;
2671 for (t = target_stack; t != NULL; t = t->beneath)
2673 /* If this target knows how to create a new program, then
2674 assume we will still be able to after killing the current
2675 one. Either killing and mourning will not pop T, or else
2676 find_default_run_target will find it again. */
2677 if (t->to_create_inferior != NULL)
2680 /* Do not worry about thread_stratum targets that can not
2681 create inferiors. Assume they will be pushed again if
2682 necessary, and continue to the process_stratum. */
2683 if (t->to_stratum == thread_stratum
2684 || t->to_stratum == arch_stratum)
2687 error (_("The \"%s\" target does not support \"run\". "
2688 "Try \"help target\" or \"continue\"."),
2692 /* This function is only called if the target is running. In that
2693 case there should have been a process_stratum target and it
2694 should either know how to create inferiors, or not... */
2695 internal_error (__FILE__, __LINE__, _("No targets found"));
2698 /* Look through the list of possible targets for a target that can
2699 execute a run or attach command without any other data. This is
2700 used to locate the default process stratum.
2702 If DO_MESG is not NULL, the result is always valid (error() is
2703 called for errors); else, return NULL on error. */
2705 static struct target_ops *
2706 find_default_run_target (char *do_mesg)
2708 struct target_ops **t;
2709 struct target_ops *runable = NULL;
2714 for (t = target_structs; t < target_structs + target_struct_size;
2717 if ((*t)->to_can_run != delegate_can_run && target_can_run (*t))
2727 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2736 find_default_attach (struct target_ops *ops, char *args, int from_tty)
2738 struct target_ops *t;
2740 t = find_default_run_target ("attach");
2741 (t->to_attach) (t, args, from_tty);
2746 find_default_create_inferior (struct target_ops *ops,
2747 char *exec_file, char *allargs, char **env,
2750 struct target_ops *t;
2752 t = find_default_run_target ("run");
2753 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
2758 find_default_can_async_p (struct target_ops *ignore)
2760 struct target_ops *t;
2762 /* This may be called before the target is pushed on the stack;
2763 look for the default process stratum. If there's none, gdb isn't
2764 configured with a native debugger, and target remote isn't
2766 t = find_default_run_target (NULL);
2767 if (t && t->to_can_async_p != delegate_can_async_p)
2768 return (t->to_can_async_p) (t);
2773 find_default_is_async_p (struct target_ops *ignore)
2775 struct target_ops *t;
2777 /* This may be called before the target is pushed on the stack;
2778 look for the default process stratum. If there's none, gdb isn't
2779 configured with a native debugger, and target remote isn't
2781 t = find_default_run_target (NULL);
2782 if (t && t->to_is_async_p != delegate_is_async_p)
2783 return (t->to_is_async_p) (t);
2788 find_default_supports_non_stop (struct target_ops *self)
2790 struct target_ops *t;
2792 t = find_default_run_target (NULL);
2793 if (t && t->to_supports_non_stop)
2794 return (t->to_supports_non_stop) (t);
2799 target_supports_non_stop (void)
2801 struct target_ops *t;
2803 for (t = ¤t_target; t != NULL; t = t->beneath)
2804 if (t->to_supports_non_stop)
2805 return t->to_supports_non_stop (t);
2810 /* Implement the "info proc" command. */
2813 target_info_proc (char *args, enum info_proc_what what)
2815 struct target_ops *t;
2817 /* If we're already connected to something that can get us OS
2818 related data, use it. Otherwise, try using the native
2820 if (current_target.to_stratum >= process_stratum)
2821 t = current_target.beneath;
2823 t = find_default_run_target (NULL);
2825 for (; t != NULL; t = t->beneath)
2827 if (t->to_info_proc != NULL)
2829 t->to_info_proc (t, args, what);
2832 fprintf_unfiltered (gdb_stdlog,
2833 "target_info_proc (\"%s\", %d)\n", args, what);
2843 find_default_supports_disable_randomization (struct target_ops *self)
2845 struct target_ops *t;
2847 t = find_default_run_target (NULL);
2848 if (t && t->to_supports_disable_randomization)
2849 return (t->to_supports_disable_randomization) (t);
2854 target_supports_disable_randomization (void)
2856 struct target_ops *t;
2858 for (t = ¤t_target; t != NULL; t = t->beneath)
2859 if (t->to_supports_disable_randomization)
2860 return t->to_supports_disable_randomization (t);
2866 target_get_osdata (const char *type)
2868 struct target_ops *t;
2870 /* If we're already connected to something that can get us OS
2871 related data, use it. Otherwise, try using the native
2873 if (current_target.to_stratum >= process_stratum)
2874 t = current_target.beneath;
2876 t = find_default_run_target ("get OS data");
2881 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
2884 /* Determine the current address space of thread PTID. */
2886 struct address_space *
2887 target_thread_address_space (ptid_t ptid)
2889 struct address_space *aspace;
2890 struct inferior *inf;
2891 struct target_ops *t;
2893 for (t = current_target.beneath; t != NULL; t = t->beneath)
2895 if (t->to_thread_address_space != NULL)
2897 aspace = t->to_thread_address_space (t, ptid);
2898 gdb_assert (aspace);
2901 fprintf_unfiltered (gdb_stdlog,
2902 "target_thread_address_space (%s) = %d\n",
2903 target_pid_to_str (ptid),
2904 address_space_num (aspace));
2909 /* Fall-back to the "main" address space of the inferior. */
2910 inf = find_inferior_pid (ptid_get_pid (ptid));
2912 if (inf == NULL || inf->aspace == NULL)
2913 internal_error (__FILE__, __LINE__,
2914 _("Can't determine the current "
2915 "address space of thread %s\n"),
2916 target_pid_to_str (ptid));
2922 /* Target file operations. */
2924 static struct target_ops *
2925 default_fileio_target (void)
2927 /* If we're already connected to something that can perform
2928 file I/O, use it. Otherwise, try using the native target. */
2929 if (current_target.to_stratum >= process_stratum)
2930 return current_target.beneath;
2932 return find_default_run_target ("file I/O");
2935 /* Open FILENAME on the target, using FLAGS and MODE. Return a
2936 target file descriptor, or -1 if an error occurs (and set
2939 target_fileio_open (const char *filename, int flags, int mode,
2942 struct target_ops *t;
2944 for (t = default_fileio_target (); t != NULL; t = t->beneath)
2946 if (t->to_fileio_open != NULL)
2948 int fd = t->to_fileio_open (t, filename, flags, mode, target_errno);
2951 fprintf_unfiltered (gdb_stdlog,
2952 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
2953 filename, flags, mode,
2954 fd, fd != -1 ? 0 : *target_errno);
2959 *target_errno = FILEIO_ENOSYS;
2963 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
2964 Return the number of bytes written, or -1 if an error occurs
2965 (and set *TARGET_ERRNO). */
2967 target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
2968 ULONGEST offset, int *target_errno)
2970 struct target_ops *t;
2972 for (t = default_fileio_target (); t != NULL; t = t->beneath)
2974 if (t->to_fileio_pwrite != NULL)
2976 int ret = t->to_fileio_pwrite (t, fd, write_buf, len, offset,
2980 fprintf_unfiltered (gdb_stdlog,
2981 "target_fileio_pwrite (%d,...,%d,%s) "
2983 fd, len, pulongest (offset),
2984 ret, ret != -1 ? 0 : *target_errno);
2989 *target_errno = FILEIO_ENOSYS;
2993 /* Read up to LEN bytes FD on the target into READ_BUF.
2994 Return the number of bytes read, or -1 if an error occurs
2995 (and set *TARGET_ERRNO). */
2997 target_fileio_pread (int fd, gdb_byte *read_buf, int len,
2998 ULONGEST offset, int *target_errno)
3000 struct target_ops *t;
3002 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3004 if (t->to_fileio_pread != NULL)
3006 int ret = t->to_fileio_pread (t, fd, read_buf, len, offset,
3010 fprintf_unfiltered (gdb_stdlog,
3011 "target_fileio_pread (%d,...,%d,%s) "
3013 fd, len, pulongest (offset),
3014 ret, ret != -1 ? 0 : *target_errno);
3019 *target_errno = FILEIO_ENOSYS;
3023 /* Close FD on the target. Return 0, or -1 if an error occurs
3024 (and set *TARGET_ERRNO). */
3026 target_fileio_close (int fd, int *target_errno)
3028 struct target_ops *t;
3030 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3032 if (t->to_fileio_close != NULL)
3034 int ret = t->to_fileio_close (t, fd, target_errno);
3037 fprintf_unfiltered (gdb_stdlog,
3038 "target_fileio_close (%d) = %d (%d)\n",
3039 fd, ret, ret != -1 ? 0 : *target_errno);
3044 *target_errno = FILEIO_ENOSYS;
3048 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3049 occurs (and set *TARGET_ERRNO). */
3051 target_fileio_unlink (const char *filename, int *target_errno)
3053 struct target_ops *t;
3055 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3057 if (t->to_fileio_unlink != NULL)
3059 int ret = t->to_fileio_unlink (t, filename, target_errno);
3062 fprintf_unfiltered (gdb_stdlog,
3063 "target_fileio_unlink (%s) = %d (%d)\n",
3064 filename, ret, ret != -1 ? 0 : *target_errno);
3069 *target_errno = FILEIO_ENOSYS;
3073 /* Read value of symbolic link FILENAME on the target. Return a
3074 null-terminated string allocated via xmalloc, or NULL if an error
3075 occurs (and set *TARGET_ERRNO). */
3077 target_fileio_readlink (const char *filename, int *target_errno)
3079 struct target_ops *t;
3081 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3083 if (t->to_fileio_readlink != NULL)
3085 char *ret = t->to_fileio_readlink (t, filename, target_errno);
3088 fprintf_unfiltered (gdb_stdlog,
3089 "target_fileio_readlink (%s) = %s (%d)\n",
3090 filename, ret? ret : "(nil)",
3091 ret? 0 : *target_errno);
3096 *target_errno = FILEIO_ENOSYS;
3101 target_fileio_close_cleanup (void *opaque)
3103 int fd = *(int *) opaque;
3106 target_fileio_close (fd, &target_errno);
3109 /* Read target file FILENAME. Store the result in *BUF_P and
3110 return the size of the transferred data. PADDING additional bytes are
3111 available in *BUF_P. This is a helper function for
3112 target_fileio_read_alloc; see the declaration of that function for more
3116 target_fileio_read_alloc_1 (const char *filename,
3117 gdb_byte **buf_p, int padding)
3119 struct cleanup *close_cleanup;
3120 size_t buf_alloc, buf_pos;
3126 fd = target_fileio_open (filename, FILEIO_O_RDONLY, 0700, &target_errno);
3130 close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
3132 /* Start by reading up to 4K at a time. The target will throttle
3133 this number down if necessary. */
3135 buf = xmalloc (buf_alloc);
3139 n = target_fileio_pread (fd, &buf[buf_pos],
3140 buf_alloc - buf_pos - padding, buf_pos,
3144 /* An error occurred. */
3145 do_cleanups (close_cleanup);
3151 /* Read all there was. */
3152 do_cleanups (close_cleanup);
3162 /* If the buffer is filling up, expand it. */
3163 if (buf_alloc < buf_pos * 2)
3166 buf = xrealloc (buf, buf_alloc);
3173 /* Read target file FILENAME. Store the result in *BUF_P and return
3174 the size of the transferred data. See the declaration in "target.h"
3175 function for more information about the return value. */
3178 target_fileio_read_alloc (const char *filename, gdb_byte **buf_p)
3180 return target_fileio_read_alloc_1 (filename, buf_p, 0);
3183 /* Read target file FILENAME. The result is NUL-terminated and
3184 returned as a string, allocated using xmalloc. If an error occurs
3185 or the transfer is unsupported, NULL is returned. Empty objects
3186 are returned as allocated but empty strings. A warning is issued
3187 if the result contains any embedded NUL bytes. */
3190 target_fileio_read_stralloc (const char *filename)
3194 LONGEST i, transferred;
3196 transferred = target_fileio_read_alloc_1 (filename, &buffer, 1);
3197 bufstr = (char *) buffer;
3199 if (transferred < 0)
3202 if (transferred == 0)
3203 return xstrdup ("");
3205 bufstr[transferred] = 0;
3207 /* Check for embedded NUL bytes; but allow trailing NULs. */
3208 for (i = strlen (bufstr); i < transferred; i++)
3211 warning (_("target file %s "
3212 "contained unexpected null characters"),
3222 default_region_ok_for_hw_watchpoint (struct target_ops *self,
3223 CORE_ADDR addr, int len)
3225 return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
3229 default_watchpoint_addr_within_range (struct target_ops *target,
3231 CORE_ADDR start, int length)
3233 return addr >= start && addr < start + length;
3236 static struct gdbarch *
3237 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3239 return target_gdbarch ();
3243 return_zero (struct target_ops *ignore)
3249 return_zero_has_execution (struct target_ops *ignore, ptid_t ignore2)
3255 * Find the next target down the stack from the specified target.
3259 find_target_beneath (struct target_ops *t)
3267 find_target_at (enum strata stratum)
3269 struct target_ops *t;
3271 for (t = current_target.beneath; t != NULL; t = t->beneath)
3272 if (t->to_stratum == stratum)
3279 /* The inferior process has died. Long live the inferior! */
3282 generic_mourn_inferior (void)
3286 ptid = inferior_ptid;
3287 inferior_ptid = null_ptid;
3289 /* Mark breakpoints uninserted in case something tries to delete a
3290 breakpoint while we delete the inferior's threads (which would
3291 fail, since the inferior is long gone). */
3292 mark_breakpoints_out ();
3294 if (!ptid_equal (ptid, null_ptid))
3296 int pid = ptid_get_pid (ptid);
3297 exit_inferior (pid);
3300 /* Note this wipes step-resume breakpoints, so needs to be done
3301 after exit_inferior, which ends up referencing the step-resume
3302 breakpoints through clear_thread_inferior_resources. */
3303 breakpoint_init_inferior (inf_exited);
3305 registers_changed ();
3307 reopen_exec_file ();
3308 reinit_frame_cache ();
3310 if (deprecated_detach_hook)
3311 deprecated_detach_hook ();
3314 /* Convert a normal process ID to a string. Returns the string in a
3318 normal_pid_to_str (ptid_t ptid)
3320 static char buf[32];
3322 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
3327 default_pid_to_str (struct target_ops *ops, ptid_t ptid)
3329 return normal_pid_to_str (ptid);
3332 /* Error-catcher for target_find_memory_regions. */
3334 dummy_find_memory_regions (struct target_ops *self,
3335 find_memory_region_ftype ignore1, void *ignore2)
3337 error (_("Command not implemented for this target."));
3341 /* Error-catcher for target_make_corefile_notes. */
3343 dummy_make_corefile_notes (struct target_ops *self,
3344 bfd *ignore1, int *ignore2)
3346 error (_("Command not implemented for this target."));
3350 /* Set up the handful of non-empty slots needed by the dummy target
3354 init_dummy_target (void)
3356 dummy_target.to_shortname = "None";
3357 dummy_target.to_longname = "None";
3358 dummy_target.to_doc = "";
3359 dummy_target.to_create_inferior = find_default_create_inferior;
3360 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
3361 dummy_target.to_supports_disable_randomization
3362 = find_default_supports_disable_randomization;
3363 dummy_target.to_stratum = dummy_stratum;
3364 dummy_target.to_has_all_memory = return_zero;
3365 dummy_target.to_has_memory = return_zero;
3366 dummy_target.to_has_stack = return_zero;
3367 dummy_target.to_has_registers = return_zero;
3368 dummy_target.to_has_execution = return_zero_has_execution;
3369 dummy_target.to_magic = OPS_MAGIC;
3371 install_dummy_methods (&dummy_target);
3375 debug_to_open (char *args, int from_tty)
3377 debug_target.to_open (args, from_tty);
3379 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
3383 target_close (struct target_ops *targ)
3385 gdb_assert (!target_is_pushed (targ));
3387 if (targ->to_xclose != NULL)
3388 targ->to_xclose (targ);
3389 else if (targ->to_close != NULL)
3390 targ->to_close (targ);
3393 fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
3397 target_attach (char *args, int from_tty)
3399 current_target.to_attach (¤t_target, args, from_tty);
3401 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
3406 target_thread_alive (ptid_t ptid)
3410 retval = current_target.to_thread_alive (¤t_target, ptid);
3412 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3413 ptid_get_pid (ptid), retval);
3419 target_find_new_threads (void)
3421 current_target.to_find_new_threads (¤t_target);
3423 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
3427 target_stop (ptid_t ptid)
3431 warning (_("May not interrupt or stop the target, ignoring attempt"));
3435 (*current_target.to_stop) (¤t_target, ptid);
3439 debug_to_post_attach (struct target_ops *self, int pid)
3441 debug_target.to_post_attach (&debug_target, pid);
3443 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
3446 /* Concatenate ELEM to LIST, a comma separate list, and return the
3447 result. The LIST incoming argument is released. */
3450 str_comma_list_concat_elem (char *list, const char *elem)
3453 return xstrdup (elem);
3455 return reconcat (list, list, ", ", elem, (char *) NULL);
3458 /* Helper for target_options_to_string. If OPT is present in
3459 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3460 Returns the new resulting string. OPT is removed from
3464 do_option (int *target_options, char *ret,
3465 int opt, char *opt_str)
3467 if ((*target_options & opt) != 0)
3469 ret = str_comma_list_concat_elem (ret, opt_str);
3470 *target_options &= ~opt;
3477 target_options_to_string (int target_options)
3481 #define DO_TARG_OPTION(OPT) \
3482 ret = do_option (&target_options, ret, OPT, #OPT)
3484 DO_TARG_OPTION (TARGET_WNOHANG);
3486 if (target_options != 0)
3487 ret = str_comma_list_concat_elem (ret, "unknown???");
3495 debug_print_register (const char * func,
3496 struct regcache *regcache, int regno)
3498 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3500 fprintf_unfiltered (gdb_stdlog, "%s ", func);
3501 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
3502 && gdbarch_register_name (gdbarch, regno) != NULL
3503 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3504 fprintf_unfiltered (gdb_stdlog, "(%s)",
3505 gdbarch_register_name (gdbarch, regno));
3507 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
3508 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
3510 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3511 int i, size = register_size (gdbarch, regno);
3512 gdb_byte buf[MAX_REGISTER_SIZE];
3514 regcache_raw_collect (regcache, regno, buf);
3515 fprintf_unfiltered (gdb_stdlog, " = ");
3516 for (i = 0; i < size; i++)
3518 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3520 if (size <= sizeof (LONGEST))
3522 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
3524 fprintf_unfiltered (gdb_stdlog, " %s %s",
3525 core_addr_to_string_nz (val), plongest (val));
3528 fprintf_unfiltered (gdb_stdlog, "\n");
3532 target_fetch_registers (struct regcache *regcache, int regno)
3534 current_target.to_fetch_registers (¤t_target, regcache, regno);
3536 debug_print_register ("target_fetch_registers", regcache, regno);
3540 target_store_registers (struct regcache *regcache, int regno)
3542 struct target_ops *t;
3544 if (!may_write_registers)
3545 error (_("Writing to registers is not allowed (regno %d)"), regno);
3547 current_target.to_store_registers (¤t_target, regcache, regno);
3550 debug_print_register ("target_store_registers", regcache, regno);
3555 target_core_of_thread (ptid_t ptid)
3557 int retval = current_target.to_core_of_thread (¤t_target, ptid);
3560 fprintf_unfiltered (gdb_stdlog,
3561 "target_core_of_thread (%d) = %d\n",
3562 ptid_get_pid (ptid), retval);
3567 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3569 int retval = current_target.to_verify_memory (¤t_target,
3570 data, memaddr, size);
3573 fprintf_unfiltered (gdb_stdlog,
3574 "target_verify_memory (%s, %s) = %d\n",
3575 paddress (target_gdbarch (), memaddr),
3581 /* The documentation for this function is in its prototype declaration in
3585 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3589 ret = current_target.to_insert_mask_watchpoint (¤t_target,
3593 fprintf_unfiltered (gdb_stdlog, "\
3594 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3595 core_addr_to_string (addr),
3596 core_addr_to_string (mask), rw, ret);
3601 /* The documentation for this function is in its prototype declaration in
3605 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3609 ret = current_target.to_remove_mask_watchpoint (¤t_target,
3613 fprintf_unfiltered (gdb_stdlog, "\
3614 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
3615 core_addr_to_string (addr),
3616 core_addr_to_string (mask), rw, ret);
3621 /* The documentation for this function is in its prototype declaration
3625 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
3627 return current_target.to_masked_watch_num_registers (¤t_target,
3631 /* The documentation for this function is in its prototype declaration
3635 target_ranged_break_num_registers (void)
3637 return current_target.to_ranged_break_num_registers (¤t_target);
3642 struct btrace_target_info *
3643 target_enable_btrace (ptid_t ptid)
3645 return current_target.to_enable_btrace (¤t_target, ptid);
3651 target_disable_btrace (struct btrace_target_info *btinfo)
3653 current_target.to_disable_btrace (¤t_target, btinfo);
3659 target_teardown_btrace (struct btrace_target_info *btinfo)
3661 current_target.to_teardown_btrace (¤t_target, btinfo);
3667 target_read_btrace (VEC (btrace_block_s) **btrace,
3668 struct btrace_target_info *btinfo,
3669 enum btrace_read_type type)
3671 return current_target.to_read_btrace (¤t_target, btrace, btinfo, type);
3677 target_stop_recording (void)
3679 current_target.to_stop_recording (¤t_target);
3685 target_info_record (void)
3687 struct target_ops *t;
3689 for (t = current_target.beneath; t != NULL; t = t->beneath)
3690 if (t->to_info_record != NULL)
3692 t->to_info_record (t);
3702 target_save_record (const char *filename)
3704 current_target.to_save_record (¤t_target, filename);
3710 target_supports_delete_record (void)
3712 struct target_ops *t;
3714 for (t = current_target.beneath; t != NULL; t = t->beneath)
3715 if (t->to_delete_record != NULL)
3724 target_delete_record (void)
3726 current_target.to_delete_record (¤t_target);
3732 target_record_is_replaying (void)
3734 return current_target.to_record_is_replaying (¤t_target);
3740 target_goto_record_begin (void)
3742 current_target.to_goto_record_begin (¤t_target);
3748 target_goto_record_end (void)
3750 current_target.to_goto_record_end (¤t_target);
3756 target_goto_record (ULONGEST insn)
3758 current_target.to_goto_record (¤t_target, insn);
3764 target_insn_history (int size, int flags)
3766 current_target.to_insn_history (¤t_target, size, flags);
3772 target_insn_history_from (ULONGEST from, int size, int flags)
3774 current_target.to_insn_history_from (¤t_target, from, size, flags);
3780 target_insn_history_range (ULONGEST begin, ULONGEST end, int flags)
3782 current_target.to_insn_history_range (¤t_target, begin, end, flags);
3788 target_call_history (int size, int flags)
3790 current_target.to_call_history (¤t_target, size, flags);
3796 target_call_history_from (ULONGEST begin, int size, int flags)
3798 current_target.to_call_history_from (¤t_target, begin, size, flags);
3804 target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
3806 current_target.to_call_history_range (¤t_target, begin, end, flags);
3810 debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
3812 debug_target.to_prepare_to_store (&debug_target, regcache);
3814 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
3819 const struct frame_unwind *
3820 target_get_unwinder (void)
3822 return current_target.to_get_unwinder (¤t_target);
3827 const struct frame_unwind *
3828 target_get_tailcall_unwinder (void)
3830 return current_target.to_get_tailcall_unwinder (¤t_target);
3833 /* Default implementation of to_decr_pc_after_break. */
3836 default_target_decr_pc_after_break (struct target_ops *ops,
3837 struct gdbarch *gdbarch)
3839 return gdbarch_decr_pc_after_break (gdbarch);
3845 target_decr_pc_after_break (struct gdbarch *gdbarch)
3847 return current_target.to_decr_pc_after_break (¤t_target, gdbarch);
3851 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
3852 int write, struct mem_attrib *attrib,
3853 struct target_ops *target)
3857 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
3860 fprintf_unfiltered (gdb_stdlog,
3861 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
3862 paddress (target_gdbarch (), memaddr), len,
3863 write ? "write" : "read", retval);
3869 fputs_unfiltered (", bytes =", gdb_stdlog);
3870 for (i = 0; i < retval; i++)
3872 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
3874 if (targetdebug < 2 && i > 0)
3876 fprintf_unfiltered (gdb_stdlog, " ...");
3879 fprintf_unfiltered (gdb_stdlog, "\n");
3882 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
3886 fputc_unfiltered ('\n', gdb_stdlog);
3892 debug_to_files_info (struct target_ops *target)
3894 debug_target.to_files_info (target);
3896 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
3900 debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
3901 struct bp_target_info *bp_tgt)
3905 retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
3907 fprintf_unfiltered (gdb_stdlog,
3908 "target_insert_breakpoint (%s, xxx) = %ld\n",
3909 core_addr_to_string (bp_tgt->placed_address),
3910 (unsigned long) retval);
3915 debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
3916 struct bp_target_info *bp_tgt)
3920 retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
3922 fprintf_unfiltered (gdb_stdlog,
3923 "target_remove_breakpoint (%s, xxx) = %ld\n",
3924 core_addr_to_string (bp_tgt->placed_address),
3925 (unsigned long) retval);
3930 debug_to_can_use_hw_breakpoint (struct target_ops *self,
3931 int type, int cnt, int from_tty)
3935 retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
3936 type, cnt, from_tty);
3938 fprintf_unfiltered (gdb_stdlog,
3939 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
3940 (unsigned long) type,
3941 (unsigned long) cnt,
3942 (unsigned long) from_tty,
3943 (unsigned long) retval);
3948 debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
3949 CORE_ADDR addr, int len)
3953 retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
3956 fprintf_unfiltered (gdb_stdlog,
3957 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
3958 core_addr_to_string (addr), (unsigned long) len,
3959 core_addr_to_string (retval));
3964 debug_to_can_accel_watchpoint_condition (struct target_ops *self,
3965 CORE_ADDR addr, int len, int rw,
3966 struct expression *cond)
3970 retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
3974 fprintf_unfiltered (gdb_stdlog,
3975 "target_can_accel_watchpoint_condition "
3976 "(%s, %d, %d, %s) = %ld\n",
3977 core_addr_to_string (addr), len, rw,
3978 host_address_to_string (cond), (unsigned long) retval);
3983 debug_to_stopped_by_watchpoint (struct target_ops *ops)
3987 retval = debug_target.to_stopped_by_watchpoint (&debug_target);
3989 fprintf_unfiltered (gdb_stdlog,
3990 "target_stopped_by_watchpoint () = %ld\n",
3991 (unsigned long) retval);
3996 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
4000 retval = debug_target.to_stopped_data_address (target, addr);
4002 fprintf_unfiltered (gdb_stdlog,
4003 "target_stopped_data_address ([%s]) = %ld\n",
4004 core_addr_to_string (*addr),
4005 (unsigned long)retval);
4010 debug_to_watchpoint_addr_within_range (struct target_ops *target,
4012 CORE_ADDR start, int length)
4016 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
4019 fprintf_filtered (gdb_stdlog,
4020 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4021 core_addr_to_string (addr), core_addr_to_string (start),
4027 debug_to_insert_hw_breakpoint (struct target_ops *self,
4028 struct gdbarch *gdbarch,
4029 struct bp_target_info *bp_tgt)
4033 retval = debug_target.to_insert_hw_breakpoint (&debug_target,
4036 fprintf_unfiltered (gdb_stdlog,
4037 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4038 core_addr_to_string (bp_tgt->placed_address),
4039 (unsigned long) retval);
4044 debug_to_remove_hw_breakpoint (struct target_ops *self,
4045 struct gdbarch *gdbarch,
4046 struct bp_target_info *bp_tgt)
4050 retval = debug_target.to_remove_hw_breakpoint (&debug_target,
4053 fprintf_unfiltered (gdb_stdlog,
4054 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4055 core_addr_to_string (bp_tgt->placed_address),
4056 (unsigned long) retval);
4061 debug_to_insert_watchpoint (struct target_ops *self,
4062 CORE_ADDR addr, int len, int type,
4063 struct expression *cond)
4067 retval = debug_target.to_insert_watchpoint (&debug_target,
4068 addr, len, type, cond);
4070 fprintf_unfiltered (gdb_stdlog,
4071 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4072 core_addr_to_string (addr), len, type,
4073 host_address_to_string (cond), (unsigned long) retval);
4078 debug_to_remove_watchpoint (struct target_ops *self,
4079 CORE_ADDR addr, int len, int type,
4080 struct expression *cond)
4084 retval = debug_target.to_remove_watchpoint (&debug_target,
4085 addr, len, type, cond);
4087 fprintf_unfiltered (gdb_stdlog,
4088 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4089 core_addr_to_string (addr), len, type,
4090 host_address_to_string (cond), (unsigned long) retval);
4095 debug_to_terminal_init (struct target_ops *self)
4097 debug_target.to_terminal_init (&debug_target);
4099 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
4103 debug_to_terminal_inferior (struct target_ops *self)
4105 debug_target.to_terminal_inferior (&debug_target);
4107 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
4111 debug_to_terminal_ours_for_output (struct target_ops *self)
4113 debug_target.to_terminal_ours_for_output (&debug_target);
4115 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
4119 debug_to_terminal_ours (struct target_ops *self)
4121 debug_target.to_terminal_ours (&debug_target);
4123 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
4127 debug_to_terminal_save_ours (struct target_ops *self)
4129 debug_target.to_terminal_save_ours (&debug_target);
4131 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
4135 debug_to_terminal_info (struct target_ops *self,
4136 const char *arg, int from_tty)
4138 debug_target.to_terminal_info (&debug_target, arg, from_tty);
4140 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
4145 debug_to_load (struct target_ops *self, char *args, int from_tty)
4147 debug_target.to_load (&debug_target, args, from_tty);
4149 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
4153 debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
4155 debug_target.to_post_startup_inferior (&debug_target, ptid);
4157 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
4158 ptid_get_pid (ptid));
4162 debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
4166 retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
4168 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
4175 debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
4179 retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
4181 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
4188 debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
4192 retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
4194 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
4201 debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
4205 retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
4207 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
4214 debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
4218 retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
4220 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
4227 debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
4231 retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
4233 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
4240 debug_to_has_exited (struct target_ops *self,
4241 int pid, int wait_status, int *exit_status)
4245 has_exited = debug_target.to_has_exited (&debug_target,
4246 pid, wait_status, exit_status);
4248 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
4249 pid, wait_status, *exit_status, has_exited);
4255 debug_to_can_run (struct target_ops *self)
4259 retval = debug_target.to_can_run (&debug_target);
4261 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
4266 static struct gdbarch *
4267 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
4269 struct gdbarch *retval;
4271 retval = debug_target.to_thread_architecture (ops, ptid);
4273 fprintf_unfiltered (gdb_stdlog,
4274 "target_thread_architecture (%s) = %s [%s]\n",
4275 target_pid_to_str (ptid),
4276 host_address_to_string (retval),
4277 gdbarch_bfd_arch_info (retval)->printable_name);
4282 debug_to_stop (struct target_ops *self, ptid_t ptid)
4284 debug_target.to_stop (&debug_target, ptid);
4286 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
4287 target_pid_to_str (ptid));
4291 debug_to_rcmd (struct target_ops *self, char *command,
4292 struct ui_file *outbuf)
4294 debug_target.to_rcmd (&debug_target, command, outbuf);
4295 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
4299 debug_to_pid_to_exec_file (struct target_ops *self, int pid)
4303 exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
4305 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
4312 setup_target_debug (void)
4314 memcpy (&debug_target, ¤t_target, sizeof debug_target);
4316 current_target.to_open = debug_to_open;
4317 current_target.to_post_attach = debug_to_post_attach;
4318 current_target.to_prepare_to_store = debug_to_prepare_to_store;
4319 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
4320 current_target.to_files_info = debug_to_files_info;
4321 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
4322 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
4323 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
4324 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
4325 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
4326 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
4327 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
4328 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
4329 current_target.to_stopped_data_address = debug_to_stopped_data_address;
4330 current_target.to_watchpoint_addr_within_range
4331 = debug_to_watchpoint_addr_within_range;
4332 current_target.to_region_ok_for_hw_watchpoint
4333 = debug_to_region_ok_for_hw_watchpoint;
4334 current_target.to_can_accel_watchpoint_condition
4335 = debug_to_can_accel_watchpoint_condition;
4336 current_target.to_terminal_init = debug_to_terminal_init;
4337 current_target.to_terminal_inferior = debug_to_terminal_inferior;
4338 current_target.to_terminal_ours_for_output
4339 = debug_to_terminal_ours_for_output;
4340 current_target.to_terminal_ours = debug_to_terminal_ours;
4341 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
4342 current_target.to_terminal_info = debug_to_terminal_info;
4343 current_target.to_load = debug_to_load;
4344 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
4345 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
4346 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
4347 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
4348 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
4349 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
4350 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
4351 current_target.to_has_exited = debug_to_has_exited;
4352 current_target.to_can_run = debug_to_can_run;
4353 current_target.to_stop = debug_to_stop;
4354 current_target.to_rcmd = debug_to_rcmd;
4355 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
4356 current_target.to_thread_architecture = debug_to_thread_architecture;
4360 static char targ_desc[] =
4361 "Names of targets and files being debugged.\nShows the entire \
4362 stack of targets currently in use (including the exec-file,\n\
4363 core-file, and process, if any), as well as the symbol file name.";
4366 default_rcmd (struct target_ops *self, char *command, struct ui_file *output)
4368 error (_("\"monitor\" command not supported by this target."));
4372 do_monitor_command (char *cmd,
4375 target_rcmd (cmd, gdb_stdtarg);
4378 /* Print the name of each layers of our target stack. */
4381 maintenance_print_target_stack (char *cmd, int from_tty)
4383 struct target_ops *t;
4385 printf_filtered (_("The current target stack is:\n"));
4387 for (t = target_stack; t != NULL; t = t->beneath)
4389 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
4393 /* Controls if async mode is permitted. */
4394 int target_async_permitted = 0;
4396 /* The set command writes to this variable. If the inferior is
4397 executing, target_async_permitted is *not* updated. */
4398 static int target_async_permitted_1 = 0;
4401 set_target_async_command (char *args, int from_tty,
4402 struct cmd_list_element *c)
4404 if (have_live_inferiors ())
4406 target_async_permitted_1 = target_async_permitted;
4407 error (_("Cannot change this setting while the inferior is running."));
4410 target_async_permitted = target_async_permitted_1;
4414 show_target_async_command (struct ui_file *file, int from_tty,
4415 struct cmd_list_element *c,
4418 fprintf_filtered (file,
4419 _("Controlling the inferior in "
4420 "asynchronous mode is %s.\n"), value);
4423 /* Temporary copies of permission settings. */
4425 static int may_write_registers_1 = 1;
4426 static int may_write_memory_1 = 1;
4427 static int may_insert_breakpoints_1 = 1;
4428 static int may_insert_tracepoints_1 = 1;
4429 static int may_insert_fast_tracepoints_1 = 1;
4430 static int may_stop_1 = 1;
4432 /* Make the user-set values match the real values again. */
4435 update_target_permissions (void)
4437 may_write_registers_1 = may_write_registers;
4438 may_write_memory_1 = may_write_memory;
4439 may_insert_breakpoints_1 = may_insert_breakpoints;
4440 may_insert_tracepoints_1 = may_insert_tracepoints;
4441 may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
4442 may_stop_1 = may_stop;
4445 /* The one function handles (most of) the permission flags in the same
4449 set_target_permissions (char *args, int from_tty,
4450 struct cmd_list_element *c)
4452 if (target_has_execution)
4454 update_target_permissions ();
4455 error (_("Cannot change this setting while the inferior is running."));
4458 /* Make the real values match the user-changed values. */
4459 may_write_registers = may_write_registers_1;
4460 may_insert_breakpoints = may_insert_breakpoints_1;
4461 may_insert_tracepoints = may_insert_tracepoints_1;
4462 may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
4463 may_stop = may_stop_1;
4464 update_observer_mode ();
4467 /* Set memory write permission independently of observer mode. */
4470 set_write_memory_permission (char *args, int from_tty,
4471 struct cmd_list_element *c)
4473 /* Make the real values match the user-changed values. */
4474 may_write_memory = may_write_memory_1;
4475 update_observer_mode ();
4480 initialize_targets (void)
4482 init_dummy_target ();
4483 push_target (&dummy_target);
4485 add_info ("target", target_info, targ_desc);
4486 add_info ("files", target_info, targ_desc);
4488 add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
4489 Set target debugging."), _("\
4490 Show target debugging."), _("\
4491 When non-zero, target debugging is enabled. Higher numbers are more\n\
4492 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
4496 &setdebuglist, &showdebuglist);
4498 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
4499 &trust_readonly, _("\
4500 Set mode for reading from readonly sections."), _("\
4501 Show mode for reading from readonly sections."), _("\
4502 When this mode is on, memory reads from readonly sections (such as .text)\n\
4503 will be read from the object file instead of from the target. This will\n\
4504 result in significant performance improvement for remote targets."),
4506 show_trust_readonly,
4507 &setlist, &showlist);
4509 add_com ("monitor", class_obscure, do_monitor_command,
4510 _("Send a command to the remote monitor (remote targets only)."));
4512 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
4513 _("Print the name of each layer of the internal target stack."),
4514 &maintenanceprintlist);
4516 add_setshow_boolean_cmd ("target-async", no_class,
4517 &target_async_permitted_1, _("\
4518 Set whether gdb controls the inferior in asynchronous mode."), _("\
4519 Show whether gdb controls the inferior in asynchronous mode."), _("\
4520 Tells gdb whether to control the inferior in asynchronous mode."),
4521 set_target_async_command,
4522 show_target_async_command,
4526 add_setshow_boolean_cmd ("may-write-registers", class_support,
4527 &may_write_registers_1, _("\
4528 Set permission to write into registers."), _("\
4529 Show permission to write into registers."), _("\
4530 When this permission is on, GDB may write into the target's registers.\n\
4531 Otherwise, any sort of write attempt will result in an error."),
4532 set_target_permissions, NULL,
4533 &setlist, &showlist);
4535 add_setshow_boolean_cmd ("may-write-memory", class_support,
4536 &may_write_memory_1, _("\
4537 Set permission to write into target memory."), _("\
4538 Show permission to write into target memory."), _("\
4539 When this permission is on, GDB may write into the target's memory.\n\
4540 Otherwise, any sort of write attempt will result in an error."),
4541 set_write_memory_permission, NULL,
4542 &setlist, &showlist);
4544 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
4545 &may_insert_breakpoints_1, _("\
4546 Set permission to insert breakpoints in the target."), _("\
4547 Show permission to insert breakpoints in the target."), _("\
4548 When this permission is on, GDB may insert breakpoints in the program.\n\
4549 Otherwise, any sort of insertion attempt will result in an error."),
4550 set_target_permissions, NULL,
4551 &setlist, &showlist);
4553 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
4554 &may_insert_tracepoints_1, _("\
4555 Set permission to insert tracepoints in the target."), _("\
4556 Show permission to insert tracepoints in the target."), _("\
4557 When this permission is on, GDB may insert tracepoints in the program.\n\
4558 Otherwise, any sort of insertion attempt will result in an error."),
4559 set_target_permissions, NULL,
4560 &setlist, &showlist);
4562 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
4563 &may_insert_fast_tracepoints_1, _("\
4564 Set permission to insert fast tracepoints in the target."), _("\
4565 Show permission to insert fast tracepoints in the target."), _("\
4566 When this permission is on, GDB may insert fast tracepoints.\n\
4567 Otherwise, any sort of insertion attempt will result in an error."),
4568 set_target_permissions, NULL,
4569 &setlist, &showlist);
4571 add_setshow_boolean_cmd ("may-interrupt", class_support,
4573 Set permission to interrupt or signal the target."), _("\
4574 Show permission to interrupt or signal the target."), _("\
4575 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4576 Otherwise, any attempt to interrupt or stop will be ignored."),
4577 set_target_permissions, NULL,
4578 &setlist, &showlist);