X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fthread.c;h=8853e9105b18d25c5bce35e7d5fa38e0c39934a5;hb=01d4100f869abd604b90548c47e77dd5b781a7f6;hp=22c35fa674bd30bf382531ff1ff7a5d1c1675ff7;hpb=81490ea1cb9493404e7a8df7866bd38b13320ab8;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/thread.c b/gdb/thread.c
index 22c35fa674..8853e9105b 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -1,15 +1,15 @@
 /* Multi-process/thread control for GDB, the GNU debugger.
-   Copyright 1986, 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001
-   Free Software Foundation, Inc.
+
+   Copyright (C) 1986, 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001, 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
+
    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
-   
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -18,9 +18,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "symtab.h"
@@ -30,18 +28,17 @@
 #include "value.h"
 #include "target.h"
 #include "gdbthread.h"
+#include "exceptions.h"
 #include "command.h"
 #include "gdbcmd.h"
 #include "regcache.h"
+#include "gdb.h"
+#include "gdb_string.h"
 
 #include <ctype.h>
 #include <sys/types.h>
 #include <signal.h>
-#ifdef UI_OUT
 #include "ui-out.h"
-#endif
-
-/*#include "lynxos-core.h" */
 
 /* Definition of struct thread_info exported to gdbthread.h */
 
@@ -61,9 +58,28 @@ static void thread_apply_all_command (char *, int);
 static int thread_alive (struct thread_info *);
 static void info_threads_command (char *, int);
 static void thread_apply_command (char *, int);
-static void restore_current_thread (int);
-static void switch_to_thread (int pid);
+static void restore_current_thread (ptid_t);
+static void switch_to_thread (ptid_t ptid);
 static void prune_threads (void);
+static struct cleanup *make_cleanup_restore_current_thread (ptid_t,
+                                                            struct frame_id);
+
+void
+delete_step_resume_breakpoint (void *arg)
+{
+  struct breakpoint **breakpointp = (struct breakpoint **) arg;
+  struct thread_info *tp;
+
+  if (*breakpointp != NULL)
+    {
+      delete_breakpoint (*breakpointp);
+      for (tp = thread_list; tp; tp = tp->next)
+	if (tp->step_resume_breakpoint == *breakpointp)
+	  tp->step_resume_breakpoint = NULL;
+
+      *breakpointp = NULL;
+    }
+}
 
 static void
 free_thread (struct thread_info *tp)
@@ -103,43 +119,28 @@ init_thread_list (void)
    so that back_ends can initialize their private data.  */
 
 struct thread_info *
-add_thread (int pid)
+add_thread (ptid_t ptid)
 {
   struct thread_info *tp;
 
-  tp = (struct thread_info *) xmalloc (sizeof (struct thread_info));
-
-  tp->pid = pid;
+  tp = (struct thread_info *) xmalloc (sizeof (*tp));
+  memset (tp, 0, sizeof (*tp));
+  tp->ptid = ptid;
   tp->num = ++highest_thread_num;
-  tp->prev_pc = 0;
-  tp->prev_func_start = 0;
-  tp->prev_func_name = NULL;
-  tp->step_range_start = 0;
-  tp->step_range_end = 0;
-  tp->step_frame_address = 0;
-  tp->step_resume_breakpoint = 0;
-  tp->through_sigtramp_breakpoint = 0;
-  tp->handling_longjmp = 0;
-  tp->trap_expected = 0;
-  tp->another_trap = 0;
-  tp->stepping_through_solib_after_catch = 0;
-  tp->stepping_through_solib_catchpoints = NULL;
-  tp->stepping_through_sigtramp = 0;
   tp->next = thread_list;
-  tp->private = NULL;
   thread_list = tp;
   return tp;
 }
 
 void
-delete_thread (int pid)
+delete_thread (ptid_t ptid)
 {
   struct thread_info *tp, *tpprev;
 
   tpprev = NULL;
 
   for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
-    if (tp->pid == pid)
+    if (ptid_equal (tp->ptid, ptid))
       break;
 
   if (!tp)
@@ -165,14 +166,14 @@ find_thread_id (int num)
   return NULL;
 }
 
