struct ui_file;
struct mem_attrib;
struct target_ops;
+struct bp_location;
struct bp_target_info;
struct regcache;
struct target_section_table;
struct uploaded_tsv;
struct uploaded_tp;
struct static_tracepoint_marker;
-
+struct traceframe_info;
struct expression;
/* This include file defines the interface between the main part
/* 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_AVAILABLE_FEATURES,
/* Currently loaded libraries, in XML format. */
TARGET_OBJECT_LIBRARIES,
+ /* Currently loaded libraries specific for SVR4 systems, in XML format. */
+ TARGET_OBJECT_LIBRARIES_SVR4,
/* Get OS specific data. The ANNEX specifies the type (running
processes, etc.). The data being transfered is expected to follow
the DTD specified in features/osdata.dtd. */
The size of the data transfered is always 8 bytes (the size of an
address on ia64). */
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_insert_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_can_use_hw_breakpoint) (int, int, int);
+ int (*to_ranged_break_num_registers) (struct target_ops *);
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, struct expression *);
int (*to_insert_watchpoint) (CORE_ADDR, int, int, struct expression *);
+ int (*to_insert_mask_watchpoint) (struct target_ops *,
+ CORE_ADDR, CORE_ADDR, int);
+ int (*to_remove_mask_watchpoint) (struct target_ops *,
+ CORE_ADDR, CORE_ADDR, int);
int (*to_stopped_by_watchpoint) (void);
int to_have_steppable_watchpoint;
int to_have_continuable_watchpoint;
int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int,
struct expression *);
+ int (*to_masked_watch_num_registers) (struct target_ops *,
+ CORE_ADDR, CORE_ADDR);
void (*to_terminal_init) (void);
void (*to_terminal_inferior) (void);
void (*to_terminal_ours_for_output) (void);
void (*to_terminal_info) (char *, int);
void (*to_kill) (struct target_ops *);
void (*to_load) (char *, int);
- int (*to_lookup_symbol) (char *, CORE_ADDR *);
void (*to_create_inferior) (struct target_ops *,
char *, char *, char **, int);
void (*to_post_startup_inferior) (ptid_t);
int (*to_has_exited) (int, int, int *);
void (*to_mourn_inferior) (struct target_ops *);
int (*to_can_run) (void);
- void (*to_notice_signals) (ptid_t ptid);
+
+ /* Documentation of this routine is provided with the corresponding
+ target_* macro. */
+ void (*to_pass_signals) (int, unsigned char *);
+
int (*to_thread_alive) (struct target_ops *, ptid_t ptid);
void (*to_find_new_threads) (struct target_ops *);
char *(*to_pid_to_str) (struct target_ops *, ptid_t);
char *(*to_extra_thread_info) (struct thread_info *);
+ char *(*to_thread_name) (struct thread_info *);
void (*to_stop) (ptid_t);
void (*to_rcmd) (char *command, struct ui_file *output);
char *(*to_pid_to_exec_file) (int pid);
int (*to_has_memory) (struct target_ops *);
int (*to_has_stack) (struct target_ops *);
int (*to_has_registers) (struct target_ops *);
- int (*to_has_execution) (struct target_ops *);
+ int (*to_has_execution) (struct target_ops *, ptid_t);
int to_has_thread_control; /* control thread execution */
int to_attach_no_wait;
/* ASYNC target controls */
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
VEC(static_tracepoint_marker_p) *(*to_static_tracepoint_markers_by_strid)
(const char *id);
+ /* Return a traceframe info object describing the current
+ traceframe's contents. 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);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
#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);
extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
int len);
+extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
+ int len);
+
/* Fetches the target's memory map. If one is found it is sorted
and returned, after some consistency checking. Otherwise, NULL
is returned. */
extern void target_load (char *arg, int from_tty);
-/* Look up a symbol in the target's symbol table. NAME is the symbol
- name. ADDRP is a CORE_ADDR * pointing to where the value of the
- symbol should be returned. The result is 0 if successful, nonzero
- if the symbol does not exist in the target environment. This
- function should not call error() if communication with the target
- is interrupted, since it is called from symbol reading, but should
- return nonzero, possibly doing a complain(). */
-
-#define target_lookup_symbol(name, addrp) \
- (*current_target.to_lookup_symbol) (name, addrp)
-
/* Start an inferior process and set inferior_ptid to its pid.
EXEC_FILE is the file to run.
ALLARGS is a string containing the arguments to the program.
#define target_can_run(t) \
((t)->to_can_run) ()
-/* post process changes to signal handling in the inferior. */
+/* Set list of signals to be handled in the target.
-#define target_notice_signals(ptid) \
- (*current_target.to_notice_signals) (ptid)
+ PASS_SIGNALS is an array of size NSIG, indexed by target signal number
+ (enum target_signal). For every signal whose entry in this array is
+ non-zero, the target is allowed -but not required- to skip reporting
+ arrival of the signal to the GDB core by returning from target_wait,
+ and to pass the signal directly to the inferior instead.
+
+ However, if the target is hardware single-stepping a thread that is
+ about to receive a signal, it needs to be reported in any case, even
+ if mentioned in a previous target_pass_signals call. */
+
+extern void target_pass_signals (int nsig, unsigned char *pass_signals);
/* Check to see if a thread is still alive. */
case this will become true after target_create_inferior or
target_attach. */
-extern int target_has_execution_1 (void);
-#define target_has_execution target_has_execution_1 ()
+extern int target_has_execution_1 (ptid_t);
+
+/* Like target_has_execution_1, but always passes inferior_ptid. */
+
+extern int target_has_execution_current (void);
+
+#define target_has_execution target_has_execution_current ()
/* Default implementations for process_stratum targets. Return true
if there's a selected inferior, false otherwise. */
extern int default_child_has_memory (struct target_ops *ops);
extern int default_child_has_stack (struct target_ops *ops);
extern int default_child_has_registers (struct target_ops *ops);
-extern int default_child_has_execution (struct target_ops *ops);
+extern int default_child_has_execution (struct target_ops *ops,
+ ptid_t the_ptid);
/* Can the target support the debugger control of thread execution?
Can it lock the thread scheduler? */
#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_extra_thread_info(TP) \
(current_target.to_extra_thread_info (TP))
+/* Return the thread's name. A NULL result means that the target
+ could not determine this thread's name. */
+
+extern char *target_thread_name (struct thread_info *);
+
/* Attempts to find the pathname of the executable file
that was run to create a specified process.
#define target_remove_watchpoint(addr, len, type, cond) \
(*current_target.to_remove_watchpoint) (addr, len, type, cond)
+/* Insert a new masked watchpoint at ADDR using the mask MASK.
+ RW may be hw_read for a read watchpoint, hw_write for a write watchpoint
+ or hw_access for an access watchpoint. Returns 0 for success, 1 if
+ masked watchpoints are not supported, -1 for failure. */
+
+extern int target_insert_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
+
+/* Remove a masked watchpoint at ADDR with the mask MASK.
+ RW may be hw_read for a read watchpoint, hw_write for a write watchpoint
+ or hw_access for an access watchpoint. Returns 0 for success, non-zero
+ for failure. */
+
+extern int target_remove_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
+
#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
#define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt)
+/* Return number of debug registers needed for a ranged breakpoint,
+ or -1 if ranged breakpoints are not supported. */
+
+extern int target_ranged_break_num_registers (void);
+
/* Return non-zero if target knows the data address which triggered this
target_stopped_by_watchpoint, in such case place it to *ADDR_P. Only the
INFERIOR_PTID task is being queried. */
#define target_can_accel_watchpoint_condition(addr, len, type, cond) \
(*current_target.to_can_accel_watchpoint_condition) (addr, len, type, cond)
+/* Return number of debug registers needed for a masked watchpoint,
+ -1 if masked watchpoints are not supported or -2 if the given address
+ and mask combination cannot be used. */
+
+extern int target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask);
+
/* Target can execute in reverse? */
#define target_can_execute_reverse \
(current_target.to_can_execute_reverse ? \
#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))
#define target_static_tracepoint_markers_by_strid(marker_id) \
(*current_target.to_static_tracepoint_markers_by_strid) (marker_id)
+#define target_traceframe_info() \
+ (*current_target.to_traceframe_info) ()
+
/* Command logging facility. */
#define target_log_command(p) \