/* 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 ERR. */
+/* Return the string form of STATUS. */
-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, const char *, int);
void (*to_post_attach) (struct target_ops *, int)
TARGET_DEFAULT_IGNORE ();
void (*to_detach) (struct target_ops *ops, const char *, int)
TARGET_DEFAULT_IGNORE ();
- void (*to_disconnect) (struct target_ops *, char *, int);
+ void (*to_disconnect) (struct target_ops *, const char *, int)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
ptid_t (*to_wait) (struct target_ops *,
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);
- int (*to_can_run) (struct target_ops *);
+ /* 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);
/* Documentation of this routine is provided with the corresponding
target_* macro. */
void (*to_program_signals) (struct target_ops *, int, unsigned char *)
TARGET_DEFAULT_IGNORE ();
- int (*to_thread_alive) (struct target_ops *, ptid_t ptid);
+ int (*to_thread_alive) (struct target_ops *, ptid_t ptid)
+ TARGET_DEFAULT_RETURN (0);
void (*to_find_new_threads) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
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)
+ const 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)
thread-local storage for the thread PTID and the shared library
or executable file given by OBJFILE. If that block of
thread-local storage hasn't been allocated yet, this function
- may return an error. */
+ may return an error. LOAD_MODULE_ADDR may be zero for statically
+ linked multithreaded inferiors. */
CORE_ADDR (*to_get_thread_local_address) (struct target_ops *ops,
ptid_t ptid,
CORE_ADDR load_module_addr,
'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.
This method should not cache data; if the memory map could
change unexpectedly, it should be invalidated, and higher
layers will re-fetch it. */
- VEC(mem_region_s) *(*to_memory_map) (struct target_ops *);
+ VEC(mem_region_s) *(*to_memory_map) (struct target_ops *)
+ 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
Return -1 if there is insufficient buffer for a whole entry.
Return 1 if an entry was read into *TYPEP and *VALP. */
int (*to_auxv_parse) (struct target_ops *ops, gdb_byte **readptr,
- gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
+ gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
+ TARGET_DEFAULT_FUNC (default_auxv_parse);
/* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
sequence of bytes in PATTERN with length PATTERN_LEN.
int (*to_search_memory) (struct target_ops *ops,
CORE_ADDR start_addr, ULONGEST search_space_len,
const gdb_byte *pattern, ULONGEST pattern_len,
- CORE_ADDR *found_addrp);
+ CORE_ADDR *found_addrp)
+ TARGET_DEFAULT_FUNC (default_search_memory);
/* Can target execute in reverse? */
int (*to_can_execute_reverse) (struct target_ops *)
The default implementation always returns the inferior's
address space. */
struct address_space *(*to_thread_address_space) (struct target_ops *,
- ptid_t);
+ ptid_t)
+ TARGET_DEFAULT_FUNC (default_thread_address_space);
/* Target file operations. */
encountered while reading memory. */
int (*to_verify_memory) (struct target_ops *, const gdb_byte *data,
CORE_ADDR memaddr, ULONGEST size)
- TARGET_DEFAULT_NORETURN (tcomplain ());
+ TARGET_DEFAULT_FUNC (default_verify_memory);
/* Return the address of the start of the Thread Information Block
a Windows OS specific feature. */
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. */
/* Enable branch tracing for PTID and allocate a branch trace target
information struct for reading and for disabling branch trace. */
struct btrace_target_info *(*to_enable_btrace) (struct target_ops *,
- ptid_t ptid);
+ ptid_t ptid)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Disable branch tracing and deallocate TINFO. */
void (*to_disable_btrace) (struct target_ops *,
- struct btrace_target_info *tinfo);
+ struct btrace_target_info *tinfo)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Disable branch tracing and deallocate TINFO. This function is similar
to to_disable_btrace, except that it is called during teardown and is
only allowed to perform actions that are safe. A counter-example would
be attempting to talk to a remote target. */
void (*to_teardown_btrace) (struct target_ops *,
- struct btrace_target_info *tinfo);
+ struct btrace_target_info *tinfo)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Read branch trace data for the thread indicated by BTINFO into DATA.
DATA is cleared before new trace is added.
enum btrace_error (*to_read_btrace) (struct target_ops *self,
VEC (btrace_block_s) **data,
struct btrace_target_info *btinfo,
- enum btrace_read_type type);
+ enum btrace_read_type type)
+ TARGET_DEFAULT_NORETURN (tcomplain ());
/* Stop trace recording. */
- void (*to_stop_recording) (struct target_ops *);
+ void (*to_stop_recording) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
/* Print information about the recording. */
void (*to_info_record) (struct target_ops *);
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);
+
+/* 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. */
-void target_attach (char *, int);
+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.
/* Disconnect from the current target without resuming it (leaving it
waiting for a debugger). */
-extern void target_disconnect (char *, int);
+extern void target_disconnect (const char *, int);
/* Resume execution of the target process PTID (or a group of
threads). STEP says whether to single-step or to run free; SIGGNAL
#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);
#define target_can_lock_scheduler \
(current_target.to_has_thread_control & tc_schedlock)
-/* Should the target enable async mode if it is supported? Temporary
- cludge until async mode is a strict superset of sync mode. */
+/* Controls whether async mode is permitted. */
extern int target_async_permitted;
/* Can the target support asynchronous execution? */
/* 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)))
/* See to_get_tailcall_unwinder in struct target_ops. */
extern const struct frame_unwind *target_get_tailcall_unwinder (void);
+/* This implements basic memory verification, reading target memory
+ and performing the comparison here (as opposed to accelerated
+ verification making use of the qCRC packet, for example). */
+
+extern int simple_verify_memory (struct target_ops* ops,
+ const gdb_byte *data,
+ CORE_ADDR memaddr, ULONGEST size);
+
/* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range matches
the contents of [DATA,DATA+SIZE). Returns 1 if there's a match, 0
if there's a mismatch, and -1 if an error is encountered while
/* 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
extern int memory_insert_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
+/* Check whether the memory at the breakpoint's placed address still
+ contains the expected breakpoint instruction. */
+
+extern int memory_validate_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt);
+
extern int default_memory_remove_breakpoint (struct gdbarch *,
struct bp_target_info *);
extern void target_require_runnable (void);
-extern void find_default_attach (struct target_ops *, char *, int);
+extern void find_default_attach (struct target_ops *, const char *, int);
extern void find_default_create_inferior (struct target_ops *,
char *, char *, char **, int);
\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 / deliverable / binutils-gdb.git / blobdiff