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 program has entered or returned from a system call. On
HP-UX, this is used in the hardware watchpoint implementation.
- The syscall's unique integer ID number is in value.syscall_id */
+ The syscall's unique integer ID number is in value.syscall_id. */
TARGET_WAITKIND_SYSCALL_ENTRY,
TARGET_WAITKIND_SYSCALL_RETURN,
/* An event has occured, but we should wait again.
Remote_async_wait() returns this when there is an event
on the inferior, but the rest of the world is not interested in
- it. The inferior has not stopped, but has just sent some output
- to the console, for instance. In this case, we want to go back
+ it. The inferior has not stopped, but has just sent some output
+ to the console, for instance. In this case, we want to go back
to the event loop and wait there for another event from the
inferior, rather than being stuck in the remote_async_wait()
- function. This way the event loop is responsive to other events,
+ function. sThis way the event loop is responsive to other events,
like for instance the user typing. */
TARGET_WAITKIND_IGNORE,
INF_EXEC_COMPLETE,
/* We are called to do some stuff after the inferior stops, but we
are expected to reenter the proceed() and
- handle_inferior_event() functions. This is used only in case of
+ handle_inferior_event() functions. This is used only in case of
'step n' like commands. */
INF_EXEC_CONTINUE
};
TARGET_OBJECT_THREADS,
/* Collected static trace data. */
TARGET_OBJECT_STATIC_TRACE_DATA,
- /* Possible future objects: TARGET_OBJECT_FILE, ... */
+ /* The HP-UX registers (those that can be obtained or modified by using
+ the TT_LWP_RUREGS/TT_LWP_WUREGS ttrace requests). */
+ TARGET_OBJECT_HPUX_UREGS,
+ /* The HP-UX shared library linkage pointer. ANNEX should be a string
+ image of the code address whose linkage pointer we are looking for.
+
+ 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,
+ /* Possible future objects: TARGET_OBJECT_FILE, ... */
};
/* Enumeration of the kinds of traceframe searches that a target may
struct memory_read_result
{
- /* First address that was read. */
+ /* First address that was read. */
ULONGEST begin;
/* Past-the-end address. */
ULONGEST end;
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 */
RAM. The returned memory regions should not overlap.
The order of regions does not matter; target_memory_map will
- sort regions by starting address. For that reason, this
+ sort regions by starting address. For that reason, this
function should not be called directly except via
target_memory_map.
/* 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
+ 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);
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?
*/
/* Describes a request for a memory write operation. */
struct memory_write_request
{
- /* Begining address that must be written. */
+ /* Begining address that must be written. */
ULONGEST begin;
- /* Past-the-end address. */
+ /* Past-the-end address. */
ULONGEST end;
- /* The data to write. */
+ /* The data to write. */
gdb_byte *data;
/* A callback baton for progress reporting for this request. */
void *baton;
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? */
cludge until async mode is a strict superset of sync mode. */
extern int target_async_permitted;
-/* Can the target support asynchronous execution? */
+/* Can the target support asynchronous execution? */
#define target_can_async_p() (current_target.to_can_async_p ())
-/* Is the target in asynchronous execution mode? */
+/* Is the target in asynchronous execution mode? */
#define target_is_async_p() (current_target.to_is_async_p ())
int target_supports_non_stop (void);
-/* Put the target in async mode with the specified callback function. */
+/* Put the target in async mode with the specified callback function. */
#define target_async(CALLBACK,CONTEXT) \
(current_target.to_async ((CALLBACK), (CONTEXT)))
-/* This is to be used ONLY within call_function_by_hand(). It provides
+/* 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
+ 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
+ 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.
+ 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,
#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_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) \
/* Speed in bits per second, or -1 which means don't mess with the speed. */
extern int baud_rate;
-/* Timeout limit for response from target. */
+/* Timeout limit for response from target. */
extern int remote_timeout;
\f
extern void update_target_permissions (void);
\f
-/* Imported from machine dependent code */
+/* Imported from machine dependent code. */
-/* Blank target vector entries are initialized to target_ignore. */
+/* Blank target vector entries are initialized to target_ignore. */
void target_ignore (void);
-extern struct target_ops deprecated_child_ops;
-
#endif /* !defined (TARGET_H) */
projects / deliverable / binutils-gdb.git / blobdiff