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
{
dummy_stratum, /* The lowest of the low */
file_stratum, /* Executable files, etc */
- core_stratum, /* Core dump files */
- process_stratum, /* Executing processes */
+ process_stratum, /* Executing processes or core dump files */
thread_stratum, /* Executing threads */
record_stratum, /* Support record debugging */
arch_stratum /* Architecture overrides */
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
const char *annex, gdb_byte *buf,
ULONGEST offset, LONGEST len);
-extern LONGEST target_read_until_error (struct target_ops *ops,
- enum target_object object,
- const char *annex, gdb_byte *buf,
- ULONGEST offset, LONGEST len);
+struct memory_read_result
+ {
+ /* First address that was read. */
+ ULONGEST begin;
+ /* Past-the-end address. */
+ ULONGEST end;
+ /* The data. */
+ gdb_byte *data;
+};
+typedef struct memory_read_result memory_read_result_s;
+DEF_VEC_O(memory_read_result_s);
+
+extern void free_memory_read_result_vector (void *);
+
+extern VEC(memory_read_result_s)* read_memory_robust (struct target_ops *ops,
+ ULONGEST offset,
+ LONGEST len);
extern LONGEST target_write (struct target_ops *ops,
enum target_object object,
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);
int (*to_async_mask) (int);
int (*to_supports_non_stop) (void);
/* find_memory_regions support method for gcore */
- int (*to_find_memory_regions) (int (*) (CORE_ADDR,
- unsigned long,
- int, int, int,
- void *),
- void *);
+ int (*to_find_memory_regions) (find_memory_region_ftype func, void *data);
/* make_corefile_notes support method for gcore */
char * (*to_make_corefile_notes) (bfd *, int *);
/* get_bookmark support method for bookmarks */
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_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) \
strictly above ABOVE_STRATUM. */
extern void pop_all_targets_above (enum strata above_stratum, int quitting);
+extern int target_is_pushed (struct target_ops *t);
+
extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
CORE_ADDR offset);
extern struct target_ops *find_run_target (void);
-extern struct target_ops *find_core_target (void);
-
extern struct target_ops *find_target_beneath (struct target_ops *);
/* Read OS data object of type TYPE from the target, and return it in
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