/* No further transfer is possible. */
TARGET_XFER_EOF = 0,
+ /* The piece of the object requested is unavailable. */
+ TARGET_XFER_UNAVAILABLE = 2,
+
/* 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. */
+ /* Keep list in sync with target_xfer_status_to_string. */
};
-#define TARGET_XFER_STATUS_ERROR_P(STATUS) ((STATUS) < TARGET_XFER_EOF)
+/* Return the string form of STATUS. */
-/* Return the string form of ERR. */
-
-extern const char *target_xfer_status_to_string (enum target_xfer_status err);
+extern const char *
+ target_xfer_status_to_string (enum target_xfer_status status);
/* Enumeration of the kinds of traceframe searches that a target may
be able to perform. */
to xfree everything (including the "struct target_ops"). */
void (*to_xclose) (struct target_ops *targ);
void (*to_close) (struct target_ops *);
- void (*to_attach) (struct target_ops *ops, char *, int)
- TARGET_DEFAULT_FUNC (find_default_attach);
+ /* Attaches to a process on the target side. Arguments are as
+ passed to the `attach' command by the user. This routine can
+ be called when the target is not on the target-stack, if the
+ target_can_run routine returns 1; in that case, it must push
+ itself onto the stack. Upon exit, the target should be ready
+ for normal operations, and should be ready to deliver the
+ status of the process immediately (without waiting) to an
+ upcoming target_wait call. */
+ void (*to_attach) (struct target_ops *ops, char *, int);
void (*to_post_attach) (struct target_ops *, int)
TARGET_DEFAULT_IGNORE ();
void (*to_detach) (struct target_ops *ops, const char *, int)
void (*to_prepare_to_store) (struct target_ops *, struct regcache *)
TARGET_DEFAULT_NORETURN (noprocess ());
- /* Transfer LEN bytes of memory between GDB address MYADDR and
- target address MEMADDR. If WRITE, transfer them to the target, else
- transfer them from the target. TARGET is the target from which we
- get this function.
-
- Return value, N, is one of the following:
-
- 0 means that we can't handle this. If errno has been set, it is the
- error which prevented us from doing it (FIXME: What about bfd_error?).
-
- positive (call it N) means that we have transferred N bytes
- starting at MEMADDR. We might be able to handle more bytes
- beyond this length, but no promises.
-
- negative (call its absolute value N) means that we cannot
- transfer right at MEMADDR, but we could transfer at least
- something at MEMADDR + N.
-
- NOTE: cagney/2004-10-01: This has been entirely superseeded by
- to_xfer_partial and inferior inheritance. */
-
- int (*deprecated_xfer_memory) (CORE_ADDR memaddr, gdb_byte *myaddr,
- int len, int write,
- struct mem_attrib *attrib,
- struct target_ops *target);
-
void (*to_files_info) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
int (*to_insert_breakpoint) (struct target_ops *, struct gdbarch *,
TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_load) (struct target_ops *, char *, int)
TARGET_DEFAULT_NORETURN (tcomplain ());
+ /* 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.
+ ENV is the environment vector to pass. Errors reported with error().
+ On VxWorks and various standalone systems, we ignore exec_file. */
void (*to_create_inferior) (struct target_ops *,
char *, char *, char **, int);
void (*to_post_startup_inferior) (struct target_ops *, ptid_t)
TARGET_DEFAULT_RETURN (0);
void (*to_mourn_inferior) (struct target_ops *)
TARGET_DEFAULT_FUNC (default_mourn_inferior);
+ /* Note that to_can_run is special and can be invoked on an
+ unpushed target. Targets defining this method must also define
+ to_can_async_p and to_supports_non_stop. */
int (*to_can_run) (struct target_ops *)
TARGET_DEFAULT_RETURN (0);
char *(*to_pid_to_str) (struct target_ops *, ptid_t)
TARGET_DEFAULT_FUNC (default_pid_to_str);
char *(*to_extra_thread_info) (struct target_ops *, struct thread_info *)
- TARGET_DEFAULT_RETURN (0);
+ TARGET_DEFAULT_RETURN (NULL);
char *(*to_thread_name) (struct target_ops *, struct thread_info *)
- TARGET_DEFAULT_RETURN (0);
+ TARGET_DEFAULT_RETURN (NULL);
void (*to_stop) (struct target_ops *, ptid_t)
TARGET_DEFAULT_IGNORE ();
void (*to_rcmd) (struct target_ops *,
char *command, struct ui_file *output)
TARGET_DEFAULT_FUNC (default_rcmd);
char *(*to_pid_to_exec_file) (struct target_ops *, int pid)
- TARGET_DEFAULT_RETURN (0);
+ TARGET_DEFAULT_RETURN (NULL);
void (*to_log_command) (struct target_ops *, const char *)
TARGET_DEFAULT_IGNORE ();
struct target_section_table *(*to_get_section_table) (struct target_ops *)
- TARGET_DEFAULT_RETURN (0);
+ TARGET_DEFAULT_RETURN (NULL);
enum strata to_stratum;
int (*to_has_all_memory) (struct target_ops *);
int (*to_has_memory) (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 */
+ /* This method must be implemented in some situations. See the
+ comment on 'to_can_run'. */
int (*to_can_async_p) (struct target_ops *)
- TARGET_DEFAULT_FUNC (find_default_can_async_p);
+ TARGET_DEFAULT_RETURN (0);
int (*to_is_async_p) (struct target_ops *)
- TARGET_DEFAULT_FUNC (find_default_is_async_p);
+ TARGET_DEFAULT_RETURN (0);
void (*to_async) (struct target_ops *, async_callback_ftype *, void *)
TARGET_DEFAULT_NORETURN (tcomplain ());
- int (*to_supports_non_stop) (struct target_ops *);
+ /* This method must be implemented in some situations. See the
+ comment on 'to_can_run'. */
+ int (*to_supports_non_stop) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (0);
/* find_memory_regions support method for gcore */
int (*to_find_memory_regions) (struct target_ops *,
find_memory_region_ftype func, void *data)
'enum target_xfer_status' value). Save the number of bytes
actually transferred in *XFERED_LEN if transfer is successful
(TARGET_XFER_OK) or the number unavailable bytes if the requested
- data is unavailable (TARGET_XFER_E_UNAVAILABLE). *XFERED_LEN
+ data is unavailable (TARGET_XFER_UNAVAILABLE). *XFERED_LEN
smaller than LEN does not indicate the end of the object, only
the end of the transfer; higher level code should continue
transferring if desired. This is handled in target.c.
change unexpectedly, it should be invalidated, and higher
layers will re-fetch it. */
VEC(mem_region_s) *(*to_memory_map) (struct target_ops *)
- TARGET_DEFAULT_RETURN (0);
+ TARGET_DEFAULT_RETURN (NULL);
/* Erases the region of flash memory starting at ADDRESS, of
length LENGTH.
void (*to_flash_done) (struct target_ops *)
TARGET_DEFAULT_NORETURN (tcomplain ());
- /* Describe the architecture-specific features of this target.
- Returns the description found, or NULL if no description
- was available. */
- const struct target_desc *(*to_read_description) (struct target_ops *ops);
+ /* Describe the architecture-specific features of this target. If
+ OPS doesn't have a description, this should delegate to the
+ "beneath" target. Returns the description found, or NULL if no
+ description was available. */
+ const struct target_desc *(*to_read_description) (struct target_ops *ops)
+ TARGET_DEFAULT_RETURN (NULL);
/* Build the PTID of the thread on which a given task is running,
based on LWP and THREAD. These values are extracted from the
TARGET_DEFAULT_NORETURN (tcomplain ());
/* Return a traceframe info object describing the current
- traceframe's contents. If the target doesn't support
- traceframe info, return NULL. If the current traceframe is not
- selected (the current traceframe number is -1), the target can
- choose to return either NULL or an empty traceframe info. If
- NULL is returned, for example in remote target, GDB will read
- from the live inferior. If an empty traceframe info is
- returned, for example in tfile target, which means the
- traceframe info is available, but the requested memory is not
- available in it. GDB will try to see if the requested memory
- is available in the read-only sections. This method should not
- cache data; higher layers take care of caching, invalidating,
- and re-fetching when necessary. */
+ 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) (struct target_ops *)
- TARGET_DEFAULT_RETURN (0);
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Ask the target to use or not to use agent according to USE. Return 1
successful, 0 otherwise. */
int (*to_augmented_libraries_svr4_read) (struct target_ops *)
TARGET_DEFAULT_RETURN (0);
- /* Those unwinders are tried before any other arch unwinders. Use NULL if
- it is not used. */
- const struct frame_unwind *to_get_unwinder;
- const struct frame_unwind *to_get_tailcall_unwinder;
+ /* Those unwinders are tried before any other arch unwinders. If
+ SELF doesn't have unwinders, it should delegate to the
+ "beneath" target. */
+ const struct frame_unwind *(*to_get_unwinder) (struct target_ops *self)
+ TARGET_DEFAULT_RETURN (NULL);
+
+ const struct frame_unwind *(*to_get_tailcall_unwinder) (struct target_ops *self)
+ TARGET_DEFAULT_RETURN (NULL);
/* Return the number of bytes by which the PC needs to be decremented
after executing a breakpoint instruction.
Defaults to gdbarch_decr_pc_after_break (GDBARCH). */
CORE_ADDR (*to_decr_pc_after_break) (struct target_ops *ops,
- struct gdbarch *gdbarch);
+ struct gdbarch *gdbarch)
+ TARGET_DEFAULT_FUNC (default_target_decr_pc_after_break);
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
void target_close (struct target_ops *targ);
-/* Attaches to a process on the target side. Arguments are as passed
- to the `attach' command by the user. This routine can be called
- when the target is not on the target-stack, if the target_can_run
- routine returns 1; in that case, it must push itself onto the stack.
- Upon exit, the target should be ready for normal operations, and
- should be ready to deliver the status of the process immediately
- (without waiting) to an upcoming target_wait call. */
+/* Find the correct target to use for "attach". If a target on the
+ current stack supports attaching, then it is returned. Otherwise,
+ the default run target is returned. */
+
+extern struct target_ops *find_attach_target (void);
-void target_attach (char *, int);
+/* Find the correct target to use for "run". If a target on the
+ current stack supports creating a new inferior, then it is
+ returned. Otherwise, the default run target is returned. */
+
+extern struct target_ops *find_run_target (void);
/* Some targets don't generate traps when attaching to the inferior,
or their target_attach implementation takes care of the waiting.
#define target_files_info() \
(*current_target.to_files_info) (¤t_target)
-/* Insert a hardware breakpoint at address BP_TGT->placed_address in
+/* Insert a breakpoint at address BP_TGT->placed_address in
the target machine. Returns 0 for success, and returns non-zero or
throws an error (with a detailed failure reason error code and
message) otherwise. */
extern void target_load (char *arg, int from_tty);
-/* 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.
- ENV is the environment vector to pass. Errors reported with error().
- On VxWorks and various standalone systems, we ignore exec_file. */
-
-void target_create_inferior (char *exec_file, char *args,
- char **env, int from_tty);
-
/* Some targets (such as ttrace-based HPUX) don't allow us to request
notification of inferior events such as fork and vork immediately
after the inferior is created. (This because of how gdb gets an
target is currently executing; for some targets, that's the same as
whether or not the target is capable of execution, but there are
also targets which can be current while not executing. In that
- case this will become true after target_create_inferior or
- target_attach. */
+ case this will become true after to_create_inferior or
+ to_attach. */
extern int target_has_execution_1 (ptid_t);
/* Is the target in asynchronous execution mode? */
#define target_is_async_p() (current_target.to_is_async_p (¤t_target))
-int target_supports_non_stop (void);
-
/* Put the target in async mode with the specified callback function. */
#define target_async(CALLBACK,CONTEXT) \
(current_target.to_async (¤t_target, (CALLBACK), (CONTEXT)))
/* Routines for maintenance of the target structures...
complete_target_initialization: Finalize a target_ops by filling in
- any fields needed by the target implementation.
+ any fields needed by the target implementation. Unnecessary for
+ targets which are registered via add_target, as this part gets
+ taken care of then.
add_target: Add a target to the list of all possible targets.
+ This only makes sense for targets that should be activated using
+ the "target TARGET_NAME ..." command.
push_target: Make this target the top of the stack of currently used
targets, within its particular stratum of the stack. Result
\f
/* Imported from machine dependent code. */
-/* Blank target vector entries are initialized to target_ignore. */
-void target_ignore (void);
-
/* See to_supports_btrace in struct target_ops. */
#define target_supports_btrace() \
(current_target.to_supports_btrace (¤t_target))
projects / platform / upstream / binutils.git / blobdiff