/* 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.
struct traceframe_info;
struct expression;
struct dcache_struct;
+struct inferior;
+
+#include "infrun.h" /* For enum exec_direction_kind. */
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
/* 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, ... */
};
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
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,
int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *,
struct bp_target_info *)
TARGET_DEFAULT_FUNC (memory_remove_breakpoint);
+
+ /* 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 *, int, int, int)
TARGET_DEFAULT_RETURN (0);
int (*to_ranged_break_num_registers) (struct target_ops *)
int (*to_thread_alive) (struct target_ops *, ptid_t ptid)
TARGET_DEFAULT_RETURN (0);
- void (*to_find_new_threads) (struct target_ops *)
+ 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);
TARGET_DEFAULT_RETURN (0);
int (*to_is_async_p) (struct target_ops *)
TARGET_DEFAULT_RETURN (0);
- void (*to_async) (struct target_ops *, async_callback_ftype *, void *)
+ void (*to_async) (struct target_ops *, int)
TARGET_DEFAULT_NORETURN (tcomplain ());
/* This method must be implemented in some situations. See the
comment on 'to_can_run'. */
/* 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
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. */
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. */
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)
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 *)
TARGET_DEFAULT_IGNORE ();
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)
- TARGET_DEFAULT_FUNC (default_target_decr_pc_after_break);
-
/* Prepare to generate a core file. */
void (*to_prepare_to_generate_core) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
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.
+/* 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. */
- After doing this, either terminal_ours or terminal_inferior
- should be called to get back to a normal state of affairs. */
-
-#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. */
extern int target_supports_terminal_ours (void);
+/* 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. */
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). Note that this function is
/* Is the target in asynchronous execution mode? */
#define target_is_async_p() (current_target.to_is_async_p (¤t_target))
-/* 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))
#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 \
/* 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. */
/* 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
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. */
extern void target_require_runnable (void);
-extern void find_default_attach (struct target_ops *, const 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,
/* 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;
/* Imported from machine dependent code. */
/* 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);
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_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_decr_pc_after_break. */
-extern CORE_ADDR target_decr_pc_after_break (struct gdbarch *gdbarch);
-
/* See to_prepare_to_generate_core. */
extern void target_prepare_to_generate_core (void);
projects / deliverable / binutils-gdb.git / blobdiff