-/* Find a thread_info by matching 'pid'.  */
+/* Find a thread_info by matching PTID.  */
 struct thread_info *
-find_thread_pid (int pid)
+find_thread_pid (ptid_t ptid)
 {
   struct thread_info *tp;
 
   for (tp = thread_list; tp; tp = tp->next)
-    if (tp->pid == pid)
+    if (ptid_equal (tp->ptid, ptid))
       return tp;
 
   return NULL;
@@ -218,48 +219,52 @@ valid_thread_id (int num)
 }
 
 int
-pid_to_thread_id (int pid)
+pid_to_thread_id (ptid_t ptid)
 {
   struct thread_info *tp;
 
   for (tp = thread_list; tp; tp = tp->next)
-    if (tp->pid == pid)
+    if (ptid_equal (tp->ptid, ptid))
       return tp->num;
 
   return 0;
 }
 
-int
+ptid_t
 thread_id_to_pid (int num)
 {
   struct thread_info *thread = find_thread_id (num);
   if (thread)
-    return thread->pid;
+    return thread->ptid;
   else
-    return -1;
+    return pid_to_ptid (-1);
 }
 
 int
-in_thread_list (int pid)
+in_thread_list (ptid_t ptid)
 {
   struct thread_info *tp;
 
   for (tp = thread_list; tp; tp = tp->next)
-    if (tp->pid == pid)
+    if (ptid_equal (tp->ptid, ptid))
       return 1;
 
   return 0;			/* Never heard of 'im */
 }
-#ifdef UI_OUT
+
 /* Print a list of thread ids currently known, and the total number of
    threads. To be used from within catch_errors. */
-static int 
-do_captured_list_thread_ids (void *arg)
+static int
+do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
 {
   struct thread_info *tp;
   int num = 0;
+  struct cleanup *cleanup_chain;
+
+  prune_threads ();
+  target_find_new_threads ();
 
-  ui_out_list_begin (uiout, "thread-ids");
+  cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
 
   for (tp = thread_list; tp; tp = tp->next)
     {
@@ -267,7 +272,7 @@ do_captured_list_thread_ids (void *arg)
       ui_out_field_int (uiout, "thread-id", tp->num);
     }
 
-  ui_out_list_end (uiout);
+  do_cleanups (cleanup_chain);
   ui_out_field_int (uiout, "number-of-threads", num);
   return GDB_RC_OK;
 }
@@ -275,96 +280,103 @@ do_captured_list_thread_ids (void *arg)
 /* Official gdblib interface function to get a list of thread ids and
    the total number. */
 enum gdb_rc
-gdb_list_thread_ids (/* output object */)
+gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
 {
-  return catch_errors (do_captured_list_thread_ids, NULL,
-		       NULL, RETURN_MASK_ALL);
+  if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
+				 error_message, RETURN_MASK_ALL) < 0)
+    return GDB_RC_FAIL;
+  return GDB_RC_OK;
 }
-#endif
 
 /* Load infrun state for the thread PID.  */
 
 void
-load_infrun_state (int pid, CORE_ADDR *prev_pc, CORE_ADDR *prev_func_start,
-		   char **prev_func_name, int *trap_expected,
+load_infrun_state (ptid_t ptid,
+		   CORE_ADDR *prev_pc,
+		   int *trap_expected,
 		   struct breakpoint **step_resume_breakpoint,
-		   struct breakpoint **through_sigtramp_breakpoint,
-		   CORE_ADDR *step_range_start, CORE_ADDR *step_range_end,
-		   CORE_ADDR *step_frame_address, int *handling_longjmp,
-		   int *another_trap, int *stepping_through_solib_after_catch,
+		   CORE_ADDR *step_range_start,
+		   CORE_ADDR *step_range_end,
+		   struct frame_id *step_frame_id,
+		   int *handling_longjmp,
+		   int *another_trap,
+		   int *stepping_through_solib_after_catch,
 		   bpstat *stepping_through_solib_catchpoints,
-		   int *stepping_through_sigtramp)
+		   int *current_line,
+		   struct symtab **current_symtab)
 {
   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 (pid));
