/* Multi-process/thread control for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
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;
+/* The current/selected thread. */
+static thread_info *current_thread_;
-static int thread_alive (struct thread_info *);
+/* Returns true if THR is the current thread. */
-/* RAII type used to increase / decrease the refcount of each thread
- in a given list of threads. */
-
-class scoped_inc_dec_ref
+static bool
+is_current_thread (const thread_info *thr)
{
-public:
- explicit scoped_inc_dec_ref (const std::vector<thread_info *> &thrds)
- : m_thrds (thrds)
- {
- for (thread_info *thr : m_thrds)
- thr->incref ();
- }
-
- ~scoped_inc_dec_ref ()
- {
- for (thread_info *thr : m_thrds)
- thr->decref ();
- }
-
-private:
- const std::vector<thread_info *> &m_thrds;
-};
-
+ return thr == current_thread_;
+}
struct thread_info*
inferior_thread (void)
{
- struct thread_info *tp = find_thread_ptid (inferior_ptid);
- gdb_assert (tp);
- return tp;
+ gdb_assert (current_thread_ != nullptr);
+ return current_thread_;
}
/* Delete the breakpoint pointed at by BP_P, if there's one. */
thread_cancel_execution_command (tp);
- clear_inline_frame_state (tp->ptid);
+ clear_inline_frame_state (tp);
}
/* Set the TP's state as exited. */
static void
-set_thread_exited (thread_info *tp, int silent)
+set_thread_exited (thread_info *tp, bool silent)
{
- /* Dead threads don't need to step-over. Remove from queue. */
+ /* Dead threads don't need to step-over. Remove from chain. */
if (tp->step_over_next != NULL)
- thread_step_over_chain_remove (tp);
+ global_thread_step_over_chain_remove (tp);
if (tp->state != THREAD_EXITED)
{
struct thread_info *last;
for (last = inf->thread_list; last->next != NULL; last = last->next)
- ;
+ gdb_assert (ptid != last->ptid
+ || last->state == THREAD_EXITED);
+
+ gdb_assert (ptid != last->ptid
+ || last->state == THREAD_EXITED);
+
last->next = tp;
}
}
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);
+ gdb_assert (targ != nullptr);
- thread_info *tp = find_thread_ptid (inf, 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.
- The OS is reusing this id --- delete it, and recreate a new
- one. */
- {
- /* In addition to deleting the thread, if this is the current
- thread, then we need to take care that delete_thread doesn't
- really delete the thread if it is inferior_ptid. Create a
- new template thread in the list with an invalid ptid, switch
- to it, delete the original thread, reset the new thread's
- ptid, and switch to it. */
-
- if (inferior_ptid == ptid)
- {
- thread_info *new_thr = new_thread (inf, null_ptid);
+ inferior *inf = find_inferior_ptid (targ, ptid);
- /* Make switch_to_thread not read from the thread. */
- new_thr->state = THREAD_EXITED;
- switch_to_no_thread ();
-
- /* Now we can delete it. */
- delete_thread (tp);
-
- /* Now reset its ptid, and reswitch inferior_ptid to it. */
- new_thr->ptid = ptid;
- new_thr->state = THREAD_STOPPED;
- switch_to_thread (new_thr);
-
- gdb::observers::new_thread.notify (new_thr);
-
- /* All done. */
- return new_thr;
- }
- else
- /* Just go ahead and delete it. */
- delete_thread (tp);
- }
+ /* We may have an old thread with the same id in the thread list.
+ If we do, it must be dead, otherwise we wouldn't be adding a new
+ thread with the same id. The OS is reusing this id --- delete
+ the old thread, and create a new one. */
+ thread_info *tp = find_thread_ptid (inf, ptid);
+ if (tp != nullptr)
+ delete_thread (tp);
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;
{
/* 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. */
}
}
-/* Remove TP from step-over chain LIST_P. */
+/* See gdbthread.h. */
-static void
-step_over_chain_remove (struct thread_info **list_p, struct thread_info *tp)
+void
+thread_step_over_chain_remove (thread_info **list_p, thread_info *tp)
{
gdb_assert (tp->step_over_next != NULL);
gdb_assert (tp->step_over_prev != NULL);
/* See gdbthread.h. */
-struct thread_info *
-thread_step_over_chain_next (struct thread_info *tp)
+thread_info *
+thread_step_over_chain_next (thread_info *chain_head, thread_info *tp)
{
- struct thread_info *next = tp->step_over_next;
+ thread_info *next = tp->step_over_next;
- return (next == step_over_queue_head ? NULL : next);
+ return next == chain_head ? NULL : next;
+}
+
+/* See gdbthread.h. */
+
+struct thread_info *
+global_thread_step_over_chain_next (struct thread_info *tp)
+{
+ return thread_step_over_chain_next (global_thread_step_over_chain_head, tp);
}
/* See gdbthread.h. */
/* See gdbthread.h. */
+int
+thread_step_over_chain_length (thread_info *tp)
+{
+ if (tp == nullptr)
+ return 0;
+
+ gdb_assert (thread_is_in_step_over_chain (tp));
+
+ int num = 1;
+
+ for (thread_info *iter = tp->step_over_next;
+ iter != tp;
+ iter = iter->step_over_next)
+ ++num;
+
+ return num;
+}
+
+/* See gdbthread.h. */
+
+void
+global_thread_step_over_chain_enqueue (struct thread_info *tp)
+{
+ infrun_debug_printf ("enqueueing thread %s in global step over chain",
+ target_pid_to_str (tp->ptid).c_str ());
+
+ step_over_chain_enqueue (&global_thread_step_over_chain_head, tp);
+}
+
+/* See gdbthread.h. */
+
void
-thread_step_over_chain_enqueue (struct thread_info *tp)
+global_thread_step_over_chain_enqueue_chain (thread_info *chain_head)
{
- step_over_chain_enqueue (&step_over_queue_head, tp);
+ gdb_assert (chain_head->step_over_next != nullptr);
+ gdb_assert (chain_head->step_over_prev != nullptr);
+
+ if (global_thread_step_over_chain_head == nullptr)
+ global_thread_step_over_chain_head = chain_head;
+ else
+ {
+ thread_info *global_last = global_thread_step_over_chain_head->step_over_prev;
+ thread_info *chain_last = chain_head->step_over_prev;
+
+ chain_last->step_over_next = global_thread_step_over_chain_head;
+ global_last->step_over_next = chain_head;
+ global_thread_step_over_chain_head->step_over_prev = chain_last;
+ chain_head->step_over_prev = global_last;
+ }
}
/* See gdbthread.h. */
void
-thread_step_over_chain_remove (struct thread_info *tp)
+global_thread_step_over_chain_remove (struct thread_info *tp)
{
- step_over_chain_remove (&step_over_queue_head, tp);
+ infrun_debug_printf ("removing thread %s from global step over chain",
+ target_pid_to_str (tp->ptid).c_str ());
+
+ thread_step_over_chain_remove (&global_thread_step_over_chain_head, tp);
}
/* Delete the thread referenced by THR. If SILENT, don't notify
delete tp;
}
-/* Delete thread THREAD and notify of thread exit. If this is the
- current thread, don't actually delete it, but tag it as exited and
- do the notification. If this is the user selected thread, clear
- it. */
+/* See gdbthread.h. */
void
delete_thread (thread_info *thread)
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);
struct thread_info *
find_thread_ptid (inferior *inf, ptid_t ptid)
{
- for (thread_info *tp : inf->threads ())
+ gdb_assert (inf != nullptr);
+
+ for (thread_info *tp : inf->non_exited_threads ())
if (tp->ptid == ptid)
return tp;
}
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. */
{
gdb_assert (inf->pid != 0);
- /* Prefer the current thread. */
- if (inf == current_inferior ())
+ /* Prefer the current thread, if there's one. */
+ if (inf == current_inferior () && inferior_ptid != null_ptid)
return inferior_thread ();
for (thread_info *tp : inf->non_exited_threads ())
}
/* 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);
tp->ptid = new_ptid;
- gdb::observers::thread_ptid_changed.notify (old_ptid, new_ptid);
+ gdb::observers::thread_ptid_changed.notify (targ, old_ptid, new_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;
}
/* Helper for set_running, that marks one thread either running or
stopped. */
-static int
-set_running_thread (struct thread_info *tp, int running)
+static bool
+set_running_thread (struct thread_info *tp, bool running)
{
- int started = 0;
+ bool started = false;
if (running && tp->state == THREAD_STOPPED)
- started = 1;
+ started = true;
tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
if (!running)
the step-over queue, so that we don't try to resume
it until the user wants it to. */
if (tp->step_over_next != NULL)
- thread_step_over_chain_remove (tp);
+ global_thread_step_over_chain_remove (tp);
}
return started;
}
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 ())
{
if (show_global_ids || uiout->is_mi_like_p ())
uiout->field_signed ("id", tp->global_num);
+ /* Switch to the thread (and inferior / target). */
+ switch_to_thread (tp);
+
/* 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
}
else
{
- uiout->field_string ("target-id",
- thread_target_id_str (tp).c_str ());
+ uiout->field_string ("target-id", thread_target_id_str (tp));
}
if (tp->state == THREAD_RUNNING)
uiout->text ("(running)\n");
else
{
- /* The switch below puts us at the top of the stack (leaf
+ /* The switch above put 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 (),
set_current_program_space (inf->pspace);
set_current_inferior (inf);
- inferior_ptid = thread->ptid;
+ current_thread_ = thread;
+ inferior_ptid = current_thread_->ptid;
}
/* See gdbthread.h. */
void
switch_to_no_thread ()
{
- if (inferior_ptid == null_ptid)
+ if (current_thread_ == nullptr)
return;
+ current_thread_ = nullptr;
inferior_ptid = null_ptid;
reinit_frame_cache ();
}
{
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);
}
-static void
-restore_selected_frame (struct frame_id a_frame_id, int frame_level)
-{
- struct frame_info *frame = NULL;
- int count;
-
- /* This means there was no selected frame. */
- if (frame_level == -1)
- {
- select_frame (NULL);
- return;
- }
-
- gdb_assert (frame_level >= 0);
-
- /* Restore by level first, check if the frame id is the same as
- expected. If that fails, try restoring by frame id. If that
- fails, nothing to do, just warn the user. */
-
- count = frame_level;
- frame = find_relative_frame (get_current_frame (), &count);
- if (count == 0
- && frame != NULL
- /* The frame ids must match - either both valid or both outer_frame_id.
- The latter case is not failsafe, but since it's highly unlikely
- the search by level finds the wrong frame, it's 99.9(9)% of
- the time (for all practical purposes) safe. */
- && frame_id_eq (get_frame_id (frame), a_frame_id))
- {
- /* Cool, all is fine. */
- select_frame (frame);
- return;
- }
-
- frame = frame_find_by_id (a_frame_id);
- if (frame != NULL)
- {
- /* Cool, refound it. */
- select_frame (frame);
- return;
- }
-
- /* Nothing else to do, the frame layout really changed. Select the
- innermost stack frame. */
- select_frame (get_current_frame ());
-
- /* Warn the user. */
- if (frame_level > 0 && !current_uiout->is_mi_like_p ())
- {
- warning (_("Couldn't restore frame #%d in "
- "current thread. Bottom (innermost) frame selected:"),
- frame_level);
- /* For MI, we should probably have a notification about
- current frame change. But this error is not very
- likely, so don't bother for now. */
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
- }
-}
+/* See frame.h. */
void
scoped_restore_current_thread::restore ()
in the mean time exited (or killed, detached, etc.), then don't revert
back to it, but instead simply drop back to no thread selected. */
&& m_inf->pid != 0)
- switch_to_thread (m_thread);
+ switch_to_thread (m_thread.get ());
else
- {
- switch_to_no_thread ();
- set_current_inferior (m_inf);
- }
+ switch_to_inferior_no_thread (m_inf.get ());
/* The running state of the originally selected thread may have
changed, so we have to recheck it here. */
if (inferior_ptid != null_ptid
&& m_was_stopped
&& m_thread->state == THREAD_STOPPED
- && target_has_registers
- && target_has_stack
- && target_has_memory)
+ && target_has_registers ()
+ && target_has_stack ()
+ && target_has_memory ())
restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
+
+ set_language (m_lang);
}
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 ();
- m_inf->decref ();
+ restore ();
}
scoped_restore_current_thread::scoped_restore_current_thread ()
{
- m_thread = NULL;
- m_inf = current_inferior ();
+ m_inf = inferior_ref::new_reference (current_inferior ());
+
+ m_lang = current_language->la_language;
if (inferior_ptid != null_ptid)
{
- thread_info *tp = inferior_thread ();
- struct frame_info *frame;
+ m_thread = thread_info_ref::new_reference (inferior_thread ());
- m_was_stopped = tp->state == THREAD_STOPPED;
- if (m_was_stopped
- && target_has_registers
- && target_has_stack
- && target_has_memory)
- {
- /* When processing internal events, there might not be a
- selected frame. If we naively call get_selected_frame
- here, then we can end up reading debuginfo for the
- current frame, but we don't generally need the debuginfo
- at this point. */
- frame = get_selected_frame_if_set ();
- }
- else
- frame = NULL;
-
- m_selected_frame_id = get_frame_id (frame);
- m_selected_frame_level = frame_relative_level (frame);
-
- tp->incref ();
- m_thread = tp;
+ m_was_stopped = m_thread->state == THREAD_STOPPED;
+ save_selected_frame (&m_selected_frame_id, &m_selected_frame_level);
}
-
- m_inf->incref ();
}
/* See gdbthread.h. */
ascending order. */
static bool
-tp_array_compar_ascending (const thread_info *a, const thread_info *b)
+tp_array_compar_ascending (const thread_info_ref &a, const thread_info_ref &b)
{
if (a->inf->num != b->inf->num)
return a->inf->num < b->inf->num;
descending order. */
static bool
-tp_array_compar_descending (const thread_info *a, const thread_info *b)
+tp_array_compar_descending (const thread_info_ref &a, const thread_info_ref &b)
{
if (a->inf->num != b->inf->num)
return a->inf->num > b->inf->num;
return (a->per_inf_num > b->per_inf_num);
}
-/* Switch to thread THR and execute CMD.
+/* Assuming that THR is the current thread, execute CMD.
FLAGS.QUIET controls the printing of the thread information.
- FLAGS.CONT and FLAGS.SILENT control how to handle errors. */
+ FLAGS.CONT and FLAGS.SILENT control how to handle errors. Can throw an
+ exception if !FLAGS.SILENT and !FLAGS.CONT and CMD fails. */
static void
thr_try_catch_cmd (thread_info *thr, const char *cmd, int from_tty,
const qcs_flags &flags)
{
- switch_to_thread (thr);
+ gdb_assert (is_current_thread (thr));
+
+ /* The thread header is computed before running the command since
+ the command can change the inferior, which is not permitted
+ by thread_target_id_str. */
+ std::string thr_header =
+ string_printf (_("\nThread %s (%s):\n"), print_thread_id (thr),
+ thread_target_id_str (thr).c_str ());
+
try
{
std::string cmd_result = execute_command_to_string
if (!flags.silent || cmd_result.length () > 0)
{
if (!flags.quiet)
- printf_filtered (_("\nThread %s (%s):\n"),
- print_thread_id (thr),
- target_pid_to_str (inferior_ptid).c_str ());
+ printf_filtered ("%s", thr_header.c_str ());
printf_filtered ("%s", cmd_result.c_str ());
}
}
if (!flags.silent)
{
if (!flags.quiet)
- printf_filtered (_("\nThread %s (%s):\n"),
- print_thread_id (thr),
- target_pid_to_str (inferior_ptid).c_str ());
+ printf_filtered ("%s", thr_header.c_str ());
if (flags.cont)
printf_filtered ("%s\n", ex.what ());
else
thread, in case the command is one that wipes threads. E.g.,
detach, kill, disconnect, etc., or even normally continuing
over an inferior or thread exit. */
- std::vector<thread_info *> thr_list_cpy;
+ std::vector<thread_info_ref> thr_list_cpy;
thr_list_cpy.reserve (tc);
for (thread_info *tp : all_non_exited_threads ())
- thr_list_cpy.push_back (tp);
+ thr_list_cpy.push_back (thread_info_ref::new_reference (tp));
gdb_assert (thr_list_cpy.size () == tc);
- /* Increment the refcounts, and restore them back on scope
- exit. */
- scoped_inc_dec_ref inc_dec_ref (thr_list_cpy);
-
auto *sorter = (ascending
? tp_array_compar_ascending
: tp_array_compar_descending);
scoped_restore_current_thread restore_thread;
- for (thread_info *thr : thr_list_cpy)
- if (thread_alive (thr))
- thr_try_catch_cmd (thr, cmd, from_tty, flags);
+ for (thread_info_ref &thr : thr_list_cpy)
+ if (switch_to_thread_if_alive (thr.get ()))
+ thr_try_catch_cmd (thr.get (), 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;
if (inferior_ptid == null_ptid)
error (_("No thread selected"));
- if (target_has_stack)
+ if (target_has_stack ())
{
struct thread_info *tp = inferior_thread ();
if (tmp != 0)
error (_("Invalid regexp (%s): %s"), tmp, arg);
+ /* We're going to be switching threads. */
+ scoped_restore_current_thread restore_thread;
+
update_thread_list ();
+
for (thread_info *tp : all_threads ())
{
+ switch_to_inferior_no_thread (tp->inf);
+
if (tp->name != NULL && re_exec (tp->name))
{
printf_filtered (_("Thread %s has name '%s'\n"),
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
exited thread we can now delete. */
- prune_threads ();
+ delete_exited_threads ();
}
/* Print thread and frame switch command response. */
uiout->text ("[Switching to thread ");
uiout->field_string ("new-thread-id", print_thread_id (tp));
uiout->text (" (");
- uiout->text (target_pid_to_str (inferior_ptid).c_str ());
+ uiout->text (target_pid_to_str (inferior_ptid));
uiout->text (")]");
}
}
}
/* 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)
{
- threads_executing = 1;
- break;
+ targ->threads_executing = true;
+ return;
+ }
+
+ for (thread_info *tp : inf->non_exited_threads ())
+ {
+ if (tp->executing)
+ {
+ targ->threads_executing = true;
+ return;
+ }
}
}
}
NULL
};
+void _initialize_thread ();
void
-_initialize_thread (void)
+_initialize_thread ()
{
static struct cmd_list_element *thread_apply_list = NULL;
cmd_list_element *c;
= gdb::option::build_help (_("\
Display currently known threads.\n\
Usage: info threads [OPTION]... [ID]...\n\
+If ID is given, it is a space-separated list of IDs of threads to display.\n\
+Otherwise, all threads are displayed.\n\
\n\
Options:\n\
-%OPTIONS%\
-If ID is given, it is a space-separated list of IDs of threads to display.\n\
-Otherwise, all threads are displayed."),
+%OPTIONS%"),
info_threads_opts);
c = add_info ("threads", info_threads_command, info_threads_help.c_str ());
set_cmd_completer_handle_brkchars (c, info_threads_command_completer);
- add_prefix_cmd ("thread", class_run, thread_command, _("\
+ cmd_list_element *thread_cmd
+ = add_prefix_cmd ("thread", class_run, thread_command, _("\
Use this command to switch between threads.\n\
The new thread ID must be currently known."),
- &thread_cmd_list, "thread ", 1, &cmdlist);
+ &thread_cmd_list, 1, &cmdlist);
+
+ add_com_alias ("t", thread_cmd, class_run, 1);
#define THREAD_APPLY_OPTION_HELP "\
Prints per-inferior thread number and target system's thread id\n\
c = add_prefix_cmd ("apply", class_run, thread_apply_command,
thread_apply_help.c_str (),
- &thread_apply_list, "thread apply ", 1,
+ &thread_apply_list, 1,
&thread_cmd_list);
set_cmd_completer_handle_brkchars (c, thread_apply_command_completer);
Will display thread ids whose name, target ID, or extra info matches REGEXP."),
&thread_cmd_list);
- add_com_alias ("t", "thread", class_run, 1);
-
add_setshow_boolean_cmd ("thread-events", no_class,
&print_thread_events, _("\
Set printing of thread events (such as thread start and exit)."), _("\