/* Interface between GDB and target environments, including files and processes
- Copyright (C) 1990-2013 Free Software Foundation, Inc.
+ Copyright (C) 1990-2014 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
struct static_tracepoint_marker;
struct traceframe_info;
struct expression;
+struct dcache_struct;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
it goes into the file stratum, which is always below the process
stratum. */
-#include "target-common.h"
+#include "target/resume.h"
+#include "target/wait.h"
+#include "target/waitstatus.h"
#include "bfd.h"
#include "symtab.h"
#include "memattr.h"
if it is not in a region marked as such, since it is known to be
"normal" RAM. */
TARGET_OBJECT_STACK_MEMORY,
+ /* Memory known to be part of the target code. This is cached even
+ if it is not in a region marked as such. */
+ TARGET_OBJECT_CODE_MEMORY,
/* Kernel Unwind Table. See "ia64-tdep.c". */
TARGET_OBJECT_UNWIND_TABLE,
/* Transfer auxilliary vector. */
/* Possible future objects: TARGET_OBJECT_FILE, ... */
};
+/* Possible values returned by target_xfer_partial, etc. */
+
+enum target_xfer_status
+{
+ /* Some bytes are transferred. */
+ TARGET_XFER_OK = 1,
+
+ /* No further transfer is possible. */
+ TARGET_XFER_EOF = 0,
+
+ /* Generic I/O error. Note that it's important that this is '-1',
+ as we still have target_xfer-related code returning hardcoded
+ '-1' on error. */
+ TARGET_XFER_E_IO = -1,
+
+ /* Transfer failed because the piece of the object requested is
+ unavailable. */
+ TARGET_XFER_E_UNAVAILABLE = -2,
+
+ /* Keep list in sync with target_xfer_error_to_string. */
+};
+
+#define TARGET_XFER_STATUS_ERROR_P(STATUS) ((STATUS) < TARGET_XFER_EOF)
+
+/* Return the string form of ERR. */
+
+extern const char *target_xfer_status_to_string (enum target_xfer_status err);
+
/* Enumeration of the kinds of traceframe searches that a target may
be able to perform. */
typedef struct static_tracepoint_marker *static_tracepoint_marker_p;
DEF_VEC_P(static_tracepoint_marker_p);
+typedef enum target_xfer_status
+ target_xfer_partial_ftype (struct target_ops *ops,
+ enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset,
+ ULONGEST len,
+ ULONGEST *xfered_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.
- 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. */
+ Return the number of bytes actually transfered, or a negative error
+ code (an 'enum target_xfer_error' value) 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. */
extern LONGEST target_read (struct target_ops *ops,
enum target_object object,
enum target_object object,
const char *annex);
+/* See target_ops->to_xfer_partial. */
+extern target_xfer_partial_ftype target_xfer_partial;
+
/* Wrappers to target read/write that perform memory transfers. They
throw an error if the memory transfer fails.
\f
struct thread_info; /* fwd decl for parameter list below: */
+/* The type of the callback to the to_async method. */
+
+typedef void async_callback_ftype (enum inferior_event_type event_type,
+ void *context);
+
+/* These defines are used to mark target_ops methods. The script
+ make-target-delegates scans these and auto-generates the base
+ method implementations. There are four macros that can be used:
+
+ 1. TARGET_DEFAULT_IGNORE. There is no argument. The base method
+ does nothing. This is only valid if the method return type is
+ 'void'.
+
+ 2. TARGET_DEFAULT_NORETURN. The argument is a function call, like
+ 'tcomplain ()'. The base method simply makes this call, which is
+ assumed not to return.
+
+ 3. TARGET_DEFAULT_RETURN. The argument is a C expression. The
+ base method returns this expression's value.
+
+ 4. TARGET_DEFAULT_FUNC. The argument is the name of a function.
+ make-target-delegates does not generate a base method in this case,
+ but instead uses the argument function as the base method. */
+
+#define TARGET_DEFAULT_IGNORE()
+#define TARGET_DEFAULT_NORETURN(ARG)
+#define TARGET_DEFAULT_RETURN(ARG)
+#define TARGET_DEFAULT_FUNC(ARG)
+
struct target_ops
{
struct target_ops *beneath; /* To the target under this one. */
void (*to_close) (void);
void (*to_attach) (struct target_ops *ops, char *, int);
void (*to_post_attach) (int);
- void (*to_detach) (struct target_ops *ops, char *, int);
+ void (*to_detach) (struct target_ops *ops, const char *, int);
void (*to_disconnect) (struct target_ops *, char *, int);
- void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal);
+ void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
+ TARGET_DEFAULT_NORETURN (noprocess ());
ptid_t (*to_wait) (struct target_ops *,
- ptid_t, struct target_waitstatus *, int);
+ ptid_t, struct target_waitstatus *, int)
+ TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_fetch_registers) (struct target_ops *, struct regcache *, int);
- void (*to_store_registers) (struct target_ops *, struct regcache *, int);
- void (*to_prepare_to_store) (struct regcache *);
+ void (*to_store_registers) (struct target_ops *, struct regcache *, int)
+ TARGET_DEFAULT_NORETURN (noprocess ());
+ void (*to_prepare_to_store) (struct target_ops *, struct regcache *);
/* Transfer LEN bytes of memory between GDB address MYADDR and
target address MEMADDR. If WRITE, transfer them to the target, else
struct target_ops *target);
void (*to_files_info) (struct target_ops *);
- int (*to_insert_breakpoint) (struct gdbarch *, struct bp_target_info *);
- int (*to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *);
+ int (*to_insert_breakpoint) (struct target_ops *, struct gdbarch *,
+ struct bp_target_info *)
+ TARGET_DEFAULT_FUNC (memory_insert_breakpoint);
+ int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *,
+ struct bp_target_info *)
+ TARGET_DEFAULT_FUNC (memory_remove_breakpoint);
int (*to_can_use_hw_breakpoint) (int, int, int);
int (*to_ranged_break_num_registers) (struct target_ops *);
int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
CORE_ADDR, CORE_ADDR, int);
int (*to_remove_mask_watchpoint) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
- int (*to_stopped_by_watchpoint) (void);
+ int (*to_stopped_by_watchpoint) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
int to_have_steppable_watchpoint;
int to_have_continuable_watchpoint;
- int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
+ int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *)
+ TARGET_DEFAULT_RETURN (0);
int (*to_watchpoint_addr_within_range) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
int (*to_remove_fork_catchpoint) (int);
int (*to_insert_vfork_catchpoint) (int);
int (*to_remove_vfork_catchpoint) (int);
- int (*to_follow_fork) (struct target_ops *, int);
+ int (*to_follow_fork) (struct target_ops *, int, int);
int (*to_insert_exec_catchpoint) (int);
int (*to_remove_exec_catchpoint) (int);
int (*to_set_syscall_catchpoint) (int, int, int, int, int *);
int to_has_thread_control; /* control thread execution */
int to_attach_no_wait;
/* ASYNC target controls */
- int (*to_can_async_p) (void);
- int (*to_is_async_p) (void);
- void (*to_async) (void (*) (enum inferior_event_type, void *), void *);
+ int (*to_can_async_p) (struct target_ops *)
+ TARGET_DEFAULT_FUNC (find_default_can_async_p);
+ int (*to_is_async_p) (struct target_ops *)
+ TARGET_DEFAULT_FUNC (find_default_is_async_p);
+ void (*to_async) (struct target_ops *, async_callback_ftype *, void *)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
int (*to_supports_non_stop) (void);
/* find_memory_regions support method for gcore */
int (*to_find_memory_regions) (find_memory_region_ftype func, void *data);
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.
+ Return the transferred status, error or OK (an
+ 'enum target_xfer_status' value). Save the number of bytes
+ actually transferred in *XFERED_LEN if transfer is successful
+ (TARGET_XFER_OK) or the number unavailable bytes if the requested
+ data is unavailable (TARGET_XFER_E_UNAVAILABLE). *XFERED_LEN
+ 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
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,
- ULONGEST offset, LONGEST len);
+ enum target_xfer_status (*to_xfer_partial) (struct target_ops *ops,
+ enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+ TARGET_DEFAULT_RETURN (TARGET_XFER_E_IO);
/* Returns the memory map for the target. A return value of NULL
means that no memory map is available. If a memory address
be attempting to talk to a remote target. */
void (*to_teardown_btrace) (struct btrace_target_info *tinfo);
- /* Read branch trace data. */
- VEC (btrace_block_s) *(*to_read_btrace) (struct btrace_target_info *,
- enum btrace_read_type);
+ /* Read branch trace data for the thread indicated by BTINFO into DATA.
+ DATA is cleared before new trace is added.
+ The branch trace will start with the most recent block and continue
+ towards older blocks. */
+ enum btrace_error (*to_read_btrace) (VEC (btrace_block_s) **data,
+ struct btrace_target_info *btinfo,
+ enum btrace_read_type type);
/* Stop trace recording. */
void (*to_stop_recording) (void);
void (*to_insn_history_from) (ULONGEST from, int size, int flags);
/* Disassemble a section of the recorded execution trace from instruction
- BEGIN (inclusive) to instruction END (exclusive). */
+ BEGIN (inclusive) to instruction END (inclusive). */
void (*to_insn_history_range) (ULONGEST begin, ULONGEST end, int flags);
/* Print a function trace of the recorded execution trace.
void (*to_call_history_from) (ULONGEST begin, int size, int flags);
/* Print a function trace of an execution trace section from function BEGIN
- (inclusive) to function END (exclusive). */
+ (inclusive) to function END (inclusive). */
void (*to_call_history_range) (ULONGEST begin, ULONGEST end, int flags);
/* Nonzero if TARGET_OBJECT_LIBRARIES_SVR4 may be read with a
non-empty annex. */
int (*to_augmented_libraries_svr4_read) (void);
+ /* Those unwinders are tried before any other arch unwinders. Use NULL if
+ it is not used. */
+ const struct frame_unwind *to_get_unwinder;
+ const struct frame_unwind *to_get_tailcall_unwinder;
+
+ /* Return the number of bytes by which the PC needs to be decremented
+ after executing a breakpoint instruction.
+ Defaults to gdbarch_decr_pc_after_break (GDBARCH). */
+ CORE_ADDR (*to_decr_pc_after_break) (struct target_ops *ops,
+ struct gdbarch *gdbarch);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
typed by the user (e.g. a signal to send the process). FROM_TTY
says whether to be verbose or not. */
-extern void target_detach (char *, int);
+extern void target_detach (const char *, int);
/* Disconnect from the current target without resuming it (leaving it
waiting for a debugger). */
debugged. */
#define target_prepare_to_store(regcache) \
- (*current_target.to_prepare_to_store) (regcache)
+ (*current_target.to_prepare_to_store) (¤t_target, regcache)
/* Determine current address space of thread PTID. */
#define target_can_run_breakpoint_commands() \
(*current_target.to_can_run_breakpoint_commands) ()
-/* Invalidate all target dcaches. */
-extern void target_dcache_invalidate (void);
-
extern int target_read_string (CORE_ADDR, char **, int, int *);
extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
ssize_t len);
+extern int target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
+ ssize_t len);
+
extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
+extern int target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
+
extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
ssize_t len);
#define target_files_info() \
(*current_target.to_files_info) (¤t_target)
-/* Insert a breakpoint at address BP_TGT->placed_address in the target
- machine. Result is 0 for success, or an errno value. */
+/* Insert a hardware breakpoint at address BP_TGT->placed_address in
+ the target machine. Returns 0 for success, and returns non-zero or
+ throws an error (with a detailed failure reason error code and
+ message) otherwise. */
extern int target_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt);
/* Remove a breakpoint at address BP_TGT->placed_address in the target
- machine. Result is 0 for success, or an errno value. */
+ machine. Result is 0 for success, non-zero for error. */
extern int target_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt);
This function returns 1 if the inferior should not be resumed
(i.e. there is another event pending). */
-int target_follow_fork (int follow_child);
+int target_follow_fork (int follow_child, int detach_fork);
/* On some targets, we can catch an inferior exec event when it
occurs. These functions insert/remove an already-created
extern int target_async_permitted;
/* Can the target support asynchronous execution? */
-#define target_can_async_p() (current_target.to_can_async_p ())
+#define target_can_async_p() (current_target.to_can_async_p (¤t_target))
/* Is the target in asynchronous execution mode? */
-#define target_is_async_p() (current_target.to_is_async_p ())
+#define target_is_async_p() (current_target.to_is_async_p (¤t_target))
int target_supports_non_stop (void);
/* Put the target in async mode with the specified callback function. */
#define target_async(CALLBACK,CONTEXT) \
- (current_target.to_async ((CALLBACK), (CONTEXT)))
+ (current_target.to_async (¤t_target, (CALLBACK), (CONTEXT)))
#define target_execution_direction() \
(current_target.to_execution_direction ())
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
write). Only the INFERIOR_PTID task is being queried. */
-#define target_stopped_by_watchpoint \
- (*current_target.to_stopped_by_watchpoint)
+#define target_stopped_by_watchpoint() \
+ ((*current_target.to_stopped_by_watchpoint) (¤t_target))
/* Non-zero if we have steppable watchpoints */
extern int target_remove_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
+/* Insert a hardware breakpoint at address BP_TGT->placed_address in
+ the target machine. Returns 0 for success, and returns non-zero or
+ throws an error (with a detailed failure reason error code and
+ message) otherwise. */
+
#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
extern int target_core_of_thread (ptid_t ptid);
+/* See to_get_unwinder in struct target_ops. */
+extern const struct frame_unwind *target_get_unwinder (void);
+
+/* See to_get_tailcall_unwinder in struct target_ops. */
+extern const struct frame_unwind *target_get_tailcall_unwinder (void);
+
/* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range matches
the contents of [DATA,DATA+SIZE). Returns 1 if there's a match, 0
if there's a mismatch, and -1 if an error is encountered while
/* From mem-break.c */
-extern int memory_remove_breakpoint (struct gdbarch *,
+extern int memory_remove_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
-extern int memory_insert_breakpoint (struct gdbarch *,
+extern int memory_insert_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
extern int default_memory_remove_breakpoint (struct gdbarch *,
extern struct target_ops *find_target_beneath (struct target_ops *);
+/* Find the target at STRATUM. If no target is at that stratum,
+ return NULL. */
+
+struct target_ops *find_target_at (enum strata stratum);
+
/* Read OS data object of type TYPE from the target, and return it in
XML format. The result is NUL-terminated and returned as a string,
allocated using xmalloc. If an error occurs or the transfer is
extern void target_teardown_btrace (struct btrace_target_info *btinfo);
/* See to_read_btrace in struct target_ops. */
-extern VEC (btrace_block_s) *target_read_btrace (struct btrace_target_info *,
- enum btrace_read_type);
+extern enum btrace_error target_read_btrace (VEC (btrace_block_s) **,
+ struct btrace_target_info *,
+ enum btrace_read_type);
/* See to_stop_recording in struct target_ops. */
extern void target_stop_recording (void);
/* See to_call_history_range. */
extern void target_call_history_range (ULONGEST begin, ULONGEST end, int flags);
+/* See to_decr_pc_after_break. Start searching for the target at OPS. */
+extern CORE_ADDR forward_target_decr_pc_after_break (struct target_ops *ops,
+ struct gdbarch *gdbarch);
+
+/* See to_decr_pc_after_break. */
+extern CORE_ADDR target_decr_pc_after_break (struct gdbarch *gdbarch);
+
#endif /* !defined (TARGET_H) */
projects / deliverable / binutils-gdb.git / blobdiff