/* Interface between GDB and target environments, including files and processes
- Copyright (C) 1990-2014 Free Software Foundation, Inc.
+ Copyright (C) 1990-2016 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. */
+#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
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"
#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 */
/* Process a normal inferior event which will result in target_wait
being called. */
INF_REG_EVENT,
- /* We are called because a timer went off. */
- INF_TIMER,
/* We are called to do stuff after the inferior stops. */
INF_EXEC_COMPLETE,
- /* We are called to do some stuff after the inferior stops, but we
- are expected to reenter the proceed() and
- handle_inferior_event() functions. This is used only in case of
- 'step n' like commands. */
- INF_EXEC_CONTINUE
};
\f
/* Target objects which can be transfered using target_read,
/* 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,
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:
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. */
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"). */
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)
+ 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)
- TARGET_DEFAULT_NORETURN (noprocess ());
+ ptid_t, struct target_waitstatus *,
+ int TARGET_DEBUG_PRINTER (target_debug_print_options))
+ TARGET_DEFAULT_FUNC (default_target_wait);
void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
TARGET_DEFAULT_IGNORE ();
void (*to_store_registers) (struct target_ops *, struct regcache *, int)
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);
/* 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 *,
- CORE_ADDR, CORE_ADDR, int)
+ CORE_ADDR, CORE_ADDR,
+ enum target_hw_bp_type)
TARGET_DEFAULT_RETURN (1);
int (*to_remove_mask_watchpoint) (struct target_ops *,
- CORE_ADDR, CORE_ADDR, int)
+ CORE_ADDR, CORE_ADDR,
+ enum target_hw_bp_type)
TARGET_DEFAULT_RETURN (1);
int (*to_stopped_by_watchpoint) (struct target_ops *)
TARGET_DEFAULT_RETURN (0);
int (*to_masked_watch_num_registers) (struct target_ops *,
CORE_ADDR, CORE_ADDR)
TARGET_DEFAULT_RETURN (-1);
+
+ /* Return 1 for sure target can do single step. Return -1 for
+ unknown. Return 0 for target can't do. */
+ int (*to_can_do_single_step) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (-1);
+
void (*to_terminal_init) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
void (*to_terminal_inferior) (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.
TARGET_DEFAULT_RETURN (1);
int (*to_remove_exec_catchpoint) (struct target_ops *, int)
TARGET_DEFAULT_RETURN (1);
+ void (*to_follow_exec) (struct target_ops *, struct inferior *, char *)
+ TARGET_DEFAULT_IGNORE ();
int (*to_set_syscall_catchpoint) (struct target_ops *,
int, int, int, int, int *)
TARGET_DEFAULT_RETURN (1);
/* 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)
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);
char *(*to_extra_thread_info) (struct target_ops *, struct thread_info *)
TARGET_DEFAULT_RETURN (NULL);
- char *(*to_thread_name) (struct target_ops *, struct thread_info *)
+ const char *(*to_thread_name) (struct target_ops *, struct thread_info *)
TARGET_DEFAULT_RETURN (NULL);
void (*to_stop) (struct target_ops *, ptid_t)
TARGET_DEFAULT_IGNORE ();
+ void (*to_interrupt) (struct target_ops *, ptid_t)
+ TARGET_DEFAULT_IGNORE ();
+ void (*to_check_pending_interrupt) (struct target_ops *)
+ 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 (NULL);
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 ());
+ void (*to_thread_events) (struct target_ops *, int)
+ TARGET_DEFAULT_IGNORE ();
/* 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);
+ /* Return true if the target operates in non-stop mode even with
+ "set non-stop off". */
+ int (*to_always_non_stop_p) (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)
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
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
/* Target file operations. */
- /* Open FILENAME on the target, using FLAGS and MODE. Return a
+ /* 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).
+ If WARN_IF_SLOW is nonzero, print a warning message if the file
+ is being accessed over a link that may be slow. 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,
+ struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
int *target_errno);
/* Write up to LEN bytes from WRITE_BUF to FD on the target.
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. */
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 ();
/* 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)
TARGET_DEFAULT_NORETURN (tcomplain ());
- /* Delete the recorded execution trace from the current position onwards. */
+ /* 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 *)
+ /* Query if the record target is currently replaying PTID. */
+ int (*to_record_is_replaying) (struct target_ops *, ptid_t ptid)
+ TARGET_DEFAULT_RETURN (0);
+
+ /* Query if the record target will replay PTID if it were resumed in
+ execution direction DIR. */
+ int (*to_record_will_replay) (struct target_ops *, ptid_t ptid, int dir)
TARGET_DEFAULT_RETURN (0);
+ /* Stop replaying. */
+ void (*to_record_stop_replaying) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
+
/* Go to the begin of the execution trace. */
void (*to_goto_record_begin) (struct target_ops *)
TARGET_DEFAULT_NORETURN (tcomplain ());
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 ();
+
+ /* 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?
/* 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
- is the signal to be given to the target, or GDB_SIGNAL_0 for no
+ threads). STEP says whether to hardware single-step or to run free;
+ SIGGNAL is the signal to be given to the target, or GDB_SIGNAL_0 for no
signal. The caller may not pass GDB_SIGNAL_DEFAULT. A specific
PTID means `step/resume only this process id'. A wildcard PTID
(all threads, or all threads of process) means `step/resume
extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status,
int options);
+/* The default target_ops::to_wait implementation. */
+
+extern ptid_t default_target_wait (struct target_ops *ops,
+ ptid_t ptid,
+ struct target_waitstatus *status,
+ int options);
+
/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
extern void target_fetch_registers (struct regcache *regcache, int regno);
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. */
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);
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);
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);
+
+/* Returns true if our terminal settings are in effect. */
+
+extern int target_terminal_is_ours (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. */
-/* 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. */
sections. The target may define switches, or other non-switch
arguments, as it pleases. */
-extern void target_load (char *arg, 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
int target_follow_fork (int follow_child, int detach_fork);
+/* Handle the target-specific bookkeeping required when the inferior
+ makes an exec call. INF is the exec'd inferior. */
+
+void target_follow_exec (struct inferior *inf, char *execd_pathname);
+
/* On some targets, we can catch an inferior exec event when it
occurs. These functions insert/remove an already-created
catchpoint for such events. They return 0 for success, 1 if the
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);
+/* Interrupt the target just like the user typed a ^C on the
+ inferior's controlling terminal. (For instance, under Unix, this
+ should act like SIGINT). This function is asynchronous. */
+
+extern void target_interrupt (ptid_t ptid);
+
+/* Some targets install their own SIGINT handler while the target is
+ running. This method is called from the QUIT macro to give such
+ targets a chance to process a Ctrl-C. The target may e.g., choose
+ to interrupt the (potentially) long running operation, or give up
+ waiting and disconnect. */
+
+extern void target_check_pending_interrupt (void);
+
/* Send the specified COMMAND to the target's monitor
(shell,interpreter) for execution. The result of the query is
placed in OUTBUF. */
/* 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. */
+extern void target_async (int enable);
+
+/* Enables/disables thread create and exit events. */
+extern void target_thread_events (int enable);
+
+/* Whether support for controlling the target backends always in
+ non-stop mode is enabled. */
+extern enum auto_boolean target_non_stop_enabled;
+
+/* Is the target in non-stop mode? Some targets control the inferior
+ in non-stop mode even with "set non-stop off". Always true if "set
+ non-stop" is on. */
+extern int target_is_non_stop_p (void);
#define target_execution_direction() \
(current_target.to_execution_direction (¤t_target))
#define target_extra_thread_info(TP) \
(current_target.to_extra_thread_info (¤t_target, TP))
-/* Return the thread's name. A NULL result means that the target
- could not determine this thread's name. */
+/* Return the thread's name, or NULL if the target is unable to determine it.
+ The returned value must not be freed by the caller. */
-extern char *target_thread_name (struct thread_info *);
+extern const char *target_thread_name (struct thread_info *);
/* Attempts to find the pathname of the executable file
that was run to create a specified process.
#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. */
addr, len)
+#define target_can_do_single_step() \
+ (*current_target.to_can_do_single_step) (¤t_target)
+
/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.
TYPE is 0 for write, 1 for read, and 2 for read/write accesses.
COND is the expression for its condition, or NULL if there's none.
or hw_access for an access watchpoint. Returns 0 for success, 1 if
masked watchpoints are not supported, -1 for failure. */
-extern int target_insert_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
+extern int target_insert_mask_watchpoint (CORE_ADDR, CORE_ADDR,
+ enum target_hw_bp_type);
/* Remove a masked watchpoint at ADDR with the mask MASK.
RW may be hw_read for a read watchpoint, hw_write for a write watchpoint
or hw_access for an access watchpoint. Returns 0 for success, non-zero
for failure. */
-extern int target_remove_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
+extern int target_remove_mask_watchpoint (CORE_ADDR, CORE_ADDR,
+ enum target_hw_bp_type);
/* Insert a hardware breakpoint at address BP_TGT->placed_address in
the target machine. Returns 0 for success, and returns non-zero or
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
/* 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);
+
+/* Like target_fileio_open, but print a warning message if the
+ file is being accessed over a link that may be slow. */
+extern int target_fileio_open_warn_if_slow (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. */
/* Does whatever cleanup is required to get rid of all pushed targets. */
extern void pop_all_targets (void);
+/* Like pop_all_targets, but pops only targets whose stratum is at or
+ above STRATUM. */
+extern void pop_all_targets_at_and_above (enum strata stratum);
+
/* Like pop_all_targets, but pops only targets whose stratum is
strictly above ABOVE_STRATUM. */
extern void pop_all_targets_above (enum strata above_stratum);
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_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);
extern void target_delete_record (void);
/* See to_record_is_replaying in struct target_ops. */
-extern int target_record_is_replaying (void);
+extern int target_record_is_replaying (ptid_t ptid);
+
+/* See to_record_will_replay in struct target_ops. */
+extern int target_record_will_replay (ptid_t ptid, int dir);
+
+/* See to_record_stop_replaying in struct target_ops. */
+extern void target_record_stop_replaying (void);
/* See to_goto_record_begin in struct target_ops. */
extern void target_goto_record_begin (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_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) */