/* Multi-process/thread control for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
+ 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
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;
}
{
clear_thread_inferior_resources (tp);
- /* FIXME: do I ever need to call the back-end to give it a
- chance at this private data before deleting the thread? */
if (tp->private)
- xfree (tp->private);
+ {
+ if (tp->private_dtor)
+ tp->private_dtor (tp->private);
+ else
+ xfree (tp->private);
+ }
xfree (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;
{
if (tp->state_ != THREAD_EXITED)
{
- if (!silent)
- observer_notify_thread_exit (tp);
+ observer_notify_thread_exit (tp, silent);
/* Tag it as exited. */
tp->state_ = THREAD_EXITED;
thread_list = tp->next;
/* Notify thread exit, but only if we haven't already. */
- if (!silent && tp->state_ != THREAD_EXITED)
- observer_notify_thread_exit (tp);
+ if (tp->state_ != THREAD_EXITED)
+ observer_notify_thread_exit (tp, silent);
free_thread (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;
thread_id_to_pid (int num)
{
struct thread_info *thread = find_thread_id (num);
+
if (thread)
return thread->ptid;
else
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;
+}
+
+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
struct cleanup *cleanup_chain;
int current_thread = -1;
- prune_threads ();
- target_find_new_threads ();
+ update_thread_list ();
cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
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)
{
char *extra_info;
int current_thread = -1;
- prune_threads ();
- target_find_new_threads ();
+ update_thread_list ();
current_ptid = inferior_ptid;
/* We'll be switching threads temporarily. */
for (tp = thread_list; tp; tp = tp->next)
{
struct cleanup *chain2;
+ int core;
if (requested_thread != -1 && tp->num != requested_thread)
continue;
if (ui_out_is_mi_like_p (uiout))
{
char *state = "stopped";
+
if (tp->state_ == THREAD_RUNNING)
state = "running";
ui_out_field_string (uiout, "state", state);
}
+ core = target_core_of_thread (tp->ptid);
+ if (ui_out_is_mi_like_p (uiout) && core != -1)
+ ui_out_field_int (uiout, "core", core);
+
do_cleanups (chain2);
}
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;
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);
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.),
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);
+ 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++;
}
if (cmd == NULL || *cmd == '\000')
error (_("Please specify a command following the thread ID list"));
- prune_threads ();
- target_find_new_threads ();
+ update_thread_list ();
old_chain = make_cleanup_restore_current_thread ();
return GDB_RC_OK;
}
+void
+update_thread_list (void)
+{
+ prune_threads ();
+ target_find_new_threads ();
+}
+
/* Commands with a prefix of `thread'. */
struct cmd_list_element *thread_cmd_list = NULL;