#include "gdbsupport/common-inferior.h"
#include "gdbthread.h"
+#include "thread-map.h"
+
+#include "process-stratum-target.h"
struct infcall_suspend_state;
struct infcall_control_state;
extern void continue_1 (int all_threads);
-extern void interrupt_target_1 (int all_threads);
+extern void interrupt_target_1 (bool all_threads);
using delete_longjmp_breakpoint_cleanup
= FORWARD_SCOPE_EXIT (delete_longjmp_breakpoint);
extern void set_current_inferior (inferior *);
+/* Switch inferior (and program space) to INF, and switch to no thread
+ selected. */
+extern void switch_to_inferior_no_thread (inferior *inf);
+
/* GDB represents the state of each program execution with an object
called an inferior. An inferior typically corresponds to a process
but is more general and applies also to targets that do not have a
/* Returns true if we can delete this inferior. */
bool deletable () const { return refcount () == 0; }
+ /* Push T in this inferior's target stack. */
+ void push_target (struct target_ops *t)
+ { m_target_stack.push (t); }
+
+ /* Unpush T from this inferior's target stack. */
+ int unpush_target (struct target_ops *t)
+ { return m_target_stack.unpush (t); }
+
+ /* Returns true if T is pushed in this inferior's target stack. */
+ bool target_is_pushed (target_ops *t)
+ { return m_target_stack.is_pushed (t); }
+
+ /* Find the target beneath T in this inferior's target stack. */
+ target_ops *find_target_beneath (const target_ops *t)
+ { return m_target_stack.find_beneath (t); }
+
+ /* Return the target at the top of this inferior's target stack. */
+ target_ops *top_target ()
+ { return m_target_stack.top (); }
+
+ /* Return the target at process_stratum level in this inferior's
+ target stack. */
+ struct process_stratum_target *process_target ()
+ { return (process_stratum_target *) m_target_stack.at (process_stratum); }
+
+ /* Return the target at STRATUM in this inferior's target stack. */
+ target_ops *target_at (enum strata stratum)
+ { return m_target_stack.at (stratum); }
+
+ bool has_execution ()
+ { return target_has_execution_1 (this); }
+
/* Pointer to next inferior in singly-linked list of inferiors. */
struct inferior *next = NULL;
/* This inferior's thread list. */
- thread_info *thread_list = nullptr;
+ ptid_thread_map thread_map;
/* Returns a range adapter covering the inferior's threads,
including exited threads. Used like this:
for (thread_info *thr : inf->threads ())
{ .... }
*/
- inf_threads_range threads ()
- { return inf_threads_range (this->thread_list); }
+ all_thread_map_range threads ()
+ { return all_thread_map_range (this->thread_map); }
/* Returns a range adapter covering the inferior's non-exited
threads. Used like this:
for (thread_info *thr : inf->non_exited_threads ())
{ .... }
*/
- inf_non_exited_threads_range non_exited_threads ()
- { return inf_non_exited_threads_range (this->thread_list); }
-
- /* Like inferior::threads(), but returns a range adapter that can be
- used with range-for, safely. I.e., it is safe to delete the
- currently-iterated thread, like this:
-
- for (thread_info *t : inf->threads_safe ())
- if (some_condition ())
- delete f;
- */
- inline safe_inf_threads_range threads_safe ()
- { return safe_inf_threads_range (this->thread_list); }
+ non_exited_thread_map_range non_exited_threads ()
+ { return non_exited_thread_map_range (this->thread_map); }
/* Convenient handle (GDB inferior id). Unique across all
inferiors. */
/* Per inferior data-pointers required by other GDB modules. */
REGISTRY_FIELDS;
+
+private:
+ /* The inferior's target stack. */
+ target_stack m_target_stack;
};
/* Keep a registry of per-inferior data-pointers required by other GDB
extern void inferior_appeared (struct inferior *inf, int pid);
-/* Get rid of all inferiors. */
-extern void discard_all_inferiors (void);
-
-/* Search function to lookup an inferior by target 'pid'. */
-extern struct inferior *find_inferior_pid (int pid);
+/* Search function to lookup an inferior of TARG by target 'pid'. */
+extern struct inferior *find_inferior_pid (process_stratum_target *targ,
+ int pid);
-/* Search function to lookup an inferior whose pid is equal to 'ptid.pid'. */
-extern struct inferior *find_inferior_ptid (ptid_t ptid);
+/* Search function to lookup an inferior of TARG whose pid is equal to
+ 'ptid.pid'. */
+extern struct inferior *find_inferior_ptid (process_stratum_target *targ,
+ ptid_t ptid);
/* Search function to lookup an inferior by GDB 'num'. */
extern struct inferior *find_inferior_id (int num);
/* Returns true if the inferior list is not empty. */
extern int have_inferiors (void);
-/* Returns the number of live inferiors (real live processes). */
-extern int number_of_live_inferiors (void);
+/* Returns the number of live inferiors running on PROC_TARGET (real
+ live processes with execution). */
+extern int number_of_live_inferiors (process_stratum_target *proc_target);
/* Returns true if there are any live inferiors in the inferior list
(not cores, not executables, real live processes). */
*/
inline all_inferiors_range
-all_inferiors ()
+all_inferiors (process_stratum_target *proc_target = nullptr)
{
- return {};
+ return all_inferiors_range (proc_target);
}
/* Return a range that can be used to walk over all inferiors with PID
not zero, with range-for. */
inline all_non_exited_inferiors_range
-all_non_exited_inferiors ()
+all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
{
- return {};
+ return all_non_exited_inferiors_range (proc_target);
}
/* Prune away automatically added inferiors that aren't required
projects / deliverable / binutils-gdb.git / blobdiff