void (*to_set_disconnected_tracing) (struct target_ops *, int val);
void (*to_set_circular_trace_buffer) (struct target_ops *, int val);
/* Set the size of trace buffer in the target. */
- void (*to_set_trace_buffer_size) (LONGEST val);
+ void (*to_set_trace_buffer_size) (struct target_ops *, LONGEST val);
/* Add/change textual notes about the trace run, returning 1 if
successful, 0 otherwise. */
- int (*to_set_trace_notes) (const char *user, const char *notes,
+ int (*to_set_trace_notes) (struct target_ops *,
+ const char *user, const char *notes,
const char *stopnotes);
/* Return the processor core that thread PTID was last seen on.
/* Return the address of the start of the Thread Information Block
a Windows OS specific feature. */
- int (*to_get_tib_address) (ptid_t ptid, CORE_ADDR *addr);
+ int (*to_get_tib_address) (struct target_ops *,
+ ptid_t ptid, CORE_ADDR *addr);
/* Send the new settings of write permission variables. */
- void (*to_set_permissions) (void);
+ void (*to_set_permissions) (struct target_ops *);
/* Look for a static tracepoint marker at ADDR, and fill in MARKER
with its details. Return 1 on success, 0 on failure. */
- int (*to_static_tracepoint_marker_at) (CORE_ADDR,
+ int (*to_static_tracepoint_marker_at) (struct target_ops *, CORE_ADDR,
struct static_tracepoint_marker *marker);
/* Return a vector of all tracepoints markers string id ID, or all
markers if ID is NULL. */
VEC(static_tracepoint_marker_p) *(*to_static_tracepoint_markers_by_strid)
- (const char *id);
+ (struct target_ops *, const char *id);
/* Return a traceframe info object describing the current
traceframe's contents. If the target doesn't support
is available in the read-only sections. This method should not
cache data; higher layers take care of caching, invalidating,
and re-fetching when necessary. */
- struct traceframe_info *(*to_traceframe_info) (void);
+ struct traceframe_info *(*to_traceframe_info) (struct target_ops *);
/* Ask the target to use or not to use agent according to USE. Return 1
successful, 0 otherwise. */
- int (*to_use_agent) (int use);
+ int (*to_use_agent) (struct target_ops *, int use);
/* Is the target able to use agent in current state? */
- int (*to_can_use_agent) (void);
+ int (*to_can_use_agent) (struct target_ops *);
/* Check whether the target supports branch tracing. */
int (*to_supports_btrace) (struct target_ops *)
/* Enable branch tracing for PTID and allocate a branch trace target
information struct for reading and for disabling branch trace. */
- struct btrace_target_info *(*to_enable_btrace) (ptid_t ptid);
+ struct btrace_target_info *(*to_enable_btrace) (struct target_ops *,
+ ptid_t ptid);
/* Disable branch tracing and deallocate TINFO. */
- void (*to_disable_btrace) (struct btrace_target_info *tinfo);
+ void (*to_disable_btrace) (struct target_ops *,
+ struct btrace_target_info *tinfo);
/* Disable branch tracing and deallocate TINFO. This function is similar
to to_disable_btrace, except that it is called during teardown and is
only allowed to perform actions that are safe. A counter-example would
be attempting to talk to a remote target. */
- void (*to_teardown_btrace) (struct btrace_target_info *tinfo);
+ void (*to_teardown_btrace) (struct target_ops *,
+ struct btrace_target_info *tinfo);
/* 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,
+ enum btrace_error (*to_read_btrace) (struct target_ops *self,
+ 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_stop_recording) (struct target_ops *);
/* Print information about the recording. */
- void (*to_info_record) (void);
+ void (*to_info_record) (struct target_ops *);
/* Save the recorded execution trace into a file. */
void (*to_save_record) (const char *filename);
(*current_target.to_set_circular_trace_buffer) (¤t_target, val)
#define target_set_trace_buffer_size(val) \
- (*current_target.to_set_trace_buffer_size) (val)
+ (*current_target.to_set_trace_buffer_size) (¤t_target, val)
#define target_set_trace_notes(user,notes,stopnotes) \
- (*current_target.to_set_trace_notes) ((user), (notes), (stopnotes))
+ (*current_target.to_set_trace_notes) (¤t_target, \
+ (user), (notes), (stopnotes))
#define target_get_tib_address(ptid, addr) \
- (*current_target.to_get_tib_address) ((ptid), (addr))
+ (*current_target.to_get_tib_address) (¤t_target, (ptid), (addr))
#define target_set_permissions() \
- (*current_target.to_set_permissions) ()
+ (*current_target.to_set_permissions) (¤t_target)
#define target_static_tracepoint_marker_at(addr, marker) \
- (*current_target.to_static_tracepoint_marker_at) (addr, marker)
+ (*current_target.to_static_tracepoint_marker_at) (¤t_target, \
+ addr, marker)
#define target_static_tracepoint_markers_by_strid(marker_id) \
- (*current_target.to_static_tracepoint_markers_by_strid) (marker_id)
+ (*current_target.to_static_tracepoint_markers_by_strid) (¤t_target, \
+ marker_id)
#define target_traceframe_info() \
- (*current_target.to_traceframe_info) ()
+ (*current_target.to_traceframe_info) (¤t_target)
#define target_use_agent(use) \
- (*current_target.to_use_agent) (use)
+ (*current_target.to_use_agent) (¤t_target, use)
#define target_can_use_agent() \
- (*current_target.to_can_use_agent) ()
+ (*current_target.to_can_use_agent) (¤t_target)
#define target_augmented_libraries_svr4_read() \
(*current_target.to_augmented_libraries_svr4_read) ()