/* 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)
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_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 *,
const char *command, struct ui_file *output)
TARGET_DEFAULT_FUNC (default_rcmd);
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);
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);
+/* 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. */
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.