/* Interface between GDB and target environments, including files and processes
- Copyright (C) 1990-2016 Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
#include "vec.h"
#include "gdb_signals.h"
#include "btrace.h"
+#include "record.h"
#include "command.h"
#include "break-common.h" /* For enum target_hw_bp_type. */
int TARGET_DEBUG_PRINTER (target_debug_print_step),
enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
+ void (*to_commit_resume) (struct target_ops *)
+ TARGET_DEFAULT_IGNORE ();
ptid_t (*to_wait) (struct target_ops *,
ptid_t, struct target_waitstatus *,
int TARGET_DEBUG_PRINTER (target_debug_print_options))
struct bp_target_info *)
TARGET_DEFAULT_FUNC (memory_insert_breakpoint);
int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *,
- struct bp_target_info *)
+ struct bp_target_info *,
+ enum remove_bp_reason)
TARGET_DEFAULT_FUNC (memory_remove_breakpoint);
/* Returns true if the target stopped because it executed a
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_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);
ULONGEST *xfered_len)
TARGET_DEFAULT_RETURN (TARGET_XFER_E_IO);
+ /* Return the limit on the size of any single memory transfer
+ for the target. */
+
+ ULONGEST (*to_get_memory_xfer_limit) (struct target_ops *)
+ TARGET_DEFAULT_RETURN (ULONGEST_MAX);
+
/* Returns the memory map for the target. A return value of NULL
means that no memory map is available. If a memory address
does not fall within any returned regions, it's assumed to be
const struct btrace_target_info *)
TARGET_DEFAULT_RETURN (NULL);
+ /* Current recording method. */
+ enum record_method (*to_record_method) (struct target_ops *, ptid_t ptid)
+ TARGET_DEFAULT_RETURN (RECORD_METHOD_NONE);
+
/* Stop trace recording. */
void (*to_stop_recording) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
#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 void target_disconnect (const char *, int);
-/* Resume execution of the target process PTID (or a group of
- 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
- INFERIOR_PTID, and let other threads (for which the wildcard PTID
- matches) resume with their 'thread->suspend.stop_signal' signal
- (usually GDB_SIGNAL_0) if it is in "pass" state, or with no signal
- if in "no pass" state. */
-
+/* Resume execution (or prepare for execution) of a target thread,
+ process or all processes. 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 INFERIOR_PTID, and let other threads
+ (for which the wildcard PTID matches) resume with their
+ 'thread->suspend.stop_signal' signal (usually GDB_SIGNAL_0) if it
+ is in "pass" state, or with no signal if in "no pass" state.
+
+ In order to efficiently handle batches of resumption requests,
+ targets may implement this method such that it records the
+ resumption request, but defers the actual resumption to the
+ target_commit_resume method implementation. See
+ target_commit_resume below. */
extern void target_resume (ptid_t ptid, int step, enum gdb_signal signal);
-/* Wait for process pid to do something. PTID = -1 to wait for any
- pid to do something. Return pid of child, or -1 in case of error;
- store status through argument pointer STATUS. Note that it is
- _NOT_ OK to throw_exception() out of target_wait() without popping
- the debugging target from the stack; GDB isn't prepared to get back
- to the prompt with a debugging target but without the frame cache,
- stop_pc, etc., set up. OPTIONS is a bitwise OR of TARGET_W*
- options. */
+/* Commit a series of resumption requests previously prepared with
+ target_resume calls.
+
+ GDB always calls target_commit_resume after calling target_resume
+ one or more times. A target may thus use this method in
+ coordination with the target_resume method to batch target-side
+ resumption requests. In that case, the target doesn't actually
+ resume in its target_resume implementation. Instead, it prepares
+ the resumption in target_resume, and defers the actual resumption
+ to target_commit_resume. E.g., the remote target uses this to
+ coalesce multiple resumption requests in a single vCont packet. */
+extern void target_commit_resume ();
+
+/* Setup to defer target_commit_resume calls, and return a cleanup
+ that reactivates target_commit_resume, if it was previously
+ active. */
+struct cleanup *make_cleanup_defer_target_commit_resume ();
-extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status,
- int options);
+/* For target_read_memory see target/target.h. */
/* The default target_ops::to_wait implementation. */
int target_info_proc (const char *, enum info_proc_what);
-/* Returns true if this target can debug multiple processes
- simultaneously. */
-
-#define target_supports_multi_process() \
- (*current_target.to_supports_multi_process) (¤t_target)
-
/* Returns true if this target can disable address space randomization. */
int target_supports_disable_randomization (void);
is returned. */
VEC(mem_region_s) *target_memory_map (void);
+/* Erases all flash memory regions on the target. */
+void flash_erase_command (char *cmd, int from_tty);
+
/* Erase the specified flash region. */
void target_flash_erase (ULONGEST address, LONGEST length);
machine. Result is 0 for success, non-zero for error. */
extern int target_remove_breakpoint (struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt);
+ struct bp_target_info *bp_tgt,
+ enum remove_bp_reason reason);
/* 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. */
extern void target_terminal_init (void);
-/* Put the inferior's terminal settings into effect.
- This is preparation for starting or resuming the inferior. */
+/* Put the inferior's terminal settings into effect. This is
+ preparation for starting or resuming the inferior. This is a no-op
+ unless called with the main UI as current UI. */
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. This is a no-op if terminal_ours
- was most recently called. */
+ was most recently called. This is a no-op unless called with the main
+ UI as current UI. */
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. */
+/* Put our terminal settings into effect. First record the inferior's
+ terminal settings so they can be restored properly later. This is
+ a no-op unless called with the main UI as current UI. */
extern void target_terminal_ours (void);
be defined by those targets that require the debugger to perform
cleanup or internal state changes in response to the process event. */
-/* The inferior process has died. Do what is right. */
-
-void target_mourn_inferior (void);
+/* For target_mourn_inferior see target/target.h. */
/* Does target have enough data to do a run or attach command? */
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. */
+/* 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);
-extern void target_check_pending_interrupt (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
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, \
/* From mem-break.c */
extern int memory_remove_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
+ struct bp_target_info *,
+ enum remove_bp_reason);
extern int memory_insert_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
/* See to_delete_record in struct target_ops. */
extern void target_delete_record (void);
+/* See to_record_method. */
+extern enum record_method target_record_method (ptid_t ptid);
+
/* See to_record_is_replaying in struct target_ops. */
extern int target_record_is_replaying (ptid_t ptid);