/* Interface between GDB and target environments, including files and processes
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
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. */
#if !defined (TARGET_H)
#define TARGET_H
struct ui_file;
struct mem_attrib;
struct target_ops;
+struct bp_target_info;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
/* Given a name (SIGHUP, etc.), return its signal. */
enum target_signal target_signal_from_name (char *);
\f
-/* Request the transfer of up to LEN 8-bit bytes of the target's
- OBJECT. The OFFSET, for a seekable object, specifies the starting
- point. The ANNEX can be used to provide additional data-specific
- information to the target.
-
- Return the number of bytes actually transfered, zero when no
- further transfer is possible, and -1 when the transfer is not
- supported.
-
- NOTE: cagney/2003-10-17: The current interface does not support a
- "retry" mechanism. Instead it assumes that at least one byte will
- be transfered on each call.
-
- NOTE: cagney/2003-10-17: The current interface can lead to
- fragmented transfers. Lower target levels should not implement
- hacks, such as enlarging the transfer, in an attempt to compensate
- for this. Instead, the target stack should be extended so that it
- implements supply/collect methods and a look-aside object cache.
- With that available, the lowest target can safely and freely "push"
- data up the stack.
-
- NOTE: cagney/2003-10-17: Unlike the old query and the memory
- transfer mechanisms, these methods are explicitly parameterized by
- the target that it should be applied to.
-
- NOTE: cagney/2003-10-17: Just like the old query and memory xfer
- methods, these new methods perform partial transfers. The only
- difference is that these new methods thought to include "partial"
- in the name. The old code's failure to do this lead to much
- confusion and duplication of effort as each target object attempted
- to locally take responsibility for something it didn't have to
- worry about.
-
- NOTE: cagney/2003-10-17: With a TARGET_OBJECT_KOD object, for
- backward compatibility with the "target_query" method that this
- replaced, when OFFSET and LEN are both zero, return the "minimum"
- buffer size. See "remote.c" for further information. */
+/* Target objects which can be transfered using target_read,
+ target_write, et cetera. */
enum target_object
{
- /* Kernel Object Display transfer. See "kod.c" and "remote.c". */
- TARGET_OBJECT_KOD,
/* AVR target specific transfer. See "avr-tdep.c" and "remote.c". */
TARGET_OBJECT_AVR,
/* Transfer up-to LEN bytes of memory starting at OFFSET. */
/* Possible future objects: TARGET_OBJECT_FILE, TARGET_OBJECT_PROC, ... */
};
-extern LONGEST target_read_partial (struct target_ops *ops,
- enum target_object object,
- const char *annex, gdb_byte *buf,
- ULONGEST offset, LONGEST len);
+/* Request that OPS transfer up to LEN 8-bit bytes of the target's
+ OBJECT. The OFFSET, for a seekable object, specifies the
+ starting point. The ANNEX can be used to provide additional
+ data-specific information to the target.
-extern LONGEST target_write_partial (struct target_ops *ops,
- enum target_object object,
- const char *annex, const gdb_byte *buf,
- ULONGEST offset, LONGEST len);
+ Return the number of bytes actually transfered, or -1 if the
+ transfer is not supported or otherwise fails. Return of a positive
+ value less than LEN indicates that no further transfer is possible.
+ Unlike the raw to_xfer_partial interface, callers of these
+ functions do not need to retry partial transfers. */
-/* Wrappers to perform the full transfer. */
extern LONGEST target_read (struct target_ops *ops,
enum target_object object,
const char *annex, gdb_byte *buf,
const char *annex, const gdb_byte *buf,
ULONGEST offset, LONGEST len);
+/* Wrapper to perform a full read of unknown size. OBJECT/ANNEX will
+ be read using OPS. The return value will be -1 if the transfer
+ fails or is not supported; 0 if the object is empty; or the length
+ of the object otherwise. If a positive value is returned, a
+ sufficiently large buffer will be allocated using xmalloc and
+ returned in *BUF_P containing the contents of the object.
+
+ This method should be used for objects sufficiently small to store
+ in a single xmalloc'd buffer, when no fixed bound on the object's
+ size is known in advance. Don't try to read TARGET_OBJECT_MEMORY
+ through this function. */
+
+extern LONGEST target_read_alloc (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, gdb_byte **buf_p);
+
+/* 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. */
+
+extern char *target_read_stralloc (struct target_ops *ops,
+ enum target_object object,
+ const char *annex);
+
/* Wrappers to target read/write that perform memory transfers. They
throw an error if the memory transfer fails.
void (*to_attach) (char *, int);
void (*to_post_attach) (int);
void (*to_detach) (char *, int);
- void (*to_disconnect) (char *, int);
+ void (*to_disconnect) (struct target_ops *, char *, int);
void (*to_resume) (ptid_t, int, enum target_signal);
ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
void (*to_fetch_registers) (int);
struct target_ops *target);
void (*to_files_info) (struct target_ops *);
- int (*to_insert_breakpoint) (CORE_ADDR, gdb_byte *);
- int (*to_remove_breakpoint) (CORE_ADDR, gdb_byte *);
+ int (*to_insert_breakpoint) (struct bp_target_info *);
+ int (*to_remove_breakpoint) (struct bp_target_info *);
int (*to_can_use_hw_breakpoint) (int, int, int);
- int (*to_insert_hw_breakpoint) (CORE_ADDR, gdb_byte *);
- int (*to_remove_hw_breakpoint) (CORE_ADDR, gdb_byte *);
+ int (*to_insert_hw_breakpoint) (struct bp_target_info *);
+ int (*to_remove_hw_breakpoint) (struct bp_target_info *);
int (*to_remove_watchpoint) (CORE_ADDR, int, int);
int (*to_insert_watchpoint) (CORE_ADDR, int, int);
int (*to_stopped_by_watchpoint) (void);
int to_have_continuable_watchpoint;
int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
- int (*to_region_size_ok_for_hw_watchpoint) (int);
+ int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
void (*to_terminal_init) (void);
void (*to_terminal_inferior) (void);
void (*to_terminal_ours_for_output) (void);
CORE_ADDR load_module_addr,
CORE_ADDR offset);
- /* Perform partial transfers on OBJECT. See target_read_partial
- and target_write_partial for details of each variant. One, and
- only one, of readbuf or writebuf must be non-NULL. */
+ /* Request that OPS transfer up to LEN 8-bit bytes of the target's
+ OBJECT. The OFFSET, for a seekable object, specifies the
+ starting point. The ANNEX can be used to provide additional
+ data-specific information to the target.
+
+ Return the number of bytes actually transfered, zero when no
+ further transfer is possible, and -1 when the transfer is not
+ supported. Return of a positive value smaller than LEN does
+ not indicate the end of the object, only the end of the
+ transfer; higher level code should continue transferring if
+ desired. This is handled in target.c.
+
+ The interface does not support a "retry" mechanism. Instead it
+ assumes that at least one byte will be transfered on each
+ successful call.
+
+ NOTE: cagney/2003-10-17: The current interface can lead to
+ fragmented transfers. Lower target levels should not implement
+ hacks, such as enlarging the transfer, in an attempt to
+ compensate for this. Instead, the target stack should be
+ extended so that it implements supply/collect methods and a
+ look-aside object cache. With that available, the lowest
+ target can safely and freely "push" data up the stack.
+
+ See target_read and target_write for more information. One,
+ and only one, of readbuf or writebuf must be non-NULL. */
+
LONGEST (*to_xfer_partial) (struct target_ops *ops,
enum target_object object, const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
of bytes actually transfered is not defined) and ERR is set to a
non-zero error indication. */
-extern int target_read_memory_partial (CORE_ADDR addr, char *buf, int len,
- int *err);
+extern int target_read_memory_partial (CORE_ADDR addr, gdb_byte *buf,
+ int len, int *err);
-extern int target_write_memory_partial (CORE_ADDR addr, char *buf, int len,
- int *err);
+extern int target_write_memory_partial (CORE_ADDR addr, gdb_byte *buf,
+ int len, int *err);
extern char *child_pid_to_exec_file (int);
#define target_files_info() \
(*current_target.to_files_info) (¤t_target)
-/* Insert a breakpoint at address ADDR in the target machine. SAVE is
- a pointer to memory allocated for saving the target contents. It
- is guaranteed by the caller to be long enough to save the number of
- breakpoint bytes indicated by BREAKPOINT_FROM_PC. Result is 0 for
- success, or an errno value. */
+/* Insert a breakpoint at address BP_TGT->placed_address in the target
+ machine. Result is 0 for success, or an errno value. */
-#define target_insert_breakpoint(addr, save) \
- (*current_target.to_insert_breakpoint) (addr, save)
+#define target_insert_breakpoint(bp_tgt) \
+ (*current_target.to_insert_breakpoint) (bp_tgt)
-/* Remove a breakpoint at address ADDR in the target machine.
- SAVE is a pointer to the same save area
- that was previously passed to target_insert_breakpoint.
- Result is 0 for success, or an errno value. */
+/* Remove a breakpoint at address BP_TGT->placed_address in the target
+ machine. Result is 0 for success, or an errno value. */
-#define target_remove_breakpoint(addr, save) \
- (*current_target.to_remove_breakpoint) (addr, save)
+#define target_remove_breakpoint(bp_tgt) \
+ (*current_target.to_remove_breakpoint) (bp_tgt)
/* Initialize the terminal settings we record for the inferior,
before we actually run the inferior. */
/* Load an executable file into the target process. This is expected
to not only bring new code into the target process, but also to
- update GDB's symbol tables to match. */
+ update GDB's symbol tables to match.
+
+ ARG contains command-line arguments, to be broken down with
+ buildargv (). The first non-switch argument is the filename to
+ load, FILE; the second is a number (as parsed by strtoul (..., ...,
+ 0)), which is an offset to apply to the load addresses of FILE's
+ sections. The target may define switches, or other non-switch
+ arguments, as it pleases. */
extern void target_load (char *arg, int from_tty);
(*current_target.to_can_use_hw_breakpoint) (TYPE, CNT, OTHERTYPE);
#endif
-#if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
-#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \
- (*current_target.to_region_size_ok_for_hw_watchpoint) (byte_count)
+#ifndef TARGET_REGION_OK_FOR_HW_WATCHPOINT
+#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(addr, len) \
+ (*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
#endif
#endif
#ifndef target_insert_hw_breakpoint
-#define target_insert_hw_breakpoint(addr, save) \
- (*current_target.to_insert_hw_breakpoint) (addr, save)
+#define target_insert_hw_breakpoint(bp_tgt) \
+ (*current_target.to_insert_hw_breakpoint) (bp_tgt)
-#define target_remove_hw_breakpoint(addr, save) \
- (*current_target.to_remove_hw_breakpoint) (addr, save)
+#define target_remove_hw_breakpoint(bp_tgt) \
+ (*current_target.to_remove_hw_breakpoint) (bp_tgt)
#endif
extern int target_stopped_data_address_p (struct target_ops *);
/* From mem-break.c */
-extern int memory_remove_breakpoint (CORE_ADDR, gdb_byte *);
+extern int memory_remove_breakpoint (struct bp_target_info *);
-extern int memory_insert_breakpoint (CORE_ADDR, gdb_byte *);
+extern int memory_insert_breakpoint (struct bp_target_info *);
-extern int default_memory_remove_breakpoint (CORE_ADDR, gdb_byte *);
+extern int default_memory_remove_breakpoint (struct bp_target_info *);
-extern int default_memory_insert_breakpoint (CORE_ADDR, gdb_byte *);
+extern int default_memory_insert_breakpoint (struct bp_target_info *);
/* From target.c */
projects / binutils.git / blobdiff