/* 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*
+struct thread_info*
inferior_thread (void)
{
struct thread_info *tp = find_thread_pid (inferior_ptid);
}
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);
{
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);
}
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;
+}
+
/* Print a list of thread ids currently known, and the total number of
threads. To be used from within catch_errors. */
static int
struct thread_info *tp;
int num = 0;
struct cleanup *cleanup_chain;
+ int current_thread = -1;
prune_threads ();
target_find_new_threads ();
{
if (tp->state_ == THREAD_EXITED)
continue;
+
+ if (ptid_equal (tp->ptid, inferior_ptid))
+ current_thread = tp->num;
+
num++;
ui_out_field_int (uiout, "thread-id", tp->num);
}
do_cleanups (cleanup_chain);
+
+ if (current_thread != -1)
+ ui_out_field_int (uiout, "current-thread-id", current_thread);
ui_out_field_int (uiout, "number-of-threads", num);
return GDB_RC_OK;
}
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,
- int *stop_step,
- int *step_multi,
- enum target_signal *stop_signal)
-{
- 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;
- *stop_step = tp->stop_step;
- *step_multi = tp->step_multi;
- *stop_signal = tp->stop_signal;
- }
-}
-
-/* Save infrun state for the thread PID. */
-
-void
-save_infrun_state (ptid_t ptid,
- struct continuation *continuations,
- struct continuation *intermediate_continuations,
- int stop_step,
- int step_multi,
- enum target_signal stop_signal)
-{
- 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;
- tp->stop_step = stop_step;
- tp->step_multi = step_multi;
- tp->stop_signal = stop_signal;
- }
-}
-
/* 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);
set_running (ptid_t ptid, int running)
{
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;
- }
+ 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 (any_started && !suppress_resume_observer)
- observer_notify_target_resumed (ptid);
+ 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
{
if (running && tp->state_ == THREAD_STOPPED)
started = 1;
tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
- if (started && !suppress_resume_observer)
+ if (started)
observer_notify_target_resumed (ptid);
}
}
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_;
set_executing (ptid_t ptid, int executing)
{
struct thread_info *tp;
+ int all = ptid_equal (ptid, minus_one_ptid);
- if (!thread_list)
+ if (all || ptid_is_pid (ptid))
{
- /* 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;
+ for (tp = thread_list; tp; tp = tp->next)
+ if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
+ tp->executing_ = executing;
+ }
+ else
+ {
+ tp = find_thread_pid (ptid);
+ gdb_assert (tp);
+ tp->executing_ = executing;
}
+}
+
+void
+set_stop_requested (ptid_t ptid, int stop)
+{
+ 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->stop_requested = stop;
}
else
{
tp = find_thread_pid (ptid);
gdb_assert (tp);
- tp->executing_ = executing;
+ 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);
+}
+
+void
+finish_thread_state (ptid_t ptid)
+{
+ struct thread_info *tp;
+ int all;
+ int any_started = 0;
+
+ all = ptid_equal (ptid, minus_one_ptid);
+
+ if (all || ptid_is_pid (ptid))
+ {
+ for (tp = thread_list; tp; tp = tp->next)
+ {
+ if (tp->state_ == THREAD_EXITED)
+ continue;
+ if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
+ {
+ if (tp->executing_ && tp->state_ == THREAD_STOPPED)
+ any_started = 1;
+ tp->state_ = tp->executing_ ? THREAD_RUNNING : THREAD_STOPPED;
+ }
+ }
}
+ else
+ {
+ tp = find_thread_pid (ptid);
+ gdb_assert (tp);
+ if (tp->state_ != THREAD_EXITED)
+ {
+ if (tp->executing_ && tp->state_ == THREAD_STOPPED)
+ any_started = 1;
+ tp->state_ = tp->executing_ ? THREAD_RUNNING : THREAD_STOPPED;
+ }
+ }
+
+ if (any_started)
+ observer_notify_target_resumed (ptid);
+}
+
+void
+finish_thread_state_cleanup (void *arg)
+{
+ ptid_t *ptid_p = arg;
+
+ gdb_assert (arg);
+
+ finish_thread_state (*ptid_p);
}
/* Prints the list of threads and their details on UIOUT.
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_field_int (uiout, "id", tp->num);
ui_out_text (uiout, " ");
- ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
+ ui_out_field_string (uiout, "target-id", target_pid_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);
+ || !thread_list
+ || ptid_equal (inferior_ptid, null_ptid));
if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
ui_out_field_int (uiout, "current-thread-id", current_thread);
ui_out_message (uiout, 0, "\n\
The current thread <Thread ID %d> has terminated. See `help thread'.\n",
current_thread);
+ else if (thread_list
+ && current_thread == -1
+ && ptid_equal (current_ptid, null_ptid))
+ ui_out_message (uiout, 0, "\n\
+No selected thread. See `help thread'.\n");
}
}
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. */
/* We don't check for is_stopped, because we're called at times
while in the TARGET_RUNNING state, e.g., while handling an
internal event. */
- if (!is_exited (ptid) && !is_executing (ptid))
- stop_pc = read_pc ();
+ if (!ptid_equal (inferior_ptid, null_ptid)
+ && !is_exited (ptid)
+ && !is_executing (ptid))
+ stop_pc = regcache_read_pc (get_thread_regcache (ptid));
else
stop_pc = ~(CORE_ADDR) 0;
}
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
{
struct thread_info *tp;
struct current_thread_cleanup *old = arg;
- restore_current_thread (old->inferior_ptid);
+
+ tp = find_thread_pid (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
+ && 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. */
- if (old->was_stopped
+ if (!ptid_equal (inferior_ptid, null_ptid)
+ && old->was_stopped
&& is_stopped (inferior_ptid)
&& target_has_registers
&& target_has_stack
old = xmalloc (sizeof (struct current_thread_cleanup));
old->inferior_ptid = inferior_ptid;
- old->was_stopped = is_stopped (inferior_ptid);
- if (old->was_stopped
- && target_has_registers
- && target_has_stack
- && target_has_memory)
- frame = get_selected_frame (NULL);
- else
- frame = NULL;
- old->selected_frame_id = get_frame_id (frame);
- old->selected_frame_level = frame_relative_level (frame);
+ if (!ptid_equal (inferior_ptid, null_ptid))
+ {
+ old->was_stopped = is_stopped (inferior_ptid);
+ if (old->was_stopped
+ && target_has_registers
+ && target_has_stack
+ && target_has_memory)
+ frame = get_selected_frame (NULL);
+ else
+ frame = NULL;
- tp = find_thread_pid (inferior_ptid);
- if (tp)
- tp->refcount++;
+ old->selected_frame_id = get_frame_id (frame);
+ old->selected_frame_level = frame_relative_level (frame);
+
+ tp = find_thread_pid (inferior_ptid);
+ if (tp)
+ tp->refcount++;
+ }
return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
restore_current_thread_cleanup_dtor);
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));
+ tp->num, target_pid_to_str (inferior_ptid));
execute_command (cmd, from_tty);
strcpy (cmd, saved_cmd); /* Restore exact command used previously */
}
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));
+ target_pid_to_str (inferior_ptid));
execute_command (cmd, from_tty);
/* Restore exact command used previously. */
{
if (!tidstr)
{
+ if (ptid_equal (inferior_ptid, null_ptid))
+ error (_("No thread selected"));
+
if (target_has_stack)
{
if (is_exited (inferior_ptid))
printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
pid_to_thread_id (inferior_ptid),
- target_tid_to_str (inferior_ptid));
+ target_pid_to_str (inferior_ptid));
else
printf_filtered (_("[Current thread is %d (%s)]\n"),
pid_to_thread_id (inferior_ptid),
- target_tid_to_str (inferior_ptid));
+ target_pid_to_str (inferior_ptid));
}
else
error (_("No stack."));
return;
}
- annotate_thread_changed ();
gdb_thread_select (uiout, tidstr, NULL);
}
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);
+
+ annotate_thread_changed ();
ui_out_text (uiout, "[Switching to thread ");
ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
ui_out_text (uiout, " (");
- ui_out_text (uiout, target_tid_to_str (inferior_ptid));
+ ui_out_text (uiout, target_pid_to_str (inferior_ptid));
ui_out_text (uiout, ")]");
/* Note that we can't reach this with an exited thread, due to the
_initialize_thread (void)
{
static struct cmd_list_element *thread_apply_list = NULL;
- struct cmd_list_element *c;
- c = add_info ("threads", info_threads_command,
- _("IDs of currently known threads."));
- set_cmd_no_selected_thread_ok (c);
+ add_info ("threads", info_threads_command,
+ _("IDs of currently known threads."));
- c = add_prefix_cmd ("thread", class_run, thread_command, _("\
+ add_prefix_cmd ("thread", class_run, thread_command, _("\
Use this command to switch between threads.\n\
The new thread ID must be currently known."),
- &thread_cmd_list, "thread ", 1, &cmdlist);
- set_cmd_no_selected_thread_ok (c);
+ &thread_cmd_list, "thread ", 1, &cmdlist);
- c = add_prefix_cmd ("apply", class_run, thread_apply_command,
- _("Apply a command to a list of threads."),
- &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
- set_cmd_no_selected_thread_ok (c);
+ add_prefix_cmd ("apply", class_run, thread_apply_command,
+ _("Apply a command to a list of threads."),
+ &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
- c = add_cmd ("all", class_run, thread_apply_all_command,
- _("Apply a command to all threads."), &thread_apply_list);
- set_cmd_no_selected_thread_ok (c);
+ add_cmd ("all", class_run, thread_apply_all_command,
+ _("Apply a command to all threads."), &thread_apply_list);
if (!xdb_commands)
add_com_alias ("t", "thread", class_run, 1);
projects / deliverable / binutils-gdb.git / blobdiff