struct trace_status;
struct uploaded_tsv;
struct uploaded_tp;
+struct static_tracepoint_marker;
+
+struct expression;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
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, ... */
};
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
int (*to_can_use_hw_breakpoint) (int, int, int);
int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_remove_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
- int (*to_remove_watchpoint) (CORE_ADDR, int, int);
- int (*to_insert_watchpoint) (CORE_ADDR, int, int);
+
+ /* Documentation of what the two routines below are expected to do is
+ provided with the corresponding target_* macros. */
+ int (*to_remove_watchpoint) (CORE_ADDR, int, int, struct expression *);
+ int (*to_insert_watchpoint) (CORE_ADDR, int, int, struct expression *);
+
int (*to_stopped_by_watchpoint) (void);
int to_have_steppable_watchpoint;
int to_have_continuable_watchpoint;
int (*to_watchpoint_addr_within_range) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
+ int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int,
+ struct expression *);
void (*to_terminal_init) (void);
void (*to_terminal_inferior) (void);
void (*to_terminal_ours_for_output) (void);
location pointed to by VAL, else returning 0. */
int (*to_get_trace_state_variable_value) (int tsv, LONGEST *val);
- int (*to_save_trace_data) (char *filename);
+ int (*to_save_trace_data) (const char *filename);
int (*to_upload_tracepoints) (struct uploaded_tp **utpp);
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
/* 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.
+ COND is the expression for its condition, or NULL if there's none.
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)
+#define target_insert_watchpoint(addr, len, type, cond) \
+ (*current_target.to_insert_watchpoint) (addr, len, type, cond)
-#define target_remove_watchpoint(addr, len, type) \
- (*current_target.to_remove_watchpoint) (addr, len, type)
+#define target_remove_watchpoint(addr, len, type, cond) \
+ (*current_target.to_remove_watchpoint) (addr, len, type, cond)
#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
#define target_watchpoint_addr_within_range(target, addr, start, length) \
(*target.to_watchpoint_addr_within_range) (target, addr, start, length)
+/* Return non-zero if the target is capable of using hardware to evaluate
+ the condition expression. In this case, if the condition is false when
+ the watched memory location changes, execution may continue without the
+ debugger being notified.
+
+ Due to limitations in the hardware implementation, it may be capable of
+ avoiding triggering the watchpoint in some cases where the condition
+ expression is false, but may report some false positives as well.
+ For this reason, GDB will still evaluate the condition expression when
+ the watchpoint triggers. */
+#define target_can_accel_watchpoint_condition(addr, len, type, cond) \
+ (*current_target.to_can_accel_watchpoint_condition) (addr, len, type, cond)
+
/* Target can execute in reverse? */
#define target_can_execute_reverse \
(current_target.to_can_execute_reverse ? \
#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) \
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 */