struct static_tracepoint_marker;
struct traceframe_info;
struct expression;
+struct dcache_struct;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
it goes into the file stratum, which is always below the process
stratum. */
+#include "target/resume.h"
+#include "target/wait.h"
+#include "target/waitstatus.h"
#include "bfd.h"
#include "symtab.h"
#include "memattr.h"
tc_schedlock = 1, /* Can lock the thread scheduler. */
};
-/* Stuff for target_wait. */
-
-/* Generally, what has the program done? */
-enum target_waitkind
- {
- /* The program has exited. The exit status is in value.integer. */
- TARGET_WAITKIND_EXITED,
-
- /* The program has stopped with a signal. Which signal is in
- value.sig. */
- TARGET_WAITKIND_STOPPED,
-
- /* The program has terminated with a signal. Which signal is in
- value.sig. */
- TARGET_WAITKIND_SIGNALLED,
-
- /* The program is letting us know that it dynamically loaded something
- (e.g. it called load(2) on AIX). */
- TARGET_WAITKIND_LOADED,
-
- /* The program has forked. A "related" process' PTID is in
- value.related_pid. I.e., if the child forks, value.related_pid
- is the parent's ID. */
-
- TARGET_WAITKIND_FORKED,
-
- /* The program has vforked. A "related" process's PTID is in
- value.related_pid. */
-
- TARGET_WAITKIND_VFORKED,
-
- /* The program has exec'ed a new executable file. The new file's
- pathname is pointed to by value.execd_pathname. */
-
- TARGET_WAITKIND_EXECD,
-
- /* The program had previously vforked, and now the child is done
- with the shared memory region, because it exec'ed or exited.
- Note that the event is reported to the vfork parent. This is
- only used if GDB did not stay attached to the vfork child,
- otherwise, a TARGET_WAITKIND_EXECD or
- TARGET_WAITKIND_EXIT|SIGNALLED event associated with the child
- has the same effect. */
- TARGET_WAITKIND_VFORK_DONE,
-
- /* 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. */
-
- TARGET_WAITKIND_SYSCALL_ENTRY,
- TARGET_WAITKIND_SYSCALL_RETURN,
-
- /* Nothing happened, but we stopped anyway. This perhaps should be handled
- within target_wait, but I'm not sure target_wait should be resuming the
- inferior. */
- TARGET_WAITKIND_SPURIOUS,
-
- /* 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
- to the event loop and wait there for another event from the
- inferior, rather than being stuck in the remote_async_wait()
- function. sThis way the event loop is responsive to other events,
- like for instance the user typing. */
- TARGET_WAITKIND_IGNORE,
-
- /* The target has run out of history information,
- and cannot run backward any further. */
- TARGET_WAITKIND_NO_HISTORY,
-
- /* There are no resumed children left in the program. */
- TARGET_WAITKIND_NO_RESUMED
- };
-
-struct target_waitstatus
- {
- enum target_waitkind kind;
-
- /* Forked child pid, execd pathname, exit status, signal number or
- syscall number. */
- union
- {
- int integer;
- enum gdb_signal sig;
- ptid_t related_pid;
- char *execd_pathname;
- int syscall_number;
- }
- value;
- };
-
-/* Options that can be passed to target_wait. */
-
-/* Return immediately if there's no event already queued. If this
- options is not requested, target_wait blocks waiting for an
- event. */
-#define TARGET_WNOHANG 1
-
/* The structure below stores information about a system call.
It is basically used in the "catch syscall" command, and in
every function that gives information about a system call.
/* Possible future objects: TARGET_OBJECT_FILE, ... */
};
+/* Possible error codes returned by target_xfer_partial, etc. */
+
+enum target_xfer_error
+{
+ /* Generic I/O error. Note that it's important that this is '-1',
+ as we still have target_xfer-related code returning hardcoded
+ '-1' on error. */
+ TARGET_XFER_E_IO = -1,
+
+ /* Transfer failed because the piece of the object requested is
+ unavailable. */
+ TARGET_XFER_E_UNAVAILABLE = -2,
+
+ /* Keep list in sync with target_xfer_error_to_string. */
+};
+
+/* Return the string form of ERR. */
+
+extern const char *target_xfer_error_to_string (enum target_xfer_error err);
+
/* Enumeration of the kinds of traceframe searches that a target may
be able to perform. */
starting point. The ANNEX can be used to provide additional
data-specific information to the target.
- Return the number of bytes actually transfered, or -1 if the
- transfer is not supported or otherwise fails. Return of a positive
- value less than LEN indicates that no further transfer is possible.
- Unlike the raw to_xfer_partial interface, callers of these
- functions do not need to retry partial transfers. */
+ Return the number of bytes actually transfered, or a negative error
+ code (an 'enum target_xfer_error' value) if the transfer is not
+ supported or otherwise fails. Return of a positive value less than
+ LEN indicates that no further transfer is possible. Unlike the raw
+ to_xfer_partial interface, callers of these functions do not need
+ to retry partial transfers. */
extern LONGEST target_read (struct target_ops *ops,
enum target_object object,
enum target_object object,
const char *annex);
+/* See target_ops->to_xfer_partial. */
+
+extern LONGEST target_xfer_partial (struct target_ops *ops,
+ enum target_object object,
+ const char *annex,
+ void *readbuf, const void *writebuf,
+ ULONGEST offset, LONGEST len);
+
/* Wrappers to target read/write that perform memory transfers. They
throw an error if the memory transfer fails.
void (*to_close) (void);
void (*to_attach) (struct target_ops *ops, char *, int);
void (*to_post_attach) (int);
- void (*to_detach) (struct target_ops *ops, char *, int);
+ void (*to_detach) (struct target_ops *ops, const char *, int);
void (*to_disconnect) (struct target_ops *, char *, int);
void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal);
ptid_t (*to_wait) (struct target_ops *,
int (*to_remove_fork_catchpoint) (int);
int (*to_insert_vfork_catchpoint) (int);
int (*to_remove_vfork_catchpoint) (int);
- int (*to_follow_fork) (struct target_ops *, int);
+ int (*to_follow_fork) (struct target_ops *, int, int);
int (*to_insert_exec_catchpoint) (int);
int (*to_remove_exec_catchpoint) (int);
int (*to_set_syscall_catchpoint) (int, int, int, int, int *);
data-specific information to the target.
Return the number of bytes actually transfered, zero when no
- further transfer is possible, and -1 when the transfer is not
+ further transfer is possible, and a negative error code (really
+ an 'enum target_xfer_error' value) when the transfer is not
supported. Return of a positive value smaller than LEN does
not indicate the end of the object, only the end of the
transfer; higher level code should continue transferring if
typed by the user (e.g. a signal to send the process). FROM_TTY
says whether to be verbose or not. */
-extern void target_detach (char *, int);
+extern void target_detach (const char *, int);
/* Disconnect from the current target without resuming it (leaving it
waiting for a debugger). */
#define target_can_run_breakpoint_commands() \
(*current_target.to_can_run_breakpoint_commands) ()
-/* Invalidate all target dcaches. */
-extern void target_dcache_invalidate (void);
-
extern int target_read_string (CORE_ADDR, char **, int, int *);
extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
(*current_target.to_files_info) (¤t_target)
/* Insert a breakpoint at address BP_TGT->placed_address in the target
- machine. Result is 0 for success, or an errno value. */
+ machine. Result is 0 for success, non-zero for error. */
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. */
+ machine. Result is 0 for success, non-zero for error. */
extern int target_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt);
This function returns 1 if the inferior should not be resumed
(i.e. there is another event pending). */
-int target_follow_fork (int follow_child);
+int target_follow_fork (int follow_child, int detach_fork);
/* On some targets, we can catch an inferior exec event when it
occurs. These functions insert/remove an already-created
/* Routines for maintenance of the target structures...
+ complete_target_initialization: Finalize a target_ops by filling in
+ any fields needed by the target implementation.
+
add_target: Add a target to the list of all possible targets.
push_target: Make this target the top of the stack of currently used
unpush_target: Remove this from the stack of currently used targets,
no matter where it is on the list. Returns 0 if no
- change, 1 if removed from stack.
-
- pop_target: Remove the top thing on the stack of current targets. */
+ change, 1 if removed from stack. */
extern void add_target (struct target_ops *);
extern void add_target_with_completer (struct target_ops *t,
completer_ftype *completer);
+extern void complete_target_initialization (struct target_ops *t);
+
/* Adds a command ALIAS for target T and marks it deprecated. This is useful
for maintaining backwards compatibility when renaming targets. */
extern void target_preopen (int);
-extern void pop_target (void);
-
/* Does whatever cleanup is required to get rid of all pushed targets. */
extern void pop_all_targets (void);