THREAD_EXITED,
};
-extern struct thread_info*
+struct thread_info*
inferior_thread (void)
{
- struct thread_info *tp = find_thread_pid (inferior_ptid);
+ struct thread_info *tp = find_thread_ptid (inferior_ptid);
gdb_assert (tp);
return tp;
}
thread_list = NULL;
}
+/* Allocate a new thread with target id PTID and add it to the thread
+ list. */
+
+static struct thread_info *
+new_thread (ptid_t ptid)
+{
+ struct thread_info *tp;
+
+ tp = xcalloc (1, sizeof (*tp));
+
+ tp->ptid = ptid;
+ tp->num = ++highest_thread_num;
+ tp->next = thread_list;
+ thread_list = tp;
+
+ /* Nothing to follow yet. */
+ tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
+ tp->state_ = THREAD_STOPPED;
+
+ return tp;
+}
+
struct thread_info *
add_thread_silent (ptid_t ptid)
{
struct thread_info *tp;
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (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 (ptid_equal (inferior_ptid, ptid))
{
- tp = xmalloc (sizeof (*tp));
- memset (tp, 0, sizeof (*tp));
- tp->ptid = minus_one_ptid;
- tp->num = ++highest_thread_num;
- tp->next = thread_list;
- thread_list = tp;
+ tp = new_thread (ptid);
/* Make switch_to_thread not read from the thread. */
tp->state_ = THREAD_EXITED;
delete_thread (ptid);
}
- tp = (struct thread_info *) xmalloc (sizeof (*tp));
- memset (tp, 0, sizeof (*tp));
- tp->ptid = ptid;
- tp->num = ++highest_thread_num;
- tp->next = thread_list;
- thread_list = tp;
-
+ tp = new_thread (ptid);
observer_notify_new_thread (tp);
return tp;
/* Find a thread_info by matching PTID. */
struct thread_info *
-find_thread_pid (ptid_t ptid)
+find_thread_ptid (ptid_t ptid)
{
struct thread_info *tp;
return 0; /* Never heard of 'im */
}
+/* Finds the first thread of the inferior given by PID. If PID is -1,
+ return the first thread in the list. */
+
+struct thread_info *
+first_thread_of_process (int pid)
+{
+ struct thread_info *tp, *ret = NULL;
+
+ for (tp = thread_list; tp; tp = tp->next)
+ if (pid == -1 || ptid_get_pid (tp->ptid) == pid)
+ if (ret == NULL || tp->num < ret->num)
+ ret = tp;
+
+ return ret;
+}
+
+struct thread_info *
+any_thread_of_process (int pid)
+{
+ struct thread_info *tp;
+
+ for (tp = thread_list; tp; tp = tp->next)
+ if (ptid_get_pid (tp->ptid) == pid)
+ return tp;
+
+ return NULL;
+}
+
/* Print a list of thread ids currently known, and the total number of
threads. To be used from within catch_errors. */
static int
inf = find_inferior_pid (ptid_get_pid (old_ptid));
inf->pid = ptid_get_pid (new_ptid);
- tp = find_thread_pid (old_ptid);
+ tp = find_thread_ptid (old_ptid);
tp->ptid = new_ptid;
observer_notify_thread_ptid_changed (old_ptid, new_ptid);
set_running (ptid_t ptid, int running)
{
struct thread_info *tp;
+ int all = ptid_equal (ptid, minus_one_ptid);
/* 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 (PIDGET (ptid) == -1)
+ if (all || ptid_is_pid (ptid))
{
int any_started = 0;
for (tp = thread_list; tp; tp = tp->next)
- {
- if (tp->state_ == THREAD_EXITED)
- continue;
- if (running && tp->state_ == THREAD_STOPPED)
- any_started = 1;
- tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
- }
+ if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
+ {
+ if (tp->state_ == THREAD_EXITED)
+ continue;
+ if (running && tp->state_ == THREAD_STOPPED)
+ any_started = 1;
+ tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
+ }
if (any_started)
observer_notify_target_resumed (ptid);
}
else
{
int started = 0;
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (ptid);
gdb_assert (tp);
gdb_assert (tp->state_ != THREAD_EXITED);
if (running && tp->state_ == THREAD_STOPPED)
{
struct thread_info *tp;
- if (!target_has_execution)
- return 0;
-
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (ptid);
gdb_assert (tp);
return tp->state_ == state;
}
int
is_stopped (ptid_t ptid)
{
- /* Without execution, this property is always true. */
- if (!target_has_execution)
- return 1;
-
return is_thread_state (ptid, THREAD_STOPPED);
}
int
is_exited (ptid_t ptid)
{
- /* Without execution, this property is always false. */
- if (!target_has_execution)
- return 0;
-
return is_thread_state (ptid, THREAD_EXITED);
}
int
is_running (ptid_t ptid)
{
- /* Without execution, this property is always false. */
- if (!target_has_execution)
- return 0;
-
return is_thread_state (ptid, THREAD_RUNNING);
}
{
struct thread_info *tp;
- if (!target_has_execution)
- return 0;
-
for (tp = thread_list; tp; tp = tp->next)
if (tp->state_ == THREAD_RUNNING)
return 1;
{
struct thread_info *tp;
- if (!target_has_execution)
- return 0;
-
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (ptid);
gdb_assert (tp);
return tp->executing_;
}
set_executing (ptid_t ptid, int executing)
{
struct thread_info *tp;
+ int all = ptid_equal (ptid, minus_one_ptid);
- if (PIDGET (ptid) == -1)
+ if (all || ptid_is_pid (ptid))
{
for (tp = thread_list; tp; tp = tp->next)
- tp->executing_ = executing;
+ if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
+ tp->executing_ = executing;
}
else
{
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (ptid);
gdb_assert (tp);
tp->executing_ = executing;
}
}
else
{
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (ptid);
gdb_assert (tp);
tp->stop_requested = stop;
}
}
else
{
- tp = find_thread_pid (ptid);
+ tp = find_thread_ptid (ptid);
gdb_assert (tp);
if (tp->state_ != THREAD_EXITED)
{
if (!ptid_equal (inferior_ptid, null_ptid)
&& !is_exited (ptid)
&& !is_executing (ptid))
- stop_pc = read_pc ();
+ stop_pc = regcache_read_pc (get_thread_regcache (ptid));
else
stop_pc = ~(CORE_ADDR) 0;
}
frame = find_relative_frame (get_current_frame (), &count);
if (count == 0
&& frame != NULL
- /* Either the frame ids match, of they're both invalid. The
- latter case is not failsafe, but since it's highly unlikely
+ /* 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)
- /* Note: could be better to check every frame_id
- member for equality here. */
- || (!frame_id_p (get_frame_id (frame))
- && !frame_id_p (a_frame_id))))
+ && frame_id_eq (get_frame_id (frame), a_frame_id))
{
/* Cool, all is fine. */
select_frame (frame);
struct thread_info *tp;
struct current_thread_cleanup *old = arg;
- tp = find_thread_pid (old->inferior_ptid);
+ tp = find_thread_ptid (old->inferior_ptid);
/* If the previously selected thread belonged to a process that has
in the mean time been deleted (due to normal exit, detach, etc.),
then don't revert back to it, but instead simply drop back to no
thread selected. */
if (tp
- && is_exited (tp->ptid)
- && find_inferior_pid (ptid_get_pid (tp->ptid)) == NULL)
- restore_current_thread (null_ptid);
- else
+ && find_inferior_pid (ptid_get_pid (tp->ptid)) != NULL)
restore_current_thread (old->inferior_ptid);
+ else
+ restore_current_thread (null_ptid);
/* The running state of the originally selected thread may have
changed, so we have to recheck it here. */
{
struct current_thread_cleanup *old = arg;
struct thread_info *tp;
- tp = find_thread_pid (old->inferior_ptid);
+ tp = find_thread_ptid (old->inferior_ptid);
if (tp)
tp->refcount--;
xfree (old);
old->selected_frame_id = get_frame_id (frame);
old->selected_frame_level = frame_relative_level (frame);
- tp = find_thread_pid (inferior_ptid);
+ tp = find_thread_ptid (inferior_ptid);
if (tp)
tp->refcount++;
}
projects / deliverable / binutils-gdb.git / blobdiff