/* Interface between GDB and target environments, including files and processes
- Copyright (C) 1990-2021 Free Software Foundation, Inc.
+ Copyright (C) 1990-2022 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
#include "btrace.h"
#include "record.h"
#include "command.h"
-#include "disasm.h"
+#include "disasm-flags.h"
#include "tracepoint.h"
#include "gdbsupport/break-common.h" /* For enum target_hw_bp_type. */
int TARGET_DEBUG_PRINTER (target_debug_print_step),
enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
- virtual void commit_resume ()
+
+ /* Ensure that all resumed threads are committed to the target.
+
+ See the description of
+ process_stratum_target::commit_resumed_state for more
+ details. */
+ virtual void commit_resumed ()
TARGET_DEFAULT_IGNORE ();
+
/* See target_wait's description. Note that implementations of
this method must not assume that inferior_ptid on entry is
pointing at the thread or inferior that ends up reporting an
virtual bool can_create_inferior ();
virtual void create_inferior (const char *, const std::string &,
char **, int);
- virtual void post_startup_inferior (ptid_t)
- TARGET_DEFAULT_IGNORE ();
virtual int insert_fork_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
virtual int remove_fork_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
virtual int remove_vfork_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
- virtual bool follow_fork (bool, bool)
+ virtual void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool)
TARGET_DEFAULT_FUNC (default_follow_fork);
virtual int insert_exec_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
virtual int remove_exec_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
- virtual void follow_exec (struct inferior *, const char *)
+ virtual void follow_exec (inferior *, ptid_t, const char *)
TARGET_DEFAULT_IGNORE ();
virtual int set_syscall_catchpoint (int, bool, int,
gdb::array_view<const int>)
TARGET_DEFAULT_NORETURN (tcomplain ());
virtual int async_wait_fd ()
TARGET_DEFAULT_NORETURN (noprocess ());
+ /* Return true if the target has pending events to report to the
+ core. If true, then GDB avoids resuming the target until all
+ pending events are consumed, so that multiple resumptions can
+ be coalesced as an optimization. Most targets can't tell
+ whether they have pending events without calling target_wait,
+ so we default to returning false. The only downside is that a
+ potential optimization is missed. */
+ virtual bool has_pending_events ()
+ TARGET_DEFAULT_RETURN (false);
virtual void thread_events (int)
TARGET_DEFAULT_IGNORE ();
/* This method must be implemented in some situations. See the
virtual void flash_done ()
TARGET_DEFAULT_NORETURN (tcomplain ());
- /* Describe the architecture-specific features of this target. If
- OPS doesn't have a description, this should delegate to the
- "beneath" target. Returns the description found, or NULL if no
- description was available. */
+ /* Describe the architecture-specific features of the current
+ inferior.
+
+ Returns the description found, or nullptr if no description was
+ available.
+
+ If some target features differ between threads, the description
+ returned by read_description (and the resulting gdbarch) won't
+ accurately describe all threads. In this case, the
+ thread_architecture method can be used to obtain gdbarches that
+ accurately describe each thread. */
virtual const struct target_desc *read_description ()
TARGET_DEFAULT_RETURN (NULL);
based on LWP and THREAD. These values are extracted from the
task Private_Data section of the Ada Task Control Block, and
their interpretation depends on the target. */
- virtual ptid_t get_ada_task_ptid (long lwp, long thread)
+ virtual ptid_t get_ada_task_ptid (long lwp, ULONGEST thread)
TARGET_DEFAULT_FUNC (default_get_ada_task_ptid);
/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
virtual bool can_use_agent ()
TARGET_DEFAULT_RETURN (false);
- /* Enable branch tracing for PTID using CONF configuration.
+ /* Enable branch tracing for TP using CONF configuration.
Return a branch trace target information struct for reading and for
disabling branch trace. */
- virtual struct btrace_target_info *enable_btrace (ptid_t ptid,
+ virtual struct btrace_target_info *enable_btrace (thread_info *tp,
const struct btrace_config *conf)
TARGET_DEFAULT_NORETURN (tcomplain ());
target_ops *m_stack[(int) debug_stratum + 1] {};
};
-/* The ops structure for our "current" target process. This should
- never be NULL. If there is no target, it points to the dummy_target. */
-
-extern target_ops *current_top_target ();
-
/* Return the dummy target. */
extern target_ops *get_dummy_target ();
extern void target_post_attach (int pid);
+/* Display a message indicating we're about to attach to a given
+ process. */
+
+extern void target_announce_attach (int from_tty, int pid);
+
/* Display a message indicating we're about to detach from the current
inferior process. */
extern void target_disconnect (const char *, int);
-/* 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.
+/* Resume execution (or prepare for execution) of the current thread
+ (INFERIOR_PTID), while optionally letting other threads of the
+ current process or all processes run free.
+
+ STEP says whether to hardware single-step the current thread or to
+ let it run free; SIGNAL is the signal to be given to the current
+ thread, or GDB_SIGNAL_0 for no signal. The caller may not pass
+ GDB_SIGNAL_DEFAULT.
+
+ SCOPE_PTID indicates the resumption scope. I.e., which threads
+ (other than the current) run free. If resuming a single thread,
+ SCOPE_PTID is the same thread as the current thread. A wildcard
+ SCOPE_PTID (all threads, or all threads of process) lets threads
+ other than the current (for which the wildcard SCOPE_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. Note neither STEP nor SIGNAL apply to any thread
+ other than the current.
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);
-
-/* 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 reactivate
- target_commit_resume on destruction, if it was previously
- active. */
-extern scoped_restore_tmpl<int> make_scoped_defer_target_commit_resume ();
+extern void target_resume (ptid_t scope_ptid,
+ int step, enum gdb_signal signal);
+
+/* Ensure that all resumed threads are committed to the target.
+
+ See the description of process_stratum_target::commit_resumed_state
+ for more details. */
+extern void target_commit_resumed ();
/* For target_read_memory see target/target.h. */
struct target_waitstatus *status,
target_wait_flags options);
+/* Return true if the target has pending events to report to the core.
+ See target_ops::has_pending_events(). */
+
+extern bool target_has_pending_events ();
+
/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
extern void target_fetch_registers (struct regcache *regcache, int regno);
extern bool target_can_run_breakpoint_commands ();
-/* Read a string from target memory at address MEMADDR. The string
- will be at most LEN bytes long (note that excess bytes may be read
- in some cases -- but these will not be returned). Returns nullptr
- on error. */
-
-extern gdb::unique_xmalloc_ptr<char> target_read_string
- (CORE_ADDR memaddr, int len, int *bytes_read = nullptr);
-
/* For target_read_memory see target/target.h. */
extern int target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
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
- after the inferior is created. (This because of how gdb gets an
- inferior created via invoking a shell to do it. In such a scenario,
- if the shell init file has commands in it, the shell will fork and
- exec for each of those commands, and we will see each such fork
- event. Very bad.)
-
- Such targets will supply an appropriate definition for this function. */
-
-extern void target_post_startup_inferior (ptid_t ptid);
-
/* On some targets, we can catch an inferior fork or vfork 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_remove_vfork_catchpoint (int pid);
-/* If the inferior forks or vforks, this function will be called at
- the next resume in order to perform any bookkeeping and fiddling
- necessary to continue debugging either the parent or child, as
- requested, and releasing the other. Information about the fork
- or vfork event is available via get_last_target_status ().
- This function returns true if the inferior should not be resumed
- (i.e. there is another event pending). */
+/* Call the follow_fork method on the current target stack.
+
+ This function is called when the inferior forks or vforks, to perform any
+ bookkeeping and fiddling necessary to continue debugging either the parent,
+ the child or both. */
+
+void target_follow_fork (inferior *inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_fork);
-bool target_follow_fork (bool follow_child, bool detach_fork);
+/* Handle the target-specific bookkeeping required when the inferior makes an
+ exec call.
-/* Handle the target-specific bookkeeping required when the inferior
- makes an exec call. INF is the exec'd inferior. */
+ The current inferior at the time of the call is the inferior that did the
+ exec. FOLLOW_INF is the inferior in which execution continues post-exec.
+ If "follow-exec-mode" is "same", FOLLOW_INF is the same as the current
+ inferior, meaning that execution continues with the same inferior. If
+ "follow-exec-mode" is "new", FOLLOW_INF is a different inferior, meaning
+ that execution continues in a new inferior.
-void target_follow_exec (struct inferior *inf, const char *execd_pathname);
+ On exit, the target must leave FOLLOW_INF as the current inferior. */
+
+void target_follow_exec (inferior *follow_inf, ptid_t ptid,
+ const char *execd_pathname);
/* On some targets, we can catch an inferior exec event when it
occurs. These functions insert/remove an already-created
/* Can the target support asynchronous execution? */
extern bool target_can_async_p ();
+/* An overload of the above that can be called when the target is not yet
+ pushed, this calls TARGET::can_async_p directly. */
+extern bool target_can_async_p (struct target_ops *target);
+
/* Is the target in asynchronous execution mode? */
extern bool target_is_async_p ();
extern const char *target_extra_thread_info (thread_info *tp);
/* 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. */
+ The returned value must not be freed by the caller.
+
+ You likely don't want to call this function, but use the thread_name
+ function instead, which prefers the user-given thread name, if set. */
extern const char *target_thread_name (struct thread_info *);
extern const struct target_desc *target_read_description (struct target_ops *);
-extern ptid_t target_get_ada_task_ptid (long lwp, long tid);
+extern ptid_t target_get_ada_task_ptid (long lwp, ULONGEST tid);
/* Main entry point for searching memory. */
extern int target_search_memory (CORE_ADDR start_addr,
extern gdb::unique_xmalloc_ptr<char> target_fileio_read_stralloc
(struct inferior *inf, const char *filename);
+/* Invalidate the target associated with open handles that were open
+ on target TARG, since we're about to close (and maybe destroy) the
+ target. The handles remain open from the client's perspective, but
+ trying to do anything with them other than closing them will fail
+ with EIO. */
+extern void fileio_handles_invalidate_target (target_ops *targ);
/* Tracepoint-related operations. */
/* See to_enable_btrace in struct target_ops. */
extern struct btrace_target_info *
- target_enable_btrace (ptid_t ptid, const struct btrace_config *);
+ target_enable_btrace (thread_info *tp, const struct btrace_config *);
/* See to_disable_btrace in struct target_ops. */
extern void target_disable_btrace (struct btrace_target_info *btinfo);
projects / binutils-gdb.git / blobdiff