+  tp = find_thread_id (pid_to_thread_id (ptid));
   if (tp == NULL)
     return;
 
   *prev_pc = tp->prev_pc;
-  *prev_func_start = tp->prev_func_start;
-  *prev_func_name = tp->prev_func_name;
+  *trap_expected = tp->trap_expected;
   *step_resume_breakpoint = tp->step_resume_breakpoint;
   *step_range_start = tp->step_range_start;
   *step_range_end = tp->step_range_end;
-  *step_frame_address = tp->step_frame_address;
-  *through_sigtramp_breakpoint = tp->through_sigtramp_breakpoint;
+  *step_frame_id = tp->step_frame_id;
   *handling_longjmp = tp->handling_longjmp;
-  *trap_expected = tp->trap_expected;
   *another_trap = tp->another_trap;
-  *stepping_through_solib_after_catch = tp->stepping_through_solib_after_catch;
-  *stepping_through_solib_catchpoints = tp->stepping_through_solib_catchpoints;
-  *stepping_through_sigtramp = tp->stepping_through_sigtramp;
+  *stepping_through_solib_after_catch =
+    tp->stepping_through_solib_after_catch;
+  *stepping_through_solib_catchpoints =
+    tp->stepping_through_solib_catchpoints;
+  *current_line = tp->current_line;
+  *current_symtab = tp->current_symtab;
 }
 
 /* Save infrun state for the thread PID.  */
 
 void
-save_infrun_state (int pid, CORE_ADDR prev_pc, CORE_ADDR prev_func_start,
-		   char *prev_func_name, int trap_expected,
+save_infrun_state (ptid_t ptid,
+		   CORE_ADDR prev_pc,
+		   int trap_expected,
 		   struct breakpoint *step_resume_breakpoint,
-		   struct breakpoint *through_sigtramp_breakpoint,
-		   CORE_ADDR step_range_start, CORE_ADDR step_range_end,
-		   CORE_ADDR step_frame_address, int handling_longjmp,
-		   int another_trap, int stepping_through_solib_after_catch,
+		   CORE_ADDR step_range_start,
+		   CORE_ADDR step_range_end,
+		   const struct frame_id *step_frame_id,
+		   int handling_longjmp,
+		   int another_trap,
+		   int stepping_through_solib_after_catch,
 		   bpstat stepping_through_solib_catchpoints,
-		   int stepping_through_sigtramp)
+		   int current_line,
+		   struct symtab *current_symtab)
 {
   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 (pid));
+  tp = find_thread_id (pid_to_thread_id (ptid));
   if (tp == NULL)
     return;
 
   tp->prev_pc = prev_pc;
-  tp->prev_func_start = prev_func_start;
-  tp->prev_func_name = prev_func_name;
+  tp->trap_expected = trap_expected;
   tp->step_resume_breakpoint = step_resume_breakpoint;
   tp->step_range_start = step_range_start;
   tp->step_range_end = step_range_end;
-  tp->step_frame_address = step_frame_address;
-  tp->through_sigtramp_breakpoint = through_sigtramp_breakpoint;
+  tp->step_frame_id = (*step_frame_id);
   tp->handling_longjmp = handling_longjmp;
-  tp->trap_expected = trap_expected;
   tp->another_trap = another_trap;
   tp->stepping_through_solib_after_catch = stepping_through_solib_after_catch;
   tp->stepping_through_solib_catchpoints = stepping_through_solib_catchpoints;
