/* Interface between GDB and target environments, including files and processes
- Copyright (C) 1990-2015 Free Software Foundation, Inc.
+ Copyright (C) 1990-2016 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
/* 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,
ptid_t (*to_wait) (struct target_ops *,
ptid_t, struct target_waitstatus *,
int TARGET_DEBUG_PRINTER (target_debug_print_options))
- TARGET_DEFAULT_NORETURN (noprocess ());
+ 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)
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_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);
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_pass_ctrlc) (struct target_ops *)
+ TARGET_DEFAULT_FUNC (default_target_pass_ctrlc);
void (*to_rcmd) (struct target_ops *,
const char *command, struct ui_file *output)
TARGET_DEFAULT_FUNC (default_rcmd);
TARGET_DEFAULT_RETURN (0);
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 *)
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 ());
#define target_post_attach(pid) \
(*current_target.to_post_attach) (¤t_target, pid)
+/* Display a message indicating we're about to detach from the current
+ inferior process. */
+
+extern void target_announce_detach (int from_tty);
+
/* Takes a program previously attached to and detaches it.
The program may resume execution (some targets do, some don't) and will
no longer stop on signals, etc. We better not have left any breakpoints
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);
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. */
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 void target_interrupt (ptid_t ptid);
+/* Pass a ^C, as determined to have been pressed by checking the quit
+ flag, to the target. Normally calls target_interrupt, but remote
+ targets may take the opportunity to detect the remote side is not
+ responding and offer to disconnect. */
+
+extern void target_pass_ctrlc (void);
+
+/* The default target_ops::to_pass_ctrlc implementation. Simply calls
+ target_interrupt. */
+extern void default_target_pass_ctrlc (struct target_ops *ops);
+
/* Send the specified COMMAND to the target's monitor
(shell,interpreter) for execution. The result of the query is
placed in OUTBUF. */
/* 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;
#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.
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... */
+ one. OTHERTYPE is the number of watchpoints of other types than
+ this one used so far. */
#define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \
(*current_target.to_can_use_hw_breakpoint) (¤t_target, \
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
/* 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_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);
projects / deliverable / binutils-gdb.git / blobdiff