static int highest_thread_num;
-/* True if any thread is, or may be executing. We need to track this
- separately because until we fully sync the thread list, we won't
- know whether the target is fully stopped, even if we see stop
- events for all known threads, because any of those threads may have
- spawned new threads we haven't heard of yet. */
-static int threads_executing;
-
-static int thread_alive (struct thread_info *);
-
/* RAII type used to increase / decrease the refcount of each thread
in a given list of threads. */
struct thread_info*
inferior_thread (void)
{
- struct thread_info *tp = find_thread_ptid (inferior_ptid);
+ struct thread_info *tp = find_thread_ptid (current_inferior (), inferior_ptid);
gdb_assert (tp);
return tp;
}
thread_cancel_execution_command (tp);
- clear_inline_frame_state (tp->ptid);
+ clear_inline_frame_state (tp);
}
/* Set the TP's state as exited. */
}
struct thread_info *
-add_thread_silent (ptid_t ptid)
+add_thread_silent (process_stratum_target *targ, ptid_t ptid)
{
- struct inferior *inf = find_inferior_ptid (ptid);
- gdb_assert (inf != NULL);
+ inferior *inf;
- thread_info *tp = find_thread_ptid (inf, ptid);
+ thread_info *tp = find_thread_ptid (targ, ptid);
if (tp)
/* Found an old thread with the same id. It has to be dead,
otherwise we wouldn't be adding a new thread with the same id.
if (inferior_ptid == ptid)
{
- thread_info *new_thr = new_thread (inf, null_ptid);
+ thread_info *new_thr = new_thread (tp->inf, null_ptid);
/* Make switch_to_thread not read from the thread. */
new_thr->state = THREAD_EXITED;
/* All done. */
return new_thr;
}
- else
- /* Just go ahead and delete it. */
- delete_thread (tp);
+
+ inf = tp->inf;
+
+ /* Just go ahead and delete it. */
+ delete_thread (tp);
}
+ else
+ inf = find_inferior_ptid (targ, ptid);
tp = new_thread (inf, ptid);
gdb::observers::new_thread.notify (tp);
}
struct thread_info *
-add_thread_with_info (ptid_t ptid, private_thread_info *priv)
+add_thread_with_info (process_stratum_target *targ, ptid_t ptid,
+ private_thread_info *priv)
{
- struct thread_info *result = add_thread_silent (ptid);
+ thread_info *result = add_thread_silent (targ, ptid);
result->priv.reset (priv);
}
struct thread_info *
-add_thread (ptid_t ptid)
+add_thread (process_stratum_target *targ, ptid_t ptid)
{
- return add_thread_with_info (ptid, NULL);
+ return add_thread_with_info (targ, ptid, NULL);
}
private_thread_info::~private_thread_info () = default;
xfree (this->name);
}
+/* Returns true if THR is the current thread. */
+
+static bool
+is_current_thread (const thread_info *thr)
+{
+ return thr->inf == current_inferior () && thr->ptid == inferior_ptid;
+}
+
/* See gdbthread.h. */
bool
{
/* If this is the current thread, or there's code out there that
relies on it existing (refcount > 0) we can't delete yet. */
- return refcount () == 0 && ptid != inferior_ptid;
+ return refcount () == 0 && !is_current_thread (this);
}
/* Add TP to the end of the step-over chain LIST_P. */
return NULL;
}
-/* Find a thread_info by matching PTID. */
+/* See gdbthread.h. */
struct thread_info *
-find_thread_ptid (ptid_t ptid)
+find_thread_ptid (process_stratum_target *targ, ptid_t ptid)
{
- inferior *inf = find_inferior_ptid (ptid);
+ inferior *inf = find_inferior_ptid (targ, ptid);
if (inf == NULL)
return NULL;
return find_thread_ptid (inf, ptid);
}
int
-thread_count (void)
+thread_count (process_stratum_target *proc_target)
{
- auto rng = all_threads ();
+ auto rng = all_threads (proc_target);
return std::distance (rng.begin (), rng.end ());
}
return 0;
}
-int
-in_thread_list (ptid_t ptid)
+bool
+in_thread_list (process_stratum_target *targ, ptid_t ptid)
{
- return find_thread_ptid (ptid) != nullptr;
+ return find_thread_ptid (targ, ptid) != nullptr;
}
/* Finds the first thread of the inferior. */
}
/* Return true if TP is an active thread. */
-static int
-thread_alive (struct thread_info *tp)
+static bool
+thread_alive (thread_info *tp)
{
if (tp->state == THREAD_EXITED)
- return 0;
- if (!target_thread_alive (tp->ptid))
- return 0;
- return 1;
+ return false;
+
+ /* Ensure we're looking at the right target stack. */
+ gdb_assert (tp->inf == current_inferior ());
+
+ return target_thread_alive (tp->ptid);
+}
+
+/* Switch to thread TP if it is alive. Returns true if successfully
+ switched, false otherwise. */
+
+static bool
+switch_to_thread_if_alive (thread_info *thr)
+{
+ scoped_restore_current_thread restore_thread;
+
+ /* Switch inferior first, so that we're looking at the right target
+ stack. */
+ switch_to_inferior_no_thread (thr->inf);
+
+ if (thread_alive (thr))
+ {
+ switch_to_thread (thr);
+ restore_thread.dont_restore ();
+ return true;
+ }
+
+ return false;
}
/* See gdbthreads.h. */
void
prune_threads (void)
{
+ scoped_restore_current_thread restore_thread;
+
for (thread_info *tp : all_threads_safe ())
- if (!thread_alive (tp))
- delete_thread (tp);
+ {
+ switch_to_inferior_no_thread (tp->inf);
+
+ if (!thread_alive (tp))
+ delete_thread (tp);
+ }
}
/* See gdbthreads.h. */
}
void
-thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
+thread_change_ptid (process_stratum_target *targ,
+ ptid_t old_ptid, ptid_t new_ptid)
{
struct inferior *inf;
struct thread_info *tp;
/* It can happen that what we knew as the target inferior id
changes. E.g, target remote may only discover the remote process
pid after adding the inferior to GDB's list. */
- inf = find_inferior_ptid (old_ptid);
+ inf = find_inferior_ptid (targ, old_ptid);
inf->pid = new_ptid.pid ();
tp = find_thread_ptid (inf, old_ptid);
/* See gdbthread.h. */
void
-set_resumed (ptid_t ptid, int resumed)
+set_resumed (process_stratum_target *targ, ptid_t ptid, bool resumed)
{
- for (thread_info *tp : all_non_exited_threads (ptid))
+ for (thread_info *tp : all_non_exited_threads (targ, ptid))
tp->resumed = resumed;
}
}
void
-set_running (ptid_t ptid, int running)
+set_running (process_stratum_target *targ, ptid_t ptid, bool running)
{
/* We try not to notify the observer if no thread has actually
changed the running state -- merely to reduce the number of
multiple *running notifications just fine. */
bool any_started = false;
- for (thread_info *tp : all_non_exited_threads (ptid))
+ for (thread_info *tp : all_non_exited_threads (targ, ptid))
if (set_running_thread (tp, running))
any_started = true;
}
void
-set_executing (ptid_t ptid, int executing)
+set_executing (process_stratum_target *targ, ptid_t ptid, bool executing)
{
- for (thread_info *tp : all_non_exited_threads (ptid))
+ for (thread_info *tp : all_non_exited_threads (targ, ptid))
set_executing_thread (tp, executing);
/* It only takes one running thread to spawn more threads. */
if (executing)
- threads_executing = 1;
+ targ->threads_executing = true;
/* Only clear the flag if the caller is telling us everything is
stopped. */
else if (minus_one_ptid == ptid)
- threads_executing = 0;
+ targ->threads_executing = false;
}
/* See gdbthread.h. */
-int
-threads_are_executing (void)
+bool
+threads_are_executing (process_stratum_target *target)
{
- return threads_executing;
+ return target->threads_executing;
}
void
-set_stop_requested (ptid_t ptid, int stop)
+set_stop_requested (process_stratum_target *targ, ptid_t ptid, bool stop)
{
- for (thread_info *tp : all_non_exited_threads (ptid))
+ for (thread_info *tp : all_non_exited_threads (targ, ptid))
tp->stop_requested = stop;
/* Call the stop requested observer so other components of GDB can
}
void
-finish_thread_state (ptid_t ptid)
+finish_thread_state (process_stratum_target *targ, ptid_t ptid)
{
bool any_started = false;
- for (thread_info *tp : all_non_exited_threads (ptid))
+ for (thread_info *tp : all_non_exited_threads (targ, ptid))
if (set_running_thread (tp, tp->executing))
any_started = true;
gdb::optional<ui_out_emit_list> list_emitter;
gdb::optional<ui_out_emit_table> table_emitter;
+ /* We'll be switching threads temporarily below. */
+ scoped_restore_current_thread restore_thread;
+
if (uiout->is_mi_like_p ())
list_emitter.emplace (uiout, "threads");
else
if (!uiout->is_mi_like_p ())
{
+ /* Switch inferiors so we're looking at the right
+ target stack. */
+ switch_to_inferior_no_thread (tp->inf);
+
target_id_col_width
= std::max (target_id_col_width,
thread_target_id_str (tp).size ());
uiout->table_body ();
}
- /* We'll be switching threads temporarily. */
- scoped_restore_current_thread restore_thread;
-
for (inferior *inf : all_inferiors ())
for (thread_info *tp : inf->threads ())
- {
- int core;
+ {
+ int core;
- any_thread = true;
- if (tp == current_thread && tp->state == THREAD_EXITED)
- current_exited = true;
+ any_thread = true;
+ if (tp == current_thread && tp->state == THREAD_EXITED)
+ current_exited = true;
- if (!should_print_thread (requested_threads, default_inf_num,
- global_ids, pid, tp))
- continue;
+ if (!should_print_thread (requested_threads, default_inf_num,
+ global_ids, pid, tp))
+ continue;
- ui_out_emit_tuple tuple_emitter (uiout, NULL);
+ ui_out_emit_tuple tuple_emitter (uiout, NULL);
- if (!uiout->is_mi_like_p ())
- {
- if (tp == current_thread)
- uiout->field_string ("current", "*");
- else
- uiout->field_skip ("current");
+ if (!uiout->is_mi_like_p ())
+ {
+ if (tp == current_thread)
+ uiout->field_string ("current", "*");
+ else
+ uiout->field_skip ("current");
- uiout->field_string ("id-in-tg", print_thread_id (tp));
- }
+ uiout->field_string ("id-in-tg", print_thread_id (tp));
+ }
- if (show_global_ids || uiout->is_mi_like_p ())
- uiout->field_signed ("id", tp->global_num);
+ if (show_global_ids || uiout->is_mi_like_p ())
+ uiout->field_signed ("id", tp->global_num);
- /* For the CLI, we stuff everything into the target-id field.
- This is a gross hack to make the output come out looking
- correct. The underlying problem here is that ui-out has no
- way to specify that a field's space allocation should be
- shared by several fields. For MI, we do the right thing
- instead. */
+ /* Switch to the thread (and inferior / target). */
+ switch_to_thread (tp);
- if (uiout->is_mi_like_p ())
- {
- uiout->field_string ("target-id", target_pid_to_str (tp->ptid));
+ /* For the CLI, we stuff everything into the target-id field.
+ This is a gross hack to make the output come out looking
+ correct. The underlying problem here is that ui-out has no
+ way to specify that a field's space allocation should be
+ shared by several fields. For MI, we do the right thing
+ instead. */
- const char *extra_info = target_extra_thread_info (tp);
- if (extra_info != nullptr)
- uiout->field_string ("details", extra_info);
+ if (uiout->is_mi_like_p ())
+ {
+ uiout->field_string ("target-id", target_pid_to_str (tp->ptid));
- const char *name = (tp->name != nullptr
- ? tp->name
- : target_thread_name (tp));
- if (name != NULL)
- uiout->field_string ("name", name);
- }
- else
- {
- uiout->field_string ("target-id",
- thread_target_id_str (tp).c_str ());
- }
+ const char *extra_info = target_extra_thread_info (tp);
+ if (extra_info != nullptr)
+ uiout->field_string ("details", extra_info);
- if (tp->state == THREAD_RUNNING)
- uiout->text ("(running)\n");
- else
- {
- /* The switch below puts us at the top of the stack (leaf
- frame). */
- switch_to_thread (tp);
- print_stack_frame (get_selected_frame (NULL),
- /* For MI output, print frame level. */
- uiout->is_mi_like_p (),
- LOCATION, 0);
- }
+ const char *name = (tp->name != nullptr
+ ? tp->name
+ : target_thread_name (tp));
+ if (name != NULL)
+ uiout->field_string ("name", name);
+ }
+ else
+ {
+ uiout->field_string ("target-id",
+ thread_target_id_str (tp).c_str ());
+ }
- if (uiout->is_mi_like_p ())
- {
- const char *state = "stopped";
+ if (tp->state == THREAD_RUNNING)
+ uiout->text ("(running)\n");
+ else
+ {
+ /* The switch above put us at the top of the stack (leaf
+ frame). */
+ print_stack_frame (get_selected_frame (NULL),
+ /* For MI output, print frame level. */
+ uiout->is_mi_like_p (),
+ LOCATION, 0);
+ }
- if (tp->state == THREAD_RUNNING)
- state = "running";
- uiout->field_string ("state", state);
- }
+ if (uiout->is_mi_like_p ())
+ {
+ const char *state = "stopped";
- core = target_core_of_thread (tp->ptid);
- if (uiout->is_mi_like_p () && core != -1)
- uiout->field_signed ("core", core);
- }
+ if (tp->state == THREAD_RUNNING)
+ state = "running";
+ uiout->field_string ("state", state);
+ }
+
+ core = target_core_of_thread (tp->ptid);
+ if (uiout->is_mi_like_p () && core != -1)
+ uiout->field_signed ("core", core);
+ }
/* This end scope restores the current thread and the frame
selected before the "info threads" command, and it finishes the
{
gdb_assert (thr != NULL);
- if (inferior_ptid == thr->ptid)
+ if (is_current_thread (thr))
return;
switch_to_thread_no_regs (thr);
/* See gdbsupport/common-gdbthread.h. */
void
-switch_to_thread (ptid_t ptid)
+switch_to_thread (process_stratum_target *proc_target, ptid_t ptid)
{
- thread_info *thr = find_thread_ptid (ptid);
+ thread_info *thr = find_thread_ptid (proc_target, ptid);
switch_to_thread (thr);
}
}
}
-scoped_restore_current_thread::~scoped_restore_current_thread ()
+void
+scoped_restore_current_thread::restore ()
{
/* If an entry of thread_info was previously selected, it won't be
deleted because we've increased its refcount. The thread represented
&& target_has_stack
&& target_has_memory)
restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
+}
+
+scoped_restore_current_thread::~scoped_restore_current_thread ()
+{
+ if (!m_dont_restore)
+ {
+ try
+ {
+ restore ();
+ }
+ catch (const gdb_exception &ex)
+ {
+ /* We're in a dtor, there's really nothing else we can do
+ but swallow the exception. */
+ }
+ }
if (m_thread != NULL)
m_thread->decref ();
scoped_restore_current_thread restore_thread;
for (thread_info *thr : thr_list_cpy)
- if (thread_alive (thr))
+ if (switch_to_thread_if_alive (thr))
thr_try_catch_cmd (thr, cmd, from_tty, flags);
}
}
continue;
}
- if (!thread_alive (tp))
+ if (!switch_to_thread_if_alive (tp))
{
warning (_("Thread %s has terminated."), print_thread_id (tp));
continue;
void
thread_select (const char *tidstr, thread_info *tp)
{
- if (!thread_alive (tp))
+ if (!switch_to_thread_if_alive (tp))
error (_("Thread ID %s has terminated."), tidstr);
- switch_to_thread (tp);
-
annotate_thread_changed ();
/* Since the current thread may have changed, see if there is any
}
/* Update the 'threads_executing' global based on the threads we know
- about right now. */
+ about right now. This is used by infrun to tell whether we should
+ pull events out of the current target. */
static void
update_threads_executing (void)
{
- threads_executing = 0;
- for (thread_info *tp : all_non_exited_threads ())
+ process_stratum_target *targ = current_inferior ()->process_target ();
+
+ if (targ == NULL)
+ return;
+
+ targ->threads_executing = false;
+
+ for (inferior *inf : all_non_exited_inferiors (targ))
{
- if (tp->executing)
+ if (!inf->has_execution ())
+ continue;
+
+ /* If the process has no threads, then it must be we have a
+ process-exit event pending. */
+ if (inf->thread_list == NULL)
+ {
+ targ->threads_executing = true;
+ return;
+ }
+
+ for (thread_info *tp : inf->non_exited_threads ())
{
- threads_executing = 1;
- break;
+ if (tp->executing)
+ {
+ targ->threads_executing = true;
+ return;
+ }
}
}
}
projects / deliverable / binutils-gdb.git / blobdiff