-  tp->stepping_through_sigtramp = stepping_through_sigtramp;
+  tp->current_line = current_line;
+  tp->current_symtab = current_symtab;
 }
 
 /* Return true if TP is an active thread. */
 static int
 thread_alive (struct thread_info *tp)
 {
-  if (tp->pid == -1)
+  if (PIDGET (tp->ptid) == -1)
     return 0;
-  if (!target_thread_alive (tp->pid))
+  if (!target_thread_alive (tp->ptid))
     {
-      tp->pid = -1;		/* Mark it as dead */
+      tp->ptid = pid_to_ptid (-1);	/* Mark it as dead */
       return 0;
     }
   return 1;
@@ -379,7 +391,7 @@ prune_threads (void)
     {
       next = tp->next;
       if (!thread_alive (tp))
-	delete_thread (tp->pid);
+	delete_thread (tp->ptid);
     }
 }
 
@@ -394,114 +406,110 @@ static void
 info_threads_command (char *arg, int from_tty)
 {
   struct thread_info *tp;
-  int current_pid;
+  ptid_t current_ptid;
   struct frame_info *cur_frame;
-  int saved_frame_level = selected_frame_level;
-  int counter;
+  struct cleanup *old_chain;
+  struct frame_id saved_frame_id;
   char *extra_info;
 
-  /* Avoid coredumps which would happen if we tried to access a NULL
-     selected_frame.  */
-  if (!target_has_stack)
-    error ("No stack.");
+  /* Backup current thread and selected frame.  */
+  saved_frame_id = get_frame_id (get_selected_frame (NULL));
+  old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 
   prune_threads ();
   target_find_new_threads ();
-  current_pid = inferior_pid;
+  current_ptid = inferior_ptid;
   for (tp = thread_list; tp; tp = tp->next)
     {
-      if (tp->pid == current_pid)
+      if (ptid_equal (tp->ptid, current_ptid))
 	printf_filtered ("* ");
       else
 	printf_filtered ("  ");
 
-#ifdef HPUXHPPA
-      printf_filtered ("%d %s", tp->num, target_tid_to_str (tp->pid));
-#else
-      printf_filtered ("%d %s", tp->num, target_pid_to_str (tp->pid));
-#endif
+      printf_filtered ("%d %s", tp->num, target_tid_to_str (tp->ptid));
 
       extra_info = target_extra_thread_info (tp);
       if (extra_info)
 	printf_filtered (" (%s)", extra_info);
       puts_filtered ("  ");
-
-      switch_to_thread (tp->pid);
-      if (selected_frame)
-	print_only_stack_frame (selected_frame, -1, 0);
-      else
-	printf_filtered ("[No stack.]\n");
+      /* That switch put us at the top of the stack (leaf frame).  */
+      switch_to_thread (tp->ptid);
+      print_stack_frame (get_selected_frame (NULL), 0, LOCATION);
     }
 
-  switch_to_thread (current_pid);
-
-  /* Code below copied from "up_silently_base" in "stack.c".
-   * It restores the frame set by the user before the "info threads"
-   * command.  We have finished the info-threads display by switching
-   * back to the current thread.  That switch has put us at the top
-   * of the stack (leaf frame).
-   */
-  counter = saved_frame_level;
-  cur_frame = find_relative_frame (selected_frame, &counter);
-  if (counter != 0)
-    {
-      /* Ooops, can't restore, tell user where we are. */
-      warning ("Couldn't restore frame in current thread, at frame 0");
-      print_stack_frame (selected_frame, -1, 0);
-    }
-  else
+  /* Restores the current thread and the frame selected before
+     the "info threads" command.  */
+  do_cleanups (old_chain);
+
+  /*  If case we were not able to find the original frame, print the
+      new selected frame.  */
+  if (frame_find_by_id (saved_frame_id) == NULL)
     {
-      select_frame (cur_frame, saved_frame_level);
+      warning (_("Couldn't restore frame in current thread, at frame 0"));
+      print_stack_frame (get_selected_frame (NULL), 0, LOCATION);
     }
-
-  /* re-show current frame. */
-  show_stack_frame (cur_frame);
 }
 
 /* Switch from one thread to another. */
 
 static void
