struct bp_target_info;
struct regcache;
struct target_section_table;
+struct trace_state_variable;
+struct trace_status;
+struct uploaded_tsv;
+struct uploaded_tp;
+struct static_tracepoint_marker;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
/* Extra signal info. Usually the contents of `siginfo_t' on unix
platforms. */
TARGET_OBJECT_SIGNAL_INFO,
+ /* The list of threads that are being debugged. */
+ TARGET_OBJECT_THREADS,
+ /* Collected static trace data. */
+ TARGET_OBJECT_STATIC_TRACE_DATA,
/* Possible future objects: TARGET_OBJECT_FILE, ... */
};
+/* Enumeration of the kinds of traceframe searches that a target may
+ be able to perform. */
+
+enum trace_find_type
+ {
+ tfind_number,
+ tfind_pc,
+ tfind_tp,
+ tfind_range,
+ tfind_outside,
+ };
+
+typedef struct static_tracepoint_marker *static_tracepoint_marker_p;
+DEF_VEC_P(static_tracepoint_marker_p);
+
/* 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
struct address_space *(*to_thread_address_space) (struct target_ops *,
ptid_t);
+ /* Tracepoint-related operations. */
+
+ /* Prepare the target for a tracing run. */
+ void (*to_trace_init) (void);
+
+ /* Send full details of a tracepoint to the target. */
+ void (*to_download_tracepoint) (struct breakpoint *t);
+
+ /* Send full details of a trace state variable to the target. */
+ void (*to_download_trace_state_variable) (struct trace_state_variable *tsv);
+
+ /* Inform the target info of memory regions that are readonly
+ (such as text sections), and so it should return data from
+ those rather than look in the trace buffer. */
+ void (*to_trace_set_readonly_regions) (void);
+
+ /* Start a trace run. */
+ void (*to_trace_start) (void);
+
+ /* Get the current status of a tracing run. */
+ int (*to_get_trace_status) (struct trace_status *ts);
+
+ /* Stop a trace run. */
+ void (*to_trace_stop) (void);
+
+ /* Ask the target to find a trace frame of the given type TYPE,
+ using NUM, ADDR1, and ADDR2 as search parameters. Returns the
+ number of the trace frame, and also the tracepoint number at
+ TPP. If no trace frame matches, return -1. May throw if the
+ operation fails. */
+ int (*to_trace_find) (enum trace_find_type type, int num,
+ ULONGEST addr1, ULONGEST addr2, int *tpp);
+
+ /* Get the value of the trace state variable number TSV, returning
+ 1 if the value is known and writing the value itself into the
+ location pointed to by VAL, else returning 0. */
+ int (*to_get_trace_state_variable_value) (int tsv, LONGEST *val);
+
+ int (*to_save_trace_data) (const char *filename);
+
+ int (*to_upload_tracepoints) (struct uploaded_tp **utpp);
+
+ int (*to_upload_trace_state_variables) (struct uploaded_tsv **utsvp);
+
+ LONGEST (*to_get_raw_trace_data) (gdb_byte *buf,
+ ULONGEST offset, LONGEST len);
+
+ /* Set the target's tracing behavior in response to unexpected
+ disconnection - set VAL to 1 to keep tracing, 0 to stop. */
+ void (*to_set_disconnected_tracing) (int val);
+ void (*to_set_circular_trace_buffer) (int val);
+
+ /* Return the processor core that thread PTID was last seen on.
+ This information is updated only when:
+ - update_thread_list is called
+ - thread stops
+ If the core cannot be determined -- either for the specified thread, or
+ right now, or in this debug session, or for this target -- return -1. */
+ int (*to_core_of_thread) (struct target_ops *, ptid_t ptid);
+
+ /* 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 reading memory. */
+ int (*to_verify_memory) (struct target_ops *, const gdb_byte *data,
+ CORE_ADDR memaddr, ULONGEST size);
+
+ /* 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);
+
+ /* Send the new settings of write permission variables. */
+ void (*to_set_permissions) (void);
+
+ /* 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,
+ 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);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
/* 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(gdbarch, bp_tgt) \
- (*current_target.to_insert_breakpoint) (gdbarch, bp_tgt)
+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. */
-#define target_remove_breakpoint(gdbarch, bp_tgt) \
- (*current_target.to_remove_breakpoint) (gdbarch, bp_tgt)
+extern int target_remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt);
/* Initialize the terminal settings we record for the inferior,
before we actually run the inferior. */
Unix, this should act like SIGSTOP). This function is normally
used by GUIs to implement a stop button. */
-#define target_stop(ptid) (*current_target.to_stop) (ptid)
+extern void target_stop (ptid_t ptid);
/* Send the specified COMMAND to the target's monitor
(shell,interpreter) for execution. The result of the query is
(*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
-/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. TYPE is 0
- for write, 1 for read, and 2 for read/write accesses. Returns 0 for
- success, non-zero for failure. */
+/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.
+ TYPE is 0 for write, 1 for read, and 2 for read/write accesses.
+ Returns 0 for success, 1 if the watchpoint type is not supported,
+ -1 for failure. */
#define target_insert_watchpoint(addr, len, type) \
(*current_target.to_insert_watchpoint) (addr, len, type)
ULONGEST pattern_len,
CORE_ADDR *found_addrp);
+/* Tracepoint-related operations. */
+
+#define target_trace_init() \
+ (*current_target.to_trace_init) ()
+
+#define target_download_tracepoint(t) \
+ (*current_target.to_download_tracepoint) (t)
+
+#define target_download_trace_state_variable(tsv) \
+ (*current_target.to_download_trace_state_variable) (tsv)
+
+#define target_trace_start() \
+ (*current_target.to_trace_start) ()
+
+#define target_trace_set_readonly_regions() \
+ (*current_target.to_trace_set_readonly_regions) ()
+
+#define target_get_trace_status(ts) \
+ (*current_target.to_get_trace_status) (ts)
+
+#define target_trace_stop() \
+ (*current_target.to_trace_stop) ()
+
+#define target_trace_find(type,num,addr1,addr2,tpp) \
+ (*current_target.to_trace_find) ((type), (num), (addr1), (addr2), (tpp))
+
+#define target_get_trace_state_variable_value(tsv,val) \
+ (*current_target.to_get_trace_state_variable_value) ((tsv), (val))
+
+#define target_save_trace_data(filename) \
+ (*current_target.to_save_trace_data) (filename)
+
+#define target_upload_tracepoints(utpp) \
+ (*current_target.to_upload_tracepoints) (utpp)
+
+#define target_upload_trace_state_variables(utsvp) \
+ (*current_target.to_upload_trace_state_variables) (utsvp)
+
+#define target_get_raw_trace_data(buf,offset,len) \
+ (*current_target.to_get_raw_trace_data) ((buf), (offset), (len))
+
+#define target_set_disconnected_tracing(val) \
+ (*current_target.to_set_disconnected_tracing) (val)
+
+#define target_set_circular_trace_buffer(val) \
+ (*current_target.to_set_circular_trace_buffer) (val)
+
+#define target_get_tib_address(ptid, addr) \
+ (*current_target.to_get_tib_address) ((ptid), (addr))
+
+#define target_set_permissions() \
+ (*current_target.to_set_permissions) ()
+
+#define target_static_tracepoint_marker_at(addr, marker) \
+ (*current_target.to_static_tracepoint_marker_at) (addr, marker)
+
+#define target_static_tracepoint_markers_by_strid(marker_id) \
+ (*current_target.to_static_tracepoint_markers_by_strid) (marker_id)
+
/* Command logging facility. */
#define target_log_command(p) \
(*current_target.to_log_command) (p); \
while (0)
+
+extern int target_core_of_thread (ptid_t ptid);
+
+/* 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
+ reading memory. Throws an error if the functionality is found not
+ to be supported by the current target. */
+int target_verify_memory (const gdb_byte *data,
+ CORE_ADDR memaddr, ULONGEST size);
+
/* Routines for maintenance of the target structures...
add_target: Add a target to the list of all possible targets.
extern void add_target (struct target_ops *);
-extern int push_target (struct target_ops *);
+extern void push_target (struct target_ops *);
extern int unpush_target (struct target_ops *);
extern void initialize_targets (void);
-extern NORETURN void noprocess (void) ATTR_NORETURN;
+extern void noprocess (void) ATTRIBUTE_NORETURN;
extern void target_require_runnable (void);
to restore it back to the current value. */
extern struct cleanup *make_show_memory_breakpoints_cleanup (int show);
+extern int may_write_registers;
+extern int may_write_memory;
+extern int may_insert_breakpoints;
+extern int may_insert_tracepoints;
+extern int may_insert_fast_tracepoints;
+extern int may_stop;
+
+extern void update_target_permissions (void);
+
\f
/* Imported from machine dependent code */
projects / deliverable / binutils-gdb.git / blobdiff