struct expression;
struct dcache_struct;
+#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
specific to the communications interface between us and the
/* Branch trace data, in XML format. */
TARGET_OBJECT_BTRACE,
/* Branch trace configuration, in XML format. */
- TARGET_OBJECT_BTRACE_CONF
+ 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, ... */
};
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 *)
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. */
+ /* Return nonzero if the filesystem accessed by the
+ target_fileio_* methods is the local filesystem,
+ zero otherwise. */
+ int (*to_filesystem_is_local) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (1);
+
/* Open FILENAME on the target, using FLAGS and MODE. Return a
target file descriptor, or -1 if an error occurs (and set
*TARGET_ERRNO). */
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);
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 ();
/* 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 \
/* Target file operations. */
+/* Return nonzero if the filesystem accessed by the target_fileio_*
+ methods is the local filesystem, zero otherwise. */
+#define target_filesystem_is_local() \
+ current_target.to_filesystem_is_local (¤t_target)
+
/* 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_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);
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;
/* 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);