-switch_to_thread (int pid)
+switch_to_thread (ptid_t ptid)
 {
-  if (pid == inferior_pid)
+  if (ptid_equal (ptid, inferior_ptid))
     return;
 
-  inferior_pid = pid;
-  flush_cached_frames ();
+  inferior_ptid = ptid;
+  reinit_frame_cache ();
   registers_changed ();
   stop_pc = read_pc ();
-  select_frame (get_current_frame (), 0);
 }
 
 static void
-restore_current_thread (int pid)
+restore_current_thread (ptid_t ptid)
+{
+  if (!ptid_equal (ptid, inferior_ptid))
+    {
+      switch_to_thread (ptid);
+    }
+}
+
+static void
+restore_selected_frame (struct frame_id a_frame_id)
 {
-  if (pid != inferior_pid)
+  struct frame_info *selected_frame_info = NULL;
+
+  if (frame_id_eq (a_frame_id, null_frame_id))
+    return;        
+
+  if ((selected_frame_info = frame_find_by_id (a_frame_id)) != NULL)
     {
-      switch_to_thread (pid);
-      print_stack_frame (get_current_frame (), 0, -1);
+      select_frame (selected_frame_info);
     }
 }
 
 struct current_thread_cleanup
 {
-  int inferior_pid;
+  ptid_t inferior_ptid;
+  struct frame_id selected_frame_id;
 };
 
 static void
 do_restore_current_thread_cleanup (void *arg)
 {
   struct current_thread_cleanup *old = arg;
-  restore_current_thread (old->inferior_pid);
+  restore_current_thread (old->inferior_ptid);
+  restore_selected_frame (old->selected_frame_id);
   xfree (old);
 }
 
 static struct cleanup *
-make_cleanup_restore_current_thread (int inferior_pid)
+make_cleanup_restore_current_thread (ptid_t inferior_ptid, 
+                                     struct frame_id a_frame_id)
 {
   struct current_thread_cleanup *old
     = xmalloc (sizeof (struct current_thread_cleanup));
-  old->inferior_pid = inferior_pid;
+  old->inferior_ptid = inferior_ptid;
+  old->selected_frame_id = a_frame_id;
   return make_cleanup (do_restore_current_thread_cleanup, old);
 }
 
@@ -521,11 +529,16 @@ thread_apply_all_command (char *cmd, int from_tty)
   struct cleanup *old_chain;
   struct cleanup *saved_cmd_cleanup_chain;
   char *saved_cmd;
+  struct frame_id saved_frame_id;
+  ptid_t current_ptid;
+  int thread_has_changed = 0;
 
   if (cmd == NULL || *cmd == '\000')
-    error ("Please specify a command following the thread ID list");
-
-  old_chain = make_cleanup_restore_current_thread (inferior_pid);
+    error (_("Please specify a command following the thread ID list"));
+  
+  current_ptid = inferior_ptid;
+  saved_frame_id = get_frame_id (get_selected_frame (NULL));
+  old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 
   /* It is safe to update the thread list now, before
      traversing it for "thread apply all".  MVS */
@@ -538,21 +551,22 @@ thread_apply_all_command (char *cmd, int from_tty)
   for (tp = thread_list; tp; tp = tp->next)
     if (thread_alive (tp))
       {
-	switch_to_thread (tp->pid);
-#ifdef HPUXHPPA
-	printf_filtered ("\nThread %d (%s):\n",
-			 tp->num,
-			 target_tid_to_str (inferior_pid));
-#else
-	printf_filtered ("\nThread %d (%s):\n", tp->num,
-			 target_pid_to_str (inferior_pid));
-#endif
+	switch_to_thread (tp->ptid);
+	printf_filtered (_("\nThread %d (%s):\n"),
+			 tp->num, target_tid_to_str (inferior_ptid));
 	execute_command (cmd, from_tty);
-	strcpy (cmd, saved_cmd); /* Restore exact command used previously */
+	strcpy (cmd, saved_cmd);	/* Restore exact command used previously */
       }
 
