#include "tid-parse.h"
#include <algorithm>
#include "common/gdb_optional.h"
+#include "inline-frame.h"
/* Definition of struct thread_info exported to gdbthread.h. */
/* Prototypes for local functions. */
-struct thread_info *thread_list = NULL;
static int highest_thread_num;
/* True if any thread is, or may be executing. We need to track this
btrace_teardown (tp);
thread_cancel_execution_command (tp);
+
+ clear_inline_frame_state (tp->ptid);
}
/* Set the TP's state as exited. */
void
init_thread_list (void)
{
- struct thread_info *tp, *tmp;
-
highest_thread_num = 0;
- ALL_THREADS_SAFE (tp, tmp)
+ for (thread_info *tp : all_threads_safe ())
{
+ inferior *inf = tp->inf;
+
if (tp->deletable ())
delete tp;
else
set_thread_exited (tp, 1);
- }
- thread_list = NULL;
- threads_executing = 0;
+ inf->thread_list = NULL;
+ }
}
/* Allocate a new thread of inferior INF with target id PTID and add
{
thread_info *tp = new thread_info (inf, ptid);
- if (thread_list == NULL)
- thread_list = tp;
+ if (inf->thread_list == NULL)
+ inf->thread_list = tp;
else
{
struct thread_info *last;
- for (last = thread_list; last->next != NULL; last = last->next)
+ for (last = inf->thread_list; last->next != NULL; last = last->next)
;
last->next = tp;
}
struct thread_info *
add_thread_silent (ptid_t ptid)
{
- struct thread_info *tp;
struct inferior *inf = find_inferior_ptid (ptid);
gdb_assert (inf != NULL);
- tp = find_thread_ptid (ptid);
+ 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.
xfree (this->name);
}
+/* See gdbthread.h. */
+
+bool
+thread_info::deletable () const
+{
+ /* 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;
+}
+
/* Add TP to the end of the step-over chain LIST_P. */
static void
tpprev = NULL;
- for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
+ for (tp = thr->inf->thread_list; tp; tpprev = tp, tp = tp->next)
if (tp == thr)
break;
if (tpprev)
tpprev->next = tp->next;
else
- thread_list = tp->next;
+ tp->inf->thread_list = tp->next;
delete tp;
}
struct thread_info *
find_thread_global_id (int global_id)
{
- struct thread_info *tp;
-
- for (tp = thread_list; tp; tp = tp->next)
+ for (thread_info *tp : all_threads ())
if (tp->global_num == global_id)
return tp;
static struct thread_info *
find_thread_id (struct inferior *inf, int thr_num)
{
- struct thread_info *tp;
-
- for (tp = thread_list; tp; tp = tp->next)
- if (tp->inf == inf && tp->per_inf_num == thr_num)
+ for (thread_info *tp : inf->threads ())
+ if (tp->per_inf_num == thr_num)
return tp;
return NULL;
struct thread_info *
find_thread_ptid (ptid_t ptid)
{
- struct thread_info *tp;
+ inferior *inf = find_inferior_ptid (ptid);
+ if (inf == NULL)
+ return NULL;
+ return find_thread_ptid (inf, ptid);
+}
- for (tp = thread_list; tp; tp = tp->next)
+/* See gdbthread.h. */
+
+struct thread_info *
+find_thread_ptid (inferior *inf, ptid_t ptid)
+{
+ for (thread_info *tp : inf->threads ())
if (tp->ptid == ptid)
return tp;
iterate_over_threads (int (*callback) (struct thread_info *, void *),
void *data)
{
- struct thread_info *tp, *next;
-
- for (tp = thread_list; tp; tp = next)
- {
- next = tp->next;
- if ((*callback) (tp, data))
- return tp;
- }
+ for (thread_info *tp : all_threads_safe ())
+ if ((*callback) (tp, data))
+ return tp;
return NULL;
}
+/* See gdbthread.h. */
+
+bool
+any_thread_p ()
+{
+ for (thread_info *tp ATTRIBUTE_UNUSED : all_threads ())
+ return true;
+ return false;
+}
+
int
thread_count (void)
{
- int result = 0;
- struct thread_info *tp;
-
- for (tp = thread_list; tp; tp = tp->next)
- ++result;
-
- return result;
+ auto rng = all_threads ();
+ return std::distance (rng.begin (), rng.end ());
}
/* Return the number of non-exited threads in the thread list. */
static int
live_threads_count (void)
{
- int result = 0;
- struct thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
- ++result;
-
- return result;
+ auto rng = all_non_exited_threads ();
+ return std::distance (rng.begin (), rng.end ());
}
int
valid_global_thread_id (int global_id)
{
- struct thread_info *tp;
-
- for (tp = thread_list; tp; tp = tp->next)
+ for (thread_info *tp : all_threads ())
if (tp->global_num == global_id)
return 1;
int
in_thread_list (ptid_t ptid)
{
- struct thread_info *tp;
-
- for (tp = thread_list; tp; tp = tp->next)
- if (tp->ptid == ptid)
- return 1;
-
- return 0; /* Never heard of 'im. */
+ return find_thread_ptid (ptid) != nullptr;
}
/* Finds the first thread of the inferior. */
thread_info *
first_thread_of_inferior (inferior *inf)
{
- struct thread_info *tp, *ret = NULL;
-
- for (tp = thread_list; tp; tp = tp->next)
- if (tp->inf == inf)
- if (ret == NULL || tp->global_num < ret->global_num)
- ret = tp;
-
- return ret;
+ return inf->thread_list;
}
thread_info *
any_thread_of_inferior (inferior *inf)
{
- struct thread_info *tp;
-
gdb_assert (inf->pid != 0);
/* Prefer the current thread. */
if (inf == current_inferior ())
return inferior_thread ();
- ALL_NON_EXITED_THREADS (tp)
- if (tp->inf == inf)
- return tp;
+ for (thread_info *tp : inf->non_exited_threads ())
+ return tp;
return NULL;
}
any_live_thread_of_inferior (inferior *inf)
{
struct thread_info *curr_tp = NULL;
- struct thread_info *tp;
struct thread_info *tp_executing = NULL;
gdb_assert (inf != NULL && inf->pid != 0);
return curr_tp;
}
- ALL_NON_EXITED_THREADS (tp)
- if (tp->inf == inf)
- {
- if (!tp->executing)
- return tp;
+ for (thread_info *tp : inf->non_exited_threads ())
+ {
+ if (!tp->executing)
+ return tp;
- tp_executing = tp;
- }
+ tp_executing = tp;
+ }
/* If both the current thread and all live threads are executing,
prefer the current thread. */
void
prune_threads (void)
{
- struct thread_info *tp, *tmp;
-
- ALL_THREADS_SAFE (tp, tmp)
- {
- if (!thread_alive (tp))
- delete_thread (tp);
- }
+ for (thread_info *tp : all_threads_safe ())
+ if (!thread_alive (tp))
+ delete_thread (tp);
}
/* See gdbthreads.h. */
void
delete_exited_threads (void)
{
- struct thread_info *tp, *tmp;
-
- ALL_THREADS_SAFE (tp, tmp)
- {
- if (tp->state == THREAD_EXITED)
- delete_thread (tp);
- }
+ for (thread_info *tp : all_threads_safe ())
+ if (tp->state == THREAD_EXITED)
+ delete_thread (tp);
}
/* Return true value if stack temporaies are enabled for the thread
inf = find_inferior_ptid (old_ptid);
inf->pid = new_ptid.pid ();
- tp = find_thread_ptid (old_ptid);
+ tp = find_thread_ptid (inf, old_ptid);
tp->ptid = new_ptid;
gdb::observers::thread_ptid_changed.notify (old_ptid, new_ptid);
void
set_resumed (ptid_t ptid, int resumed)
{
- struct thread_info *tp;
- int all = ptid == minus_one_ptid;
-
- if (all || ptid.is_pid ())
- {
- for (tp = thread_list; tp; tp = tp->next)
- if (all || tp->ptid.pid () == ptid.pid ())
- tp->resumed = resumed;
- }
- else
- {
- tp = find_thread_ptid (ptid);
- gdb_assert (tp != NULL);
- tp->resumed = resumed;
- }
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ tp->resumed = resumed;
}
/* Helper for set_running, that marks one thread either running or
void
set_running (ptid_t ptid, int running)
{
- struct thread_info *tp;
- int all = ptid == minus_one_ptid;
- int any_started = 0;
+ /* We try not to notify the observer if no thread has actually
+ changed the running state -- merely to reduce the number of
+ messages to the MI frontend. A frontend is supposed to handle
+ multiple *running notifications just fine. */
+ bool any_started = false;
- /* We try not to notify the observer if no thread has actually changed
- the running state -- merely to reduce the number of messages to
- frontend. Frontend is supposed to handle multiple *running just fine. */
- if (all || ptid.is_pid ())
- {
- for (tp = thread_list; tp; tp = tp->next)
- if (all || tp->ptid.pid () == ptid.pid ())
- {
- if (tp->state == THREAD_EXITED)
- continue;
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ if (set_running_thread (tp, running))
+ any_started = true;
- if (set_running_thread (tp, running))
- any_started = 1;
- }
- }
- else
- {
- tp = find_thread_ptid (ptid);
- gdb_assert (tp != NULL);
- gdb_assert (tp->state != THREAD_EXITED);
- if (set_running_thread (tp, running))
- any_started = 1;
- }
if (any_started)
gdb::observers::target_resumed.notify (ptid);
}
-static int
-is_thread_state (ptid_t ptid, enum thread_state state)
-{
- struct thread_info *tp;
-
- tp = find_thread_ptid (ptid);
- gdb_assert (tp);
- return tp->state == state;
-}
-
-int
-is_stopped (ptid_t ptid)
-{
- return is_thread_state (ptid, THREAD_STOPPED);
-}
-
-int
-is_exited (ptid_t ptid)
-{
- return is_thread_state (ptid, THREAD_EXITED);
-}
-
-int
-is_running (ptid_t ptid)
-{
- return is_thread_state (ptid, THREAD_RUNNING);
-}
-
-int
-is_executing (ptid_t ptid)
-{
- struct thread_info *tp;
-
- tp = find_thread_ptid (ptid);
- gdb_assert (tp);
- return tp->executing;
-}
/* Helper for set_executing. Set's the thread's 'executing' field
from EXECUTING, and if EXECUTING is true also clears the thread's
void
set_executing (ptid_t ptid, int executing)
{
- struct thread_info *tp;
- int all = ptid == minus_one_ptid;
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ set_executing_thread (tp, executing);
- if (all || ptid.is_pid ())
- {
- for (tp = thread_list; tp; tp = tp->next)
- if (all || tp->ptid.pid () == ptid.pid ())
- set_executing_thread (tp, executing);
- }
- else
- {
- tp = find_thread_ptid (ptid);
- gdb_assert (tp);
- set_executing_thread (tp, executing);
- }
-
- /* It only takes one running thread to spawn more threads.*/
+ /* It only takes one running thread to spawn more threads. */
if (executing)
threads_executing = 1;
/* Only clear the flag if the caller is telling us everything is
void
set_stop_requested (ptid_t ptid, int stop)
{
- struct thread_info *tp;
- int all = ptid == minus_one_ptid;
-
- if (all || ptid.is_pid ())
- {
- for (tp = thread_list; tp; tp = tp->next)
- if (all || tp->ptid.pid () == ptid.pid ())
- tp->stop_requested = stop;
- }
- else
- {
- tp = find_thread_ptid (ptid);
- gdb_assert (tp);
- tp->stop_requested = stop;
- }
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ tp->stop_requested = stop;
/* Call the stop requested observer so other components of GDB can
react to this request. */
void
finish_thread_state (ptid_t ptid)
{
- struct thread_info *tp;
- int all;
- int any_started = 0;
+ bool any_started = false;
- all = ptid == minus_one_ptid;
-
- if (all || ptid.is_pid ())
- {
- for (tp = thread_list; tp; tp = tp->next)
- {
- if (tp->state == THREAD_EXITED)
- continue;
- if (all || ptid.pid () == tp->ptid.pid ())
- {
- if (set_running_thread (tp, tp->executing))
- any_started = 1;
- }
- }
- }
- else
- {
- tp = find_thread_ptid (ptid);
- gdb_assert (tp);
- if (tp->state != THREAD_EXITED)
- {
- if (set_running_thread (tp, tp->executing))
- any_started = 1;
- }
- }
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ if (set_running_thread (tp, tp->executing))
+ any_started = true;
if (any_started)
gdb::observers::target_resumed.notify (ptid);
int global_ids, int pid,
int show_global_ids)
{
- struct thread_info *tp;
- struct inferior *inf;
int default_inf_num = current_inferior ()->num;
update_thread_list ();
accommodate the largest entry. */
size_t target_id_col_width = 17;
- ALL_THREADS (tp)
+ for (thread_info *tp : all_threads ())
{
if (!should_print_thread (requested_threads, default_inf_num,
global_ids, pid, tp))
/* We'll be switching threads temporarily. */
scoped_restore_current_thread restore_thread;
- ALL_THREADS_BY_INFERIOR (inf, tp)
+ for (inferior *inf : all_inferiors ())
+ for (thread_info *tp : inf->threads ())
{
int core;
std::vector<thread_info *> thr_list_cpy;
thr_list_cpy.reserve (tc);
- {
- thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
- {
- thr_list_cpy.push_back (tp);
- }
-
- gdb_assert (thr_list_cpy.size () == tc);
- }
+ for (thread_info *tp : all_non_exited_threads ())
+ thr_list_cpy.push_back (tp);
+ gdb_assert (thr_list_cpy.size () == tc);
/* Increment the refcounts, and restore them back on scope
exit. */
static void
thread_find_command (const char *arg, int from_tty)
{
- struct thread_info *tp;
const char *tmp;
unsigned long match = 0;
error (_("Invalid regexp (%s): %s"), tmp, arg);
update_thread_list ();
- for (tp = thread_list; tp; tp = tp->next)
+ for (thread_info *tp : all_threads ())
{
if (tp->name != NULL && re_exec (tp->name))
{
static void
update_threads_executing (void)
{
- struct thread_info *tp;
-
threads_executing = 0;
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
{
if (tp->executing)
{
projects / deliverable / binutils-gdb.git / blobdiff