/* Select target systems and architectures at runtime for GDB.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include <errno.h>
#include "regcache.h"
#include "gdb_assert.h"
#include "gdbcore.h"
+#include "exceptions.h"
+#include "target-descriptions.h"
static void target_info (char *, int);
-static void maybe_kill_then_create_inferior (char *, char *, char **);
-
static void maybe_kill_then_attach (char *, int);
static void kill_or_be_killed (int);
static void default_terminal_info (char *, int);
-static int default_region_size_ok_for_hw_watchpoint (int);
+static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
static int nosymbol (char *, CORE_ADDR *);
-static void tcomplain (void);
+static void tcomplain (void) ATTR_NORETURN;
static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
static LONGEST default_xfer_partial (struct target_ops *ops,
enum target_object object,
- const char *annex, void *readbuf,
- const void *writebuf,
+ const char *annex, gdb_byte *readbuf,
+ 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, char *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);
+static struct target_ops debug_target;
+
static void debug_to_open (char *, int);
static void debug_to_close (int);
static void debug_to_detach (char *, int);
-static void debug_to_disconnect (char *, int);
-
static void debug_to_resume (ptid_t, int, enum target_signal);
static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
static void debug_to_prepare_to_store (void);
-static int debug_to_xfer_memory (CORE_ADDR, char *, int, int,
- struct mem_attrib *, struct target_ops *);
-
static void debug_to_files_info (struct target_ops *);
-static int debug_to_insert_breakpoint (CORE_ADDR, char *);
+static int debug_to_insert_breakpoint (struct bp_target_info *);
-static int debug_to_remove_breakpoint (CORE_ADDR, char *);
+static int debug_to_remove_breakpoint (struct bp_target_info *);
static int debug_to_can_use_hw_breakpoint (int, int, int);
-static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *);
+static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
-static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *);
+static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
static int debug_to_stopped_by_watchpoint (void);
-static CORE_ADDR debug_to_stopped_data_address (void);
+static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
-static int debug_to_region_size_ok_for_hw_watchpoint (int);
+static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
static void debug_to_terminal_init (void);
static int debug_to_lookup_symbol (char *, CORE_ADDR *);
-static void debug_to_create_inferior (char *, char *, char **);
-
static void debug_to_mourn_inferior (void);
static int debug_to_can_run (void);
static void debug_to_stop (void);
+/* NOTE: cagney/2004-09-29: Many targets reference this variable in
+ wierd and mysterious ways. Putting the variable here lets those
+ wierd and mysterious ways keep building while they are being
+ converted to the inferior inheritance structure. */
+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;
+static void
+show_targetdebug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Target debugging is %s.\n"), value);
+}
static void setup_target_debug (void);
target_structs[target_struct_size++] = t;
if (targetlist == NULL)
- add_prefix_cmd ("target", class_run, target_command,
- "Connect to a target machine or process.\n\
+ add_prefix_cmd ("target", class_run, target_command, _("\
+Connect to a target machine or process.\n\
The first argument is the type or protocol of the target machine.\n\
Remaining arguments are interpreted by the target protocol. For more\n\
information on the arguments for a particular protocol, type\n\
-`help target ' followed by the protocol name.",
+`help target ' followed by the protocol name."),
&targetlist, "target ", 0, &cmdlist);
add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
}
static void
tcomplain (void)
{
- error ("You can't do that when your target is `%s'",
+ error (_("You can't do that when your target is `%s'"),
current_target.to_shortname);
}
void
noprocess (void)
{
- error ("You can't do that without a process to debug.");
+ error (_("You can't do that without a process to debug."));
}
static int
if (ptid_equal (inferior_ptid, null_ptid))
noprocess ();
else
- error ("No run-time support for this");
+ error (_("No run-time support for this"));
}
static void
default_terminal_info (char *args, int from_tty)
{
- printf_unfiltered ("No saved terminal information.\n");
+ printf_unfiltered (_("No saved terminal information.\n"));
}
/* This is the default target_create_inferior and target_attach function.
{
if (target_has_execution)
{
- printf_unfiltered ("You are already running a program:\n");
+ printf_unfiltered (_("You are already running a program:\n"));
target_files_info ();
if (query ("Kill it? "))
{
target_kill ();
if (target_has_execution)
- error ("Killing the program did not help.");
+ error (_("Killing the program did not help."));
return;
}
else
{
- error ("Program not killed.");
+ error (_("Program not killed."));
}
}
tcomplain ();
}
static void
-maybe_kill_then_create_inferior (char *exec, char *args, char **env)
+maybe_kill_then_create_inferior (char *exec, char *args, char **env,
+ int from_tty)
{
kill_or_be_killed (0);
- target_create_inferior (exec, args, env);
+ target_create_inferior (exec, args, env, from_tty);
}
/* Go through the target stack from top to bottom, copying over zero
INHERIT (to_attach, t);
INHERIT (to_post_attach, t);
INHERIT (to_detach, t);
- INHERIT (to_disconnect, t);
+ /* Do not inherit to_disconnect. */
INHERIT (to_resume, t);
INHERIT (to_wait, t);
- INHERIT (to_post_wait, t);
INHERIT (to_fetch_registers, t);
INHERIT (to_store_registers, t);
INHERIT (to_prepare_to_store, t);
- INHERIT (to_xfer_memory, t);
+ INHERIT (deprecated_xfer_memory, t);
INHERIT (to_files_info, t);
INHERIT (to_insert_breakpoint, t);
INHERIT (to_remove_breakpoint, t);
INHERIT (to_stopped_data_address, t);
INHERIT (to_stopped_by_watchpoint, t);
INHERIT (to_have_continuable_watchpoint, t);
- INHERIT (to_region_size_ok_for_hw_watchpoint, t);
+ INHERIT (to_region_ok_for_hw_watchpoint, t);
INHERIT (to_terminal_init, t);
INHERIT (to_terminal_inferior, t);
INHERIT (to_terminal_ours_for_output, t);
INHERIT (to_remove_fork_catchpoint, t);
INHERIT (to_insert_vfork_catchpoint, t);
INHERIT (to_remove_vfork_catchpoint, t);
- INHERIT (to_follow_fork, t);
+ /* Do not inherit to_follow_fork. */
INHERIT (to_insert_exec_catchpoint, t);
INHERIT (to_remove_exec_catchpoint, t);
INHERIT (to_reported_exec_events_per_exec_call, 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_disconnect,
- (void (*) (char *, int))
- tcomplain);
- 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_post_wait,
- (void (*) (ptid_t, int))
- target_ignore);
- 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 (to_xfer_memory,
- (int (*) (CORE_ADDR, char *, 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_insert_hw_breakpoint,
- (int (*) (CORE_ADDR, char *))
+ (int (*) (struct bp_target_info *))
return_minus_one);
de_fault (to_remove_hw_breakpoint,
- (int (*) (CORE_ADDR, char *))
+ (int (*) (struct bp_target_info *))
return_minus_one);
de_fault (to_insert_watchpoint,
(int (*) (CORE_ADDR, int, int))
(int (*) (void))
return_zero);
de_fault (to_stopped_data_address,
- (CORE_ADDR (*) (void))
+ (int (*) (struct target_ops *, CORE_ADDR *))
return_zero);
- de_fault (to_region_size_ok_for_hw_watchpoint,
- default_region_size_ok_for_hw_watchpoint);
- de_fault (to_terminal_init,
- (void (*) (void))
+ de_fault (to_region_ok_for_hw_watchpoint,
+ default_region_ok_for_hw_watchpoint);
+ 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,
- (int (*) (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,
- (int (*) (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_follow_fork,
- (int (*) (int))
- target_ignore);
- de_fault (to_insert_exec_catchpoint,
- (int (*) (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.
fprintf_unfiltered (gdb_stderr,
"Magic number of %s target struct wrong\n",
t->to_shortname);
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
/* Find the proper stratum to install this target in. */
}
/* If there's already targets at this stratum, remove them. */
- /* FIXME: cagney/2003-10-15: I think this should be poping all
+ /* FIXME: cagney/2003-10-15: I think this should be popping all
targets to CUR, and not just those at this stratum level. */
while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
{
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
fprintf_unfiltered (gdb_stderr,
"pop_target couldn't find target %s\n",
current_target.to_shortname);
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ 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
target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
{
int tlen, origlen, offset, i;
- char buf[4];
+ gdb_byte buf[4];
int errcode = 0;
char *buffer;
int buffer_allocated;
tlen = MIN (len, 4 - (memaddr & 3));
offset = memaddr & 3;
- errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
+ errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
if (errcode != 0)
{
/* The transfer request might have crossed the boundary to an
a single byte. */
tlen = 1;
offset = 0;
- errcode = target_xfer_memory (memaddr, buf, 1, 0);
+ errcode = target_read_memory (memaddr, buf, 1);
if (errcode != 0)
goto done;
}
return NULL;
}
-/* 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.
-
- If an error occurs, no guarantee is made about the contents of the data at
- 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. */
-
-int
-target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
-{
- return target_xfer_memory (memaddr, myaddr, len, 0);
-}
-
-int
-target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
-{
- return target_xfer_memory (memaddr, myaddr, len, 1);
-}
-
-static int trust_readonly = 0;
-
-/* 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.
-
- Result is -1 on error, or the number of bytes transfered. */
+/* Perform a partial memory transfer. The arguments and return
+ value are just as for target_xfer_partial. */
-int
-do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib)
+static LONGEST
+memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf,
+ ULONGEST memaddr, LONGEST len)
{
- int res;
- int done = 0;
- struct target_ops *t;
+ LONGEST res;
+ int reg_len;
+ struct mem_region *region;
/* Zero length requests are ok and require no work. */
if (len == 0)
return 0;
- /* to_xfer_memory is not guaranteed to set errno, even when it returns
- 0. */
- errno = 0;
-
- if (!write && trust_readonly)
+ /* Try the executable file, if "trust-readonly-sections" is set. */
+ if (readbuf != NULL && trust_readonly)
{
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);
+
+ 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, myaddr, len, 0, attrib, ¤t_target);
+ return xfer_memory (memaddr, readbuf, len, 0, NULL, ops);
}
- /* The quick case is that the top target can handle the transfer. */
- res = current_target.to_xfer_memory
- (memaddr, myaddr, len, write, attrib, ¤t_target);
+ /* 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;
- /* If res <= 0 then we call it again in the loop. Ah well. */
- if (res <= 0)
+ switch (region->attrib.mode)
{
- for (t = target_stack; t != NULL; t = t->beneath)
- {
- if (!t->to_has_memory)
- continue;
-
- res = t->to_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;
- }
+ 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
+target_xfer_partial (struct target_ops *ops,
+ enum target_object object, const char *annex,
+ void *readbuf, const void *writebuf,
+ ULONGEST offset, LONGEST len)
+{
+ LONGEST retval;
-/* Perform a memory transfer. Iterate until the entire region has
- been transfered.
+ gdb_assert (ops->to_xfer_partial != NULL);
- Result is 0 or errno value. */
+ /* 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;
-static int
-target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
-{
- int res;
- int reg_len;
- struct mem_region *region;
+ /* 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;
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- {
- return 0;
+ retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
+ writebuf, offset, len);
}
- while (len > 0)
+ if (targetdebug)
{
- region = lookup_mem_region(memaddr);
- if (memaddr + len < region->hi)
- reg_len = len;
- else
- reg_len = region->hi - memaddr;
-
- switch (region->attrib.mode)
+ const unsigned char *myaddr = NULL;
+
+ fprintf_unfiltered (gdb_stdlog,
+ "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
+ ops->to_shortname,
+ (int) object,
+ (annex ? annex : "(null)"),
+ (long) readbuf, (long) writebuf,
+ paddr_nz (offset), paddr_d (len), paddr_d (retval));
+
+ if (readbuf)
+ myaddr = readbuf;
+ if (writebuf)
+ myaddr = writebuf;
+ if (retval > 0 && myaddr != NULL)
{
- case MEM_RO:
- if (write)
- return EIO;
- break;
-
- case MEM_WO:
- if (!write)
- return EIO;
- break;
- }
+ int i;
- 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)
+ fputs_unfiltered (", bytes =", gdb_stdlog);
+ for (i = 0; i < retval; i++)
{
- /* 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;
- }
+ if ((((long) &(myaddr[i])) & 0xf) == 0)
+ {
+ if (targetdebug < 2 && i > 0)
+ {
+ fprintf_unfiltered (gdb_stdlog, " ...");
+ break;
+ }
+ fprintf_unfiltered (gdb_stdlog, "\n");
+ }
- memaddr += res;
- myaddr += res;
- len -= res;
- reg_len -= res;
+ fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
+ }
}
+
+ fputc_unfiltered ('\n', gdb_stdlog);
}
-
- return 0; /* We managed to cover it all somehow. */
+ return retval;
}
+/* 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.
-/* Perform a partial memory transfer.
+ If an error occurs, no guarantee is made about the contents of the data at
+ 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 (which will retry until
+ it makes no progress, and then return how much was transferred). */
- Result is -1 on error, or the number of bytes transfered. */
+int
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+{
+ if (target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
+ myaddr, memaddr, len) == len)
+ return 0;
+ else
+ return EIO;
+}
-static int
-target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
- int write_p, int *err)
+int
+target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
{
- int res;
- int reg_len;
- struct mem_region *region;
+ if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
+ myaddr, memaddr, len) == len)
+ return 0;
+ else
+ return EIO;
+}
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- {
- *err = 0;
- return 0;
- }
+/* Fetch the target's memory map. */
- region = lookup_mem_region(memaddr);
- if (memaddr + len < region->hi)
- reg_len = len;
- else
- reg_len = region->hi - memaddr;
+VEC(mem_region_s) *
+target_memory_map (void)
+{
+ VEC(mem_region_s) *result;
+ struct mem_region *last_one, *this_one;
+ int ix;
+ struct target_ops *t;
- switch (region->attrib.mode)
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_memory_map != NULL)
+ break;
+
+ if (t == NULL)
+ return NULL;
+
+ result = t->to_memory_map (t);
+ if (result == NULL)
+ return NULL;
+
+ qsort (VEC_address (mem_region_s, result),
+ VEC_length (mem_region_s, result),
+ sizeof (struct mem_region), mem_region_cmp);
+
+ /* 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++)
{
- case MEM_RO:
- if (write_p)
+ this_one->number = ix;
+
+ if (last_one && last_one->hi > this_one->lo)
{
- *err = EIO;
- return -1;
+ warning (_("Overlapping regions in memory map: ignoring"));
+ VEC_free (mem_region_s, result);
+ return NULL;
}
- break;
+ last_one = this_one;
+ }
- case MEM_WO:
- if (write_p)
+ return result;
+}
+
+void
+target_flash_erase (ULONGEST address, LONGEST length)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_flash_erase != NULL)
{
- *err = EIO;
- return -1;
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
+ paddr (address), phex (length, 0));
+ return t->to_flash_erase (t, address, length);
}
- 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;
+ tcomplain ();
+}
- return -1;
- }
+void
+target_flash_done (void)
+{
+ struct target_ops *t;
- *err = 0;
- return res;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_flash_done != NULL)
+ {
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
+ return t->to_flash_done (t);
+ }
+
+ tcomplain ();
}
+#ifndef target_stopped_data_address_p
int
-target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
+target_stopped_data_address_p (struct target_ops *target)
{
- 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, char *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)
{
- 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, void *readbuf,
- const void *writebuf, ULONGEST offset, LONGEST len)
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
if (object == TARGET_OBJECT_MEMORY
- && ops->to_xfer_memory != NULL)
- /* If available, fall back to the target's "to_xfer_memory"
- method. */
+ && ops->deprecated_xfer_memory != NULL)
+ /* If available, fall back to the target's
+ "deprecated_xfer_memory" method. */
{
int xfered = -1;
errno = 0;
void *buffer = xmalloc (len);
struct cleanup *cleanup = make_cleanup (xfree, buffer);
memcpy (buffer, writebuf, len);
- xfered = ops->to_xfer_memory (offset, buffer, len, 1/*write*/, NULL,
- ops);
+ xfered = ops->deprecated_xfer_memory (offset, buffer, len,
+ 1/*write*/, NULL, ops);
do_cleanups (cleanup);
}
if (readbuf != NULL)
- xfered = ops->to_xfer_memory (offset, readbuf, len, 0/*read*/, NULL,
- ops);
+ xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/*read*/,
+ NULL, ops);
if (xfered > 0)
return xfered;
else if (xfered == 0 && errno == 0)
- /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
- indication of an error. */
+ /* "deprecated_xfer_memory" uses 0, cross checked against
+ ERRNO as one indication of an error. */
return 0;
else
return -1;
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;
+}
+
/* Target vector read/write partial wrapper functions.
NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
(inbuf, outbuf)", instead of separate read/write methods, make life
easier. */
-LONGEST
+static LONGEST
target_read_partial (struct target_ops *ops,
enum target_object object,
- const char *annex, void *buf,
+ const char *annex, gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
- gdb_assert (ops->to_xfer_partial != NULL);
- return ops->to_xfer_partial (ops, object, annex, buf, NULL, offset, len);
+ return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
}
-LONGEST
+static LONGEST
target_write_partial (struct target_ops *ops,
enum target_object object,
- const char *annex, const void *buf,
+ const char *annex, const gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
- gdb_assert (ops->to_xfer_partial != NULL);
- return ops->to_xfer_partial (ops, object, annex, NULL, buf, offset, len);
+ return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
}
/* Wrappers to perform the full transfer. */
LONGEST
target_read (struct target_ops *ops,
enum target_object object,
- const char *annex, void *buf,
+ const char *annex, gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
LONGEST xfered = 0;
while (xfered < len)
{
LONGEST xfer = target_read_partial (ops, object, annex,
- (bfd_byte *) buf + xfered,
+ (gdb_byte *) buf + xfered,
offset + xfered, len - xfered);
/* Call an observer, notifying them of the xfer progress? */
- if (xfer <= 0)
- /* Call memory_error? */
+ if (xfer == 0)
+ return xfered;
+ if (xfer < 0)
return -1;
xfered += xfer;
QUIT;
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 void *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,
- (bfd_byte *) buf + xfered,
+ (gdb_byte *) buf + xfered,
offset + xfered, len - xfered);
- /* Call an observer, notifying them of the xfer progress? */
- if (xfer <= 0)
- /* Call memory_error? */
+
+ if (xfer == 0)
+ return xfered;
+ if (xfer < 0)
return -1;
+
+ if (progress)
+ (*progress) (xfer, baton);
+
xfered += xfer;
QUIT;
}
return len;
}
+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);
+}
+
+/* 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. */
+
+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;
+ LONGEST n;
+
+ /* This function does not have a length parameter; it reads the
+ entire OBJECT). Also, it doesn't support objects fetched partly
+ from one target and partly from another (in a different stratum,
+ e.g. a core file and an executable). Both reasons make it
+ unsuitable for reading memory. */
+ gdb_assert (object != TARGET_OBJECT_MEMORY);
+
+ /* Start by reading up to 4K at a time. The target will throttle
+ this number down if necessary. */
+ buf_alloc = 4096;
+ buf = xmalloc (buf_alloc);
+ buf_pos = 0;
+ while (1)
+ {
+ n = target_read_partial (ops, object, annex, &buf[buf_pos],
+ buf_pos, buf_alloc - buf_pos - padding);
+ if (n < 0)
+ {
+ /* An error occurred. */
+ xfree (buf);
+ return -1;
+ }
+ else if (n == 0)
+ {
+ /* Read all there was. */
+ if (buf_pos == 0)
+ xfree (buf);
+ else
+ *buf_p = buf;
+ return buf_pos;
+ }
+
+ buf_pos += n;
+
+ /* If the buffer is filling up, expand it. */
+ if (buf_alloc < buf_pos * 2)
+ {
+ buf_alloc *= 2;
+ buf = xrealloc (buf, buf_alloc);
+ }
+
+ QUIT;
+ }
+}
+
+/* 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
-get_target_memory (struct target_ops *ops, CORE_ADDR addr, void *buf,
+get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
LONGEST len)
{
if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
get_target_memory_unsigned (struct target_ops *ops,
CORE_ADDR addr, int len)
{
- char buf[sizeof (ULONGEST)];
+ gdb_byte buf[sizeof (ULONGEST)];
gdb_assert (len <= sizeof (buf));
get_target_memory (ops, addr, buf, len);
int has_all_mem = 0;
if (symfile_objfile != NULL)
- printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
-
-#ifdef FILES_INFO_HOOK
- if (FILES_INFO_HOOK ())
- return;
-#endif
+ printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
for (t = target_stack; t != NULL; t = t->beneath)
{
if ((int) (t->to_stratum) <= (int) dummy_stratum)
continue;
if (has_all_mem)
- printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
+ printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
printf_unfiltered ("%s:\n", t->to_longname);
(t->to_files_info) (t);
has_all_mem = t->to_has_all_memory;
}
}
+/* 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)
{
if (!from_tty
- || query ("A program is being debugged already. Kill it? "))
+ || query (_("A program is being debugged already. Kill it? ")))
target_kill ();
else
- error ("Program not killed.");
+ error (_("Program not killed."));
}
/* Calling target_kill may remove the target from the stack. But if
if (target_has_execution)
pop_target ();
+
+ target_pre_inferior (from_tty);
}
/* Detach a target after doing deferred register stores. */
void
target_detach (char *args, int from_tty)
{
- /* Handle any optimized stores to the inferior. */
-#ifdef DO_DEFERRED_STORES
- DO_DEFERRED_STORES;
-#endif
(current_target.to_detach) (args, from_tty);
}
void
target_disconnect (char *args, int from_tty)
{
- /* Handle any optimized stores to the inferior. */
-#ifdef DO_DEFERRED_STORES
- DO_DEFERRED_STORES;
-#endif
- (current_target.to_disconnect) (args, from_tty);
-}
+ struct target_ops *t;
-void
-target_link (char *modname, CORE_ADDR *t_reloc)
-{
- if (DEPRECATED_STREQ (current_target.to_shortname, "rombug"))
- {
- (current_target.to_lookup_symbol) (modname, t_reloc);
- if (*t_reloc == 0)
- error ("Unable to link to %s and get relocation in rombug", modname);
- }
- else
- *t_reloc = (CORE_ADDR) -1;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_disconnect != NULL)
+ {
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
+ args, from_tty);
+ t->to_disconnect (t, args, from_tty);
+ return;
+ }
+
+ tcomplain ();
}
int
return saved_async_masked_status;
}
+/* Look through the list of possible targets for a target that can
+ follow forks. */
+
+int
+target_follow_fork (int follow_child)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_follow_fork != NULL)
+ {
+ int retval = t->to_follow_fork (t, follow_child);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
+ follow_child, retval);
+ return retval;
+ }
+ }
+
+ /* Some target returned a fork event, but did not know how to follow it. */
+ internal_error (__FILE__, __LINE__,
+ "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.
}
if (count != 1)
- error ("Don't know how to %s. Try \"help target\".", do_mesg);
+ error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
return runable;
}
}
void
-find_default_create_inferior (char *exec_file, char *allargs, char **env)
+find_default_create_inferior (char *exec_file, char *allargs, char **env,
+ int from_tty)
{
struct target_ops *t;
t = find_default_run_target ("run");
- (t->to_create_inferior) (exec_file, allargs, env);
+ (t->to_create_inferior) (exec_file, allargs, env, from_tty);
return;
}
static int
-default_region_size_ok_for_hw_watchpoint (int byte_count)
+default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
{
- return (byte_count <= TYPE_LENGTH (builtin_type_void_data_ptr));
+ return (len <= TYPE_LENGTH (builtin_type_void_data_ptr));
}
static int
/* 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;
(*t)->to_sections_end = target->to_sections_end;
}
}
+ /* There is a flattened view of the target stack in current_target,
+ so its to_sections pointer might also need updating. */
+ if (current_target.to_sections == old_value)
+ {
+ current_target.to_sections = target->to_sections;
+ current_target.to_sections_end = target->to_sections_end;
+ }
}
-
+
return old_count;
}
breakpoint_init_inferior (inf_exited);
registers_changed ();
-#ifdef CLEAR_DEFERRED_STORES
- /* Delete any pending stores to the inferior... */
- CLEAR_DEFERRED_STORES;
-#endif
-
reopen_exec_file ();
reinit_frame_cache ();
if (!show_breakpoint_hit_counts)
breakpoint_clear_ignore_counts ();
- if (detach_hook)
- detach_hook ();
+ if (deprecated_detach_hook)
+ deprecated_detach_hook ();
}
\f
/* Helper function for child_wait and the Lynx derivatives of child_wait.
int (*target_activity_function) (void);
int target_activity_fd;
\f
-/* Convert a normal process ID to a string. Returns the string in a static
- buffer. */
+/* Convert a normal process ID to a string. Returns the string in a
+ static buffer. */
char *
normal_pid_to_str (ptid_t ptid)
{
- static char buf[30];
+ static char buf[32];
- sprintf (buf, "process %d", PIDGET (ptid));
+ xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
return buf;
}
/* Error-catcher for target_find_memory_regions */
static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
{
- error ("No target.");
+ error (_("No target."));
return 0;
}
/* Error-catcher for target_make_corefile_notes */
static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
{
- error ("No target.");
+ error (_("No target."));
return NULL;
}
dummy_target.to_magic = OPS_MAGIC;
}
\f
-
-static struct target_ops debug_target;
-
static void
debug_to_open (char *args, int from_tty)
{
fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
}
-static void
-debug_to_disconnect (char *args, int from_tty)
-{
- debug_target.to_disconnect (args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
- args, from_tty);
-}
-
static void
debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
return retval;
}
-static void
-debug_to_post_wait (ptid_t ptid, int status)
-{
- debug_target.to_post_wait (ptid, status);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
- PIDGET (ptid), status);
-}
-
static void
debug_print_register (const char * func, int regno)
{
unsigned char buf[MAX_REGISTER_SIZE];
deprecated_read_register_gen (regno, buf);
fprintf_unfiltered (gdb_stdlog, " = ");
- for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i++)
+ for (i = 0; i < register_size (current_gdbarch, regno); i++)
{
fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
}
- if (DEPRECATED_REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST))
+ if (register_size (current_gdbarch, regno) <= sizeof (LONGEST))
{
fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
paddr_nz (read_register (regno)),
}
static int
-debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib,
- struct target_ops *target)
+deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
+ int write, struct mem_attrib *attrib,
+ struct target_ops *target)
{
int retval;
- retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write,
- attrib, target);
+ retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
+ attrib, target);
fprintf_unfiltered (gdb_stdlog,
"target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
}
fprintf_unfiltered (gdb_stdlog, "\n");
}
-
+
fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
}
}
}
static int
-debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
+debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
{
int retval;
- retval = debug_target.to_insert_breakpoint (addr, save);
+ retval = debug_target.to_insert_breakpoint (bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_insert_breakpoint (0x%lx, xxx) = %ld\n",
- (unsigned long) addr,
+ (unsigned long) bp_tgt->placed_address,
(unsigned long) retval);
return retval;
}
static int
-debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
+debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
{
int retval;
- retval = debug_target.to_remove_breakpoint (addr, save);
+ retval = debug_target.to_remove_breakpoint (bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_remove_breakpoint (0x%lx, xxx) = %ld\n",
- (unsigned long) addr,
+ (unsigned long) bp_tgt->placed_address,
(unsigned long) retval);
return retval;
}
}
static int
-debug_to_region_size_ok_for_hw_watchpoint (int byte_count)
+debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
{
CORE_ADDR retval;
- retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count);
+ retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
fprintf_unfiltered (gdb_stdlog,
- "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
- (unsigned long) byte_count,
+ "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
+ (unsigned long) addr,
+ (unsigned long) len,
(unsigned long) retval);
return retval;
}
return retval;
}
-static CORE_ADDR
-debug_to_stopped_data_address (void)
+static int
+debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
{
- CORE_ADDR retval;
+ int retval;
- retval = debug_target.to_stopped_data_address ();
+ retval = debug_target.to_stopped_data_address (target, addr);
fprintf_unfiltered (gdb_stdlog,
- "target_stopped_data_address () = 0x%lx\n",
- (unsigned long) retval);
+ "target_stopped_data_address ([0x%lx]) = %ld\n",
+ (unsigned long)*addr,
+ (unsigned long)retval);
return retval;
}
static int
-debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save)
+debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
{
int retval;
- retval = debug_target.to_insert_hw_breakpoint (addr, save);
+ retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
- (unsigned long) addr,
+ (unsigned long) bp_tgt->placed_address,
(unsigned long) retval);
return retval;
}
static int
-debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save)
+debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
{
int retval;
- retval = debug_target.to_remove_hw_breakpoint (addr, save);
+ retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
- (unsigned long) addr,
+ (unsigned long) bp_tgt->placed_address,
(unsigned long) retval);
return retval;
}
{
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;
}
}
static void
-debug_to_create_inferior (char *exec_file, char *args, char **env)
+debug_to_create_inferior (char *exec_file, char *args, char **env,
+ int from_tty)
{
- debug_target.to_create_inferior (exec_file, args, env);
+ debug_target.to_create_inferior (exec_file, args, env, from_tty);
- fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx)\n",
- exec_file, args);
+ fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
+ exec_file, args, from_tty);
}
static void
pid);
}
-static int
+static void
debug_to_insert_fork_catchpoint (int pid)
{
- int retval;
-
- retval = debug_target.to_insert_fork_catchpoint (pid);
+ debug_target.to_insert_fork_catchpoint (pid);
- fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
+ fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
+ pid);
}
static int
return retval;
}
-static int
+static void
debug_to_insert_vfork_catchpoint (int pid)
{
- int retval;
-
- retval = debug_target.to_insert_vfork_catchpoint (pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
- pid, retval);
+ debug_target.to_insert_vfork_catchpoint (pid);
- return retval;
+ fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
+ pid);
}
static int
return retval;
}
-static int
-debug_to_follow_fork (int follow_child)
-{
- int retval = debug_target.to_follow_fork (follow_child);
-
- fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
- follow_child, retval);
-
- return retval;
-}
-
-static int
+static void
debug_to_insert_exec_catchpoint (int pid)
{
- int retval;
-
- retval = debug_target.to_insert_exec_catchpoint (pid);
+ debug_target.to_insert_exec_catchpoint (pid);
- fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
+ fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
+ pid);
}
static int
fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
}
-static LONGEST
-debug_to_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, void *readbuf, const void *writebuf,
- ULONGEST offset, LONGEST len)
-{
- LONGEST retval;
-
- retval = debug_target.to_xfer_partial (&debug_target, object, annex,
- readbuf, writebuf, offset, len);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
- (int) object, (annex ? annex : "(null)"),
- (long) readbuf, (long) writebuf, paddr_nz (offset),
- paddr_d (len), paddr_d (retval));
-
- return retval;
-}
-
static void
debug_to_rcmd (char *command,
struct ui_file *outbuf)
current_target.to_attach = debug_to_attach;
current_target.to_post_attach = debug_to_post_attach;
current_target.to_detach = debug_to_detach;
- current_target.to_disconnect = debug_to_disconnect;
current_target.to_resume = debug_to_resume;
current_target.to_wait = debug_to_wait;
- current_target.to_post_wait = debug_to_post_wait;
current_target.to_fetch_registers = debug_to_fetch_registers;
current_target.to_store_registers = debug_to_store_registers;
current_target.to_prepare_to_store = debug_to_prepare_to_store;
- current_target.to_xfer_memory = debug_to_xfer_memory;
+ current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
current_target.to_files_info = debug_to_files_info;
current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
current_target.to_stopped_data_address = debug_to_stopped_data_address;
- current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint;
+ current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
current_target.to_terminal_init = debug_to_terminal_init;
current_target.to_terminal_inferior = debug_to_terminal_inferior;
current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
- current_target.to_follow_fork = debug_to_follow_fork;
current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
current_target.to_thread_alive = debug_to_thread_alive;
current_target.to_find_new_threads = debug_to_find_new_threads;
current_target.to_stop = debug_to_stop;
- current_target.to_xfer_partial = debug_to_xfer_partial;
current_target.to_rcmd = debug_to_rcmd;
current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
-
}
\f
|| (current_target.to_rcmd == debug_to_rcmd
&& (debug_target.to_rcmd
== (void (*) (char *, struct ui_file *)) tcomplain)))
- {
- error ("\"monitor\" command not supported by this target.\n");
- }
+ error (_("\"monitor\" command not supported by this target."));
target_rcmd (cmd, gdb_stdtarg);
}
add_info ("target", target_info, targ_desc);
add_info ("files", target_info, targ_desc);
- add_show_from_set
- (add_set_cmd ("target", class_maintenance, var_zinteger,
- (char *) &targetdebug,
- "Set target debugging.\n\
+ add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
+Set target debugging."), _("\
+Show target debugging."), _("\
When non-zero, target debugging is enabled. Higher numbers are more\n\
verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
-command.", &setdebuglist),
- &showdebuglist);
-
- add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
- &trust_readonly, "\
-Set mode for reading from readonly sections.\n\
+command."),
+ NULL,
+ show_targetdebug,
+ &setdebuglist, &showdebuglist);
+
+ 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."), _("\
When this mode is on, memory reads from readonly sections (such as .text)\n\
will be read from the object file instead of from the target. This will\n\
-result in significant performance improvement for remote targets.", "\
-Show mode for reading from readonly sections.\n",
- NULL, NULL,
+result in significant performance improvement for remote targets."),
+ NULL,
+ show_trust_readonly,
&setlist, &showlist);
add_com ("monitor", class_obscure, do_monitor_command,
- "Send a command to the remote monitor (remote targets only).");
+ _("Send a command to the remote monitor (remote targets only)."));
target_dcache = dcache_init ();
}
projects / thirdparty / binutils-gdb.git / blobdiff