+  if (!ptid_equal (current_ptid, inferior_ptid))
+    thread_has_changed = 1;
+
   do_cleanups (saved_cmd_cleanup_chain);
   do_cleanups (old_chain);
+  /* Print stack frame only if we changed thread.  */
+  if (thread_has_changed)
+    print_stack_frame (get_current_frame (), 1, SRC_LINE);
+
 }
 
 static void
@@ -563,16 +577,21 @@ thread_apply_command (char *tidlist, int from_tty)
   struct cleanup *old_chain;
   struct cleanup *saved_cmd_cleanup_chain;
   char *saved_cmd;
+  struct frame_id saved_frame_id;
+  ptid_t current_ptid;
+  int thread_has_changed = 0;
 
   if (tidlist == NULL || *tidlist == '\000')
-    error ("Please specify a thread ID list");
+    error (_("Please specify a thread ID list"));
 
   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
 
   if (*cmd == '\000')
-    error ("Please specify a command following the thread ID list");
+    error (_("Please specify a command following the thread ID list"));
 
-  old_chain = make_cleanup_restore_current_thread (inferior_pid);
+  current_ptid = inferior_ptid;
+  saved_frame_id = get_frame_id (get_selected_frame (NULL));
+  old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 
   /* Save a copy of the command in case it is clobbered by
      execute_command */
@@ -585,7 +604,7 @@ thread_apply_command (char *tidlist, int from_tty)
 
       start = strtol (tidlist, &p, 10);
       if (p == tidlist)
-	error ("Error parsing %s", tidlist);
+	error (_("Error parsing %s"), tidlist);
       tidlist = p;
 
       while (*tidlist == ' ' || *tidlist == '\t')
@@ -596,7 +615,7 @@ thread_apply_command (char *tidlist, int from_tty)
 	  tidlist++;		/* Skip the - */
 	  end = strtol (tidlist, &p, 10);
 	  if (p == tidlist)
-	    error ("Error parsing %s", tidlist);
+	    error (_("Error parsing %s"), tidlist);
 	  tidlist = p;
 
 	  while (*tidlist == ' ' || *tidlist == '\t')
@@ -610,27 +629,28 @@ thread_apply_command (char *tidlist, int from_tty)
 	  tp = find_thread_id (start);
 
 	  if (!tp)
-	    warning ("Unknown thread %d.", start);
+	    warning (_("Unknown thread %d."), start);
 	  else if (!thread_alive (tp))
-	    warning ("Thread %d has terminated.", start);
+	    warning (_("Thread %d has terminated."), start);
 	  else
 	    {
-	      switch_to_thread (tp->pid);
-#ifdef HPUXHPPA
-	      printf_filtered ("\nThread %d (%s):\n", tp->num,
-			       target_tid_to_str (inferior_pid));
-#else
-	      printf_filtered ("\nThread %d (%s):\n", tp->num,
-			       target_pid_to_str (inferior_pid));
-#endif
+	      switch_to_thread (tp->ptid);
+	      printf_filtered (_("\nThread %d (%s):\n"), tp->num,
+			       target_tid_to_str (inferior_ptid));
 	      execute_command (cmd, from_tty);
 	      strcpy (cmd, saved_cmd);	/* Restore exact command used previously */
 	    }
 	}
     }
 
+  if (!ptid_equal (current_ptid, inferior_ptid))
+    thread_has_changed = 1;
+
   do_cleanups (saved_cmd_cleanup_chain);
   do_cleanups (old_chain);
+  /* Print stack frame only if we changed thread.  */
+  if (thread_has_changed)
+    print_stack_frame (get_current_frame (), 1, SRC_LINE);
 }
 
 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
