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;
}
{
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.
/* 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 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;
+}
+
+struct thread_info *
+any_live_thread_of_process (int pid)
+{
+ struct thread_info *tp;
+ struct thread_info *tp_running = NULL;
+
+ for (tp = thread_list; tp; tp = tp->next)
+ if (ptid_get_pid (tp->ptid) == pid)
+ {
+ if (tp->state_ == THREAD_STOPPED)
+ return tp;
+ else if (tp->state_ == THREAD_RUNNING)
+ tp_running = tp;
+ }
+
+ return tp_running;
+}
+
/* 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);
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_;
}
}
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)
{
void
switch_to_thread (ptid_t ptid)
{
+ /* Switch the program space as well, if we can infer it from the now
+ current thread. Otherwise, it's up to the caller to select the
+ space it wants. */
+ if (!ptid_equal (ptid, null_ptid))
+ {
+ struct inferior *inf;
+
+ inf = find_inferior_pid (ptid_get_pid (ptid));
+ gdb_assert (inf != NULL);
+ set_current_program_space (inf->pspace);
+ set_current_inferior (inf);
+ }
+
if (ptid_equal (ptid, inferior_ptid))
return;
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);
select_frame (get_current_frame ());
/* Warn the user. */
- if (!ui_out_is_mi_like_p (uiout))
+ if (frame_level > 0 && !ui_out_is_mi_like_p (uiout))
{
warning (_("\
Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
struct frame_id selected_frame_id;
int selected_frame_level;
int was_stopped;
+ int inf_id;
};
static void
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.),
&& find_inferior_pid (ptid_get_pid (tp->ptid)) != NULL)
restore_current_thread (old->inferior_ptid);
else
- restore_current_thread (null_ptid);
+ {
+ restore_current_thread (null_ptid);
+ set_current_inferior (find_inferior_id (old->inf_id));
+ }
/* 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 = xmalloc (sizeof (struct current_thread_cleanup));
old->inferior_ptid = inferior_ptid;
+ old->inf_id = current_inferior ()->num;
if (!ptid_equal (inferior_ptid, null_ptid))
{
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++;
}