/* 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 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
+ Free Software Foundation, Inc.
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
THREAD_EXITED,
};
-static enum thread_state main_thread_state = THREAD_STOPPED;
-static int main_thread_executing = 0;
-
extern struct thread_info*
inferior_thread (void)
{
}
bpstat_clear (&tp->stop_bpstat);
+
+ discard_all_intermediate_continuations_thread (tp);
+ discard_all_continuations_thread (tp);
}
static void
struct thread_info *tp, *tpnext;
highest_thread_num = 0;
- main_thread_state = THREAD_STOPPED;
- main_thread_executing = 0;
if (!thread_list)
return;
one. */
{
/* In addition to deleting the thread, if this is the current
- thread, then we need to also get rid of the current infrun
- context, and 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, context
- switch to it, delete the original thread, reset the new
- thread's ptid, and switch to it. */
+ 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 (ptid_equal (inferior_ptid, ptid))
{
tp->num = ++highest_thread_num;
tp->next = thread_list;
thread_list = tp;
- context_switch_to (minus_one_ptid);
+
+ /* Make switch_to_thread not read from the thread. */
+ tp->state_ = THREAD_EXITED;
+ switch_to_thread (minus_one_ptid);
/* Now we can delete it. */
delete_thread (ptid);
- /* Since the context is already set to this new thread,
- reset its ptid, and reswitch inferior_ptid to it. */
+ /* Now reset its ptid, and reswitch inferior_ptid to it. */
tp->ptid = ptid;
+ tp->state_ = THREAD_STOPPED;
switch_to_thread (ptid);
observer_notify_new_thread (tp);
return GDB_RC_OK;
}
-/* Load infrun state for the thread PID. */
-
-void
-load_infrun_state (ptid_t ptid,
- struct continuation **continuations,
- struct continuation **intermediate_continuations)
-{
- struct thread_info *tp;
-
- /* If we can't find the thread, then we're debugging a single threaded
- process. No need to do anything in that case. */
- tp = find_thread_id (pid_to_thread_id (ptid));
- if (tp == NULL)
- return;
-
- /* In all-stop mode, these are global state, while in non-stop mode,
- they are per thread. */
- if (non_stop)
- {
- *continuations = tp->continuations;
- tp->continuations = NULL;
- *intermediate_continuations = tp->intermediate_continuations;
- tp->intermediate_continuations = NULL;
- }
-}
-
-/* Save infrun state for the thread PID. */
-
-void
-save_infrun_state (ptid_t ptid,
- struct continuation *continuations,
- struct continuation *intermediate_continuations)
-{
- struct thread_info *tp;
-
- /* If we can't find the thread, then we're debugging a single-threaded
- process. Nothing to do in that case. */
- tp = find_thread_id (pid_to_thread_id (ptid));
- if (tp == NULL)
- return;
-
- /* In all-stop mode, these are global state, while in non-stop mode,
- they are per thread. */
- if (non_stop)
- {
- tp->continuations = continuations;
- tp->intermediate_continuations = intermediate_continuations;
- }
-}
-
/* Return true if TP is an active thread. */
static int
thread_alive (struct thread_info *tp)
void
thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
{
- struct thread_info * tp = find_thread_pid (old_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_pid (ptid_get_pid (old_ptid));
+ inf->pid = ptid_get_pid (new_ptid);
+
+ tp = find_thread_pid (old_ptid);
tp->ptid = new_ptid;
observer_notify_thread_ptid_changed (old_ptid, new_ptid);
{
struct thread_info *tp;
- if (!thread_list)
- {
- /* This is one of the targets that does not add main
- thread to the thread list. Just use a single
- global flag to indicate that a thread is running.
-
- This problem is unique to ST programs. For MT programs,
- the main thread is always present in the thread list. If it's
- not, the first call to context_switch will mess up GDB internal
- state. */
- if (running
- && main_thread_state != THREAD_RUNNING
- && !suppress_resume_observer)
- observer_notify_target_resumed (ptid);
- main_thread_state = running ? THREAD_RUNNING : THREAD_STOPPED;
- return;
- }
-
/* 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 (!target_has_execution)
return 0;
- if (!thread_list)
- return main_thread_state == state;
-
tp = find_thread_pid (ptid);
gdb_assert (tp);
return tp->state_ == state;
if (!target_has_execution)
return 0;
- if (!thread_list)
- return main_thread_state == THREAD_RUNNING;
-
for (tp = thread_list; tp; tp = tp->next)
if (tp->state_ == THREAD_RUNNING)
return 1;
if (!target_has_execution)
return 0;
- if (!thread_list)
- return main_thread_executing;
-
tp = find_thread_pid (ptid);
gdb_assert (tp);
return tp->executing_;
{
struct thread_info *tp;
- if (!thread_list)
- {
- /* This target does not add the main thread to the thread list.
- Use a global flag to indicate that the thread is
- executing. */
- main_thread_executing = executing;
- return;
- }
-
if (PIDGET (ptid) == -1)
{
for (tp = thread_list; tp; tp = tp->next)
}
}
+void
+set_stop_requested (ptid_t ptid, int stop)
+{
+ struct thread_info *tp;
+ int all = ptid_equal (ptid, minus_one_ptid);
+
+ if (all || ptid_is_pid (ptid))
+ {
+ for (tp = thread_list; tp; tp = tp->next)
+ if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
+ tp->stop_requested = stop;
+ }
+ else
+ {
+ tp = find_thread_pid (ptid);
+ gdb_assert (tp);
+ tp->stop_requested = stop;
+ }
+
+ /* Call the stop requested observer so other components of GDB can
+ react to this request. */
+ if (stop)
+ observer_notify_thread_stop_requested (ptid);
+}
+
/* Prints the list of threads and their details on UIOUT.
This is a version of 'info_thread_command' suitable for
use from MI.
If REQUESTED_THREAD is not -1, it's the GDB id of the thread
that should be printed. Otherwise, all threads are
- printed. */
+ printed.
+ If PID is not -1, only print threads from the process PID.
+ Otherwise, threads from all attached PIDs are printed.
+ If both REQUESTED_THREAD and PID are not -1, then the thread
+ is printed if it belongs to the specified process. Otherwise,
+ an error is raised. */
void
-print_thread_info (struct ui_out *uiout, int requested_thread)
+print_thread_info (struct ui_out *uiout, int requested_thread, int pid)
{
struct thread_info *tp;
ptid_t current_ptid;
if (requested_thread != -1 && tp->num != requested_thread)
continue;
+ if (pid != -1 && PIDGET (tp->ptid) != pid)
+ {
+ if (requested_thread != -1)
+ error (_("Requested thread not found in requested process"));
+ continue;
+ }
+
if (ptid_equal (tp->ptid, current_ptid))
current_thread = tp->num;
ui_out_text (uiout, " ");
ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
- if (tp->state_ != THREAD_EXITED)
+ extra_info = target_extra_thread_info (tp);
+ if (extra_info)
{
- extra_info = target_extra_thread_info (tp);
- if (extra_info)
- {
- ui_out_text (uiout, " (");
- ui_out_field_string (uiout, "details", extra_info);
- ui_out_text (uiout, ")");
- }
- ui_out_text (uiout, " ");
+ ui_out_text (uiout, " (");
+ ui_out_field_string (uiout, "details", extra_info);
+ ui_out_text (uiout, ")");
}
+ ui_out_text (uiout, " ");
if (tp->state_ == THREAD_RUNNING)
ui_out_text (uiout, "(running)\n");
if (ui_out_is_mi_like_p (uiout))
{
char *state = "stopped";
- if (tp->state_ == THREAD_EXITED)
- state = "exited";
- else if (tp->state_ == THREAD_RUNNING)
+ if (tp->state_ == THREAD_RUNNING)
state = "running";
ui_out_field_string (uiout, "state", state);
}
the "info threads" command. */
do_cleanups (old_chain);
- if (requested_thread == -1)
+ if (pid == -1 && requested_thread == -1 )
{
gdb_assert (current_thread != -1
|| !thread_list);
static void
info_threads_command (char *arg, int from_tty)
{
- print_thread_info (uiout, -1);
+ print_thread_info (uiout, -1, -1);
}
/* Switch from one thread to another. */
static void
restore_current_thread (ptid_t ptid)
{
- if (!ptid_equal (ptid, inferior_ptid))
- {
- if (non_stop)
- context_switch_to (ptid);
- else
- switch_to_thread (ptid);
- }
+ switch_to_thread (ptid);
}
static void
for (tp = thread_list; tp; tp = tp->next)
if (thread_alive (tp))
{
- if (non_stop)
- context_switch_to (tp->ptid);
- else
- switch_to_thread (tp->ptid);
+ switch_to_thread (tp->ptid);
printf_filtered (_("\nThread %d (%s):\n"),
tp->num, target_tid_to_str (inferior_ptid));
warning (_("Thread %d has terminated."), start);
else
{
- if (non_stop)
- context_switch_to (tp->ptid);
- else
- switch_to_thread (tp->ptid);
+ switch_to_thread (tp->ptid);
printf_filtered (_("\nThread %d (%s):\n"), tp->num,
target_tid_to_str (inferior_ptid));
if (!thread_alive (tp))
error (_("Thread ID %d has terminated."), num);
- if (non_stop)
- context_switch_to (tp->ptid);
- else
- switch_to_thread (tp->ptid);
+ switch_to_thread (tp->ptid);
ui_out_text (uiout, "[Switching to thread ");
ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
projects / deliverable / binutils-gdb.git / blobdiff