* 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.

gdb/ChangeLog

@@ -1,3 +1,29 @@
+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

gdb/gdbthread.h

@@ -232,13 +232,6 @@ extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
 
 extern int thread_count (void);
 
-/* infrun context switch: save the debugger state for the given thread.  */
-extern void save_infrun_state (ptid_t ptid);
-
-/* infrun context switch: load the debugger state previously saved
-   for the given thread.  */
-extern void load_infrun_state (ptid_t ptid);
-
 /* Switch from one thread to another.  */
 extern void switch_to_thread (ptid_t ptid);
 

gdb/infcmd.c

@@ -575,7 +575,7 @@ proceed_thread_callback (struct thread_info *thread, void *arg)
   if (!is_stopped (thread->ptid))
     return 0;
 
-  context_switch_to (thread->ptid);
+  switch_to_thread (thread->ptid);
   clear_proceed_status ();
   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
   return 0;

gdb/inferior.h

@@ -132,8 +132,6 @@ extern void clear_proceed_status (void);
 
 extern void proceed (CORE_ADDR, enum target_signal, int);
 
-extern ptid_t context_switch_to (ptid_t ptid);
-
 /* When set, stop the 'step' command if we enter a function which has
    no line number information.  The normal behavior is that we step
    over such function.  */

gdb/infrun.c

@@ -1720,17 +1720,11 @@ nullify_last_target_wait_ptid (void)
   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 ",
@@ -1739,32 +1733,9 @@ context_switch (ptid_t ptid)
 			  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)
 {

gdb/mi/mi-main.c

@@ -1094,19 +1094,19 @@ mi_cmd_execute (struct mi_parse *parse)
 
   if (parse->frame != -1 && parse->thread == -1)
     error (_("Cannot specify --frame without --thread"));
-  
+
   if (parse->thread != -1)
     {
       struct thread_info *tp = find_thread_id (parse->thread);
       if (!tp)
 	error (_("Invalid thread id: %d"), parse->thread);
-      
+
-      if (non_stop)
+      if (is_exited (tp->ptid))
-	context_switch_to (tp->ptid);
+	error (_("Thread id: %d has terminated"), parse->thread);
-      else
+
-	switch_to_thread (tp->ptid);
+      switch_to_thread (tp->ptid);
     }
-  
+
   if (parse->frame != -1)
     {
       struct frame_info *fid;
@@ -1118,7 +1118,7 @@ mi_cmd_execute (struct mi_parse *parse)
       else
 	error (_("Invalid frame id: %d"), frame);
     }
-  
+
   if (parse->cmd->argv_func != NULL)
     {
       if (target_can_async_p ()

gdb/thread.c

@@ -71,9 +71,6 @@ enum thread_state
   THREAD_EXITED,
 };
 
-static enum thread_state main_thread_state = THREAD_STOPPED;
-static int main_thread_executing = 0;
-
 extern struct thread_info*
 inferior_thread (void)
 {
@@ -130,8 +127,6 @@ init_thread_list (void)
   struct thread_info *tp, *tpnext;
 
   highest_thread_num = 0;
-  main_thread_state = THREAD_STOPPED;
-  main_thread_executing = 0;
 
   if (!thread_list)
     return;
@@ -158,12 +153,11 @@ add_thread_silent (ptid_t ptid)
        one.  */
     {
       /* In addition to deleting the thread, if this is the current
-	 thread, then we need to also get rid of the current infrun
+	 thread, then we need to take care that delete_thread doesn't
-	 context, and take care that delete_thread doesn't really
+	 really delete the thread if it is inferior_ptid.  Create a
-	 delete the thread if it is inferior_ptid.  Create a new
+	 new template thread in the list with an invalid ptid, switch
-	 template thread in the list with an invalid ptid, context
+	 to it, delete the original thread, reset the new thread's
-	 switch to it, delete the original thread, reset the new
+	 ptid, and switch to it.  */
-	 thread's ptid, and switch to it.  */
 
       if (ptid_equal (inferior_ptid, ptid))
 	{
@@ -173,14 +167,17 @@ add_thread_silent (ptid_t 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,
+	  /* Now reset its ptid, and reswitch inferior_ptid to it.  */
-	     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);
@@ -442,34 +439,6 @@ gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
   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)
@@ -508,24 +477,6 @@ 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;
-    }
-
   /* 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.  */
@@ -565,9 +516,6 @@ is_thread_state (ptid_t ptid, enum thread_state state)
   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;
@@ -611,9 +559,6 @@ any_running (void)
   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;
@@ -629,9 +574,6 @@ is_executing (ptid_t ptid)
   if (!target_has_execution)
     return 0;
 
-  if (!thread_list)
-    return main_thread_executing;
-
   tp = find_thread_pid (ptid);
   gdb_assert (tp);
   return tp->executing_;
@@ -642,15 +584,6 @@ set_executing (ptid_t ptid, int 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)
@@ -805,13 +738,7 @@ switch_to_thread (ptid_t ptid)
 static void
 restore_current_thread (ptid_t ptid)
 {
-  if (!ptid_equal (ptid, inferior_ptid))
+  switch_to_thread (ptid);
-    {
-      if (non_stop)
-	context_switch_to (ptid);
-      else
-	switch_to_thread (ptid);
-    }
 }
 
 static void
@@ -967,10 +894,7 @@ thread_apply_all_command (char *cmd, int from_tty)
   for (tp = thread_list; tp; tp = tp->next)
     if (thread_alive (tp))
       {
-	if (non_stop)
+	switch_to_thread (tp->ptid);
-	  context_switch_to (tp->ptid);
-	else
-	  switch_to_thread (tp->ptid);
 
 	printf_filtered (_("\nThread %d (%s):\n"),
 			 tp->num, target_tid_to_str (inferior_ptid));
@@ -1040,10 +964,7 @@ thread_apply_command (char *tidlist, int from_tty)
 	    warning (_("Thread %d has terminated."), start);
 	  else
 	    {
-	      if (non_stop)
+	      switch_to_thread (tp->ptid);
-		context_switch_to (tp->ptid);
-	      else
-		switch_to_thread (tp->ptid);
 
 	      printf_filtered (_("\nThread %d (%s):\n"), tp->num,
 			       target_tid_to_str (inferior_ptid));
@@ -1113,10 +1034,7 @@ do_captured_thread_select (struct ui_out *uiout, void *tidstr)
   if (!thread_alive (tp))
     error (_("Thread ID %d has terminated."), num);
 
-  if (non_stop)
+  switch_to_thread (tp->ptid);
-    context_switch_to (tp->ptid);
-  else
-    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));