/* Select target systems and architectures at runtime for GDB.
- Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
Contributed by Cygnus Support.
#include "regcache.h"
#include "gdb_assert.h"
#include "gdbcore.h"
+#include "exceptions.h"
+#include "target-descriptions.h"
static void target_info (char *, int);
const gdb_byte *writebuf,
ULONGEST offset, LONGEST len);
-/* Transfer LEN bytes between target address MEMADDR and GDB address
- MYADDR. Returns 0 for success, errno code for failure (which
- includes partial transfers -- if you want a more useful response to
- partial transfers, try either target_read_memory_partial or
- target_write_memory_partial). */
+static LONGEST current_xfer_partial (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len);
-static int target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
- int write);
+static LONGEST target_xfer_partial (struct target_ops *ops,
+ enum target_object object,
+ const char *annex,
+ void *readbuf, const void *writebuf,
+ ULONGEST offset, LONGEST len);
static void init_dummy_target (void);
struct target_ops deprecated_child_ops;
/* Pointer to array of target architecture structures; the size of the
- array; the current index into the array; the allocated size of the
+ array; the current index into the array; the allocated size of the
array. */
struct target_ops **target_structs;
unsigned target_struct_size;
int attach_flag;
+/* Nonzero if we should trust readonly sections from the
+ executable when reading memory. */
+
+static int trust_readonly = 0;
+
/* Non-zero if we want to see trace of target level stuff. */
static int targetdebug = 0;
{
struct target_ops *t;
- /* First, reset curren'ts contents. */
+ /* First, reset current's contents. */
memset (¤t_target, 0, sizeof (current_target));
#define INHERIT(FIELD, TARGET) \
INHERIT (to_remove_watchpoint, t);
INHERIT (to_stopped_data_address, t);
INHERIT (to_stopped_by_watchpoint, t);
+ INHERIT (to_have_steppable_watchpoint, t);
INHERIT (to_have_continuable_watchpoint, t);
INHERIT (to_region_ok_for_hw_watchpoint, t);
INHERIT (to_terminal_init, t);
INHERIT (to_find_memory_regions, t);
INHERIT (to_make_corefile_notes, t);
INHERIT (to_get_thread_local_address, t);
+ /* Do not inherit to_read_description. */
INHERIT (to_magic, t);
+ /* Do not inherit to_memory_map. */
+ /* Do not inherit to_flash_erase. */
+ /* Do not inherit to_flash_done. */
}
#undef INHERIT
if (!current_target.field) \
current_target.field = value
- de_fault (to_open,
- (void (*) (char *, int))
+ de_fault (to_open,
+ (void (*) (char *, int))
tcomplain);
- de_fault (to_close,
- (void (*) (int))
+ de_fault (to_close,
+ (void (*) (int))
target_ignore);
- de_fault (to_attach,
+ de_fault (to_attach,
maybe_kill_then_attach);
- de_fault (to_post_attach,
- (void (*) (int))
+ de_fault (to_post_attach,
+ (void (*) (int))
target_ignore);
- de_fault (to_detach,
- (void (*) (char *, int))
+ de_fault (to_detach,
+ (void (*) (char *, int))
target_ignore);
- de_fault (to_resume,
- (void (*) (ptid_t, int, enum target_signal))
+ de_fault (to_resume,
+ (void (*) (ptid_t, int, enum target_signal))
noprocess);
- de_fault (to_wait,
- (ptid_t (*) (ptid_t, struct target_waitstatus *))
+ de_fault (to_wait,
+ (ptid_t (*) (ptid_t, struct target_waitstatus *))
noprocess);
- de_fault (to_fetch_registers,
- (void (*) (int))
+ de_fault (to_fetch_registers,
+ (void (*) (int))
target_ignore);
- de_fault (to_store_registers,
- (void (*) (int))
+ de_fault (to_store_registers,
+ (void (*) (int))
noprocess);
- de_fault (to_prepare_to_store,
- (void (*) (void))
+ de_fault (to_prepare_to_store,
+ (void (*) (void))
noprocess);
- de_fault (deprecated_xfer_memory,
- (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
+ de_fault (deprecated_xfer_memory,
+ (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
nomemory);
- de_fault (to_files_info,
- (void (*) (struct target_ops *))
+ de_fault (to_files_info,
+ (void (*) (struct target_ops *))
target_ignore);
- de_fault (to_insert_breakpoint,
+ de_fault (to_insert_breakpoint,
memory_insert_breakpoint);
- de_fault (to_remove_breakpoint,
+ de_fault (to_remove_breakpoint,
memory_remove_breakpoint);
de_fault (to_can_use_hw_breakpoint,
(int (*) (int, int, int))
return_zero);
de_fault (to_region_ok_for_hw_watchpoint,
default_region_ok_for_hw_watchpoint);
- de_fault (to_terminal_init,
- (void (*) (void))
+ de_fault (to_terminal_init,
+ (void (*) (void))
target_ignore);
- de_fault (to_terminal_inferior,
- (void (*) (void))
+ de_fault (to_terminal_inferior,
+ (void (*) (void))
target_ignore);
- de_fault (to_terminal_ours_for_output,
- (void (*) (void))
+ de_fault (to_terminal_ours_for_output,
+ (void (*) (void))
target_ignore);
- de_fault (to_terminal_ours,
- (void (*) (void))
+ de_fault (to_terminal_ours,
+ (void (*) (void))
target_ignore);
- de_fault (to_terminal_save_ours,
- (void (*) (void))
+ de_fault (to_terminal_save_ours,
+ (void (*) (void))
target_ignore);
- de_fault (to_terminal_info,
+ de_fault (to_terminal_info,
default_terminal_info);
- de_fault (to_kill,
- (void (*) (void))
+ de_fault (to_kill,
+ (void (*) (void))
noprocess);
- de_fault (to_load,
- (void (*) (char *, int))
+ de_fault (to_load,
+ (void (*) (char *, int))
tcomplain);
- de_fault (to_lookup_symbol,
- (int (*) (char *, CORE_ADDR *))
+ de_fault (to_lookup_symbol,
+ (int (*) (char *, CORE_ADDR *))
nosymbol);
- de_fault (to_create_inferior,
+ de_fault (to_create_inferior,
maybe_kill_then_create_inferior);
- de_fault (to_post_startup_inferior,
- (void (*) (ptid_t))
+ de_fault (to_post_startup_inferior,
+ (void (*) (ptid_t))
target_ignore);
- de_fault (to_acknowledge_created_inferior,
- (void (*) (int))
+ de_fault (to_acknowledge_created_inferior,
+ (void (*) (int))
target_ignore);
- de_fault (to_insert_fork_catchpoint,
- (void (*) (int))
+ de_fault (to_insert_fork_catchpoint,
+ (void (*) (int))
tcomplain);
- de_fault (to_remove_fork_catchpoint,
- (int (*) (int))
+ de_fault (to_remove_fork_catchpoint,
+ (int (*) (int))
tcomplain);
- de_fault (to_insert_vfork_catchpoint,
- (void (*) (int))
+ de_fault (to_insert_vfork_catchpoint,
+ (void (*) (int))
tcomplain);
- de_fault (to_remove_vfork_catchpoint,
- (int (*) (int))
+ de_fault (to_remove_vfork_catchpoint,
+ (int (*) (int))
tcomplain);
- de_fault (to_insert_exec_catchpoint,
- (void (*) (int))
+ de_fault (to_insert_exec_catchpoint,
+ (void (*) (int))
tcomplain);
- de_fault (to_remove_exec_catchpoint,
- (int (*) (int))
+ de_fault (to_remove_exec_catchpoint,
+ (int (*) (int))
tcomplain);
- de_fault (to_reported_exec_events_per_exec_call,
- (int (*) (void))
+ de_fault (to_reported_exec_events_per_exec_call,
+ (int (*) (void))
return_one);
- de_fault (to_has_exited,
- (int (*) (int, int, int *))
+ de_fault (to_has_exited,
+ (int (*) (int, int, int *))
return_zero);
- de_fault (to_mourn_inferior,
- (void (*) (void))
+ de_fault (to_mourn_inferior,
+ (void (*) (void))
noprocess);
- de_fault (to_can_run,
+ de_fault (to_can_run,
return_zero);
- de_fault (to_notice_signals,
- (void (*) (ptid_t))
+ de_fault (to_notice_signals,
+ (void (*) (ptid_t))
target_ignore);
- de_fault (to_thread_alive,
- (int (*) (ptid_t))
+ de_fault (to_thread_alive,
+ (int (*) (ptid_t))
return_zero);
- de_fault (to_find_new_threads,
- (void (*) (void))
+ de_fault (to_find_new_threads,
+ (void (*) (void))
target_ignore);
- de_fault (to_extra_thread_info,
- (char *(*) (struct thread_info *))
+ de_fault (to_extra_thread_info,
+ (char *(*) (struct thread_info *))
return_zero);
- de_fault (to_stop,
- (void (*) (void))
+ de_fault (to_stop,
+ (void (*) (void))
target_ignore);
- current_target.to_xfer_partial = default_xfer_partial;
- de_fault (to_rcmd,
- (void (*) (char *, struct ui_file *))
+ current_target.to_xfer_partial = current_xfer_partial;
+ de_fault (to_rcmd,
+ (void (*) (char *, struct ui_file *))
tcomplain);
- de_fault (to_enable_exception_callback,
- (struct symtab_and_line * (*) (enum exception_event_kind, int))
+ de_fault (to_enable_exception_callback,
+ (struct symtab_and_line * (*) (enum exception_event_kind, int))
nosupport_runtime);
- de_fault (to_get_current_exception_event,
- (struct exception_event_record * (*) (void))
+ de_fault (to_get_current_exception_event,
+ (struct exception_event_record * (*) (void))
nosupport_runtime);
- de_fault (to_pid_to_exec_file,
- (char *(*) (int))
+ de_fault (to_pid_to_exec_file,
+ (char *(*) (int))
return_zero);
- de_fault (to_can_async_p,
- (int (*) (void))
+ de_fault (to_can_async_p,
+ (int (*) (void))
return_zero);
- de_fault (to_is_async_p,
- (int (*) (void))
+ de_fault (to_is_async_p,
+ (int (*) (void))
return_zero);
- de_fault (to_async,
- (void (*) (void (*) (enum inferior_event_type, void*), void*))
+ de_fault (to_async,
+ (void (*) (void (*) (enum inferior_event_type, void*), void*))
tcomplain);
+ current_target.to_read_description = NULL;
#undef de_fault
/* Finally, position the target-stack beneath the squashed
current_target.beneath = target_stack;
}
+/* Mark OPS as a running target. This reverses the effect
+ of target_mark_exited. */
+
+void
+target_mark_running (struct target_ops *ops)
+{
+ struct target_ops *t;
+
+ for (t = target_stack; t != NULL; t = t->beneath)
+ if (t == ops)
+ break;
+ if (t == NULL)
+ internal_error (__FILE__, __LINE__,
+ "Attempted to mark unpushed target \"%s\" as running",
+ ops->to_shortname);
+
+ ops->to_has_execution = 1;
+ ops->to_has_all_memory = 1;
+ ops->to_has_memory = 1;
+ ops->to_has_stack = 1;
+ ops->to_has_registers = 1;
+
+ update_current_target ();
+}
+
+/* Mark OPS as a non-running target. This reverses the effect
+ of target_mark_running. */
+
+void
+target_mark_exited (struct target_ops *ops)
+{
+ struct target_ops *t;
+
+ for (t = target_stack; t != NULL; t = t->beneath)
+ if (t == ops)
+ break;
+ if (t == NULL)
+ internal_error (__FILE__, __LINE__,
+ "Attempted to mark unpushed target \"%s\" as running",
+ ops->to_shortname);
+
+ ops->to_has_execution = 0;
+ ops->to_has_all_memory = 0;
+ ops->to_has_memory = 0;
+ ops->to_has_stack = 0;
+ ops->to_has_registers = 0;
+
+ update_current_target ();
+}
+
/* Push a new target type into the stack of the existing target accessors,
possibly superseding some of the existing accessors.
return (t != target_stack);
}
-/* Remove a target_ops vector from the stack, wherever it may be.
+/* Remove a target_ops vector from the stack, wherever it may be.
Return how many times it was removed (0 or 1). */
int
internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
+/* Using the objfile specified in BATON, find the address for the
+ current thread's thread-local storage with offset OFFSET. */
+CORE_ADDR
+target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
+{
+ volatile CORE_ADDR addr = 0;
+
+ if (target_get_thread_local_address_p ()
+ && gdbarch_fetch_tls_load_module_address_p (current_gdbarch))
+ {
+ ptid_t ptid = inferior_ptid;
+ volatile struct gdb_exception ex;
+
+ TRY_CATCH (ex, RETURN_MASK_ALL)
+ {
+ CORE_ADDR lm_addr;
+
+ /* Fetch the load module address for this objfile. */
+ lm_addr = gdbarch_fetch_tls_load_module_address (current_gdbarch,
+ objfile);
+ /* If it's 0, throw the appropriate exception. */
+ if (lm_addr == 0)
+ throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
+ _("TLS load module not found"));
+
+ addr = target_get_thread_local_address (ptid, lm_addr, offset);
+ }
+ /* If an error occurred, print TLS related messages here. Otherwise,
+ throw the error to some higher catcher. */
+ if (ex.reason < 0)
+ {
+ int objfile_is_library = (objfile->flags & OBJF_SHARED);
+
+ switch (ex.error)
+ {
+ case TLS_NO_LIBRARY_SUPPORT_ERROR:
+ error (_("Cannot find thread-local variables in this thread library."));
+ break;
+ case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
+ if (objfile_is_library)
+ error (_("Cannot find shared library `%s' in dynamic"
+ " linker's load module list"), objfile->name);
+ else
+ error (_("Cannot find executable file `%s' in dynamic"
+ " linker's load module list"), objfile->name);
+ break;
+ case TLS_NOT_ALLOCATED_YET_ERROR:
+ if (objfile_is_library)
+ error (_("The inferior has not yet allocated storage for"
+ " thread-local variables in\n"
+ "the shared library `%s'\n"
+ "for %s"),
+ objfile->name, target_pid_to_str (ptid));
+ else
+ error (_("The inferior has not yet allocated storage for"
+ " thread-local variables in\n"
+ "the executable `%s'\n"
+ "for %s"),
+ objfile->name, target_pid_to_str (ptid));
+ break;
+ case TLS_GENERIC_ERROR:
+ if (objfile_is_library)
+ error (_("Cannot find thread-local storage for %s, "
+ "shared library %s:\n%s"),
+ target_pid_to_str (ptid),
+ objfile->name, ex.message);
+ else
+ error (_("Cannot find thread-local storage for %s, "
+ "executable file %s:\n%s"),
+ target_pid_to_str (ptid),
+ objfile->name, ex.message);
+ break;
+ default:
+ throw_exception (ex);
+ break;
+ }
+ }
+ }
+ /* It wouldn't be wrong here to try a gdbarch method, too; finding
+ TLS is an ABI-specific thing. But we don't do that yet. */
+ else
+ error (_("Cannot find thread-local variables on this target"));
+
+ return addr;
+}
+
#undef MIN
#define MIN(A, B) (((A) <= (B)) ? (A) : (B))
return NULL;
}
-/* Return non-zero when the target vector has supplied an xfer_partial
- method and it, rather than xfer_memory, should be used. */
-static int
-target_xfer_partial_p (void)
+/* Perform a partial memory transfer. The arguments and return
+ value are just as for target_xfer_partial. */
+
+static LONGEST
+memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
+ ULONGEST memaddr, LONGEST len)
{
- return (target_stack != NULL
- && target_stack->to_xfer_partial != default_xfer_partial);
+ LONGEST res;
+ int reg_len;
+ struct mem_region *region;
+
+ /* Zero length requests are ok and require no work. */
+ if (len == 0)
+ return 0;
+
+ /* Try the executable file, if "trust-readonly-sections" is set. */
+ if (readbuf != NULL && trust_readonly)
+ {
+ struct section_table *secp;
+
+ secp = target_section_by_addr (ops, memaddr);
+ if (secp != NULL
+ && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
+ & SEC_READONLY))
+ return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
+ }
+
+ /* Try GDB's internal data cache. */
+ region = lookup_mem_region (memaddr);
+ /* region->hi == 0 means there's no upper bound. */
+ if (memaddr + len < region->hi || region->hi == 0)
+ reg_len = len;
+ else
+ reg_len = region->hi - memaddr;
+
+ switch (region->attrib.mode)
+ {
+ case MEM_RO:
+ if (writebuf != NULL)
+ return -1;
+ break;
+
+ case MEM_WO:
+ if (readbuf != NULL)
+ return -1;
+ break;
+
+ case MEM_FLASH:
+ /* We only support writing to flash during "load" for now. */
+ if (writebuf != NULL)
+ error (_("Writing to flash memory forbidden in this context"));
+ break;
+
+ case MEM_NONE:
+ return -1;
+ }
+
+ if (region->attrib.cache)
+ {
+ /* FIXME drow/2006-08-09: This call discards OPS, so the raw
+ memory request will start back at current_target. */
+ if (readbuf != NULL)
+ res = dcache_xfer_memory (target_dcache, memaddr, readbuf,
+ reg_len, 0);
+ else
+ /* FIXME drow/2006-08-09: If we're going to preserve const
+ correctness dcache_xfer_memory should take readbuf and
+ writebuf. */
+ res = dcache_xfer_memory (target_dcache, memaddr,
+ (void *) writebuf,
+ reg_len, 1);
+ if (res <= 0)
+ return -1;
+ else
+ return res;
+ }
+
+ /* If none of those methods found the memory we wanted, fall back
+ to a target partial transfer. Normally a single call to
+ to_xfer_partial is enough; if it doesn't recognize an object
+ it will call the to_xfer_partial of the next target down.
+ But for memory this won't do. Memory is the only target
+ object which can be read from more than one valid target.
+ A core file, for instance, could have some of memory but
+ delegate other bits to the target below it. So, we must
+ manually try all targets. */
+
+ do
+ {
+ res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
+ readbuf, writebuf, memaddr, reg_len);
+ if (res > 0)
+ return res;
+
+ ops = ops->beneath;
+ }
+ while (ops != NULL);
+
+ /* If we still haven't got anything, return the last error. We
+ give up. */
+ return res;
}
static LONGEST
LONGEST retval;
gdb_assert (ops->to_xfer_partial != NULL);
- retval = ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
- offset, len);
+
+ /* If this is a memory transfer, let the memory-specific code
+ have a look at it instead. Memory transfers are more
+ complicated. */
+ if (object == TARGET_OBJECT_MEMORY)
+ retval = memory_xfer_partial (ops, readbuf, writebuf, offset, len);
+ else
+ {
+ enum target_object raw_object = object;
+
+ /* If this is a raw memory transfer, request the normal
+ memory object from other layers. */
+ if (raw_object == TARGET_OBJECT_RAW_MEMORY)
+ raw_object = TARGET_OBJECT_MEMORY;
+
+ retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
+ writebuf, offset, len);
+ }
+
if (targetdebug)
{
const unsigned char *myaddr = NULL;
if (retval > 0 && myaddr != NULL)
{
int i;
-
+
fputs_unfiltered (", bytes =", gdb_stdlog);
for (i = 0; i < retval; i++)
{
}
fprintf_unfiltered (gdb_stdlog, "\n");
}
-
+
fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
}
}
-
+
fputc_unfiltered ('\n', gdb_stdlog);
}
return retval;
}
-/* Attempt a transfer all LEN bytes starting at OFFSET between the
- inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
- the transfer succeeds, return zero, otherwize the host ERRNO is
- returned.
-
- The inferior is formed from several layers. In the case of
- corefiles, inf-corefile is layered above inf-exec and a request for
- text (corefiles do not include text pages) will be first sent to
- the core-stratum, fail, and then sent to the object-file where it
- will succeed.
-
- NOTE: cagney/2004-09-30:
-
- The old code tried to use four separate mechanisms for mapping an
- object:offset:len tuple onto an inferior and its address space: the
- target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
- overlays.
-
- This is stupid.
-
- The code below is instead using a single mechanism (currently
- strata). If that mechanism proves insufficient then re-factor it
- implementing another singluar mechanism (for instance, a generic
- object:annex onto inferior:object:annex say). */
-
-static LONGEST
-xfer_using_stratum (enum target_object object, const char *annex,
- ULONGEST offset, LONGEST len, void *readbuf,
- const void *writebuf)
-{
- LONGEST xfered;
- struct target_ops *target;
-
- /* Always successful. */
- if (len == 0)
- return 0;
- /* Never successful. */
- if (target_stack == NULL)
- return EIO;
-
- target = target_stack;
- while (1)
- {
- xfered = target_xfer_partial (target, object, annex,
- readbuf, writebuf, offset, len);
- if (xfered > 0)
- {
- /* The partial xfer succeeded, update the counts, check that
- the xfer hasn't finished and if it hasn't set things up
- for the next round. */
- len -= xfered;
- if (len <= 0)
- return 0;
- offset += xfered;
- if (readbuf != NULL)
- readbuf = (gdb_byte *) readbuf + xfered;
- if (writebuf != NULL)
- writebuf = (gdb_byte *) writebuf + xfered;
- target = target_stack;
- }
- else if (xfered < 0)
- {
- /* Something totally screwed up, abandon the attempt to
- xfer. */
- if (errno)
- return errno;
- else
- return EIO;
- }
- else
- {
- /* This "stratum" didn't work, try the next one down. */
- target = target->beneath;
- if (target == NULL)
- return EIO;
- }
- }
-}
-
/* Read LEN bytes of target memory at address MEMADDR, placing the results in
GDB's memory at MYADDR. Returns either 0 for success or an errno value
if any error occurs.
MYADDR. In particular, the caller should not depend upon partial reads
filling the buffer with good data. There is no way for the caller to know
how much good data might have been transfered anyway. Callers that can
- deal with partial reads should call target_read_memory_partial. */
+ deal with partial reads should call target_read (which will retry until
+ it makes no progress, and then return how much was transferred). */
int
target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
- if (target_xfer_partial_p ())
- return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
- memaddr, len, myaddr, NULL);
+ if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
+ myaddr, memaddr, len) == len)
+ return 0;
else
- return target_xfer_memory (memaddr, myaddr, len, 0);
+ return EIO;
}
int
target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
{
- gdb_byte *bytes = alloca (len);
- memcpy (bytes, myaddr, len);
- if (target_xfer_partial_p ())
- return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
- memaddr, len, NULL, bytes);
+ if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
+ myaddr, memaddr, len) == len)
+ return 0;
else
- return target_xfer_memory (memaddr, bytes, len, 1);
+ return EIO;
}
-#ifndef target_stopped_data_address_p
-int
-target_stopped_data_address_p (struct target_ops *target)
-{
- if (target->to_stopped_data_address
- == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
- return 0;
- if (target->to_stopped_data_address == debug_to_stopped_data_address
- && (debug_target.to_stopped_data_address
- == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
- return 0;
- return 1;
-}
-#endif
+/* Fetch the target's memory map. */
-static int trust_readonly = 0;
-static void
-show_trust_readonly (struct ui_file *file, int from_tty,
- struct cmd_list_element *c, const char *value)
+VEC(mem_region_s) *
+target_memory_map (void)
{
- fprintf_filtered (file, _("\
-Mode for reading from readonly sections is %s.\n"),
- value);
-}
+ VEC(mem_region_s) *result;
+ struct mem_region *last_one, *this_one;
+ int ix;
+ struct target_ops *t;
-/* Move memory to or from the targets. The top target gets priority;
- if it cannot handle it, it is offered to the next one down, etc.
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
- Result is -1 on error, or the number of bytes transfered. */
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_memory_map != NULL)
+ break;
-int
-do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
- struct mem_attrib *attrib)
-{
- int res;
- int done = 0;
- struct target_ops *t;
+ if (t == NULL)
+ return NULL;
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- return 0;
+ result = t->to_memory_map (t);
+ if (result == NULL)
+ return NULL;
- /* deprecated_xfer_memory is not guaranteed to set errno, even when
- it returns 0. */
- errno = 0;
+ qsort (VEC_address (mem_region_s, result),
+ VEC_length (mem_region_s, result),
+ sizeof (struct mem_region), mem_region_cmp);
- if (!write && trust_readonly)
+ /* Check that regions do not overlap. Simultaneously assign
+ a numbering for the "mem" commands to use to refer to
+ each region. */
+ last_one = NULL;
+ for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
{
- struct section_table *secp;
- /* User-settable option, "trust-readonly-sections". If true,
- then memory from any SEC_READONLY bfd section may be read
- directly from the bfd file. */
- secp = target_section_by_addr (¤t_target, memaddr);
- if (secp != NULL
- && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
- & SEC_READONLY))
- return xfer_memory (memaddr, myaddr, len, 0, attrib, ¤t_target);
- }
-
- /* The quick case is that the top target can handle the transfer. */
- res = current_target.deprecated_xfer_memory
- (memaddr, myaddr, len, write, attrib, ¤t_target);
+ this_one->number = ix;
- /* If res <= 0 then we call it again in the loop. Ah well. */
- if (res <= 0)
- {
- for (t = target_stack; t != NULL; t = t->beneath)
+ if (last_one && last_one->hi > this_one->lo)
{
- if (!t->to_has_memory)
- continue;
-
- res = t->deprecated_xfer_memory (memaddr, myaddr, len, write, attrib, t);
- if (res > 0)
- break; /* Handled all or part of xfer */
- if (t->to_has_all_memory)
- break;
+ warning (_("Overlapping regions in memory map: ignoring"));
+ VEC_free (mem_region_s, result);
+ return NULL;
}
-
- if (res <= 0)
- return -1;
+ last_one = this_one;
}
- return res;
+ return result;
}
-
-/* Perform a memory transfer. Iterate until the entire region has
- been transfered.
-
- Result is 0 or errno value. */
-
-static int
-target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write)
+void
+target_flash_erase (ULONGEST address, LONGEST length)
{
- int res;
- int reg_len;
- struct mem_region *region;
-
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- {
- return 0;
- }
-
- while (len > 0)
- {
- region = lookup_mem_region(memaddr);
- if (memaddr + len < region->hi)
- reg_len = len;
- else
- reg_len = region->hi - memaddr;
+ struct target_ops *t;
- switch (region->attrib.mode)
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_flash_erase != NULL)
{
- case MEM_RO:
- if (write)
- return EIO;
- break;
-
- case MEM_WO:
- if (!write)
- return EIO;
- break;
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
+ paddr (address), phex (length, 0));
+ t->to_flash_erase (t, address, length);
+ return;
}
- while (reg_len > 0)
- {
- if (region->attrib.cache)
- res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
- reg_len, write);
- else
- res = do_xfer_memory (memaddr, myaddr, reg_len, write,
- ®ion->attrib);
-
- if (res <= 0)
- {
- /* If this address is for nonexistent memory, read zeros
- if reading, or do nothing if writing. Return
- error. */
- if (!write)
- memset (myaddr, 0, len);
- if (errno == 0)
- return EIO;
- else
- return errno;
- }
-
- memaddr += res;
- myaddr += res;
- len -= res;
- reg_len -= res;
- }
- }
-
- return 0; /* We managed to cover it all somehow. */
+ tcomplain ();
}
-
-/* Perform a partial memory transfer.
-
- If we succeed, set *ERR to zero and return the number of bytes transferred.
- If we fail, set *ERR to a non-zero errno value, and return -1. */
-
-static int
-target_xfer_memory_partial (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
- int write_p, int *err)
+void
+target_flash_done (void)
{
- int res;
- int reg_len;
- struct mem_region *region;
-
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- {
- *err = 0;
- return 0;
- }
-
- region = lookup_mem_region(memaddr);
- if (memaddr + len < region->hi)
- reg_len = len;
- else
- reg_len = region->hi - memaddr;
-
- switch (region->attrib.mode)
- {
- case MEM_RO:
- if (write_p)
- {
- *err = EIO;
- return -1;
- }
- break;
+ struct target_ops *t;
- case MEM_WO:
- if (write_p)
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_flash_done != NULL)
{
- *err = EIO;
- return -1;
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
+ t->to_flash_done (t);
+ return;
}
- break;
- }
- if (region->attrib.cache)
- res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
- reg_len, write_p);
- else
- res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
- ®ion->attrib);
-
- if (res <= 0)
- {
- if (errno != 0)
- *err = errno;
- else
- *err = EIO;
-
- return -1;
- }
-
- *err = 0;
- return res;
+ tcomplain ();
}
+#ifndef target_stopped_data_address_p
int
-target_read_memory_partial (CORE_ADDR memaddr, gdb_byte *buf,
- int len, int *err)
+target_stopped_data_address_p (struct target_ops *target)
{
- if (target_xfer_partial_p ())
- {
- int retval;
-
- retval = target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY,
- NULL, buf, NULL, memaddr, len);
-
- if (retval <= 0)
- {
- if (errno)
- *err = errno;
- else
- *err = EIO;
- return -1;
- }
- else
- {
- *err = 0;
- return retval;
- }
- }
- else
- return target_xfer_memory_partial (memaddr, buf, len, 0, err);
+ if (target->to_stopped_data_address
+ == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
+ return 0;
+ if (target->to_stopped_data_address == debug_to_stopped_data_address
+ && (debug_target.to_stopped_data_address
+ == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
+ return 0;
+ return 1;
}
+#endif
-int
-target_write_memory_partial (CORE_ADDR memaddr, gdb_byte *buf,
- int len, int *err)
+static void
+show_trust_readonly (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
{
- if (target_xfer_partial_p ())
- {
- int retval;
-
- retval = target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY,
- NULL, NULL, buf, memaddr, len);
-
- if (retval <= 0)
- {
- if (errno)
- *err = errno;
- else
- *err = EIO;
- return -1;
- }
- else
- {
- *err = 0;
- return retval;
- }
- }
- else
- return target_xfer_memory_partial (memaddr, buf, len, 1, err);
+ fprintf_filtered (file, _("\
+Mode for reading from readonly sections is %s.\n"),
+ value);
}
/* More generic transfers. */
static LONGEST
default_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
+ const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
if (object == TARGET_OBJECT_MEMORY
return -1;
}
else if (ops->beneath != NULL)
- return target_xfer_partial (ops->beneath, object, annex,
- readbuf, writebuf, offset, len);
+ return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+ readbuf, writebuf, offset, len);
+ else
+ return -1;
+}
+
+/* The xfer_partial handler for the topmost target. Unlike the default,
+ it does not need to handle memory specially; it just passes all
+ requests down the stack. */
+
+static LONGEST
+current_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+{
+ if (ops->beneath != NULL)
+ return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+ readbuf, writebuf, offset, len);
else
return -1;
}
return len;
}
+/* An alternative to target_write with progress callbacks. */
+
LONGEST
-target_write (struct target_ops *ops,
- enum target_object object,
- const char *annex, const gdb_byte *buf,
- ULONGEST offset, LONGEST len)
+target_write_with_progress (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, const gdb_byte *buf,
+ ULONGEST offset, LONGEST len,
+ void (*progress) (ULONGEST, void *), void *baton)
{
LONGEST xfered = 0;
+
+ /* Give the progress callback a chance to set up. */
+ if (progress)
+ (*progress) (0, baton);
+
while (xfered < len)
{
LONGEST xfer = target_write_partial (ops, object, annex,
(gdb_byte *) buf + xfered,
offset + xfered, len - xfered);
- /* Call an observer, notifying them of the xfer progress? */
+
if (xfer == 0)
return xfered;
if (xfer < 0)
return -1;
+
+ if (progress)
+ (*progress) (xfer, baton);
+
xfered += xfer;
QUIT;
}
return len;
}
-/* Wrapper to perform a full read of unknown size. OBJECT/ANNEX will
- be read using OPS. The return value will be -1 if the transfer
- fails or is not supported; 0 if the object is empty; or the length
- of the object otherwise. If a positive value is returned, a
- sufficiently large buffer will be allocated using xmalloc and
- returned in *BUF_P containing the contents of the object.
+LONGEST
+target_write (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, const gdb_byte *buf,
+ ULONGEST offset, LONGEST len)
+{
+ return target_write_with_progress (ops, object, annex, buf, offset, len,
+ NULL, NULL);
+}
- This method should be used for objects sufficiently small to store
- in a single xmalloc'd buffer, when no fixed bound on the object's
- size is known in advance. Don't try to read TARGET_OBJECT_MEMORY
- through this function. */
+/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
+ the size of the transferred data. PADDING additional bytes are
+ available in *BUF_P. This is a helper function for
+ target_read_alloc; see the declaration of that function for more
+ information. */
-LONGEST
-target_read_alloc (struct target_ops *ops,
- enum target_object object,
- const char *annex, gdb_byte **buf_p)
+static LONGEST
+target_read_alloc_1 (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte **buf_p, int padding)
{
size_t buf_alloc, buf_pos;
gdb_byte *buf;
while (1)
{
n = target_read_partial (ops, object, annex, &buf[buf_pos],
- buf_pos, buf_alloc - buf_pos);
+ buf_pos, buf_alloc - buf_pos - padding);
if (n < 0)
{
/* An error occurred. */
}
}
+/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
+ the size of the transferred data. See the declaration in "target.h"
+ function for more information about the return value. */
+
+LONGEST
+target_read_alloc (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte **buf_p)
+{
+ return target_read_alloc_1 (ops, object, annex, buf_p, 0);
+}
+
+/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
+ returned as a string, allocated using xmalloc. If an error occurs
+ or the transfer is unsupported, NULL is returned. Empty objects
+ are returned as allocated but empty strings. A warning is issued
+ if the result contains any embedded NUL bytes. */
+
+char *
+target_read_stralloc (struct target_ops *ops, enum target_object object,
+ const char *annex)
+{
+ gdb_byte *buffer;
+ LONGEST transferred;
+
+ transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
+
+ if (transferred < 0)
+ return NULL;
+
+ if (transferred == 0)
+ return xstrdup ("");
+
+ buffer[transferred] = 0;
+ if (strlen (buffer) < transferred)
+ warning (_("target object %d, annex %s, "
+ "contained unexpected null characters"),
+ (int) object, annex ? annex : "(none)");
+
+ return (char *) buffer;
+}
+
/* Memory transfer methods. */
void
}
}
+/* This function is called before any new inferior is created, e.g.
+ by running a program, attaching, or connecting to a target.
+ It cleans up any state from previous invocations which might
+ change between runs. This is a subset of what target_preopen
+ resets (things which might change between targets). */
+
+void
+target_pre_inferior (int from_tty)
+{
+ invalidate_target_mem_regions ();
+
+ target_clear_description ();
+}
+
/* This is to be called by the open routine before it does
anything. */
if (target_has_execution)
pop_target ();
+
+ target_pre_inferior (from_tty);
}
/* Detach a target after doing deferred register stores. */
"could not find a target to follow fork");
}
+/* Look for a target which can describe architectural features, starting
+ from TARGET. If we find one, return its description. */
+
+const struct target_desc *
+target_read_description (struct target_ops *target)
+{
+ struct target_ops *t;
+
+ for (t = target; t != NULL; t = t->beneath)
+ if (t->to_read_description != NULL)
+ {
+ const struct target_desc *tdesc;
+
+ tdesc = t->to_read_description (t);
+ if (tdesc)
+ return tdesc;
+ }
+
+ return NULL;
+}
+
/* Look through the list of possible targets for a target that can
execute a run or attach command without any other data. This is
used to locate the default process stratum.
/* Check to see if anyone else was pointing to this structure.
If old_value was null, then no one was. */
-
+
if (old_value)
{
for (t = target_structs; t < target_structs + target_struct_size;
current_target.to_sections_end = target->to_sections_end;
}
}
-
+
return old_count;
}
deprecated_detach_hook ();
}
\f
-/* Helper function for child_wait and the Lynx derivatives of child_wait.
+/* Helper function for child_wait and the derivatives of child_wait.
HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
translation of that in OURSTATUS. */
void
}
fprintf_unfiltered (gdb_stdlog, "\n");
}
-
+
fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
}
}
{
int retval;
- retval = debug_target.to_insert_watchpoint (addr, len, type);
+ retval = debug_target.to_remove_watchpoint (addr, len, type);
fprintf_unfiltered (gdb_stdlog,
- "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
+ "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
(unsigned long) addr, len, type, (unsigned long) retval);
return retval;
}
target_rcmd (cmd, gdb_stdtarg);
}
+/* Print the name of each layers of our target stack. */
+
+static void
+maintenance_print_target_stack (char *cmd, int from_tty)
+{
+ struct target_ops *t;
+
+ printf_filtered (_("The current target stack is:\n"));
+
+ for (t = target_stack; t != NULL; t = t->beneath)
+ {
+ printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
+ }
+}
+
void
initialize_targets (void)
{
show_targetdebug,
&setdebuglist, &showdebuglist);
- add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
+ add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
&trust_readonly, _("\
Set mode for reading from readonly sections."), _("\
Show mode for reading from readonly sections."), _("\
add_com ("monitor", class_obscure, do_monitor_command,
_("Send a command to the remote monitor (remote targets only)."));
+ add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
+ _("Print the name of each layer of the internal target stack."),
+ &maintenanceprintlist);
+
target_dcache = dcache_init ();
}