struct ui_file;
struct mem_attrib;
struct target_ops;
+struct bp_location;
struct bp_target_info;
struct regcache;
struct target_section_table;
/* The target has run out of history information,
and cannot run backward any further. */
- TARGET_WAITKIND_NO_HISTORY
+ TARGET_WAITKIND_NO_HISTORY,
+
+ /* There are no resumed children left in the program. */
+ TARGET_WAITKIND_NO_RESUMED
};
struct target_waitstatus
deal with. */
enum inferior_event_type
{
- /* There is a request to quit the inferior, abandon it. */
- INF_QUIT_REQ,
/* Process a normal inferior event which will result in target_wait
being called. */
INF_REG_EVENT,
- /* Deal with an error on the inferior. */
- INF_ERROR,
/* We are called because a timer went off. */
INF_TIMER,
/* We are called to do stuff after the inferior stops. */
TARGET_OBJECT_HPUX_SOLIB_GOT,
/* Traceframe info, in XML format. */
TARGET_OBJECT_TRACEFRAME_INFO,
+ /* Load maps for FDPIC systems. */
+ TARGET_OBJECT_FDPIC,
+ /* Darwin dynamic linker info data. */
+ TARGET_OBJECT_DARWIN_DYLD_INFO
/* Possible future objects: TARGET_OBJECT_FILE, ... */
};
int (*to_can_async_p) (void);
int (*to_is_async_p) (void);
void (*to_async) (void (*) (enum inferior_event_type, void *), void *);
- int (*to_async_mask) (int);
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);
/* Can target execute in reverse? */
int (*to_can_execute_reverse) (void);
+ /* The direction the target is currently executing. Must be
+ implemented on targets that support reverse execution and async
+ mode. The default simply returns forward execution. */
+ enum exec_direction_kind (*to_execution_direction) (void);
+
/* Does this target support debugging multiple processes
simultaneously? */
int (*to_supports_multi_process) (void);
+ /* Does this target support enabling and disabling tracepoints while a trace
+ experiment is running? */
+ int (*to_supports_enable_disable_tracepoint) (void);
+
+ /* Does this target support disabling address space randomization? */
+ int (*to_supports_disable_randomization) (void);
+
+ /* Does this target support the tracenz bytecode for string collection? */
+ int (*to_supports_string_tracing) (void);
+
/* Determine current architecture of thread PTID.
The target is supposed to determine the architecture of the code where
/* 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 tracepoint location to the target. */
+ void (*to_download_tracepoint) (struct bp_location *location);
+
+ /* Is the target able to download tracepoint locations in current
+ state? */
+ int (*to_can_download_tracepoint) (void);
/* Send full details of a trace state variable to the target. */
void (*to_download_trace_state_variable) (struct trace_state_variable *tsv);
+ /* Enable a tracepoint on the target. */
+ void (*to_enable_tracepoint) (struct bp_location *location);
+
+ /* Disable a tracepoint on the target. */
+ void (*to_disable_tracepoint) (struct bp_location *location);
+
/* 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. */
/* Get the current status of a tracing run. */
int (*to_get_trace_status) (struct trace_status *ts);
+ void (*to_get_tracepoint_status) (struct breakpoint *tp,
+ struct uploaded_tp *utp);
+
/* Stop a trace run. */
void (*to_trace_stop) (void);
LONGEST (*to_get_raw_trace_data) (gdb_byte *buf,
ULONGEST offset, LONGEST len);
+ /* Get the minimum length of instruction on which a fast tracepoint
+ may be set on the target. If this operation is unsupported,
+ return -1. If for some reason the minimum length cannot be
+ determined, return 0. */
+ int (*to_get_min_fast_tracepoint_insn_len) (void);
+
/* 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);
+ /* Add/change textual notes about the trace run, returning 1 if
+ successful, 0 otherwise. */
+ int (*to_set_trace_notes) (char *user, char *notes, char* stopnotes);
+
/* Return the processor core that thread PTID was last seen on.
This information is updated only when:
- update_thread_list is called
#define target_supports_multi_process() \
(*current_target.to_supports_multi_process) ()
+/* Returns true if this target can disable address space randomization. */
+
+int target_supports_disable_randomization (void);
+
+/* Returns true if this target can enable and disable tracepoints
+ while a trace experiment is running. */
+
+#define target_supports_enable_disable_tracepoint() \
+ (*current_target.to_supports_enable_disable_tracepoint) ()
+
+#define target_supports_string_tracing() \
+ (*current_target.to_supports_string_tracing) ()
+
/* Invalidate all target dcaches. */
extern void target_dcache_invalidate (void);
#define target_async(CALLBACK,CONTEXT) \
(current_target.to_async ((CALLBACK), (CONTEXT)))
-/* This is to be used ONLY within call_function_by_hand(). It provides
- a workaround, to have inferior function calls done in sychronous
- mode, even though the target is asynchronous. After
- target_async_mask(0) is called, calls to target_can_async_p() will
- return FALSE , so that target_resume() will not try to start the
- target asynchronously. After the inferior stops, we IMMEDIATELY
- restore the previous nature of the target, by calling
- target_async_mask(1). After that, target_can_async_p() will return
- TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
-
- FIXME ezannoni 1999-12-13: we won't need this once we move
- the turning async on and off to the single execution commands,
- from where it is done currently, in remote_resume(). */
-
-#define target_async_mask(MASK) \
- (current_target.to_async_mask (MASK))
+#define target_execution_direction() \
+ (current_target.to_execution_direction ())
/* Converts a process id to a string. Usually, the string just contains
`process xyz', but on some systems it may contain
#define target_download_tracepoint(t) \
(*current_target.to_download_tracepoint) (t)
+#define target_can_download_tracepoint() \
+ (*current_target.to_can_download_tracepoint) ()
+
#define target_download_trace_state_variable(tsv) \
(*current_target.to_download_trace_state_variable) (tsv)
+#define target_enable_tracepoint(loc) \
+ (*current_target.to_enable_tracepoint) (loc)
+
+#define target_disable_tracepoint(loc) \
+ (*current_target.to_disable_tracepoint) (loc)
+
#define target_trace_start() \
(*current_target.to_trace_start) ()
#define target_get_trace_status(ts) \
(*current_target.to_get_trace_status) (ts)
+#define target_get_tracepoint_status(tp,utp) \
+ (*current_target.to_get_tracepoint_status) (tp, utp)
+
#define target_trace_stop() \
(*current_target.to_trace_stop) ()
#define target_get_raw_trace_data(buf,offset,len) \
(*current_target.to_get_raw_trace_data) ((buf), (offset), (len))
+#define target_get_min_fast_tracepoint_insn_len() \
+ (*current_target.to_get_min_fast_tracepoint_insn_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_set_trace_notes(user,notes,stopnotes) \
+ (*current_target.to_set_trace_notes) ((user), (notes), (stopnotes))
+
#define target_get_tib_address(ptid, addr) \
(*current_target.to_get_tib_address) ((ptid), (addr))
projects / deliverable / binutils-gdb.git / blobdiff