/* Select target systems and architectures at runtime for GDB.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002
+
+ 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.
This file is part of GDB.
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 "dcache.h"
#include <signal.h>
#include "regcache.h"
-
-extern int errno;
+#include "gdb_assert.h"
+#include "gdbcore.h"
+#include "exceptions.h"
+#include "target-descriptions.h"
static void target_info (char *, int);
-static void cleanup_target (struct target_ops *);
-
-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 struct target_ops *find_default_run_target (char *);
-static void update_current_target (void);
-
static void nosupport_runtime (void);
-static void normal_target_post_startup_inferior (ptid_t ptid);
+static LONGEST default_xfer_partial (struct target_ops *ops,
+ enum target_object object,
+ 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_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);
-static int debug_to_query (int /*char */ , char *, char *, int *);
+/* 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;
/* Top of target stack. */
-struct target_stack_item *target_stack;
+static struct target_ops *target_stack;
/* The target structure we are currently using to talk to a process
or file or whatever "inferior" we have. */
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);
/* The user just typed 'target' without the name of a target. */
-/* ARGSUSED */
static void
target_command (char *arg, int from_tty)
{
void
add_target (struct target_ops *t)
{
+ /* Provide default values for all "must have" methods. */
+ if (t->to_xfer_partial == NULL)
+ t->to_xfer_partial = default_xfer_partial;
+
if (!target_structs)
{
target_struct_allocsize = DEFAULT_ALLOCSIZE;
target_struct_allocsize * sizeof (*target_structs));
}
target_structs[target_struct_size++] = t;
-/* cleanup_target (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);
}
(*current_target.to_load) (arg, from_tty);
}
-/* ARGSUSED */
static int
nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
struct target_ops *t)
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."));
}
-/* ARGSUSED */
static int
nosymbol (char *name, CORE_ADDR *addrp)
{
return 1; /* Symbol does not exist in target env */
}
-/* ARGSUSED */
static void
nosupport_runtime (void)
{
if (ptid_equal (inferior_ptid, null_ptid))
noprocess ();
else
- error ("No run-time support for this");
+ error (_("No run-time support for this"));
}
-/* ARGSUSED */
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);
}
-/* Clean up a target struct so it no longer has any zero pointers in it.
- We default entries, at least to stubs that print error messages. */
-
-static void
-cleanup_target (struct target_ops *t)
-{
+/* Go through the target stack from top to bottom, copying over zero
+ entries in current_target, then filling in still empty entries. In
+ effect, we are doing class inheritance through the pushed target
+ vectors.
-#define de_fault(field, value) \
- if (!t->field) \
- t->field = value
-
- de_fault (to_open,
- (void (*) (char *, int))
- tcomplain);
- de_fault (to_close,
- (void (*) (int))
- target_ignore);
- de_fault (to_attach,
- maybe_kill_then_attach);
- de_fault (to_post_attach,
- (void (*) (int))
- target_ignore);
- de_fault (to_require_attach,
- maybe_kill_then_attach);
- de_fault (to_detach,
- (void (*) (char *, int))
- target_ignore);
- de_fault (to_require_detach,
- (void (*) (int, char *, int))
- target_ignore);
- de_fault (to_resume,
- (void (*) (ptid_t, int, enum target_signal))
- noprocess);
- 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))
- target_ignore);
- de_fault (to_store_registers,
- (void (*) (int))
- noprocess);
- 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 *))
- nomemory);
- de_fault (to_files_info,
- (void (*) (struct target_ops *))
- target_ignore);
- de_fault (to_insert_breakpoint,
- memory_insert_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 *))
- return_minus_one);
- de_fault (to_remove_hw_breakpoint,
- (int (*) (CORE_ADDR, char *))
- return_minus_one);
- de_fault (to_insert_watchpoint,
- (int (*) (CORE_ADDR, int, int))
- return_minus_one);
- de_fault (to_remove_watchpoint,
- (int (*) (CORE_ADDR, int, int))
- return_minus_one);
- de_fault (to_stopped_by_watchpoint,
- (int (*) (void))
- return_zero);
- de_fault (to_stopped_data_address,
- (CORE_ADDR (*) (void))
- 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))
- target_ignore);
- de_fault (to_terminal_inferior,
- (void (*) (void))
- target_ignore);
- de_fault (to_terminal_ours_for_output,
- (void (*) (void))
- target_ignore);
- de_fault (to_terminal_ours,
- (void (*) (void))
- target_ignore);
- de_fault (to_terminal_save_ours,
- (void (*) (void))
- target_ignore);
- de_fault (to_terminal_info,
- default_terminal_info);
- de_fault (to_kill,
- (void (*) (void))
- noprocess);
- de_fault (to_load,
- (void (*) (char *, int))
- tcomplain);
- de_fault (to_lookup_symbol,
- (int (*) (char *, CORE_ADDR *))
- nosymbol);
- de_fault (to_create_inferior,
- maybe_kill_then_create_inferior);
- de_fault (to_post_startup_inferior,
- (void (*) (ptid_t))
- target_ignore);
- de_fault (to_acknowledge_created_inferior,
- (void (*) (int))
- target_ignore);
- de_fault (to_insert_fork_catchpoint,
- (int (*) (int))
- tcomplain);
- de_fault (to_remove_fork_catchpoint,
- (int (*) (int))
- tcomplain);
- de_fault (to_insert_vfork_catchpoint,
- (int (*) (int))
- tcomplain);
- 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))
- tcomplain);
- de_fault (to_remove_exec_catchpoint,
- (int (*) (int))
- tcomplain);
- de_fault (to_reported_exec_events_per_exec_call,
- (int (*) (void))
- return_one);
- de_fault (to_has_exited,
- (int (*) (int, int, int *))
- return_zero);
- de_fault (to_mourn_inferior,
- (void (*) (void))
- noprocess);
- de_fault (to_can_run,
- return_zero);
- de_fault (to_notice_signals,
- (void (*) (ptid_t))
- target_ignore);
- de_fault (to_thread_alive,
- (int (*) (ptid_t))
- return_zero);
- de_fault (to_find_new_threads,
- (void (*) (void))
- target_ignore);
- de_fault (to_extra_thread_info,
- (char *(*) (struct thread_info *))
- return_zero);
- de_fault (to_stop,
- (void (*) (void))
- target_ignore);
- 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))
- nosupport_runtime);
- de_fault (to_get_current_exception_event,
- (struct exception_event_record * (*) (void))
- nosupport_runtime);
- de_fault (to_pid_to_exec_file,
- (char *(*) (int))
- return_zero);
- de_fault (to_can_async_p,
- (int (*) (void))
- return_zero);
- de_fault (to_is_async_p,
- (int (*) (void))
- return_zero);
- de_fault (to_async,
- (void (*) (void (*) (enum inferior_event_type, void*), void*))
- tcomplain);
-#undef de_fault
-}
-
-/* Go through the target stack from top to bottom, copying over zero entries in
- current_target. In effect, we are doing class inheritance through the
- pushed target vectors. */
+ NOTE: cagney/2003-10-17: The problem with this inheritance, as it
+ is currently implemented, is that it discards any knowledge of
+ which target an inherited method originally belonged to.
+ Consequently, new new target methods should instead explicitly and
+ locally search the target stack for the target that can handle the
+ request. */
static void
update_current_target (void)
{
- struct target_stack_item *item;
struct target_ops *t;
- /* First, reset current_target */
- memset (¤t_target, 0, sizeof current_target);
-
- for (item = target_stack; item; item = item->next)
- {
- t = item->target_ops;
+ /* First, reset curren'ts contents. */
+ memset (¤t_target, 0, sizeof (current_target));
#define INHERIT(FIELD, TARGET) \
if (!current_target.FIELD) \
- current_target.FIELD = TARGET->FIELD
+ current_target.FIELD = (TARGET)->FIELD
+ for (t = target_stack; t; t = t->beneath)
+ {
INHERIT (to_shortname, t);
INHERIT (to_longname, t);
INHERIT (to_doc, t);
INHERIT (to_close, t);
INHERIT (to_attach, t);
INHERIT (to_post_attach, t);
- INHERIT (to_require_attach, t);
INHERIT (to_detach, t);
- INHERIT (to_require_detach, 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_remove_watchpoint, t);
INHERIT (to_stopped_data_address, t);
INHERIT (to_stopped_by_watchpoint, t);
- INHERIT (to_region_size_ok_for_hw_watchpoint, t);
+ INHERIT (to_have_continuable_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_pid_to_str, t);
INHERIT (to_extra_thread_info, t);
INHERIT (to_stop, t);
- INHERIT (to_query, t);
+ /* Do not inherit to_xfer_partial. */
INHERIT (to_rcmd, t);
INHERIT (to_enable_exception_callback, t);
INHERIT (to_get_current_exception_event, t);
INHERIT (to_pid_to_exec_file, t);
INHERIT (to_stratum, t);
- INHERIT (DONT_USE, t);
INHERIT (to_has_all_memory, t);
INHERIT (to_has_memory, t);
INHERIT (to_has_stack, 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);
-
-#undef INHERIT
+ /* Do not inherit to_memory_map. */
+ /* Do not inherit to_flash_erase. */
+ /* Do not inherit to_flash_done. */
}
+#undef INHERIT
+
+ /* Clean up a target struct so it no longer has any zero pointers in
+ it. Some entries are defaulted to a method that print an error,
+ others are hard-wired to a standard recursive default. */
+
+#define de_fault(field, value) \
+ if (!current_target.field) \
+ current_target.field = value
+
+ de_fault (to_open,
+ (void (*) (char *, int))
+ tcomplain);
+ de_fault (to_close,
+ (void (*) (int))
+ target_ignore);
+ de_fault (to_attach,
+ maybe_kill_then_attach);
+ de_fault (to_post_attach,
+ (void (*) (int))
+ target_ignore);
+ de_fault (to_detach,
+ (void (*) (char *, int))
+ target_ignore);
+ de_fault (to_resume,
+ (void (*) (ptid_t, int, enum target_signal))
+ noprocess);
+ de_fault (to_wait,
+ (ptid_t (*) (ptid_t, struct target_waitstatus *))
+ noprocess);
+ de_fault (to_fetch_registers,
+ (void (*) (int))
+ target_ignore);
+ de_fault (to_store_registers,
+ (void (*) (int))
+ noprocess);
+ 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 *))
+ nomemory);
+ de_fault (to_files_info,
+ (void (*) (struct target_ops *))
+ target_ignore);
+ de_fault (to_insert_breakpoint,
+ memory_insert_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 (*) (struct bp_target_info *))
+ return_minus_one);
+ de_fault (to_remove_hw_breakpoint,
+ (int (*) (struct bp_target_info *))
+ return_minus_one);
+ de_fault (to_insert_watchpoint,
+ (int (*) (CORE_ADDR, int, int))
+ return_minus_one);
+ de_fault (to_remove_watchpoint,
+ (int (*) (CORE_ADDR, int, int))
+ return_minus_one);
+ de_fault (to_stopped_by_watchpoint,
+ (int (*) (void))
+ return_zero);
+ de_fault (to_stopped_data_address,
+ (int (*) (struct target_ops *, CORE_ADDR *))
+ return_zero);
+ 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))
+ target_ignore);
+ de_fault (to_terminal_ours_for_output,
+ (void (*) (void))
+ target_ignore);
+ de_fault (to_terminal_ours,
+ (void (*) (void))
+ target_ignore);
+ de_fault (to_terminal_save_ours,
+ (void (*) (void))
+ target_ignore);
+ de_fault (to_terminal_info,
+ default_terminal_info);
+ de_fault (to_kill,
+ (void (*) (void))
+ noprocess);
+ de_fault (to_load,
+ (void (*) (char *, int))
+ tcomplain);
+ de_fault (to_lookup_symbol,
+ (int (*) (char *, CORE_ADDR *))
+ nosymbol);
+ de_fault (to_create_inferior,
+ maybe_kill_then_create_inferior);
+ de_fault (to_post_startup_inferior,
+ (void (*) (ptid_t))
+ target_ignore);
+ de_fault (to_acknowledge_created_inferior,
+ (void (*) (int))
+ target_ignore);
+ de_fault (to_insert_fork_catchpoint,
+ (void (*) (int))
+ tcomplain);
+ de_fault (to_remove_fork_catchpoint,
+ (int (*) (int))
+ tcomplain);
+ de_fault (to_insert_vfork_catchpoint,
+ (void (*) (int))
+ tcomplain);
+ de_fault (to_remove_vfork_catchpoint,
+ (int (*) (int))
+ tcomplain);
+ de_fault (to_insert_exec_catchpoint,
+ (void (*) (int))
+ tcomplain);
+ de_fault (to_remove_exec_catchpoint,
+ (int (*) (int))
+ tcomplain);
+ de_fault (to_reported_exec_events_per_exec_call,
+ (int (*) (void))
+ return_one);
+ de_fault (to_has_exited,
+ (int (*) (int, int, int *))
+ return_zero);
+ de_fault (to_mourn_inferior,
+ (void (*) (void))
+ noprocess);
+ de_fault (to_can_run,
+ return_zero);
+ de_fault (to_notice_signals,
+ (void (*) (ptid_t))
+ target_ignore);
+ de_fault (to_thread_alive,
+ (int (*) (ptid_t))
+ return_zero);
+ de_fault (to_find_new_threads,
+ (void (*) (void))
+ target_ignore);
+ de_fault (to_extra_thread_info,
+ (char *(*) (struct thread_info *))
+ return_zero);
+ de_fault (to_stop,
+ (void (*) (void))
+ target_ignore);
+ 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))
+ nosupport_runtime);
+ de_fault (to_get_current_exception_event,
+ (struct exception_event_record * (*) (void))
+ nosupport_runtime);
+ de_fault (to_pid_to_exec_file,
+ (char *(*) (int))
+ return_zero);
+ de_fault (to_can_async_p,
+ (int (*) (void))
+ return_zero);
+ de_fault (to_is_async_p,
+ (int (*) (void))
+ return_zero);
+ 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". That way code looking for a non-inherited
+ target method can quickly and simply find it. */
+ 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,
int
push_target (struct target_ops *t)
{
- struct target_stack_item *cur, *prev, *tmp;
+ struct target_ops **cur;
/* Check magic number. If wrong, it probably means someone changed
the struct definition, but not all the places that initialize one. */
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. */
-
- for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
+ /* Find the proper stratum to install this target in. */
+ for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
{
- if ((int) (t->to_stratum) >= (int) (cur->target_ops->to_stratum))
+ if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
break;
}
- /* If there's already targets at this stratum, remove them. */
-
- if (cur)
- while (t->to_stratum == cur->target_ops->to_stratum)
- {
- /* There's already something on this stratum. Close it off. */
- if (cur->target_ops->to_close)
- (cur->target_ops->to_close) (0);
- if (prev)
- prev->next = cur->next; /* Unchain old target_ops */
- else
- target_stack = cur->next; /* Unchain first on list */
- tmp = cur->next;
- xfree (cur);
- cur = tmp;
- }
+ /* If there's already targets at this stratum, remove them. */
+ /* 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)
+ {
+ /* There's already something at this stratum level. Close it,
+ and un-hook it from the stack. */
+ struct target_ops *tmp = (*cur);
+ (*cur) = (*cur)->beneath;
+ tmp->beneath = NULL;
+ target_close (tmp, 0);
+ }
/* We have removed all targets in our stratum, now add the new one. */
-
- tmp = (struct target_stack_item *)
- xmalloc (sizeof (struct target_stack_item));
- tmp->next = cur;
- tmp->target_ops = t;
-
- if (prev)
- prev->next = tmp;
- else
- target_stack = tmp;
+ t->beneath = (*cur);
+ (*cur) = t;
update_current_target ();
- cleanup_target (¤t_target); /* Fill in the gaps */
-
if (targetdebug)
setup_target_debug ();
- return prev != 0;
+ /* Not on top? */
+ 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
unpush_target (struct target_ops *t)
{
- struct target_stack_item *cur, *prev;
-
- if (t->to_close)
- t->to_close (0); /* Let it clean up */
+ struct target_ops **cur;
+ struct target_ops *tmp;
/* Look for the specified target. Note that we assume that a target
can only occur once in the target stack. */
- for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
- if (cur->target_ops == t)
- break;
+ for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
+ {
+ if ((*cur) == t)
+ break;
+ }
- if (!cur)
+ if ((*cur) == NULL)
return 0; /* Didn't find target_ops, quit now */
- /* Unchain the target */
-
- if (!prev)
- target_stack = cur->next;
- else
- prev->next = cur->next;
+ /* NOTE: cagney/2003-12-06: In '94 the close call was made
+ unconditional by moving it to before the above check that the
+ target was in the target stack (something about "Change the way
+ pushing and popping of targets work to support target overlays
+ and inheritance"). This doesn't make much sense - only open
+ targets should be closed. */
+ target_close (t, 0);
- xfree (cur); /* Release the target_stack_item */
+ /* Unchain the target */
+ tmp = (*cur);
+ (*cur) = (*cur)->beneath;
+ tmp->beneath = NULL;
update_current_target ();
- cleanup_target (¤t_target);
return 1;
}
void
pop_target (void)
{
- (current_target.to_close) (0); /* Let it clean up */
- if (unpush_target (target_stack->target_ops) == 1)
+ target_close (¤t_target, 0); /* Let it clean up */
+ if (unpush_target (target_stack) == 1)
return;
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 nbytes_read;
}
+/* Find a section containing ADDR. */
+struct section_table *
+target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
+{
+ struct section_table *secp;
+ for (secp = target->to_sections;
+ secp < target->to_sections_end;
+ secp++)
+ {
+ if (addr >= secp->addr && addr < secp->endaddr)
+ return secp;
+ }
+ return NULL;
+}
+
+/* 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)
+{
+ 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
+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;
+
+ gdb_assert (ops->to_xfer_partial != NULL);
+
+ /* 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;
+
+ 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)
+ {
+ int i;
+
+ fputs_unfiltered (", bytes =", gdb_stdlog);
+ for (i = 0; i < retval; i++)
+ {
+ if ((((long) &(myaddr[i])) & 0xf) == 0)
+ {
+ if (targetdebug < 2 && i > 0)
+ {
+ fprintf_unfiltered (gdb_stdlog, " ...");
+ break;
+ }
+ fprintf_unfiltered (gdb_stdlog, "\n");
+ }
+
+ fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
+ }
+ }
+
+ fputc_unfiltered ('\n', gdb_stdlog);
+ }
+ 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.
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_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
+ myaddr, memaddr, len) == len)
+ return 0;
+ else
+ return EIO;
+}
+
+int
+target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+{
+ if (target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL,
+ myaddr, memaddr, len) == len)
+ return 0;
+ else
+ return EIO;
+}
+
+/* Fetch the target's memory map. */
+
+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;
+
+ 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++)
+ {
+ this_one->number = ix;
+
+ if (last_one && last_one->hi > this_one->lo)
+ {
+ warning (_("Overlapping regions in memory map: ignoring"));
+ VEC_free (mem_region_s, result);
+ return NULL;
+ }
+ last_one = this_one;
+ }
+
+ 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)
+ {
+ 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);
+ }
+
+ tcomplain ();
+}
+
+void
+target_flash_done (void)
+{
+ struct target_ops *t;
+
+ 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 (CORE_ADDR memaddr, char *myaddr, int len)
+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
+
+static void
+show_trust_readonly (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ 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 gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
- return target_xfer_memory (memaddr, myaddr, len, 0);
+ if (object == TARGET_OBJECT_MEMORY
+ && ops->deprecated_xfer_memory != NULL)
+ /* If available, fall back to the target's
+ "deprecated_xfer_memory" method. */
+ {
+ int xfered = -1;
+ errno = 0;
+ if (writebuf != NULL)
+ {
+ void *buffer = xmalloc (len);
+ struct cleanup *cleanup = make_cleanup (xfree, buffer);
+ memcpy (buffer, writebuf, len);
+ xfered = ops->deprecated_xfer_memory (offset, buffer, len,
+ 1/*write*/, NULL, ops);
+ do_cleanups (cleanup);
+ }
+ if (readbuf != NULL)
+ xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/*read*/,
+ NULL, ops);
+ if (xfered > 0)
+ return xfered;
+ else if (xfered == 0 && errno == 0)
+ /* "deprecated_xfer_memory" uses 0, cross checked against
+ ERRNO as one indication of an error. */
+ return 0;
+ else
+ return -1;
+ }
+ else if (ops->beneath != NULL)
+ return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+ readbuf, writebuf, offset, len);
+ else
+ return -1;
}
-int
-target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
+/* 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)
{
- return target_xfer_memory (memaddr, myaddr, len, 1);
+ if (ops->beneath != NULL)
+ return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+ readbuf, writebuf, offset, len);
+ else
+ return -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.
+/* Target vector read/write partial wrapper functions.
- Result is -1 on error, or the number of bytes transfered. */
+ NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
+ (inbuf, outbuf)", instead of separate read/write methods, make life
+ easier. */
-int
-do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib)
+static LONGEST
+target_read_partial (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, gdb_byte *buf,
+ ULONGEST offset, LONGEST len)
{
- int res;
- int done = 0;
- struct target_ops *t;
- struct target_stack_item *item;
-
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- return 0;
+ return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
+}
- /* to_xfer_memory is not guaranteed to set errno, even when it returns
- 0. */
- errno = 0;
+static LONGEST
+target_write_partial (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, const gdb_byte *buf,
+ ULONGEST offset, LONGEST len)
+{
+ return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
+}
- if (!write && trust_readonly)
+/* Wrappers to perform the full transfer. */
+LONGEST
+target_read (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, gdb_byte *buf,
+ ULONGEST offset, LONGEST len)
+{
+ LONGEST xfered = 0;
+ while (xfered < len)
{
- /* User-settable option, "trust-readonly-sections". If true,
- then memory from any SEC_READONLY bfd section may be read
- directly from the bfd file. */
+ LONGEST xfer = target_read_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;
+ xfered += xfer;
+ QUIT;
+ }
+ return len;
+}
- struct section_table *secp;
+/* An alternative to target_write with progress callbacks. */
- for (secp = current_target.to_sections;
- secp < current_target.to_sections_end;
- secp++)
- {
- if (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
- & SEC_READONLY)
- if (memaddr >= secp->addr && memaddr < secp->endaddr)
- return xfer_memory (memaddr, myaddr, len, 0,
- attrib, ¤t_target);
- }
- }
+LONGEST
+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;
- /* 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);
+ /* Give the progress callback a chance to set up. */
+ if (progress)
+ (*progress) (0, baton);
- /* If res <= 0 then we call it again in the loop. Ah well. */
- if (res <= 0)
+ while (xfered < len)
{
- for (item = target_stack; item; item = item->next)
- {
- t = item->target_ops;
- 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;
- }
+ LONGEST xfer = target_write_partial (ops, object, annex,
+ (gdb_byte *) buf + xfered,
+ offset + xfered, len - xfered);
- if (res <= 0)
+ if (xfer == 0)
+ return xfered;
+ if (xfer < 0)
return -1;
- }
-
- return res;
-}
-
-
-/* Perform a memory transfer. Iterate until the entire region has
- been transfered.
- Result is 0 or errno value. */
+ if (progress)
+ (*progress) (xfer, baton);
-static int
-target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
-{
- int res;
- int reg_len;
- struct mem_region *region;
-
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- {
- return 0;
+ xfered += xfer;
+ QUIT;
}
-
- while (len > 0)
+ 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)
{
- region = lookup_mem_region(memaddr);
- if (memaddr + len < region->hi)
- reg_len = len;
- else
- reg_len = region->hi - memaddr;
-
- switch (region->attrib.mode)
+ n = target_read_partial (ops, object, annex, &buf[buf_pos],
+ buf_pos, buf_alloc - buf_pos - padding);
+ if (n < 0)
{
- case MEM_RO:
- if (write)
- return EIO;
- break;
-
- case MEM_WO:
- if (!write)
- return EIO;
- break;
+ /* An error occurred. */
+ xfree (buf);
+ return -1;
}
-
- while (reg_len > 0)
+ else if (n == 0)
{
- if (region->attrib.cache)
- res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
- reg_len, write);
+ /* Read all there was. */
+ if (buf_pos == 0)
+ xfree (buf);
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;
- }
+ *buf_p = buf;
+ return buf_pos;
+ }
+
+ buf_pos += n;
- memaddr += res;
- myaddr += res;
- len -= res;
- reg_len -= res;
+ /* If the buffer is filling up, expand it. */
+ if (buf_alloc < buf_pos * 2)
+ {
+ buf_alloc *= 2;
+ buf = xrealloc (buf, buf_alloc);
}
+
+ QUIT;
}
-
- return 0; /* We managed to cover it all somehow. */
}
+/* 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. */
-/* Perform a partial memory transfer.
-
- Result is -1 on error, or the number of bytes transfered. */
-
-static int
-target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
- int write_p, int *err)
+LONGEST
+target_read_alloc (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte **buf_p)
{
- int res;
- int reg_len;
- struct mem_region *region;
+ return target_read_alloc_1 (ops, object, annex, buf_p, 0);
+}
- /* Zero length requests are ok and require no work. */
- if (len == 0)
- {
- *err = 0;
- return 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. */
- region = lookup_mem_region(memaddr);
- if (memaddr + len < region->hi)
- reg_len = len;
- else
- reg_len = region->hi - memaddr;
+char *
+target_read_stralloc (struct target_ops *ops, enum target_object object,
+ const char *annex)
+{
+ gdb_byte *buffer;
+ LONGEST transferred;
- switch (region->attrib.mode)
- {
- case MEM_RO:
- if (write_p)
- {
- *err = EIO;
- return -1;
- }
- break;
+ transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
- case MEM_WO:
- if (write_p)
- {
- *err = EIO;
- return -1;
- }
- break;
- }
+ if (transferred < 0)
+ return NULL;
- 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;
+ if (transferred == 0)
+ return xstrdup ("");
- return -1;
- }
+ buffer[transferred] = 0;
+ if (strlen (buffer) < transferred)
+ warning (_("target object %d, annex %s, "
+ "contained unexpected null characters"),
+ (int) object, annex ? annex : "(none)");
- *err = 0;
- return res;
+ return (char *) buffer;
}
-int
-target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
+/* Memory transfer methods. */
+
+void
+get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
+ LONGEST len)
{
- return target_xfer_memory_partial (memaddr, buf, len, 0, err);
+ if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
+ != len)
+ memory_error (EIO, addr);
}
-int
-target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
+ULONGEST
+get_target_memory_unsigned (struct target_ops *ops,
+ CORE_ADDR addr, int len)
{
- return target_xfer_memory_partial (memaddr, buf, len, 1, err);
+ gdb_byte buf[sizeof (ULONGEST)];
+
+ gdb_assert (len <= sizeof (buf));
+ get_target_memory (ops, addr, buf, len);
+ return extract_unsigned_integer (buf, len);
}
-/* ARGSUSED */
static void
target_info (char *args, int from_tty)
{
struct target_ops *t;
- struct target_stack_item *item;
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 (item = target_stack; item; item = item->next)
+ for (t = target_stack; t != NULL; t = t->beneath)
{
- t = item->target_ops;
-
if (!t->to_has_memory)
continue;
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_link (char *modname, CORE_ADDR *t_reloc)
+target_disconnect (char *args, int from_tty)
{
- if (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;
+ struct target_ops *t;
+
+ 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_require_attach (char *args, int from_tty)
-{
- struct target_ops *t;
-
- t = find_default_run_target ("require_attach");
- (t->to_require_attach) (args, from_tty);
- return;
-}
-
-void
-find_default_require_detach (int pid, char *args, int from_tty)
-{
- struct target_ops *t;
-
- t = find_default_run_target ("require_detach");
- (t->to_require_detach) (pid, args, from_tty);
- return;
-}
-
-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 <= REGISTER_SIZE);
+ 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;
}
struct target_ops *
find_target_beneath (struct target_ops *t)
{
- struct target_stack_item *cur;
-
- for (cur = target_stack; cur; cur = cur->next)
- if (cur->target_ops == t)
- break;
-
- if (cur == NULL || cur->next == NULL)
- return NULL;
- else
- return cur->next->target_ops;
+ return t->beneath;
}
\f
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;
}
-/* Some targets (such as ttrace-based HPUX) don't allow us to request
- notification of inferior events such as fork and vork immediately
- after the inferior is created. (This because of how gdb gets an
- inferior created via invoking a shell to do it. In such a scenario,
- if the shell init file has commands in it, the shell will fork and
- exec for each of those commands, and we will see each such fork
- event. Very bad.)
-
- This function is used by all targets that allow us to request
- notification of forks, etc at inferior creation time; e.g., in
- target_acknowledge_forked_child.
- */
-static void
-normal_target_post_startup_inferior (ptid_t ptid)
-{
- /* This space intentionally left blank. */
-}
-
/* Error-catcher for target_find_memory_regions */
-/* ARGSUSED */
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 */
-/* ARGSUSED */
static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
{
- error ("No target.");
+ error (_("No target."));
return NULL;
}
dummy_target.to_longname = "None";
dummy_target.to_doc = "";
dummy_target.to_attach = find_default_attach;
- dummy_target.to_require_attach = find_default_require_attach;
- dummy_target.to_require_detach = find_default_require_detach;
dummy_target.to_create_inferior = find_default_create_inferior;
dummy_target.to_pid_to_str = normal_pid_to_str;
dummy_target.to_stratum = dummy_stratum;
dummy_target.to_find_memory_regions = dummy_find_memory_regions;
dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
+ dummy_target.to_xfer_partial = default_xfer_partial;
dummy_target.to_magic = OPS_MAGIC;
}
\f
-
-static struct target_ops debug_target;
-
static void
debug_to_open (char *args, int from_tty)
{
static void
debug_to_close (int quitting)
{
- debug_target.to_close (quitting);
-
+ target_close (&debug_target, quitting);
fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
}
+void
+target_close (struct target_ops *targ, int quitting)
+{
+ if (targ->to_xclose != NULL)
+ targ->to_xclose (targ, quitting);
+ else if (targ->to_close != NULL)
+ targ->to_close (quitting);
+}
+
static void
debug_to_attach (char *args, int from_tty)
{
fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
}
-static void
-debug_to_require_attach (char *args, int from_tty)
-{
- debug_target.to_require_attach (args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_require_attach (%s, %d)\n", args, from_tty);
-}
-
static void
debug_to_detach (char *args, int from_tty)
{
fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
}
-static void
-debug_to_require_detach (int pid, char *args, int from_tty)
-{
- debug_target.to_require_detach (pid, args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_require_detach (%d, %s, %d)\n", pid, 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)
{
if (regno >= 0)
{
int i;
- unsigned char *buf = alloca (MAX_REGISTER_RAW_SIZE);
+ unsigned char buf[MAX_REGISTER_SIZE];
deprecated_read_register_gen (regno, buf);
fprintf_unfiltered (gdb_stdlog, " = ");
- for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
+ for (i = 0; i < register_size (current_gdbarch, regno); i++)
{
fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
}
- if (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",
(unsigned int) memaddr, /* possable truncate long long */
len, write ? "write" : "read", retval);
-
-
if (retval > 0)
{
int i;
for (i = 0; i < retval; i++)
{
if ((((long) &(myaddr[i])) & 0xf) == 0)
- fprintf_unfiltered (gdb_stdlog, "\n");
+ {
+ if (targetdebug < 2 && i > 0)
+ {
+ fprintf_unfiltered (gdb_stdlog, " ...");
+ break;
+ }
+ 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);
+ debug_target.to_insert_vfork_catchpoint (pid);
- fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
- pid, retval);
-
- 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);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
- pid, retval);
+ debug_target.to_insert_exec_catchpoint (pid);
- return retval;
+ fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
+ pid);
}
static int
fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
}
-static int
-debug_to_query (int type, char *req, char *resp, int *siz)
-{
- int retval;
-
- retval = debug_target.to_query (type, req, resp, siz);
-
- fprintf_unfiltered (gdb_stdlog, "target_query (%c, %s, %s, %d) = %d\n", type, req, resp, *siz, retval);
-
- return retval;
-}
-
static void
debug_to_rcmd (char *command,
struct ui_file *outbuf)
current_target.to_close = debug_to_close;
current_target.to_attach = debug_to_attach;
current_target.to_post_attach = debug_to_post_attach;
- current_target.to_require_attach = debug_to_require_attach;
current_target.to_detach = debug_to_detach;
- current_target.to_require_detach = debug_to_require_detach;
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_query = debug_to_query;
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\
-When non-zero, target debugging is enabled.", &setdebuglist),
- &showdebuglist);
-
- add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
- &trust_readonly, "\
-Set mode for reading from readonly sections.\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."),
+ 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