@@ -643,24 +663,19 @@ thread_command (char *tidstr, int from_tty)
     {
       /* Don't generate an error, just say which thread is current. */
       if (target_has_stack)
-	printf_filtered ("[Current thread is %d (%s)]\n",
-			 pid_to_thread_id (inferior_pid),
-#if defined(HPUXHPPA)
-			 target_tid_to_str (inferior_pid)
-#else
-			 target_pid_to_str (inferior_pid)
-#endif
-	  );
+	printf_filtered (_("[Current thread is %d (%s)]\n"),
+			 pid_to_thread_id (inferior_ptid),
+			 target_tid_to_str (inferior_ptid));
       else
-	error ("No stack.");
+	error (_("No stack."));
       return;
     }
 
-  gdb_thread_select (tidstr);
+  gdb_thread_select (uiout, tidstr, NULL);
 }
 
 static int
-do_captured_thread_select (void *tidstr)
+do_captured_thread_select (struct ui_out *uiout, void *tidstr)
 {
   int num;
   struct thread_info *tp;
@@ -669,50 +684,31 @@ do_captured_thread_select (void *tidstr)
 
   tp = find_thread_id (num);
 
-#ifdef UI_OUT
   if (!tp)
-    error ("Thread ID %d not known.", num);
-#else
-  if (!tp)
-    error ("Thread ID %d not known.  Use the \"info threads\" command to\n\
-see the IDs of currently known threads.", num);
-#endif
+    error (_("Thread ID %d not known."), num);
 
   if (!thread_alive (tp))
-    error ("Thread ID %d has terminated.\n", num);
+    error (_("Thread ID %d has terminated."), num);
 
-  switch_to_thread (tp->pid);
+  switch_to_thread (tp->ptid);
 
-#ifdef UI_OUT
   ui_out_text (uiout, "[Switching to thread ");
-  ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_pid));
+  ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
   ui_out_text (uiout, " (");
-#if defined(HPUXHPPA)
-  ui_out_text (uiout, target_tid_to_str (inferior_pid));
-#else
-  ui_out_text (uiout, target_pid_to_str (inferior_pid));
-#endif
+  ui_out_text (uiout, target_tid_to_str (inferior_ptid));
   ui_out_text (uiout, ")]");
-#else /* UI_OUT */
-  printf_filtered ("[Switching to thread %d (%s)]\n",
-		   pid_to_thread_id (inferior_pid),
-#if defined(HPUXHPPA)
-		   target_tid_to_str (inferior_pid)
-#else
-		   target_pid_to_str (inferior_pid)
-#endif
-    );
-#endif /* UI_OUT */
-
-  print_stack_frame (selected_frame, selected_frame_level, 1);
+
+  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
   return GDB_RC_OK;
 }
 
 enum gdb_rc
-gdb_thread_select (char *tidstr)
+gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
 {
-  return catch_errors (do_captured_thread_select, tidstr,
-		       NULL, RETURN_MASK_ALL);
+  if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
+				 error_message, RETURN_MASK_ALL) < 0)
+    return GDB_RC_FAIL;
+  return GDB_RC_OK;
 }
 
 /* Commands with a prefix of `thread'.  */
@@ -724,20 +720,19 @@ _initialize_thread (void)
   static struct cmd_list_element *thread_apply_list = NULL;
 
   add_info ("threads", info_threads_command,
-	    "IDs of currently known threads.");
+	    _("IDs of currently known threads."));
 
-  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);
+  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);
 
   add_prefix_cmd ("apply", class_run, thread_apply_command,
-		  "Apply a command to a list of threads.",
-		  &thread_apply_list, "apply ", 1, &thread_cmd_list);
+		  _("Apply a command to a list of threads."),
+		  &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
 
   add_cmd ("all", class_run, thread_apply_all_command,
-	   "Apply a command to all threads.",
-	   &thread_apply_list);
+	   _("Apply a command to all threads."), &thread_apply_list);
 
   if (!xdb_commands)
     add_com_alias ("t", "thread", class_run, 1);