2008-09-08 Pedro Alves <pedro@codesourcery.com>
+ * inferior.h (context_switch_to): Delete.
+ * infrun.c (context_switch): Don't save and load infrun state.
+ (context_switch_to): Delete.
+
+ * infcmd.c (proceed_thread_callback): Replace context_switch_to
+ calls by switch_to_thread calls.
+
+ * gdbthread.h (save_infrun_state, load_infrun_state): Delete.
+ * thread.c (main_thread_state, main_thread_executing): Delete.
+ (inferior_thread): Delete references to them.
+ (add_thread_silent): Fix case where we're adding a thread with the
+ same ptid as an exited thread. Remove references to
+ context-switching.
+ (load_infrun_state, save_infrun_state): Delete.
+ (thread_alive, is_thread_state, any_running, is_executing)
+ (set_executing): Remove the special handling for targets that
+ don't register any thread.
+ (restore_current_thread, thread_apply_all_command)
+ (do_captured_thread_select): Unconditionally call
+ switch_to_thread.
+
+ * mi/mi-main.c (mi_cmd_execute): Check for exited threads.
+ Call switch_to_thread instead of context_switch_to.
+
+2008-09-08 Pedro Alves <pedro@codesourcery.com>
+
Remove global continuations in favour of a per-thread
continuations.
target_last_wait_ptid = minus_one_ptid;
}
-/* Switch thread contexts, maintaining "infrun state". */
+/* Switch thread contexts. */
static void
context_switch (ptid_t ptid)
{
- /* Caution: it may happen that the new thread (or the old one!)
- is not in the thread list. In this case we must not attempt
- to "switch context", or we run the risk that our context may
- be lost. This may happen as a result of the target module
- mishandling thread creation. */
-
if (debug_infrun)
{
fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
target_pid_to_str (ptid));
}
- if (in_thread_list (inferior_ptid) && in_thread_list (ptid))
- { /* Perform infrun state context switch: */
- /* Save infrun state for the old thread. */
- save_infrun_state (inferior_ptid);
-
- /* Load infrun state for the new thread. */
- load_infrun_state (ptid);
- }
-
switch_to_thread (ptid);
}
-/* Context switch to thread PTID. */
-ptid_t
-context_switch_to (ptid_t ptid)
-{
- ptid_t current_ptid = inferior_ptid;
-
- /* Context switch to the new thread. */
- if (!ptid_equal (ptid, inferior_ptid))
- {
- context_switch (ptid);
- }
- return current_ptid;
-}
-
static void
adjust_pc_after_break (struct execution_control_state *ecs)
{
THREAD_EXITED,
};
-static enum thread_state main_thread_state = THREAD_STOPPED;
-static int main_thread_executing = 0;
-
extern struct thread_info*
inferior_thread (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 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;
-}
-
-/* Save infrun state for the thread PID. */
-
-void
-save_infrun_state (ptid_t ptid)
-{
- 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;
-}
-
/* Return true if TP is an active thread. */
static int
thread_alive (struct thread_info *tp)
{
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)
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 / external / binutils.git / commitdiff