/* Variables that describe the inferior process running under GDB:
Where it is, why it stopped, and how to step it.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#if !defined (INFERIOR_H)
#define INFERIOR_H 1
+#include <exception>
+#include <list>
+
struct target_waitstatus;
struct frame_info;
struct ui_file;
struct ui_out;
struct terminal_info;
struct target_desc_info;
-struct continuation;
struct inferior;
struct thread_info;
#include "symfile-add-flags.h"
#include "gdbsupport/refcounted-object.h"
#include "gdbsupport/forward-scope-exit.h"
+#include "gdbsupport/gdb_unique_ptr.h"
+#include "gdbsupport/intrusive_list.h"
#include "gdbsupport/common-inferior.h"
#include "gdbthread.h"
#include "process-stratum-target.h"
+#include "displaced-stepping.h"
+
+#include <unordered_map>
struct infcall_suspend_state;
struct infcall_control_state;
/* If we are restoring the inferior state due to an exception,
some error message will be printed. So, only warn the user
when we cannot restore during normal execution. */
- if (!std::uncaught_exception ())
+ bool unwinding;
+#if __cpp_lib_uncaught_exceptions
+ unwinding = std::uncaught_exceptions () > 0;
+#else
+ unwinding = std::uncaught_exception ();
+#endif
+ if (!unwinding)
warning (_("Failed to restore inferior state: %s"), e.what ());
}
}
extern void clear_sigint_trap (void);
-/* Set/get file name for default use for standard in/out in the inferior. */
-
-extern void set_inferior_io_terminal (const char *terminal_name);
-extern const char *get_inferior_io_terminal (void);
-
/* Collected pid, tid, etc. of the debugged inferior. When there's
no inferior, inferior_ptid.pid () will be 0. */
STARTUP_INFERIOR. */
extern ptid_t gdb_startup_inferior (pid_t pid, int num_traps);
-extern char *construct_inferior_arguments (int, char **);
-
/* From infcmd.c */
/* Initial inferior setup. Determines the exec file is not yet known,
extern void setup_inferior (int from_tty);
-extern void post_create_inferior (struct target_ops *, int);
+extern void post_create_inferior (int from_tty);
extern void attach_command (const char *, int);
-extern const char *get_inferior_args (void);
-
-extern void set_inferior_args (const char *);
-
extern void set_inferior_args_vector (int, char **);
extern void registers_info (const char *, int);
extern void detach_command (const char *, int);
-extern void notice_new_inferior (struct thread_info *, int, int);
+extern void notice_new_inferior (struct thread_info *, bool, int);
-extern struct value *get_return_value (struct value *function,
- struct type *value_type);
+/* Return the value of the result of a function at the end of a 'finish'
+ command/BP. If the result's value cannot be retrieved, return NULL.
+
+ FUNC_SYMBOL is the symbol of the function being returned from. FUNCTION is
+ a value containing the address of the function. */
+
+extern struct value *get_return_value (struct symbol *func_symbol,
+ struct value *function);
/* Prepare for execution command. TARGET is the target that will run
the command. BACKGROUND determines whether this is a foreground
listed exactly once in the inferior list, so placing an inferior in
the inferior list is an implicit, not counted strong reference. */
-class inferior : public refcounted_object
+class inferior : public refcounted_object,
+ public intrusive_list_node<inferior>
{
public:
explicit inferior (int pid);
void push_target (struct target_ops *t)
{ m_target_stack.push (t); }
+ /* An overload that deletes the target on failure. */
+ void push_target (target_ops_up &&t)
+ {
+ m_target_stack.push (t.get ());
+ t.release ();
+ }
+
/* Unpush T from this inferior's target stack. */
- int unpush_target (struct target_ops *t)
- { return m_target_stack.unpush (t); }
+ int unpush_target (struct target_ops *t);
/* Returns true if T is pushed in this inferior's target stack. */
bool target_is_pushed (target_ops *t)
{ return m_target_stack.at (stratum); }
bool has_execution ()
- { return target_has_execution_1 (this); }
+ { return target_has_execution (this); }
- /* Pointer to next inferior in singly-linked list of inferiors. */
- struct inferior *next = NULL;
+ /* This inferior's thread list, sorted by creation order. */
+ intrusive_list<thread_info> thread_list;
- /* This inferior's thread list. */
- thread_info *thread_list = nullptr;
+ /* A map of ptid_t to thread_info*, for average O(1) ptid_t lookup.
+ Exited threads do not appear in the map. */
+ std::unordered_map<ptid_t, thread_info *, hash_ptid> ptid_thread_map;
/* Returns a range adapter covering the inferior's threads,
including exited threads. Used like this:
{ .... }
*/
inf_threads_range threads ()
- { return inf_threads_range (this->thread_list); }
+ { return inf_threads_range (this->thread_list.begin ()); }
/* Returns a range adapter covering the inferior's non-exited
threads. Used like this:
{ .... }
*/
inf_non_exited_threads_range non_exited_threads ()
- { return inf_non_exited_threads_range (this->thread_list); }
+ { return inf_non_exited_threads_range (this->thread_list.begin ()); }
/* Like inferior::threads(), but returns a range adapter that can be
used with range-for, safely. I.e., it is safe to delete the
delete f;
*/
inline safe_inf_threads_range threads_safe ()
- { return safe_inf_threads_range (this->thread_list); }
+ { return safe_inf_threads_range (this->thread_list.begin ()); }
+
+ /* Delete all threads in the thread list. If SILENT, exit threads
+ silently. */
+ void clear_thread_list (bool silent);
+
+ /* Continuations-related methods. A continuation is an std::function
+ to be called to finish the execution of a command when running
+ GDB asynchronously. A continuation is executed after any thread
+ of this inferior stops. Continuations are used by the attach
+ command and the remote target when a new inferior is detected. */
+ void add_continuation (std::function<void ()> &&cont);
+ void do_all_continuations ();
+
+ /* Set/get file name for default use for standard in/out in the inferior.
+
+ On Unix systems, we try to make TERMINAL_NAME the inferior's controlling
+ terminal.
+
+ If TERMINAL_NAME is the empty string, then the inferior inherits GDB's
+ terminal (or GDBserver's if spawning a remote process). */
+ void set_tty (std::string terminal_name);
+ const std::string &tty ();
+
+ /* Set the argument string to use when running this inferior.
+
+ An empty string can be used to represent "no arguments". */
+ void set_args (std::string args)
+ {
+ m_args = std::move (args);
+ };
+
+ /* Get the argument string to use when running this inferior.
+
+ No arguments is represented by an empty string. */
+ const std::string &args () const
+ {
+ return m_args;
+ }
+
+ /* Set the inferior current working directory.
+
+ If CWD is empty, unset the directory. */
+ void set_cwd (std::string cwd)
+ {
+ m_cwd = std::move (cwd);
+ }
+
+ /* Get the inferior current working directory.
+
+ Return an empty string if the current working directory is not
+ specified. */
+ const std::string &cwd () const
+ {
+ return m_cwd;
+ }
/* Convenient handle (GDB inferior id). Unique across all
inferiors. */
/* The program space bound to this inferior. */
struct program_space *pspace = NULL;
- /* The arguments string to use when running. */
- char *args = NULL;
-
- /* The size of elements in argv. */
- int argc = 0;
-
- /* The vector version of arguments. If ARGC is nonzero,
- then we must compute ARGS from this (via the target).
- This is always coming from main's argv and therefore
- should never be freed. */
- char **argv = NULL;
-
- /* The current working directory that will be used when starting
- this inferior. */
- gdb::unique_xmalloc_ptr<char> cwd;
-
- /* The name of terminal device to use for I/O. */
- char *terminal = NULL;
-
/* The terminal state as set by the last target_terminal::terminal_*
call. */
target_terminal_state terminal_state = target_terminal_state::is_ours;
exits or execs. */
bool pending_detach = false;
- /* True if this inferior is a vfork parent waiting for a vfork child
- not under our control to be done with the shared memory region,
- either by exiting or execing. */
- bool waiting_for_vfork_done = false;
+ /* If non-nullptr, points to a thread that called vfork and is now waiting
+ for a vfork child not under our control to be done with the shared memory
+ region, either by exiting or execing. */
+ thread_info *thread_waiting_for_vfork_done = nullptr;
/* True if we're in the process of detaching from this inferior. */
bool detaching = false;
- /* What is left to do for an execution command after any thread of
- this inferior stops. For continuations associated with a
- specific thread, see `struct thread_info'. */
- continuation *continuations = NULL;
-
/* True if setup_inferior wasn't called for this inferior yet.
Until that is done, we must not access inferior memory or
registers, as we haven't determined the target
architecture/description. */
bool needs_setup = false;
+ /* True when we are reading the library list of the inferior during an
+ attach or handling a fork child. */
+ bool in_initial_library_scan = false;
+
/* Private data used by the target vector implementation. */
std::unique_ptr<private_inferior> priv;
private:
/* The inferior's target stack. */
target_stack m_target_stack;
+
+ /* The name of terminal device to use for I/O. */
+ std::string m_terminal;
+
+ /* The list of continuations. */
+ std::list<std::function<void ()>> m_continuations;
+
+ /* The arguments string to use when running. */
+ std::string m_args;
+
+ /* The current working directory that will be used when starting
+ this inferior. */
+ std::string m_cwd;
};
/* Keep a registry of per-inferior data-pointers required by other GDB
/* Traverse all inferiors. */
-extern struct inferior *inferior_list;
+extern intrusive_list<inferior> inferior_list;
/* Pull in the internals of the inferiors ranges and iterators. Must
be done after struct inferior is defined. */
inline all_inferiors_safe_range
all_inferiors_safe ()
{
- return {};
+ return all_inferiors_safe_range (nullptr, inferior_list);
}
/* Returns a range representing all inferiors, suitable to use with
inline all_inferiors_range
all_inferiors (process_stratum_target *proc_target = nullptr)
{
- return all_inferiors_range (proc_target);
+ return all_inferiors_range (proc_target, inferior_list);
}
/* Return a range that can be used to walk over all inferiors with PID
inline all_non_exited_inferiors_range
all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
{
- return all_non_exited_inferiors_range (proc_target);
+ return all_non_exited_inferiors_range (proc_target, inferior_list);
}
/* Prune away automatically added inferiors that aren't required
/* Print the current selected inferior. */
extern void print_selected_inferior (struct ui_out *uiout);
+/* Switch to inferior NEW_INF, a new inferior, and unless
+ NO_CONNECTION is true, push the process_stratum_target of ORG_INF
+ to NEW_INF. */
+
+extern void switch_to_inferior_and_push_target
+ (inferior *new_inf, bool no_connection, inferior *org_inf);
+
#endif /* !defined (INFERIOR_H) */
projects / binutils-gdb.git / blobdiff