X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftarget.h;h=462c0dee562d1b5aea8fa30de27c4649d7a2544c;hb=835a09d99d585bfdc9f760970908e10bd8b2fec2;hp=d90205cd02a51337b2b67a49e8f8612a9999304c;hpb=671e76cc63ebed981621ee747e18a73320ea426d;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.h b/gdb/target.h index d90205cd02..462c0dee56 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -1,6 +1,6 @@ /* Interface between GDB and target environments, including files and processes - Copyright (C) 1990-2014 Free Software Foundation, Inc. + Copyright (C) 1990-2015 Free Software Foundation, Inc. Contributed by Cygnus Support. Written by John Gilmore. @@ -38,6 +38,10 @@ struct static_tracepoint_marker; struct traceframe_info; struct expression; struct dcache_struct; +struct inferior; + +#include "infrun.h" /* For enum exec_direction_kind. */ +#include "breakpoint.h" /* For enum bptype. */ /* This include file defines the interface between the main part of the debugger, and the part which is target-specific, or @@ -58,6 +62,7 @@ struct dcache_struct; it goes into the file stratum, which is always below the process stratum. */ +#include "target/target.h" #include "target/resume.h" #include "target/wait.h" #include "target/waitstatus.h" @@ -69,6 +74,8 @@ struct dcache_struct; #include "btrace.h" #include "command.h" +#include "break-common.h" /* For enum target_hw_bp_type. */ + enum strata { dummy_stratum, /* The lowest of the low */ @@ -199,7 +206,14 @@ enum target_object /* OpenVMS Unwind Information Block. */ TARGET_OBJECT_OPENVMS_UIB, /* Branch trace data, in XML format. */ - TARGET_OBJECT_BTRACE + TARGET_OBJECT_BTRACE, + /* Branch trace configuration, in XML format. */ + TARGET_OBJECT_BTRACE_CONF, + /* The pathname of the executable file that was run to create + a specified process. ANNEX should be a string representation + of the process ID of the process in question, in hexadecimal + format. */ + TARGET_OBJECT_EXEC_FILE, /* Possible future objects: TARGET_OBJECT_FILE, ... */ }; @@ -213,23 +227,21 @@ enum target_xfer_status /* 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. */ @@ -256,13 +268,22 @@ typedef enum target_xfer_status ULONGEST len, ULONGEST *xfered_len); -/* Request that OPS transfer up to LEN 8-bit bytes of the target's - OBJECT. The OFFSET, for a seekable object, specifies the - starting point. The ANNEX can be used to provide additional - data-specific information to the target. - - Return the number of bytes actually transfered, or a negative error - code (an 'enum target_xfer_error' value) if the transfer is not +enum target_xfer_status + raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf, + const gdb_byte *writebuf, ULONGEST memaddr, + LONGEST len, ULONGEST *xfered_len); + +/* Request that OPS transfer up to LEN addressable units of the target's + OBJECT. When reading from a memory object, the size of an addressable unit + is architecture dependent and can be found using + gdbarch_addressable_memory_unit_size. Otherwise, an addressable unit is 1 + byte long. BUF should point to a buffer large enough to hold the read data, + taking into account the addressable unit size. The OFFSET, for a seekable + object, specifies the starting point. The ANNEX can be used to provide + additional data-specific information to the target. + + Return the number of addressable units actually transferred, 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 @@ -288,9 +309,24 @@ DEF_VEC_O(memory_read_result_s); extern void free_memory_read_result_vector (void *); extern VEC(memory_read_result_s)* read_memory_robust (struct target_ops *ops, - ULONGEST offset, - LONGEST len); - + const ULONGEST offset, + const LONGEST len); + +/* Request that OPS transfer up to LEN addressable units from BUF to the + target's OBJECT. When writing to a memory object, the addressable unit + size is architecture dependent and can be found using + gdbarch_addressable_memory_unit_size. Otherwise, an addressable unit is 1 + byte long. The OFFSET, for a seekable object, specifies the starting point. + The ANNEX can be used to provide additional data-specific information to + the target. + + Return the number of addressable units actually transferred, or a negative + error code (an 'enum target_xfer_status' 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_write (struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, @@ -359,6 +395,16 @@ struct thread_info; /* fwd decl for parameter list below: */ typedef void async_callback_ftype (enum inferior_event_type event_type, void *context); +/* Normally target debug printing is purely type-based. However, + sometimes it is necessary to override the debug printing on a + per-argument basis. This macro can be used, attribute-style, to + name the target debug printing function for a particular method + argument. FUNC is the name of the function. The macro's + definition is empty because it is only used by the + make-target-delegates script. */ + +#define TARGET_DEBUG_PRINTER(FUNC) + /* These defines are used to mark target_ops methods. The script make-target-delegates scans these and auto-generates the base method implementations. There are four macros that can be used: @@ -386,9 +432,9 @@ typedef void async_callback_ftype (enum inferior_event_type event_type, struct target_ops { struct target_ops *beneath; /* To the target under this one. */ - char *to_shortname; /* Name this target type */ - char *to_longname; /* Name for printing */ - char *to_doc; /* Documentation. Does not include trailing + const char *to_shortname; /* Name this target type */ + const char *to_longname; /* Name for printing */ + const char *to_doc; /* Documentation. Does not include trailing newline, and starts with a one-line descrip- tion (probably similar to to_longname). */ /* Per-target scratch pad. */ @@ -397,23 +443,34 @@ struct target_ops command, and (if successful) pushes a new target onto the stack. Targets should supply this routine, if only to provide an error message. */ - void (*to_open) (char *, int); + void (*to_open) (const char *, int); /* Old targets with a static target vector provide "to_close". New re-entrant targets provide "to_xclose" and that is expected 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_resume) (struct target_ops *, ptid_t, int, enum gdb_signal) + void (*to_disconnect) (struct target_ops *, const char *, int) + TARGET_DEFAULT_NORETURN (tcomplain ()); + void (*to_resume) (struct target_ops *, ptid_t, + int TARGET_DEBUG_PRINTER (target_debug_print_step), + enum gdb_signal) TARGET_DEFAULT_NORETURN (noprocess ()); ptid_t (*to_wait) (struct target_ops *, - ptid_t, struct target_waitstatus *, int) + ptid_t, struct target_waitstatus *, + int TARGET_DEBUG_PRINTER (target_debug_print_options)) TARGET_DEFAULT_NORETURN (noprocess ()); void (*to_fetch_registers) (struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE (); @@ -422,32 +479,6 @@ 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 *, @@ -456,7 +487,37 @@ struct target_ops int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC (memory_remove_breakpoint); - int (*to_can_use_hw_breakpoint) (struct target_ops *, int, int, int) + + /* Returns true if the target stopped because it executed a + software breakpoint. This is necessary for correct background + execution / non-stop mode operation, and for correct PC + adjustment on targets where the PC needs to be adjusted when a + software breakpoint triggers. In these modes, by the time GDB + processes a breakpoint event, the breakpoint may already be + done from the target, so GDB needs to be able to tell whether + it should ignore the event and whether it should adjust the PC. + See adjust_pc_after_break. */ + int (*to_stopped_by_sw_breakpoint) (struct target_ops *) + TARGET_DEFAULT_RETURN (0); + /* Returns true if the above method is supported. */ + int (*to_supports_stopped_by_sw_breakpoint) (struct target_ops *) + TARGET_DEFAULT_RETURN (0); + + /* Returns true if the target stopped for a hardware breakpoint. + Likewise, if the target supports hardware breakpoints, this + method is necessary for correct background execution / non-stop + mode operation. Even though hardware breakpoints do not + require PC adjustment, GDB needs to be able to tell whether the + hardware breakpoint event is a delayed event for a breakpoint + that is already gone and should thus be ignored. */ + int (*to_stopped_by_hw_breakpoint) (struct target_ops *) + TARGET_DEFAULT_RETURN (0); + /* Returns true if the above method is supported. */ + int (*to_supports_stopped_by_hw_breakpoint) (struct target_ops *) + TARGET_DEFAULT_RETURN (0); + + int (*to_can_use_hw_breakpoint) (struct target_ops *, + enum bptype, int, int) TARGET_DEFAULT_RETURN (0); int (*to_ranged_break_num_registers) (struct target_ops *) TARGET_DEFAULT_RETURN (-1); @@ -469,11 +530,11 @@ struct target_ops /* Documentation of what the two routines below are expected to do is provided with the corresponding target_* macros. */ - int (*to_remove_watchpoint) (struct target_ops *, - CORE_ADDR, int, int, struct expression *) + int (*to_remove_watchpoint) (struct target_ops *, CORE_ADDR, int, + enum target_hw_bp_type, struct expression *) TARGET_DEFAULT_RETURN (-1); - int (*to_insert_watchpoint) (struct target_ops *, - CORE_ADDR, int, int, struct expression *) + int (*to_insert_watchpoint) (struct target_ops *, CORE_ADDR, int, + enum target_hw_bp_type, struct expression *) TARGET_DEFAULT_RETURN (-1); int (*to_insert_mask_watchpoint) (struct target_ops *, @@ -513,14 +574,17 @@ struct target_ops TARGET_DEFAULT_IGNORE (); void (*to_terminal_ours) (struct target_ops *) TARGET_DEFAULT_IGNORE (); - void (*to_terminal_save_ours) (struct target_ops *) - TARGET_DEFAULT_IGNORE (); void (*to_terminal_info) (struct target_ops *, const char *, int) TARGET_DEFAULT_FUNC (default_terminal_info); void (*to_kill) (struct target_ops *) TARGET_DEFAULT_NORETURN (noprocess ()); - void (*to_load) (struct target_ops *, char *, int) + void (*to_load) (struct target_ops *, const 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) @@ -546,38 +610,45 @@ struct target_ops 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_pass_signals) (struct target_ops *, int, unsigned char *) + void (*to_pass_signals) (struct target_ops *, int, + unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals)) TARGET_DEFAULT_IGNORE (); /* Documentation of this routine is provided with the corresponding target_* function. */ - void (*to_program_signals) (struct target_ops *, int, unsigned char *) + void (*to_program_signals) (struct target_ops *, int, + unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals)) TARGET_DEFAULT_IGNORE (); - int (*to_thread_alive) (struct target_ops *, ptid_t ptid); - void (*to_find_new_threads) (struct target_ops *) + int (*to_thread_alive) (struct target_ops *, ptid_t ptid) + TARGET_DEFAULT_RETURN (0); + void (*to_update_thread_list) (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 *); @@ -586,14 +657,18 @@ 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); - void (*to_async) (struct target_ops *, async_callback_ftype *, void *) + TARGET_DEFAULT_RETURN (0); + void (*to_async) (struct target_ops *, int) 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) @@ -602,20 +677,22 @@ struct target_ops char * (*to_make_corefile_notes) (struct target_ops *, bfd *, int *) TARGET_DEFAULT_FUNC (dummy_make_corefile_notes); /* get_bookmark support method for bookmarks */ - gdb_byte * (*to_get_bookmark) (struct target_ops *, char *, int) + gdb_byte * (*to_get_bookmark) (struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN (tcomplain ()); /* goto_bookmark support method for bookmarks */ - void (*to_goto_bookmark) (struct target_ops *, gdb_byte *, int) + void (*to_goto_bookmark) (struct target_ops *, const gdb_byte *, int) TARGET_DEFAULT_NORETURN (tcomplain ()); /* Return the thread-local address at OFFSET in the 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, - CORE_ADDR offset); + CORE_ADDR offset) + TARGET_DEFAULT_NORETURN (generic_tls_error ()); /* Request that OPS transfer up to LEN 8-bit bytes of the target's OBJECT. The OFFSET, for a seekable object, specifies the @@ -626,7 +703,7 @@ struct target_ops '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. @@ -668,7 +745,8 @@ struct target_ops 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. @@ -686,10 +764,12 @@ struct target_ops 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 @@ -704,7 +784,8 @@ struct target_ops 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. @@ -715,7 +796,8 @@ struct target_ops 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 *) @@ -772,16 +854,24 @@ 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. */ - /* Open FILENAME on the target, using FLAGS and MODE. Return a - target file descriptor, or -1 if an error occurs (and set - *TARGET_ERRNO). */ + /* Return nonzero if the filesystem seen by the current inferior + is the local filesystem, zero otherwise. */ + int (*to_filesystem_is_local) (struct target_ops *) + TARGET_DEFAULT_RETURN (1); + + /* Open FILENAME on the target, in the filesystem as seen by INF, + using FLAGS and MODE. If INF is NULL, use the filesystem seen + by the debugger (GDB or, for remote targets, the remote stub). + Return a target file descriptor, or -1 if an error occurs (and + set *TARGET_ERRNO). */ int (*to_fileio_open) (struct target_ops *, - const char *filename, int flags, int mode, - int *target_errno); + struct inferior *inf, const char *filename, + int flags, int mode, int *target_errno); /* Write up to LEN bytes from WRITE_BUF to FD on the target. Return the number of bytes written, or -1 if an error occurs @@ -797,24 +887,39 @@ struct target_ops int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *target_errno); + /* Get information about the file opened as FD and put it in + SB. Return 0 on success, or -1 if an error occurs (and set + *TARGET_ERRNO). */ + int (*to_fileio_fstat) (struct target_ops *, + int fd, struct stat *sb, int *target_errno); + /* Close FD on the target. Return 0, or -1 if an error occurs (and set *TARGET_ERRNO). */ int (*to_fileio_close) (struct target_ops *, int fd, int *target_errno); - /* Unlink FILENAME on the target. Return 0, or -1 if an error - occurs (and set *TARGET_ERRNO). */ + /* Unlink FILENAME on the target, in the filesystem as seen by + INF. If INF is NULL, use the filesystem seen by the debugger + (GDB or, for remote targets, the remote stub). Return 0, or + -1 if an error occurs (and set *TARGET_ERRNO). */ int (*to_fileio_unlink) (struct target_ops *, - const char *filename, int *target_errno); - - /* Read value of symbolic link FILENAME on the target. Return a - null-terminated string allocated via xmalloc, or NULL if an error - occurs (and set *TARGET_ERRNO). */ + struct inferior *inf, + const char *filename, + int *target_errno); + + /* Read value of symbolic link FILENAME on the target, in the + filesystem as seen by INF. If INF is NULL, use the filesystem + seen by the debugger (GDB or, for remote targets, the remote + stub). Return a null-terminated string allocated via xmalloc, + or NULL if an error occurs (and set *TARGET_ERRNO). */ char *(*to_fileio_readlink) (struct target_ops *, - const char *filename, int *target_errno); + struct inferior *inf, + const char *filename, + int *target_errno); /* Implement the "info proc" command. */ - void (*to_info_proc) (struct target_ops *, char *, enum info_proc_what); + void (*to_info_proc) (struct target_ops *, const char *, + enum info_proc_what); /* Tracepoint-related operations. */ @@ -942,7 +1047,7 @@ struct target_ops 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. */ @@ -966,20 +1071,11 @@ struct target_ops 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. */ @@ -991,48 +1087,63 @@ struct target_ops TARGET_DEFAULT_RETURN (0); /* Check whether the target supports branch tracing. */ - int (*to_supports_btrace) (struct target_ops *) + int (*to_supports_btrace) (struct target_ops *, enum btrace_format) TARGET_DEFAULT_RETURN (0); - /* Enable branch tracing for PTID and allocate a branch trace target - information struct for reading and for disabling branch trace. */ + /* Enable branch tracing for PTID using CONF configuration. + Return 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, + const struct btrace_config *conf) + 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. - The branch trace will start with the most recent block and continue - towards older blocks. */ + 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_data *data, struct btrace_target_info *btinfo, - enum btrace_read_type type); + enum btrace_read_type type) + TARGET_DEFAULT_NORETURN (tcomplain ()); + + /* Get the branch trace configuration. */ + const struct btrace_config *(*to_btrace_conf) (struct target_ops *self, + const struct btrace_target_info *) + TARGET_DEFAULT_RETURN (NULL); /* 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 *); + void (*to_info_record) (struct target_ops *) + TARGET_DEFAULT_IGNORE (); /* Save the recorded execution trace into a file. */ - void (*to_save_record) (struct target_ops *, const char *filename); + void (*to_save_record) (struct target_ops *, const char *filename) + TARGET_DEFAULT_NORETURN (tcomplain ()); - /* Delete the recorded execution trace from the current position onwards. */ - void (*to_delete_record) (struct target_ops *); + /* Delete the recorded execution trace from the current position + onwards. */ + void (*to_delete_record) (struct target_ops *) + TARGET_DEFAULT_NORETURN (tcomplain ()); /* Query if the record target is currently replaying. */ - int (*to_record_is_replaying) (struct target_ops *); + int (*to_record_is_replaying) (struct target_ops *) + TARGET_DEFAULT_RETURN (0); /* Go to the begin of the execution trace. */ void (*to_goto_record_begin) (struct target_ops *) @@ -1092,16 +1203,22 @@ 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); + + /* Prepare to generate a core file. */ + void (*to_prepare_to_generate_core) (struct target_ops *) + TARGET_DEFAULT_IGNORE (); - /* 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); + /* Cleanup after generating a core file. */ + void (*to_done_generating_core) (struct target_ops *) + TARGET_DEFAULT_IGNORE (); int to_magic; /* Need sub-structure for target machine related rather than comm related? @@ -1133,15 +1250,17 @@ extern struct target_ops current_target; 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. @@ -1170,7 +1289,7 @@ extern void target_detach (const char *, int); /* 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 @@ -1225,7 +1344,7 @@ struct address_space *target_thread_address_space (ptid_t); an error was encountered while attempting to handle the request. */ -int target_info_proc (char *, enum info_proc_what); +int target_info_proc (const char *, enum info_proc_what); /* Returns true if this target can debug multiple processes simultaneously. */ @@ -1260,8 +1379,7 @@ int target_supports_disable_randomization (void); extern int target_read_string (CORE_ADDR, char **, int, int *); -extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, - ssize_t len); +/* For target_read_memory see target/target.h. */ extern int target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); @@ -1270,8 +1388,7 @@ extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); extern int target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len); -extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, - ssize_t len); +/* For target_write_memory see target/target.h. */ extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len); @@ -1335,7 +1452,7 @@ int target_write_memory_blocks (VEC(memory_write_request_s) *requests, #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. */ @@ -1349,42 +1466,42 @@ extern int target_insert_breakpoint (struct gdbarch *gdbarch, extern int target_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt); +/* Returns true if the terminal settings of the inferior are in + effect. */ + +extern int target_terminal_is_inferior (void); + /* Initialize the terminal settings we record for the inferior, before we actually run the inferior. */ -#define target_terminal_init() \ - (*current_target.to_terminal_init) (¤t_target) +extern void target_terminal_init (void); /* Put the inferior's terminal settings into effect. This is preparation for starting or resuming the inferior. */ extern void target_terminal_inferior (void); -/* Put some of our terminal settings into effect, - enough to get proper results from our output, - but do not change into or out of RAW mode - so that no input is discarded. - - After doing this, either terminal_ours or terminal_inferior - should be called to get back to a normal state of affairs. */ +/* Put some of our terminal settings into effect, enough to get proper + results from our output, but do not change into or out of RAW mode + so that no input is discarded. This is a no-op if terminal_ours + was most recently called. */ -#define target_terminal_ours_for_output() \ - (*current_target.to_terminal_ours_for_output) (¤t_target) +extern void target_terminal_ours_for_output (void); /* Put our terminal settings into effect. First record the inferior's terminal settings so they can be restored properly later. */ -#define target_terminal_ours() \ - (*current_target.to_terminal_ours) (¤t_target) +extern void target_terminal_ours (void); + +/* Return true if the target stack has a non-default + "to_terminal_ours" method. */ -/* Save our terminal settings. - This is called from TUI after entering or leaving the curses - mode. Since curses modifies our terminal this call is here - to take this change into account. */ +extern int target_supports_terminal_ours (void); -#define target_terminal_save_ours() \ - (*current_target.to_terminal_save_ours) (¤t_target) +/* Make a cleanup that restores the state of the terminal to the current + state. */ +extern struct cleanup *make_cleanup_restore_target_terminal (void); /* Print useful information about our terminal status, if such a thing exists. */ @@ -1407,16 +1524,7 @@ extern void target_kill (void); sections. The target may define switches, or other non-switch arguments, as it pleases. */ -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); +extern void target_load (const char *arg, 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 @@ -1549,13 +1657,15 @@ extern void target_program_signals (int nsig, unsigned char *program_signals); extern int target_thread_alive (ptid_t ptid); -/* Query for new threads and add them to the thread list. */ +/* Sync the target's threads with GDB's thread list. */ -extern void target_find_new_threads (void); +extern void target_update_thread_list (void); /* Make target stop in a continuable fashion. (For instance, under - Unix, this should act like SIGSTOP). This function is normally - used by GUIs to implement a stop button. */ + Unix, this should act like SIGSTOP). Note that this function is + asynchronous: it does not wait for the target to become stopped + before returning. If this is the behavior you want please use + target_stop_and_wait. */ extern void target_stop (ptid_t ptid); @@ -1595,8 +1705,8 @@ extern int target_has_registers_1 (void); 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); @@ -1622,8 +1732,7 @@ extern int default_child_has_execution (struct target_ops *ops, #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? */ @@ -1632,11 +1741,9 @@ extern int target_async_permitted; /* 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))) +/* Enables/disabled async target events. */ +#define target_async(ENABLE) \ + (current_target.to_async (¤t_target, (ENABLE))) #define target_execution_direction() \ (current_target.to_execution_direction (¤t_target)) @@ -1713,6 +1820,21 @@ extern char *target_thread_name (struct thread_info *); #define target_stopped_by_watchpoint() \ ((*current_target.to_stopped_by_watchpoint) (¤t_target)) +/* Returns non-zero if the target stopped because it executed a + software breakpoint instruction. */ + +#define target_stopped_by_sw_breakpoint() \ + ((*current_target.to_stopped_by_sw_breakpoint) (¤t_target)) + +#define target_supports_stopped_by_sw_breakpoint() \ + ((*current_target.to_supports_stopped_by_sw_breakpoint) (¤t_target)) + +#define target_stopped_by_hw_breakpoint() \ + ((*current_target.to_stopped_by_hw_breakpoint) (¤t_target)) + +#define target_supports_stopped_by_hw_breakpoint() \ + ((*current_target.to_supports_stopped_by_hw_breakpoint) (¤t_target)) + /* Non-zero if we have steppable watchpoints */ #define target_have_steppable_watchpoint \ @@ -1728,14 +1850,17 @@ extern char *target_thread_name (struct thread_info *); /* If the *_hw_beakpoint functions have not been defined elsewhere use the definitions in the target vector. */ -/* Returns non-zero if we can set a hardware watchpoint of type TYPE. TYPE is - one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or - bp_hardware_breakpoint. CNT is the number of such watchpoints used so far - (including this one?). OTHERTYPE is who knows what... */ +/* Returns positive if we can set a hardware watchpoint of type TYPE. + Returns negative if the target doesn't have enough hardware debug + registers available. Return zero if hardware watchpoint of type + TYPE isn't supported. TYPE is one of bp_hardware_watchpoint, + bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint. + CNT is the number of such watchpoints used so far, including this + one. OTHERTYPE is who knows what... */ #define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \ (*current_target.to_can_use_hw_breakpoint) (¤t_target, \ - TYPE, CNT, OTHERTYPE); + TYPE, CNT, OTHERTYPE) /* Returns the number of debug registers needed to watch the given memory region, or zero if not supported. */ @@ -1795,12 +1920,12 @@ extern int target_ranged_break_num_registers (void); target_stopped_by_watchpoint, in such case place it to *ADDR_P. Only the INFERIOR_PTID task is being queried. */ #define target_stopped_data_address(target, addr_p) \ - (*target.to_stopped_data_address) (target, addr_p) + (*(target)->to_stopped_data_address) (target, addr_p) /* Return non-zero if ADDR is within the range of a watchpoint spanning LENGTH bytes beginning at START. */ #define target_watchpoint_addr_within_range(target, addr, start, length) \ - (*target.to_watchpoint_addr_within_range) (target, addr, start, length) + (*(target)->to_watchpoint_addr_within_range) (target, addr, start, length) /* Return non-zero if the target is capable of using hardware to evaluate the condition expression. In this case, if the condition is false when @@ -1848,11 +1973,19 @@ extern int target_search_memory (CORE_ADDR start_addr, /* Target file operations. */ -/* Open FILENAME on the target, using FLAGS and MODE. Return a - target file descriptor, or -1 if an error occurs (and set - *TARGET_ERRNO). */ -extern int target_fileio_open (const char *filename, int flags, int mode, - int *target_errno); +/* Return nonzero if the filesystem seen by the current inferior + is the local filesystem, zero otherwise. */ +#define target_filesystem_is_local() \ + current_target.to_filesystem_is_local (¤t_target) + +/* Open FILENAME on the target, in the filesystem as seen by INF, + using FLAGS and MODE. If INF is NULL, use the filesystem seen + by the debugger (GDB or, for remote targets, the remote stub). + Return a target file descriptor, or -1 if an error occurs (and + set *TARGET_ERRNO). */ +extern int target_fileio_open (struct inferior *inf, + const char *filename, int flags, + int mode, int *target_errno); /* Write up to LEN bytes from WRITE_BUF to FD on the target. Return the number of bytes written, or -1 if an error occurs @@ -1866,37 +1999,58 @@ extern int target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len, extern int target_fileio_pread (int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *target_errno); +/* Get information about the file opened as FD on the target + and put it in SB. Return 0 on success, or -1 if an error + occurs (and set *TARGET_ERRNO). */ +extern int target_fileio_fstat (int fd, struct stat *sb, + int *target_errno); + /* Close FD on the target. Return 0, or -1 if an error occurs (and set *TARGET_ERRNO). */ extern int target_fileio_close (int fd, int *target_errno); -/* Unlink FILENAME on the target. Return 0, or -1 if an error - occurs (and set *TARGET_ERRNO). */ -extern int target_fileio_unlink (const char *filename, int *target_errno); - -/* Read value of symbolic link FILENAME on the target. Return a - null-terminated string allocated via xmalloc, or NULL if an error +/* Unlink FILENAME on the target, in the filesystem as seen by INF. + If INF is NULL, use the filesystem seen by the debugger (GDB or, + for remote targets, the remote stub). Return 0, or -1 if an error occurs (and set *TARGET_ERRNO). */ -extern char *target_fileio_readlink (const char *filename, int *target_errno); - -/* Read target file FILENAME. The return value will be -1 if the transfer - fails or is not supported; 0 if the object is empty; or the length - of the object otherwise. If a positive value is returned, a - sufficiently large buffer will be allocated using xmalloc and - returned in *BUF_P containing the contents of the object. +extern int target_fileio_unlink (struct inferior *inf, + const char *filename, + int *target_errno); + +/* Read value of symbolic link FILENAME on the target, in the + filesystem as seen by INF. If INF is NULL, use the filesystem seen + by the debugger (GDB or, for remote targets, the remote stub). + Return a null-terminated string allocated via xmalloc, or NULL if + an error occurs (and set *TARGET_ERRNO). */ +extern char *target_fileio_readlink (struct inferior *inf, + const char *filename, + int *target_errno); + +/* Read target file FILENAME, in the filesystem as seen by INF. If + INF is NULL, use the filesystem seen by the debugger (GDB or, for + remote targets, the remote stub). The return value will be -1 if + the transfer fails or is not supported; 0 if the object is empty; + or the length of the object otherwise. If a positive value is + returned, a sufficiently large buffer will be allocated using + xmalloc and returned in *BUF_P containing the contents of the + object. This method should be used for objects sufficiently small to store in a single xmalloc'd buffer, when no fixed bound on the object's size is known in advance. */ -extern LONGEST target_fileio_read_alloc (const char *filename, +extern LONGEST target_fileio_read_alloc (struct inferior *inf, + const char *filename, gdb_byte **buf_p); -/* Read target file FILENAME. The result is NUL-terminated and +/* Read target file FILENAME, in the filesystem as seen by INF. If + INF is NULL, use the filesystem seen by the debugger (GDB or, for + remote targets, the remote stub). The result is NUL-terminated and returned as a string, allocated using xmalloc. If an error occurs or the transfer is unsupported, NULL is returned. Empty objects are returned as allocated but empty strings. A warning is issued if the result contains any embedded NUL bytes. */ -extern char *target_fileio_read_stralloc (const char *filename); +extern char *target_fileio_read_stralloc (struct inferior *inf, + const char *filename); /* Tracepoint-related operations. */ @@ -2011,6 +2165,14 @@ extern const struct frame_unwind *target_get_unwinder (void); /* 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 @@ -2022,9 +2184,13 @@ int target_verify_memory (const gdb_byte *data, /* 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 @@ -2112,6 +2278,12 @@ extern int memory_remove_breakpoint (struct target_ops *, struct gdbarch *, 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 *); @@ -2127,11 +2299,6 @@ extern void noprocess (void) ATTRIBUTE_NORETURN; extern void target_require_runnable (void); -extern void find_default_attach (struct target_ops *, char *, int); - -extern void find_default_create_inferior (struct target_ops *, - char *, char *, char **, int); - extern struct target_ops *find_target_beneath (struct target_ops *); /* Find the target at STRATUM. If no target is at that stratum, @@ -2156,6 +2323,10 @@ extern int remote_debug; /* Speed in bits per second, or -1 which means don't mess with the speed. */ extern int baud_rate; + +/* Parity for serial port */ +extern int serial_parity; + /* Timeout limit for response from target. */ extern int remote_timeout; @@ -2177,15 +2348,12 @@ extern void update_target_permissions (void); /* 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)) +extern int target_supports_btrace (enum btrace_format); /* See to_enable_btrace in struct target_ops. */ -extern struct btrace_target_info *target_enable_btrace (ptid_t ptid); +extern struct btrace_target_info * + target_enable_btrace (ptid_t ptid, const struct btrace_config *); /* See to_disable_btrace in struct target_ops. */ extern void target_disable_btrace (struct btrace_target_info *btinfo); @@ -2194,16 +2362,17 @@ extern void target_disable_btrace (struct btrace_target_info *btinfo); extern void target_teardown_btrace (struct btrace_target_info *btinfo); /* See to_read_btrace in struct target_ops. */ -extern enum btrace_error target_read_btrace (VEC (btrace_block_s) **, +extern enum btrace_error target_read_btrace (struct btrace_data *, struct btrace_target_info *, enum btrace_read_type); +/* See to_btrace_conf in struct target_ops. */ +extern const struct btrace_config * + target_btrace_conf (const struct btrace_target_info *); + /* See to_stop_recording in struct target_ops. */ extern void target_stop_recording (void); -/* See to_info_record in struct target_ops. */ -extern void target_info_record (void); - /* See to_save_record in struct target_ops. */ extern void target_save_record (const char *filename); @@ -2243,11 +2412,10 @@ extern void target_call_history_from (ULONGEST begin, int size, int flags); /* See to_call_history_range. */ extern void target_call_history_range (ULONGEST begin, ULONGEST end, int flags); -/* See to_decr_pc_after_break. Start searching for the target at OPS. */ -extern CORE_ADDR forward_target_decr_pc_after_break (struct target_ops *ops, - struct gdbarch *gdbarch); +/* See to_prepare_to_generate_core. */ +extern void target_prepare_to_generate_core (void); -/* See to_decr_pc_after_break. */ -extern CORE_ADDR target_decr_pc_after_break (struct gdbarch *gdbarch); +/* See to_done_generating_core. */ +extern void target_done_generating_core (void); #endif /* !defined (TARGET_H) */