X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsol-thread.c;h=ab7ec5d2244ecad71f9a98be941f941cb68053ba;hb=5062cc192edb3e057e7f0c8c22d7b806077df307;hp=a613549002883ac7af10af750f2c791471e8e2c5;hpb=c5aa993b1f4add48fbdc6cc3117059f616e49875;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index a613549002..ab7ec5d224 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -1,11 +1,13 @@
-/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
-   Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Solaris threads debugging interface.
+
+   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+   2007, 2008 Free Software Foundation, Inc.
 
    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,
@@ -14,37 +16,38 @@
    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/>.  */
 
 /* This module implements a sort of half target that sits between the
-   machine-independent parts of GDB and the /proc interface (procfs.c) to
-   provide access to the Solaris user-mode thread implementation.
-
-   Solaris threads are true user-mode threads, which are invoked via the thr_*
-   and pthread_* (native and Posix respectivly) interfaces.  These are mostly
-   implemented in user-space, with all thread context kept in various
-   structures that live in the user's heap.  These should not be confused with
-   lightweight processes (LWPs), which are implemented by the kernel, and
-   scheduled without explicit intervention by the process.
-
-   Just to confuse things a little, Solaris threads (both native and Posix) are
-   actually implemented using LWPs.  In general, there are going to be more
-   threads than LWPs.  There is no fixed correspondence between a thread and an
-   LWP.  When a thread wants to run, it gets scheduled onto the first available
-   LWP and can therefore migrate from one LWP to another as time goes on.  A
+   machine-independent parts of GDB and the /proc interface (procfs.c)
+   to provide access to the Solaris user-mode thread implementation.
+
+   Solaris threads are true user-mode threads, which are invoked via
+   the thr_* and pthread_* (native and POSIX respectivly) interfaces.
+   These are mostly implemented in user-space, with all thread context
+   kept in various structures that live in the user's heap.  These
+   should not be confused with lightweight processes (LWPs), which are
+   implemented by the kernel, and scheduled without explicit
+   intervention by the process.
+
+   Just to confuse things a little, Solaris threads (both native and
+   POSIX) are actually implemented using LWPs.  In general, there are
+   going to be more threads than LWPs.  There is no fixed
+   correspondence between a thread and an LWP.  When a thread wants to
+   run, it gets scheduled onto the first available LWP and can
+   therefore migrate from one LWP to another as time goes on.  A
    sleeping thread may not be associated with an LWP at all!
 
-   To make it possible to mess with threads, Sun provides a library called
-   libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
-   have a published interface).  This interface has an upper part, which it
-   provides, and a lower part which I provide.  The upper part consists of the
-   td_* routines, which allow me to find all the threads, query their state,
-   etc...  The lower part consists of all of the ps_*, which are used by the
-   td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
-   The ps_* routines actually do most of their work by calling functions in
-   procfs.c.  */
+   To make it possible to mess with threads, Sun provides a library
+   called libthread_db.so.1 (not to be confused with
+   libthread_db.so.0, which doesn't have a published interface).  This
+   interface has an upper part, which it provides, and a lower part
+   which we provide.  The upper part consists of the td_* routines,
+   which allow us to find all the threads, query their state, etc...
+   The lower part consists of all of the ps_*, which are used by the
+   td_* routines to read/write memory, manipulate LWPs, lookup
+   symbols, etc...  The ps_* routines actually do most of their work
+   by calling functions in procfs.c.  */
 
 #include "defs.h"
 #include <thread.h>
@@ -54,10 +57,16 @@
 #include "target.h"
 #include "inferior.h"
 #include <fcntl.h>
-#include <unistd.h>
-#include <sys/stat.h>
+#include "gdb_stat.h"
 #include <dlfcn.h>
 #include "gdbcmd.h"
+#include "gdbcore.h"
+#include "regcache.h"
+#include "solib.h"
+#include "symfile.h"
+#include "observer.h"
+
+#include "gdb_string.h"
 
 extern struct target_ops sol_thread_ops;	/* Forward declaration */
 extern struct target_ops sol_core_ops;	/* Forward declaration */
@@ -71,158 +80,131 @@ struct target_ops sol_core_ops;
 extern int procfs_suppress_run;
 extern struct target_ops procfs_ops;	/* target vector for procfs.c */
 extern struct target_ops core_ops;	/* target vector for corelow.c */
-extern char *procfs_pid_to_str PARAMS ((int pid));
-
-/* Note that these prototypes differ slightly from those used in procfs.c
-   for of two reasons.  One, we can't use gregset_t, as that's got a whole
-   different meaning under Solaris (also, see above).  Two, we can't use the
-   pointer form here as these are actually arrays of ints (for Sparc's at
-   least), and are automatically coerced into pointers to ints when used as
-   parameters.  That makes it impossible to avoid a compiler warning when
-   passing pr{g fp}regset_t's from a parameter to an argument of one of
-   these functions.  */
-
-extern void supply_gregset PARAMS ((const prgregset_t));
-extern void fill_gregset PARAMS ((prgregset_t, int));
-extern void supply_fpregset PARAMS ((const prfpregset_t *));
-extern void fill_fpregset PARAMS ((prfpregset_t *, int));
-
-/* This struct is defined by us, but mainly used for the proc_service interface.
-   We don't have much use for it, except as a handy place to get a real pid
-   for memory accesses.  */
+extern char *procfs_pid_to_str (ptid_t ptid);
+
+/* Prototypes for supply_gregset etc. */
+#include "gregset.h"
+
+/* This struct is defined by us, but mainly used for the proc_service
+   interface.  We don't have much use for it, except as a handy place
+   to get a real PID for memory accesses.  */
 
 struct ps_prochandle
-  {
-    pid_t pid;
-  };
+{
+  ptid_t ptid;
+};
 
 struct string_map
-  {
-    int num;
-    char *str;
-  };
+{
+  int num;
+  char *str;
+};
 
 static struct ps_prochandle main_ph;
 static td_thragent_t *main_ta;
 static int sol_thread_active = 0;
 
-static struct cleanup *save_inferior_pid PARAMS ((void));
-static void restore_inferior_pid PARAMS ((void *pid));
-static char *td_err_string PARAMS ((td_err_e errcode));
-static char *td_state_string PARAMS ((td_thr_state_e statecode));
-static int thread_to_lwp PARAMS ((int thread_id, int default_lwp));
-static void sol_thread_resume PARAMS ((int pid, int step,
-				       enum target_signal signo));
-static int lwp_to_thread PARAMS ((int lwp));
-static int sol_thread_alive PARAMS ((int pid));
-static void sol_core_close PARAMS ((int quitting));
-
-static void init_sol_thread_ops PARAMS ((void));
-static void init_sol_core_ops PARAMS ((void));
-
-#define THREAD_FLAG 0x80000000
-#define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
-#define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
-#define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
-#define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
-#define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
-#define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
-
-/* Pointers to routines from lithread_db resolved by dlopen() */
-
-static void
-  (*p_td_log) (const int on_off);
-static td_err_e
-  (*p_td_ta_new) (const struct ps_prochandle * ph_p, td_thragent_t ** ta_pp);
-static td_err_e
-  (*p_td_ta_delete) (td_thragent_t * ta_p);
-static td_err_e
-  (*p_td_init) (void);
-static td_err_e
-  (*p_td_ta_get_ph) (const td_thragent_t * ta_p, struct ps_prochandle ** ph_pp);
-static td_err_e
-  (*p_td_ta_get_nthreads) (const td_thragent_t * ta_p, int *nthread_p);
-static td_err_e
-  (*p_td_ta_tsd_iter) (const td_thragent_t * ta_p, td_key_iter_f * cb, void *cbdata_p);
-static td_err_e
-  (*p_td_ta_thr_iter) (const td_thragent_t * ta_p, td_thr_iter_f * cb, void *cbdata_p, td_thr_state_e state,
-	       int ti_pri, sigset_t * ti_sigmask_p, unsigned ti_user_flags);
-static td_err_e
-  (*p_td_thr_validate) (const td_thrhandle_t * th_p);
-static td_err_e
-  (*p_td_thr_tsd) (const td_thrhandle_t * th_p, const thread_key_t key, void **data_pp);
-static td_err_e
-  (*p_td_thr_get_info) (const td_thrhandle_t * th_p, td_thrinfo_t * ti_p);
-static td_err_e
-  (*p_td_thr_getfpregs) (const td_thrhandle_t * th_p, prfpregset_t * fpregset);
-static td_err_e
-  (*p_td_thr_getxregsize) (const td_thrhandle_t * th_p, int *xregsize);
-static td_err_e
-  (*p_td_thr_getxregs) (const td_thrhandle_t * th_p, const caddr_t xregset);
-static td_err_e
-  (*p_td_thr_sigsetmask) (const td_thrhandle_t * th_p, const sigset_t ti_sigmask);
-static td_err_e
-  (*p_td_thr_setprio) (const td_thrhandle_t * th_p, const int ti_pri);
-static td_err_e
-  (*p_td_thr_setsigpending) (const td_thrhandle_t * th_p, const uchar_t ti_pending_flag, const sigset_t ti_pending);
-static td_err_e
-  (*p_td_thr_setfpregs) (const td_thrhandle_t * th_p, const prfpregset_t * fpregset);
-static td_err_e
-  (*p_td_thr_setxregs) (const td_thrhandle_t * th_p, const caddr_t xregset);
-static td_err_e
-  (*p_td_ta_map_id2thr) (const td_thragent_t * ta_p, thread_t tid, td_thrhandle_t * th_p);
-static td_err_e
-  (*p_td_ta_map_lwp2thr) (const td_thragent_t * ta_p, lwpid_t lwpid, td_thrhandle_t * th_p);
-static td_err_e
-  (*p_td_thr_getgregs) (const td_thrhandle_t * th_p, prgregset_t regset);
-static td_err_e
-  (*p_td_thr_setgregs) (const td_thrhandle_t * th_p, const prgregset_t regset);
+static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
+static int sol_thread_alive (ptid_t ptid);
+static void sol_core_close (int quitting);
+
+static void init_sol_thread_ops (void);
+static void init_sol_core_ops (void);
+
+/* Default definitions: These must be defined in tm.h if they are to
+   be shared with a process module such as procfs.  */
+
+#define GET_PID(ptid)		ptid_get_pid (ptid)
+#define GET_LWP(ptid)		ptid_get_lwp (ptid)
+#define GET_THREAD(ptid)	ptid_get_tid (ptid)
+
+#define is_lwp(ptid)		(GET_LWP (ptid) != 0)
+#define is_thread(ptid)		(GET_THREAD (ptid) != 0)
+
+#define BUILD_LWP(lwp, pid)	ptid_build (pid, lwp, 0)
+#define BUILD_THREAD(tid, pid)	ptid_build (pid, 0, tid)
+
+/* Pointers to routines from libthread_db resolved by dlopen().  */
+
+static void (*p_td_log)(const int on_off);
+static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
+			       td_thragent_t **ta_pp);
+static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
+static td_err_e (*p_td_init)(void);
+static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
+				  struct ps_prochandle **ph_pp);
+static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
+					int *nthread_p);
+static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
+				    td_key_iter_f *cb, void *cbdata_p);
+static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
+				    td_thr_iter_f *cb, void *cbdata_p,
+				    td_thr_state_e state, int ti_pri,
+				    sigset_t *ti_sigmask_p,
+				    unsigned ti_user_flags);
+static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
+static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
+				const thread_key_t key, void **data_pp);
+static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
+				     td_thrinfo_t *ti_p);
+static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
+				      prfpregset_t *fpregset);
+static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
+					int *xregsize);
+static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
+				     const caddr_t xregset);
+static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
+				       const sigset_t ti_sigmask);
+static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
+				    const int ti_pri);
+static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
+					  const uchar_t ti_pending_flag,
+					  const sigset_t ti_pending);
+static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
+				      const prfpregset_t *fpregset);
+static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
+				     const caddr_t xregset);
+static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
+				      thread_t tid,
+				      td_thrhandle_t *th_p);
+static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
+				       lwpid_t lwpid,
+				       td_thrhandle_t *th_p);
+static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
+				     prgregset_t regset);
+static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
+				     const prgregset_t regset);
 
-/*
 
-   LOCAL FUNCTION
-
-   td_err_string - Convert a thread_db error code to a string
-
-   SYNOPSIS
-
-   char * td_err_string (errcode)
-
-   DESCRIPTION
-
-   Return the thread_db error string associated with errcode.  If errcode
-   is unknown, then return a message.
-
- */
+/* Return the libthread_db error string associated with ERRCODE.  If
+   ERRCODE is unknown, return an appropriate message.  */
 
 static char *
-td_err_string (errcode)
-     td_err_e errcode;
+td_err_string (td_err_e errcode)
 {
-  static struct string_map
-    td_err_table[] =
+  static struct string_map td_err_table[] =
   {
-    {TD_OK, "generic \"call succeeded\""},
-    {TD_ERR, "generic error."},
-    {TD_NOTHR, "no thread can be found to satisfy query"},
-    {TD_NOSV, "no synch. variable can be found to satisfy query"},
-    {TD_NOLWP, "no lwp can be found to satisfy query"},
-    {TD_BADPH, "invalid process handle"},
-    {TD_BADTH, "invalid thread handle"},
-    {TD_BADSH, "invalid synchronization handle"},
-    {TD_BADTA, "invalid thread agent"},
-    {TD_BADKEY, "invalid key"},
-    {TD_NOMSG, "td_thr_event_getmsg() called when there was no message"},
-    {TD_NOFPREGS, "FPU register set not available for given thread"},
-    {TD_NOLIBTHREAD, "application not linked with libthread"},
-    {TD_NOEVENT, "requested event is not supported"},
-    {TD_NOCAPAB, "capability not available"},
-    {TD_DBERR, "Debugger service failed"},
-    {TD_NOAPLIC, "Operation not applicable to"},
-    {TD_NOTSD, "No thread specific data for this thread"},
-    {TD_MALLOC, "Malloc failed"},
-    {TD_PARTIALREG, "Only part of register set was writen/read"},
-    {TD_NOXREGS, "X register set not available for given thread"}
+    { TD_OK, "generic \"call succeeded\"" },
+    { TD_ERR, "generic error." },
+    { TD_NOTHR, "no thread can be found to satisfy query" },
+    { TD_NOSV, "no synch. variable can be found to satisfy query" },
+    { TD_NOLWP, "no lwp can be found to satisfy query" },
+    { TD_BADPH, "invalid process handle" },
+    { TD_BADTH, "invalid thread handle" },
+    { TD_BADSH, "invalid synchronization handle" },
+    { TD_BADTA, "invalid thread agent" },
+    { TD_BADKEY, "invalid key" },
+    { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
+    { TD_NOFPREGS, "FPU register set not available for given thread" },
+    { TD_NOLIBTHREAD, "application not linked with libthread" },
+    { TD_NOEVENT, "requested event is not supported" },
+    { TD_NOCAPAB, "capability not available" },
+    { TD_DBERR, "Debugger service failed" },
+    { TD_NOAPLIC, "Operation not applicable to" },
+    { TD_NOTSD, "No thread specific data for this thread" },
+    { TD_MALLOC, "Malloc failed" },
+    { TD_PARTIALREG, "Only part of register set was written/read" },
+    { TD_NOXREGS, "X register set not available for given thread" }
   };
   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
   int i;
@@ -232,45 +214,30 @@ td_err_string (errcode)
     if (td_err_table[i].num == errcode)
       return td_err_table[i].str;
 
-  sprintf (buf, "Unknown thread_db error code: %d", errcode);
+  sprintf (buf, "Unknown libthread_db error code: %d", errcode);
 
   return buf;
 }
-
-/*
-
-   LOCAL FUNCTION
 
-   td_state_string - Convert a thread_db state code to a string
-
-   SYNOPSIS
-
-   char * td_state_string (statecode)
-
-   DESCRIPTION
-
-   Return the thread_db state string associated with statecode.  If
-   statecode is unknown, then return a message.
-
- */
+/* Return the the libthread_db state string assicoated with STATECODE.
+   If STATECODE is unknown, return an appropriate message.  */
 
 static char *
-td_state_string (statecode)
-     td_thr_state_e statecode;
+td_state_string (td_thr_state_e statecode)
 {
-  static struct string_map
-    td_thr_state_table[] =
+  static struct string_map td_thr_state_table[] =
   {
-    {TD_THR_ANY_STATE, "any state"},
-    {TD_THR_UNKNOWN, "unknown"},
-    {TD_THR_STOPPED, "stopped"},
-    {TD_THR_RUN, "run"},
-    {TD_THR_ACTIVE, "active"},
-    {TD_THR_ZOMBIE, "zombie"},
-    {TD_THR_SLEEP, "sleep"},
-    {TD_THR_STOPPED_ASLEEP, "stopped asleep"}
+    { TD_THR_ANY_STATE, "any state" },
+    { TD_THR_UNKNOWN, "unknown" },
+    { TD_THR_STOPPED, "stopped" },
+    { TD_THR_RUN, "run" },
+    { TD_THR_ACTIVE, "active" },
+    { TD_THR_ZOMBIE, "zombie" },
+    { TD_THR_SLEEP, "sleep" },
+    { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
   };
-  const int td_thr_state_table_size = sizeof td_thr_state_table / sizeof (struct string_map);
+  const int td_thr_state_table_size =
+    sizeof td_thr_state_table / sizeof (struct string_map);
   int i;
   static char buf[50];
 
@@ -278,314 +245,228 @@ td_state_string (statecode)
     if (td_thr_state_table[i].num == statecode)
       return td_thr_state_table[i].str;
 
-  sprintf (buf, "Unknown thread_db state code: %d", statecode);
+  sprintf (buf, "Unknown libthread_db state code: %d", statecode);
 
   return buf;
 }
 
-/*
-
-   LOCAL FUNCTION
-
-   thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
-
-   SYNOPSIS
-
-   int thread_to_lwp (thread_id, default_lwp)
-
-   DESCRIPTION
 
-   This function converts a Posix or Solaris thread id to a lightweight
-   process id.  If thread_id is non-existent, that's an error.  If it's
-   an inactive thread, then we return default_lwp.
+/* Convert a POSIX or Solaris thread ID into a LWP ID.  If THREAD_ID
+   doesn't exist, that's an error.  If it's an inactive thread, return
+   DEFAULT_LPW.
 
-   NOTES
-
-   This function probably shouldn't call error()...
-
- */
+   NOTE: This function probably shouldn't call error().  */
 
-static int
-thread_to_lwp (thread_id, default_lwp)
-     int thread_id;
-     int default_lwp;
+static ptid_t
+thread_to_lwp (ptid_t thread_id, int default_lwp)
 {
   td_thrinfo_t ti;
   td_thrhandle_t th;
   td_err_e val;
 
   if (is_lwp (thread_id))
-    return thread_id;		/* It's already an LWP id */
+    return thread_id;		/* It's already an LWP ID.  */
 
-  /* It's a thread.  Convert to lwp */
+  /* It's a thread.  Convert to LWP.  */
 
   val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);	/* Thread must have terminated.  */
   else if (val != TD_OK)
-    error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));
+    error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
 
   val = p_td_thr_get_info (&th, &ti);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);	/* Thread must have terminated.  */
   else if (val != TD_OK)
-    error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));
+    error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
 
   if (ti.ti_state != TD_THR_ACTIVE)
     {
       if (default_lwp != -1)
-	return default_lwp;
-      error ("thread_to_lwp: thread state not active: %s",
+	return pid_to_ptid (default_lwp);
+      error (_("thread_to_lwp: thread state not active: %s"),
 	     td_state_string (ti.ti_state));
     }
 
   return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
 }
-
-/*
-
-   LOCAL FUNCTION
-
-   lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
 
-   SYNOPSIS
-
-   int lwp_to_thread (lwp_id)
-
-   DESCRIPTION
-
-   This function converts a lightweight process id to a Posix or Solaris
-   thread id.  If thread_id is non-existent, that's an error.
-
-   NOTES
-
-   This function probably shouldn't call error()...
+/* Convert an LWP ID into a POSIX or Solaris thread ID.  If LWP_ID
+   doesn't exists, that's an error.
 
- */
+   NOTE: This function probably shouldn't call error().  */
 
-static int
-lwp_to_thread (lwp)
-     int lwp;
+static ptid_t
+lwp_to_thread (ptid_t lwp)
 {
   td_thrinfo_t ti;
   td_thrhandle_t th;
   td_err_e val;
 
   if (is_thread (lwp))
-    return lwp;			/* It's already a thread id */
+    return lwp;			/* It's already a thread ID.  */
 
-  /* It's an lwp.  Convert it to a thread id.  */
+  /* It's an LWP.  Convert it to a thread ID.  */
 
   if (!sol_thread_alive (lwp))
-    return -1;			/* defunct lwp */
+    return pid_to_ptid (-1);	/* Must be a defunct LPW.  */
 
   val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);	/* Thread must have terminated.  */
   else if (val != TD_OK)
-    error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val));
+    error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
 
   val = p_td_thr_validate (&th);
   if (val == TD_NOTHR)
-    return lwp;			/* libthread doesn't know about it, just return lwp */
+    return lwp;			/* Unknown to libthread; just return LPW,  */
   else if (val != TD_OK)
-    error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));
+    error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
 
   val = p_td_thr_get_info (&th, &ti);
   if (val == TD_NOTHR)
-    return -1;			/* thread must have terminated */
+    return pid_to_ptid (-1);	/* Thread must have terminated.  */
   else if (val != TD_OK)
-    error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
+    error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
 
   return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
 }
 
-/*
 
-   LOCAL FUNCTION
-
-   save_inferior_pid - Save inferior_pid on the cleanup list
-   restore_inferior_pid - Restore inferior_pid from the cleanup list
-
-   SYNOPSIS
-
-   struct cleanup *save_inferior_pid ()
-   void restore_inferior_pid (int pid)
-
-   DESCRIPTION
-
-   These two functions act in unison to restore inferior_pid in
-   case of an error.
-
-   NOTES
-
-   inferior_pid is a global variable that needs to be changed by many of
-   these routines before calling functions in procfs.c.  In order to
-   guarantee that inferior_pid gets restored (in case of errors), you
-   need to call save_inferior_pid before changing it.  At the end of the
-   function, you should invoke do_cleanups to restore it.
-
- */
-
-
-static struct cleanup *
-save_inferior_pid ()
-{
-  return make_cleanup (restore_inferior_pid, (void *) inferior_pid);
-}
+/* Most target vector functions from here on actually just pass
+   through to procfs.c, as they don't need to do anything specific for
+   threads.  */
 
 static void
-restore_inferior_pid (pid)
-     void *pid;
-{
-  inferior_pid = (int) pid;
-}
-
-
-/* Most target vector functions from here on actually just pass through to
-   procfs.c, as they don't need to do anything specific for threads.  */
-
-
-/* ARGSUSED */
-static void
-sol_thread_open (arg, from_tty)
-     char *arg;
-     int from_tty;
+sol_thread_open (char *arg, int from_tty)
 {
   procfs_ops.to_open (arg, from_tty);
 }
 
-/* Attach to process PID, then initialize for debugging it
-   and wait for the trace-trap that results from attaching.  */
+/* Attach to process PID, then initialize for debugging it and wait
+   for the trace-trap that results from attaching.  */
 
 static void
-sol_thread_attach (args, from_tty)
-     char *args;
-     int from_tty;
+sol_thread_attach (char *args, int from_tty)
 {
   procfs_ops.to_attach (args, from_tty);
-  /* Must get symbols from solibs before libthread_db can run! */
-  SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0);
+
+  /* Must get symbols from shared libraries before libthread_db can run!  */
+  solib_add (NULL, from_tty, (struct target_ops *) 0, auto_solib_add);
+
   if (sol_thread_active)
     {
       printf_filtered ("sol-thread active.\n");
-      main_ph.pid = inferior_pid;	/* Save for xfer_memory */
+      main_ph.ptid = inferior_ptid; /* Save for xfer_memory.  */
       push_target (&sol_thread_ops);
-      inferior_pid = lwp_to_thread (inferior_pid);
-      if (inferior_pid == -1)
-	inferior_pid = main_ph.pid;
+      inferior_ptid = lwp_to_thread (inferior_ptid);
+      if (PIDGET (inferior_ptid) == -1)
+	inferior_ptid = main_ph.ptid;
       else
-	add_thread (inferior_pid);
+	add_thread (inferior_ptid);
     }
-  /* XXX - might want to iterate over all the threads and register them. */
+
+  /* FIXME: Might want to iterate over all the threads and register
+     them.  */
 }
 
-/* Take a program previously attached to and detaches it.
-   The program resumes execution and will no longer stop
-   on signals, etc.  We'd better not have left any breakpoints
-   in the program or it'll die when it hits one.  For this
-   to work, it may be necessary for the process to have been
-   previously attached.  It *might* work if the program was
-   started via the normal ptrace (PTRACE_TRACEME).  */
+/* Take a program previously attached to and detaches it.  The program
+   resumes execution and will no longer stop on signals, etc.  We'd
+   better not have left any breakpoints in the program or it'll die
+   when it hits one.  For this to work, it may be necessary for the
+   process to have been previously attached.  It *might* work if the
+   program was started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
-sol_thread_detach (args, from_tty)
-     char *args;
-     int from_tty;
+sol_thread_detach (char *args, int from_tty)
 {
+  inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
   unpush_target (&sol_thread_ops);
   procfs_ops.to_detach (args, from_tty);
 }
 
-/* Resume execution of process PID.  If STEP is nozero, then
-   just single step it.  If SIGNAL is nonzero, restart it with that
-   signal activated.  We may have to convert pid from a thread-id to an LWP id
-   for procfs.  */
+/* Resume execution of process PTID.  If STEP is nozero, then just
+   single step it.  If SIGNAL is nonzero, restart it with that signal
+   activated.  We may have to convert PTID from a thread ID to an LWP
+   ID for procfs.  */
 
 static void
-sol_thread_resume (pid, step, signo)
-     int pid;
-     int step;
-     enum target_signal signo;
+sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
-  if (inferior_pid == -1)
-    inferior_pid = procfs_first_available ();
+  inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
+  if (PIDGET (inferior_ptid) == -1)
+    inferior_ptid = procfs_first_available ();
 
-  if (pid != -1)
+  if (PIDGET (ptid) != -1)
     {
-      int save_pid = pid;
-
-      pid = thread_to_lwp (pid, -2);
-      if (pid == -2)		/* Inactive thread */
-	error ("This version of Solaris can't start inactive threads.");
-      if (info_verbose && pid == -1)
-	warning ("Specified thread %d seems to have terminated",
-		 GET_THREAD (save_pid));
+      ptid_t save_ptid = ptid;
+
+      ptid = thread_to_lwp (ptid, -2);
+      if (PIDGET (ptid) == -2)		/* Inactive thread.  */
+	error (_("This version of Solaris can't start inactive threads."));
+      if (info_verbose && PIDGET (ptid) == -1)
+	warning (_("Specified thread %ld seems to have terminated"),
+		 GET_THREAD (save_ptid));
     }
 
-  procfs_ops.to_resume (pid, step, signo);
+  procfs_ops.to_resume (ptid, step, signo);
 
   do_cleanups (old_chain);
 }
 
-/* Wait for any threads to stop.  We may have to convert PID from a thread id
-   to a LWP id, and vice versa on the way out.  */
+/* Wait for any threads to stop.  We may have to convert PIID from a
+   thread ID to an LWP ID, and vice versa on the way out.  */
 
-static int
-sol_thread_wait (pid, ourstatus)
-     int pid;
-     struct target_waitstatus *ourstatus;
+static ptid_t
+sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 {
-  int rtnval;
-  int save_pid;
+  ptid_t rtnval;
+  ptid_t save_ptid;
   struct cleanup *old_chain;
 
-  save_pid = inferior_pid;
-  old_chain = save_inferior_pid ();
+  save_ptid = inferior_ptid;
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
-  if (inferior_pid == -1)
-    inferior_pid = procfs_first_available ();
+  inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
+  if (PIDGET (inferior_ptid) == -1)
+    inferior_ptid = procfs_first_available ();
 
-  if (pid != -1)
+  if (PIDGET (ptid) != -1)
     {
-      int save_pid = pid;
-
-      pid = thread_to_lwp (pid, -2);
-      if (pid == -2)		/* Inactive thread */
-	error ("This version of Solaris can't start inactive threads.");
-      if (info_verbose && pid == -1)
-	warning ("Specified thread %d seems to have terminated",
-		 GET_THREAD (save_pid));
+      ptid_t save_ptid = ptid;
+
+      ptid = thread_to_lwp (ptid, -2);
+      if (PIDGET (ptid) == -2)		/* Inactive thread.  */
+	error (_("This version of Solaris can't start inactive threads."));
+      if (info_verbose && PIDGET (ptid) == -1)
+	warning (_("Specified thread %ld seems to have terminated"),
+		 GET_THREAD (save_ptid));
     }
 
-  rtnval = procfs_ops.to_wait (pid, ourstatus);
+  rtnval = procfs_ops.to_wait (ptid, ourstatus);
 
   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
     {
-      /* Map the LWP of interest back to the appropriate thread ID */
+      /* Map the LWP of interest back to the appropriate thread ID.  */
       rtnval = lwp_to_thread (rtnval);
-      if (rtnval == -1)
-	rtnval = save_pid;
+      if (PIDGET (rtnval) == -1)
+	rtnval = save_ptid;
 
-      /* See if we have a new thread */
+      /* See if we have a new thread.  */
       if (is_thread (rtnval)
-	  && rtnval != save_pid
+	  && !ptid_equal (rtnval, save_ptid)
 	  && !in_thread_list (rtnval))
-	{
-	  printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
-	  add_thread (rtnval);
-	}
+	add_thread (rtnval);
     }
 
-  /* During process initialization, we may get here without the thread package
-     being initialized, since that can only happen after we've found the shared
-     libs.  */
+  /* During process initialization, we may get here without the thread
+     package being initialized, since that can only happen after we've
+     found the shared libs.  */
 
   do_cleanups (old_chain);
 
@@ -593,71 +474,70 @@ sol_thread_wait (pid, ourstatus)
 }
 
 static void
-sol_thread_fetch_registers (regno)
-     int regno;
+sol_thread_fetch_registers (struct regcache *regcache, int regnum)
 {
   thread_t thread;
   td_thrhandle_t thandle;
   td_err_e val;
   prgregset_t gregset;
   prfpregset_t fpregset;
+  gdb_gregset_t *gregset_p = &gregset;
+  gdb_fpregset_t *fpregset_p = &fpregset;
+
 #if 0
   int xregsize;
   caddr_t xregset;
 #endif
 
-  if (!is_thread (inferior_pid))
-    {				/* LWP: pass the request on to procfs.c */
+  if (!is_thread (inferior_ptid))
+    {
+      /* It's an LWP; pass the request on to procfs.  */
       if (target_has_execution)
-	procfs_ops.to_fetch_registers (regno);
+	procfs_ops.to_fetch_registers (regcache, regnum);
       else
-	orig_core_ops.to_fetch_registers (regno);
+	orig_core_ops.to_fetch_registers (regcache, regnum);
       return;
     }
 
-  /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
-
-  thread = GET_THREAD (inferior_pid);
-
+  /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
+  thread = GET_THREAD (inferior_ptid);
   if (thread == 0)
-    error ("sol_thread_fetch_registers:  thread == 0");
+    error (_("sol_thread_fetch_registers: thread == 0"));
 
   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
   if (val != TD_OK)
-    error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
+    error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
 	   td_err_string (val));
 
-  /* Get the integer regs */
+  /* Get the general-purpose registers.  */
 
   val = p_td_thr_getgregs (&thandle, gregset);
-  if (val != TD_OK
-      && val != TD_PARTIALREG)
-    error ("sol_thread_fetch_registers: td_thr_getgregs %s",
+  if (val != TD_OK && val != TD_PARTIALREG)
+    error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
 	   td_err_string (val));
 
-  /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
-     are saved (by a thread context switch).  */
+  /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
+     and %sp are saved (by a thread context switch).  */
 
-  /* And, now the fp regs */
+  /* And, now the floating-point registers.  */
 
   val = p_td_thr_getfpregs (&thandle, &fpregset);
-  if (val != TD_OK
-      && val != TD_NOFPREGS)
-    error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
+  if (val != TD_OK && val != TD_NOFPREGS)
+    error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
 	   td_err_string (val));
 
-/* Note that we must call supply_{g fp}regset *after* calling the td routines
-   because the td routines call ps_lget* which affect the values stored in the
-   registers array.  */
+  /* Note that we must call supply_gregset and supply_fpregset *after*
+     calling the td routines because the td routines call ps_lget*
+     which affect the values stored in the registers array.  */
 
-  supply_gregset (gregset);
-  supply_fpregset (&fpregset);
+  supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
+  supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
 
 #if 0
-/* thread_db doesn't seem to handle this right */
+  /* FIXME: libthread_db doesn't seem to handle this right.  */
   val = td_thr_getxregsize (&thandle, &xregsize);
   if (val != TD_OK && val != TD_NOXREGS)
-    error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
+    error (_("sol_thread_fetch_registers: td_thr_getxregsize %s"),
 	   td_err_string (val));
 
   if (val == TD_OK)
@@ -665,64 +545,65 @@ sol_thread_fetch_registers (regno)
       xregset = alloca (xregsize);
       val = td_thr_getxregs (&thandle, xregset);
       if (val != TD_OK)
-	error ("sol_thread_fetch_registers: td_thr_getxregs %s",
+	error (_("sol_thread_fetch_registers: td_thr_getxregs %s"),
 	       td_err_string (val));
     }
 #endif
 }
 
 static void
-sol_thread_store_registers (regno)
-     int regno;
+sol_thread_store_registers (struct regcache *regcache, int regnum)
 {
   thread_t thread;
   td_thrhandle_t thandle;
   td_err_e val;
-  prgregset_t regset;
+  prgregset_t gregset;
   prfpregset_t fpregset;
 #if 0
   int xregsize;
   caddr_t xregset;
 #endif
 
-  if (!is_thread (inferior_pid))
-    {				/* LWP: pass the request on to procfs.c */
-      procfs_ops.to_store_registers (regno);
+  if (!is_thread (inferior_ptid))
+    {
+      /* It's an LWP; pass the request on to procfs.c.  */
+      procfs_ops.to_store_registers (regcache, regnum);
       return;
     }
 
-  /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
-
-  thread = GET_THREAD (inferior_pid);
+  /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t.  */
+  thread = GET_THREAD (inferior_ptid);
 
   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
   if (val != TD_OK)
-    error ("sol_thread_store_registers: td_ta_map_id2thr %s",
+    error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
 	   td_err_string (val));
 
-  if (regno != -1)
-    {				/* Not writing all the regs */
-      /* save new register value */
-      char old_value[REGISTER_SIZE];
-      memcpy (old_value, &registers[REGISTER_BYTE (regno)], REGISTER_SIZE);
+  if (regnum != -1)
+    {
+      /* Not writing all the registers.  */
+      char old_value[MAX_REGISTER_SIZE];
 
-      val = p_td_thr_getgregs (&thandle, regset);
+      /* Save new register value.  */
+      regcache_raw_collect (regcache, regnum, old_value);
+
+      val = p_td_thr_getgregs (&thandle, gregset);
       if (val != TD_OK)
-	error ("sol_thread_store_registers: td_thr_getgregs %s",
+	error (_("sol_thread_store_registers: td_thr_getgregs %s"),
 	       td_err_string (val));
       val = p_td_thr_getfpregs (&thandle, &fpregset);
       if (val != TD_OK)
-	error ("sol_thread_store_registers: td_thr_getfpregs %s",
+	error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
 	       td_err_string (val));
 
-      /* restore new register value */
-      memcpy (&registers[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);
+      /* Restore new register value.  */
+      regcache_raw_supply (regcache, regnum, old_value);
 
 #if 0
-/* thread_db doesn't seem to handle this right */
+      /* FIXME: libthread_db doesn't seem to handle this right.  */
       val = td_thr_getxregsize (&thandle, &xregsize);
       if (val != TD_OK && val != TD_NOXREGS)
-	error ("sol_thread_store_registers: td_thr_getxregsize %s",
+	error (_("sol_thread_store_registers: td_thr_getxregsize %s"),
 	       td_err_string (val));
 
       if (val == TD_OK)
@@ -730,71 +611,117 @@ sol_thread_store_registers (regno)
 	  xregset = alloca (xregsize);
 	  val = td_thr_getxregs (&thandle, xregset);
 	  if (val != TD_OK)
-	    error ("sol_thread_store_registers: td_thr_getxregs %s",
+	    error (_("sol_thread_store_registers: td_thr_getxregs %s"),
 		   td_err_string (val));
 	}
 #endif
     }
 
-  fill_gregset (regset, regno);
-  fill_fpregset (&fpregset, regno);
+  fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
+  fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
 
-  val = p_td_thr_setgregs (&thandle, regset);
+  val = p_td_thr_setgregs (&thandle, gregset);
   if (val != TD_OK)
-    error ("sol_thread_store_registers: td_thr_setgregs %s",
+    error (_("sol_thread_store_registers: td_thr_setgregs %s"),
 	   td_err_string (val));
   val = p_td_thr_setfpregs (&thandle, &fpregset);
   if (val != TD_OK)
-    error ("sol_thread_store_registers: td_thr_setfpregs %s",
+    error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
 	   td_err_string (val));
 
 #if 0
-/* thread_db doesn't seem to handle this right */
+  /* FIXME: libthread_db doesn't seem to handle this right.  */
   val = td_thr_getxregsize (&thandle, &xregsize);
   if (val != TD_OK && val != TD_NOXREGS)
-    error ("sol_thread_store_registers: td_thr_getxregsize %s",
+    error (_("sol_thread_store_registers: td_thr_getxregsize %s"),
 	   td_err_string (val));
 
-  /* Should probably do something about writing the xregs here, but what are
-     they? */
+  /* ??? Should probably do something about writing the xregs here,
+     but what are they?  */
 #endif
 }
 
 /* Get ready to modify the registers array.  On machines which store
-   individual registers, this doesn't need to do anything.  On machines
-   which store all the registers in one fell swoop, this makes sure
-   that registers contains all the registers from the program being
-   debugged.  */
+   individual registers, this doesn't need to do anything.  On
+   machines which store all the registers in one fell swoop, this
+   makes sure that registers contains all the registers from the
+   program being debugged.  */
 
 static void
-sol_thread_prepare_to_store ()
+sol_thread_prepare_to_store (struct regcache *regcache)
 {
-  procfs_ops.to_prepare_to_store ();
+  procfs_ops.to_prepare_to_store (regcache);
 }
 
+/* Transfer LEN bytes between GDB address MYADDR and target address
+   MEMADDR.  If DOWRITE is non-zero, transfer them to the target,
+   otherwise transfer them from the target.  TARGET is unused.
+
+   Returns the number of bytes transferred.  */
+
 static int
-sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int dowrite;
-     struct target_ops *target;	/* ignored */
+sol_thread_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+			int dowrite, struct mem_attrib *attrib,
+			struct target_ops *target)
 {
   int retval;
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  if (is_thread (inferior_pid) ||	/* A thread */
-      !target_thread_alive (inferior_pid))	/* An lwp, but not alive */
-    inferior_pid = procfs_first_available ();	/* Find any live lwp.  */
-  /* Note: don't need to call switch_to_thread; we're just reading memory.  */
+  if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
+    {
+      /* It's either a thread or an LWP that isn't alive.  Any live
+         LWP will do so use the first available.
+
+	 NOTE: We don't need to call switch_to_thread; we're just
+	 reading memory.  */
+      inferior_ptid = procfs_first_available ();
+    }
 
   if (target_has_execution)
-    retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
+    retval = procfs_ops.deprecated_xfer_memory (memaddr, myaddr, len,
+						dowrite, attrib, target);
   else
-    retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
-					   dowrite, target);
+    retval = orig_core_ops.deprecated_xfer_memory (memaddr, myaddr, len,
+						   dowrite, attrib, target);
+
+  do_cleanups (old_chain);
+
+  return retval;
+}
+
+/* Perform partial transfers on OBJECT.  See target_read_partial and
+   target_write_partial for details of each variant.  One, and only
+   one, of readbuf or writebuf must be non-NULL.  */
+
+static LONGEST
+sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
+			  const char *annex, gdb_byte *readbuf,
+			  const gdb_byte *writebuf,
+			 ULONGEST offset, LONGEST len)
+{
+  int retval;
+  struct cleanup *old_chain;
+
+  old_chain = save_inferior_ptid ();
+
+  if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
+    {
+      /* It's either a thread or an LWP that isn't alive.  Any live
+         LWP will do so use the first available.
+
+	 NOTE: We don't need to call switch_to_thread; we're just
+	 reading memory.  */
+      inferior_ptid = procfs_first_available ();
+    }
+
+  if (target_has_execution)
+    retval = procfs_ops.to_xfer_partial (ops, object, annex,
+					 readbuf, writebuf, offset, len);
+  else
+    retval = orig_core_ops.to_xfer_partial (ops, object, annex,
+					    readbuf, writebuf, offset, len);
 
   do_cleanups (old_chain);
 
@@ -804,85 +731,88 @@ sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
 /* Print status information about what we're accessing.  */
 
 static void
-sol_thread_files_info (ignore)
-     struct target_ops *ignore;
+sol_thread_files_info (struct target_ops *ignore)
 {
   procfs_ops.to_files_info (ignore);
 }
 
 static void
-sol_thread_kill_inferior ()
+sol_thread_kill_inferior (void)
 {
   procfs_ops.to_kill ();
 }
 
 static void
-sol_thread_notice_signals (pid)
-     int pid;
+sol_thread_notice_signals (ptid_t ptid)
 {
-  procfs_ops.to_notice_signals (PIDGET (pid));
+  procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid)));
 }
 
 /* Fork an inferior process, and start debugging it with /proc.  */
 
 static void
-sol_thread_create_inferior (exec_file, allargs, env)
-     char *exec_file;
-     char *allargs;
-     char **env;
+sol_thread_create_inferior (char *exec_file, char *allargs, char **env,
+			    int from_tty)
 {
-  procfs_ops.to_create_inferior (exec_file, allargs, env);
+  procfs_ops.to_create_inferior (exec_file, allargs, env, from_tty);
 
-  if (sol_thread_active && inferior_pid != 0)
+  if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
     {
-      main_ph.pid = inferior_pid;	/* Save for xfer_memory */
+      /* Save for xfer_memory.  */
+      main_ph.ptid = inferior_ptid;
 
       push_target (&sol_thread_ops);
 
-      inferior_pid = lwp_to_thread (inferior_pid);
-      if (inferior_pid == -1)
-	inferior_pid = main_ph.pid;
+      inferior_ptid = lwp_to_thread (inferior_ptid);
+      if (PIDGET (inferior_ptid) == -1)
+	inferior_ptid = main_ph.ptid;
 
-      add_thread (inferior_pid);
+      if (!in_thread_list (inferior_ptid))
+	add_thread (inferior_ptid);
     }
 }
 
-/* This routine is called whenever a new symbol table is read in, or when all
-   symbol tables are removed.  libthread_db can only be initialized when it
-   finds the right variables in libthread.so.  Since it's a shared library,
-   those variables don't show up until the library gets mapped and the symbol
-   table is read in.  */
+/* This routine is called whenever a new symbol table is read in, or
+   when all symbol tables are removed.  libthread_db can only be
+   initialized when it finds the right variables in libthread.so.
+   Since it's a shared library, those variables don't show up until
+   the library gets mapped and the symbol table is read in.  */
 
-void
-sol_thread_new_objfile (objfile)
-     struct objfile *objfile;
+static void
+sol_thread_new_objfile (struct objfile *objfile)
 {
   td_err_e val;
 
   if (!objfile)
     {
       sol_thread_active = 0;
-
       return;
     }
 
-  /* don't do anything if init failed to resolve the libthread_db library */
+  /* Don't do anything if init failed to resolve the libthread_db
+     library.  */
   if (!procfs_suppress_run)
     return;
 
-  /* Now, initialize the thread debugging library.  This needs to be done after
-     the shared libraries are located because it needs information from the
-     user's thread library.  */
+  /* Now, initialize libthread_db.  This needs to be done after the
+     shared libraries are located because it needs information from
+     the user's thread library.  */
 
   val = p_td_init ();
   if (val != TD_OK)
-    error ("target_new_objfile: td_init: %s", td_err_string (val));
+    {
+      warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (val));
+      return;
+    }
 
   val = p_td_ta_new (&main_ph, &main_ta);
   if (val == TD_NOLIBTHREAD)
     return;
   else if (val != TD_OK)
-    error ("target_new_objfile: td_ta_new: %s", td_err_string (val));
+    {
+      warning (_("sol_thread_new_objfile: td_ta_new: %s"), td_err_string (val));
+      return;
+    }
 
   sol_thread_active = 1;
 }
@@ -890,21 +820,22 @@ sol_thread_new_objfile (objfile)
 /* Clean up after the inferior dies.  */
 
 static void
-sol_thread_mourn_inferior ()
+sol_thread_mourn_inferior (void)
 {
   unpush_target (&sol_thread_ops);
   procfs_ops.to_mourn_inferior ();
 }
 
-/* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
+/* Mark our target-struct as eligible for stray "run" and "attach"
+   commands.  */
 
 static int
-sol_thread_can_run ()
+sol_thread_can_run (void)
 {
   return procfs_suppress_run;
 }
 
-/* 
+/*
 
    LOCAL FUNCTION
 
@@ -912,7 +843,7 @@ sol_thread_can_run ()
 
    SYNOPSIS
 
-   static bool sol_thread_alive (int pid);
+   static bool sol_thread_alive (ptid_t ptid);
 
    DESCRIPTION
 
@@ -920,73 +851,78 @@ sol_thread_can_run ()
 
  */
 
+/* Return true if PTID is still active in the inferior.  */
+
 static int
-sol_thread_alive (pid)
-     int pid;
+sol_thread_alive (ptid_t ptid)
 {
-  if (is_thread (pid))		/* non-kernel thread */
+  if (is_thread (ptid))
     {
+      /* It's a (user-level) thread.  */
       td_err_e val;
       td_thrhandle_t th;
+      int pid;
 
-      pid = GET_THREAD (pid);
+      pid = GET_THREAD (ptid);
       if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
-	return 0;		/* thread not found */
+	return 0;		/* Thread not found.  */
       if ((val = p_td_thr_validate (&th)) != TD_OK)
-	return 0;		/* thread not valid */
-      return 1;			/* known thread: return true */
+	return 0;		/* Thread not valid.  */
+      return 1;			/* Known thread.  */
     }
   else
-    /* kernel thread (LWP): let procfs test it */
     {
+      /* It's an LPW; pass the request on to procfs.  */
       if (target_has_execution)
-	return procfs_ops.to_thread_alive (pid);
+	return procfs_ops.to_thread_alive (ptid);
       else
-	return orig_core_ops.to_thread_alive (pid);
+	return orig_core_ops.to_thread_alive (ptid);
     }
 }
 
 static void
-sol_thread_stop ()
+sol_thread_stop (ptid_t ptid)
 {
-  procfs_ops.to_stop ();
+  procfs_ops.to_stop (ptid);
 }
 
-/* These routines implement the lower half of the thread_db interface.  Ie: the
-   ps_* routines.  */
+/* These routines implement the lower half of the thread_db interface,
+   i.e. the ps_* routines.  */
 
-/* Various versions of <proc_service.h> have slightly
-   different function prototypes.  In particular, we have
+/* Various versions of <proc_service.h> have slightly different
+   function prototypes.  In particular, we have
 
    NEWER                        OLDER
    struct ps_prochandle *       const struct ps_prochandle *
    void*                        char*
-   const void*          char*
-   int                  size_t
+   const void*          	char*
+   int                  	size_t
 
-   Which one you have depends on solaris version and what
-   patches you've applied.  On the theory that there are
-   only two major variants, we have configure check the
-   prototype of ps_pdwrite (), and use that info to make
-   appropriate typedefs here. */
+   Which one you have depends on the Solaris version and what patches
+   you've applied.  On the theory that there are only two major
+   variants, we have configure check the prototype of ps_pdwrite (),
+   and use that info to make appropriate typedefs here. */
 
 #ifdef PROC_SERVICE_IS_OLD
 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
 typedef char *gdb_ps_read_buf_t;
 typedef char *gdb_ps_write_buf_t;
 typedef int gdb_ps_size_t;
+typedef psaddr_t gdb_ps_addr_t;
 #else
 typedef struct ps_prochandle *gdb_ps_prochandle_t;
 typedef void *gdb_ps_read_buf_t;
 typedef const void *gdb_ps_write_buf_t;
 typedef size_t gdb_ps_size_t;
+typedef psaddr_t gdb_ps_addr_t;
 #endif
 
+/* The next four routines are called by libthread_db to tell us to
+   stop and stop a particular process or lwp.  Since GDB ensures that
+   these are all stopped by the time we call anything in thread_db,
+   these routines need to do nothing.  */
 
-/* The next four routines are called by thread_db to tell us to stop and stop
-   a particular process or lwp.  Since GDB ensures that these are all stopped
-   by the time we call anything in thread_db, these routines need to do
-   nothing.  */
+/* Process stop.  */
 
 ps_err_e
 ps_pstop (gdb_ps_prochandle_t ph)
@@ -994,63 +930,84 @@ ps_pstop (gdb_ps_prochandle_t ph)
   return PS_OK;
 }
 
+/* Process continue.  */
+
 ps_err_e
 ps_pcontinue (gdb_ps_prochandle_t ph)
 {
   return PS_OK;
 }
 
+/* LWP stop.  */
+
 ps_err_e
 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 {
   return PS_OK;
 }
 
+/* LWP continue.  */
+
 ps_err_e
 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
 {
   return PS_OK;
 }
 
+/* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table.  */
+
 ps_err_e
 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
-		   const char *ld_symbol_name, paddr_t * ld_symbol_addr)
+		   const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
 {
   struct minimal_symbol *ms;
 
   ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
-
   if (!ms)
     return PS_NOSYM;
 
   *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
-
   return PS_OK;
 }
 
 /* Common routine for reading and writing memory.  */
 
 static ps_err_e
-rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
+rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
 	   char *buf, int size)
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
+
+  if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
+    {
+      /* It's either a thread or an LWP that isn't alive.  Any live
+         LWP will do so use the first available.
+
+	 NOTE: We don't need to call switch_to_thread; we're just
+	 reading memory.  */
+      inferior_ptid = procfs_first_available ();
+    }
 
-  if (is_thread (inferior_pid) ||	/* A thread */
-      !target_thread_alive (inferior_pid))	/* An lwp, but not alive */
-    inferior_pid = procfs_first_available ();	/* Find any live lwp.  */
-  /* Note: don't need to call switch_to_thread; we're just reading memory.  */
+#if defined (__sparcv9)
+  /* For Sparc64 cross Sparc32, make sure the address has not been
+     accidentally sign-extended (or whatever) to beyond 32 bits.  */
+  if (bfd_get_arch_size (exec_bfd) == 32)
+    addr &= 0xffffffff;
+#endif
 
   while (size > 0)
     {
       int cc;
 
+      /* FIXME: passing 0 as attrib argument.  */
       if (target_has_execution)
-	cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
+	cc = procfs_ops.deprecated_xfer_memory (addr, buf, size,
+						dowrite, 0, &procfs_ops);
       else
-	cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, &core_ops);
+	cc = orig_core_ops.deprecated_xfer_memory (addr, buf, size,
+						   dowrite, 0, &core_ops);
 
       if (cc < 0)
 	{
@@ -1063,6 +1020,20 @@ rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
 
 	  return PS_ERR;
 	}
+      else if (cc == 0)
+	{
+	  if (dowrite == 0)
+	    warning (_("rw_common (): unable to read at addr 0x%lx"),
+		     (long) addr);
+	  else
+	    warning (_("rw_common (): unable to write at addr 0x%lx"),
+		     (long) addr);
+
+	  do_cleanups (old_chain);
+
+	  return PS_ERR;
+	}
+
       size -= cc;
       buf += cc;
     }
@@ -1072,82 +1043,95 @@ rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
   return PS_OK;
 }
 
+/* Copies SIZE bytes from target process .data segment to debugger memory.  */
+
 ps_err_e
-ps_pdread (gdb_ps_prochandle_t ph, paddr_t addr,
+ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 	   gdb_ps_read_buf_t buf, gdb_ps_size_t size)
 {
   return rw_common (0, ph, addr, buf, size);
 }
 
+/* Copies SIZE bytes from debugger memory .data segment to target process.  */
+
 ps_err_e
-ps_pdwrite (gdb_ps_prochandle_t ph, paddr_t addr,
+ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 	    gdb_ps_write_buf_t buf, gdb_ps_size_t size)
 {
   return rw_common (1, ph, addr, (char *) buf, size);
 }
 
+/* Copies SIZE bytes from target process .text segment to debugger memory.  */
+
 ps_err_e
-ps_ptread (gdb_ps_prochandle_t ph, paddr_t addr,
+ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 	   gdb_ps_read_buf_t buf, gdb_ps_size_t size)
 {
   return rw_common (0, ph, addr, buf, size);
 }
 
+/* Copies SIZE bytes from debugger memory .text segment to target process.  */
+
 ps_err_e
-ps_ptwrite (gdb_ps_prochandle_t ph, paddr_t addr,
+ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
 	    gdb_ps_write_buf_t buf, gdb_ps_size_t size)
 {
   return rw_common (1, ph, addr, (char *) buf, size);
 }
 
-/* Get integer regs */
+/* Get general-purpose registers for LWP.  */
 
 ps_err_e
-ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
-	     prgregset_t gregset)
+ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
 {
   struct cleanup *old_chain;
+  struct regcache *regcache;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+  regcache = get_thread_regcache (inferior_ptid);
 
   if (target_has_execution)
-    procfs_ops.to_fetch_registers (-1);
+    procfs_ops.to_fetch_registers (regcache, -1);
   else
-    orig_core_ops.to_fetch_registers (-1);
-  fill_gregset (gregset, -1);
+    orig_core_ops.to_fetch_registers (regcache, -1);
+  fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 
-/* Set integer regs */
+/* Set general-purpose registers for LWP.  */
 
 ps_err_e
 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 	     const prgregset_t gregset)
 {
   struct cleanup *old_chain;
+  struct regcache *regcache;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+  regcache = get_thread_regcache (inferior_ptid);
 
-  supply_gregset (gregset);
+  supply_gregset (regcache, (const gdb_gregset_t *) gregset);
   if (target_has_execution)
-    procfs_ops.to_store_registers (-1);
+    procfs_ops.to_store_registers (regcache, -1);
   else
-    orig_core_ops.to_store_registers (-1);
+    orig_core_ops.to_store_registers (regcache, -1);
 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 
+/* Log a message (sends to gdb_stderr).  */
+
 void
-ps_plog (const char *fmt,...)
+ps_plog (const char *fmt, ...)
 {
   va_list args;
 
@@ -1230,230 +1214,225 @@ ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
   return PS_OK;
 }
 
-/* Get floating-point regs.  */
+/* Get floating-point registers for LWP.  */
 
 ps_err_e
 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
-	       prfpregset_t * fpregset)
+	       prfpregset_t *fpregset)
 {
   struct cleanup *old_chain;
+  struct regcache *regcache;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+  regcache = get_thread_regcache (inferior_ptid);
 
   if (target_has_execution)
-    procfs_ops.to_fetch_registers (-1);
+    procfs_ops.to_fetch_registers (regcache, -1);
   else
-    orig_core_ops.to_fetch_registers (-1);
-  fill_fpregset (fpregset, -1);
+    orig_core_ops.to_fetch_registers (regcache, -1);
+  fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 
-/* Set floating-point regs.  */
+/* Set floating-point regs for LWP */
 
 ps_err_e
 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 	       const prfpregset_t * fpregset)
 {
   struct cleanup *old_chain;
+  struct regcache *regcache;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+  regcache = get_thread_regcache (inferior_ptid);
 
-  supply_fpregset (fpregset);
+  supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
   if (target_has_execution)
-    procfs_ops.to_store_registers (-1);
+    procfs_ops.to_store_registers (regcache, -1);
   else
-    orig_core_ops.to_store_registers (-1);
+    orig_core_ops.to_store_registers (regcache, -1);
 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 
-#ifdef TM_I386SOL2_H
+#ifdef PR_MODEL_LP64
+/* Identify process as 32-bit or 64-bit.  At the moment we're using
+   BFD to do this.  There might be a more Solaris-specific
+   (e.g. procfs) method, but this ought to work.  */
 
-/* Get local descriptor table.  */
+ps_err_e
+ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
+{
+  if (exec_bfd == 0)
+    *data_model = PR_MODEL_UNKNOWN;
+  else if (bfd_get_arch_size (exec_bfd) == 32)
+    *data_model = PR_MODEL_ILP32;
+  else
+    *data_model = PR_MODEL_LP64;
+
+  return PS_OK;
+}
+#endif /* PR_MODEL_LP64 */
 
-#include <sys/procfs.h>
-#include <sys/reg.h>
-#include <sys/sysi86.h>
+#if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
 
-static int nldt_allocated = 0;
-static struct ssd *ldt_bufp = NULL;
+/* Reads the local descriptor table of a LWP.
+
+   This function is necessary on x86-solaris only.  Without it, the loading
+   of libthread_db would fail because of ps_lgetLDT being undefined.  */
 
 ps_err_e
 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 	    struct ssd *pldt)
 {
-  gregset_t gregset;
-  int lwp_fd;
-  ps_err_e val;
-  int nldt;
-  int i;
-
-  /* Get procfs file descriptor for the LWP.  */
-  lwp_fd = procfs_get_pid_fd (BUILD_LWP (lwpid, PIDGET (inferior_pid)));
-  if (lwp_fd < 0)
-    return PS_BADLID;
+  /* NOTE: only used on Solaris, therefore OK to refer to procfs.c.  */
+  extern struct ssd *procfs_find_LDT_entry (ptid_t);
+  struct ssd *ret;
 
-  /* Fetch registers und LDT descriptors.  */
-  if (ioctl (lwp_fd, PIOCGREG, &gregset) == -1)
-    return PS_ERR;
+  /* FIXME: can't I get the process ID from the prochandle or
+     something?  */
 
-  if (ioctl (lwp_fd, PIOCNLDT, &nldt) == -1)
-    return PS_ERR;
+  if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
+    return PS_BADLID;
 
-  if (nldt_allocated < nldt)
+  ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
+  if (ret)
     {
-      ldt_bufp
-	= (struct ssd *) xrealloc (ldt_bufp, (nldt + 1) * sizeof (struct ssd));
-      nldt_allocated = nldt;
+      memcpy (pldt, ret, sizeof (struct ssd));
+      return PS_OK;
     }
-
-  if (ioctl (lwp_fd, PIOCLDT, ldt_bufp) == -1)
+  else
+    /* LDT not found.  */
     return PS_ERR;
-
-  /* Search LDT for the LWP via register GS.  */
-  for (i = 0; i < nldt; i++)
-    {
-      if (ldt_bufp[i].sel == (gregset[GS] & 0xffff))
-	{
-	  *pldt = ldt_bufp[i];
-	  return PS_OK;
-	}
-    }
-
-  /* LDT not found.  */
-  return PS_ERR;
 }
-#endif /* TM_I386SOL2_H */
+#endif
 
-/* Convert a pid to printable form. */
+
+/* Convert PTID to printable form.  */
 
 char *
-solaris_pid_to_str (pid)
-     int pid;
+solaris_pid_to_str (ptid_t ptid)
 {
   static char buf[100];
 
-  /* in case init failed to resolve the libthread_db library */
+  /* In case init failed to resolve the libthread_db library.  */
   if (!procfs_suppress_run)
-    return procfs_pid_to_str (pid);
+    return procfs_pid_to_str (ptid);
 
-  if (is_thread (pid))
+  if (is_thread (ptid))
     {
-      int lwp;
+      ptid_t lwp;
 
-      lwp = thread_to_lwp (pid, -2);
+      lwp = thread_to_lwp (ptid, -2);
 
-      if (lwp == -1)
-	sprintf (buf, "Thread %d (defunct)", GET_THREAD (pid));
-      else if (lwp != -2)
-	sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp));
+      if (PIDGET (lwp) == -1)
+	sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid));
+      else if (PIDGET (lwp) != -2)
+	sprintf (buf, "Thread %ld (LWP %ld)",
+		 GET_THREAD (ptid), GET_LWP (lwp));
       else
-	sprintf (buf, "Thread %d        ", GET_THREAD (pid));
+	sprintf (buf, "Thread %ld        ", GET_THREAD (ptid));
     }
-  else if (GET_LWP (pid) != 0)
-    sprintf (buf, "LWP    %d        ", GET_LWP (pid));
+  else if (GET_LWP (ptid) != 0)
+    sprintf (buf, "LWP    %ld        ", GET_LWP (ptid));
   else
-    sprintf (buf, "process %d    ", PIDGET (pid));
+    sprintf (buf, "process %d    ", PIDGET (ptid));
 
   return buf;
 }
 
 
-/* Worker bee for find_new_threads
-   Callback function that gets called once per USER thread (i.e., not
-   kernel) thread. */
+/* Worker bee for find_new_threads.  Callback function that gets
+   called once per user-level thread (i.e. not for LWP's).  */
 
 static int
-sol_find_new_threads_callback (th, ignored)
-     const td_thrhandle_t *th;
-     void *ignored;
+sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
 {
   td_err_e retval;
   td_thrinfo_t ti;
-  int pid;
+  ptid_t ptid;
 
-  if ((retval = p_td_thr_get_info (th, &ti)) != TD_OK)
-    {
-      return -1;
-    }
-  pid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_pid));
-  if (!in_thread_list (pid))
-    add_thread (pid);
+  retval = p_td_thr_get_info (th, &ti);
+  if (retval != TD_OK)
+    return -1;
+
+  ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
+  if (!in_thread_list (ptid))
+    add_thread (ptid);
 
   return 0;
 }
 
-void
-sol_find_new_threads ()
+static void
+sol_find_new_threads (void)
 {
-  /* don't do anything if init failed to resolve the libthread_db library */
+  /* Don't do anything if init failed to resolve the libthread_db
+     library.  */
   if (!procfs_suppress_run)
     return;
 
-  if (inferior_pid == -1)
+  if (PIDGET (inferior_ptid) == -1)
     {
       printf_filtered ("No process.\n");
       return;
     }
+
+  /* First Find any new LWP's.  */
+  procfs_ops.to_find_new_threads ();
+
+  /* Then find any new user-level threads.  */
   p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
 		    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 		    TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 }
 
 static void
-sol_core_open (filename, from_tty)
-     char *filename;
-     int from_tty;
+sol_core_open (char *filename, int from_tty)
 {
   orig_core_ops.to_open (filename, from_tty);
 }
 
 static void
-sol_core_close (quitting)
-     int quitting;
+sol_core_close (int quitting)
 {
   orig_core_ops.to_close (quitting);
 }
 
 static void
-sol_core_detach (args, from_tty)
-     char *args;
-     int from_tty;
+sol_core_detach (char *args, int from_tty)
 {
   unpush_target (&core_ops);
   orig_core_ops.to_detach (args, from_tty);
 }
 
 static void
-sol_core_files_info (t)
-     struct target_ops *t;
+sol_core_files_info (struct target_ops *t)
 {
   orig_core_ops.to_files_info (t);
 }
 
-/* Worker bee for info sol-thread command.  This is a callback function that
-   gets called once for each Solaris thread (ie. not kernel thread) in the 
-   inferior.  Print anything interesting that we can think of.  */
+/* Worker bee for the "info sol-thread" command.  This is a callback
+   function that gets called once for each Solaris user-level thread
+   (i.e. not for LWPs) in the inferior.  Print anything interesting
+   that we can think of.  */
 
 static int
-info_cb (th, s)
-     const td_thrhandle_t *th;
-     void *s;
+info_cb (const td_thrhandle_t *th, void *s)
 {
   td_err_e ret;
   td_thrinfo_t ti;
-  struct minimal_symbol *msym;
 
-  if ((ret = p_td_thr_get_info (th, &ti)) == TD_OK)
+  ret = p_td_thr_get_info (th, &ti);
+  if (ret == TD_OK)
     {
       printf_filtered ("%s thread #%d, lwp %d, ",
 		       ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",
@@ -1483,36 +1462,45 @@ info_cb (th, s)
 	  printf_filtered ("(stopped asleep)");
 	  break;
 	}
-      /* Print thr_create start function: */
+      /* Print thr_create start function.  */
       if (ti.ti_startfunc != 0)
-	if (msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc))
-	  printf_filtered ("   startfunc: %s\n", SYMBOL_NAME (msym));
-	else
-	  printf_filtered ("   startfunc: 0x%08x\n", ti.ti_startfunc);
+	{
+	  struct minimal_symbol *msym;
+	  msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
+	  if (msym)
+	    printf_filtered ("   startfunc: %s\n",
+			     DEPRECATED_SYMBOL_NAME (msym));
+	  else
+	    printf_filtered ("   startfunc: 0x%s\n", paddr (ti.ti_startfunc));
+	}
 
-      /* If thread is asleep, print function that went to sleep: */
+      /* If thread is asleep, print function that went to sleep.  */
       if (ti.ti_state == TD_THR_SLEEP)
-	if (msym = lookup_minimal_symbol_by_pc (ti.ti_pc))
-	  printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym));
-	else
-	  printf_filtered (" - Sleep func: 0x%08x\n", ti.ti_startfunc);
+	{
+	  struct minimal_symbol *msym;
+	  msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
+	  if (msym)
+	    printf_filtered (" - Sleep func: %s\n",
+			     DEPRECATED_SYMBOL_NAME (msym));
+	  else
+	    printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
+	}
 
-      /* Wrap up line, if necessary */
+      /* Wrap up line, if necessary.  */
       if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
 	printf_filtered ("\n");	/* don't you hate counting newlines? */
     }
   else
-    warning ("info sol-thread: failed to get info for thread.");
+    warning (_("info sol-thread: failed to get info for thread."));
 
   return 0;
 }
 
-/* List some state about each Solaris user thread in the inferior.  */
+/* List some state about each Solaris user-level thread in the
+   inferior.  */
 
 static void
-info_solthreads (args, from_tty)
-     char *args;
-     int from_tty;
+info_solthreads (char *args, int from_tty)
 {
   p_td_ta_thr_iter (main_ta, info_cb, args,
 		    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
@@ -1520,22 +1508,32 @@ info_solthreads (args, from_tty)
 }
 
 static int
-ignore (addr, contents)
-     CORE_ADDR addr;
-     char *contents;
+sol_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
+				      int, int, int, void *),
+			 void *data)
 {
-  return 0;
+  return procfs_ops.to_find_memory_regions (func, data);
 }
 
+static char *
+sol_make_note_section (bfd *obfd, int *note_size)
+{
+  return procfs_ops.to_make_corefile_notes (obfd, note_size);
+}
+
+static int
+ignore (struct bp_target_info *bp_tgt)
+{
+  return 0;
+}
 
 static void
-init_sol_thread_ops ()
+init_sol_thread_ops (void)
 {
   sol_thread_ops.to_shortname = "solaris-threads";
   sol_thread_ops.to_longname = "Solaris threads and pthread.";
   sol_thread_ops.to_doc = "Solaris threads and pthread support.";
   sol_thread_ops.to_open = sol_thread_open;
-  sol_thread_ops.to_close = 0;
   sol_thread_ops.to_attach = sol_thread_attach;
   sol_thread_ops.to_detach = sol_thread_detach;
   sol_thread_ops.to_resume = sol_thread_resume;
@@ -1543,7 +1541,8 @@ init_sol_thread_ops ()
   sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
   sol_thread_ops.to_store_registers = sol_thread_store_registers;
   sol_thread_ops.to_prepare_to_store = sol_thread_prepare_to_store;
-  sol_thread_ops.to_xfer_memory = sol_thread_xfer_memory;
+  sol_thread_ops.deprecated_xfer_memory = sol_thread_xfer_memory;
+  sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
   sol_thread_ops.to_files_info = sol_thread_files_info;
   sol_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
   sol_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
@@ -1551,15 +1550,15 @@ init_sol_thread_ops ()
   sol_thread_ops.to_terminal_inferior = terminal_inferior;
   sol_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
   sol_thread_ops.to_terminal_ours = terminal_ours;
+  sol_thread_ops.to_terminal_save_ours = terminal_save_ours;
   sol_thread_ops.to_terminal_info = child_terminal_info;
   sol_thread_ops.to_kill = sol_thread_kill_inferior;
-  sol_thread_ops.to_load = 0;
-  sol_thread_ops.to_lookup_symbol = 0;
   sol_thread_ops.to_create_inferior = sol_thread_create_inferior;
   sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
   sol_thread_ops.to_can_run = sol_thread_can_run;
   sol_thread_ops.to_notice_signals = sol_thread_notice_signals;
   sol_thread_ops.to_thread_alive = sol_thread_alive;
+  sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
   sol_thread_ops.to_find_new_threads = sol_find_new_threads;
   sol_thread_ops.to_stop = sol_thread_stop;
   sol_thread_ops.to_stratum = process_stratum;
@@ -1569,14 +1568,13 @@ init_sol_thread_ops ()
   sol_thread_ops.to_has_registers = 1;
   sol_thread_ops.to_has_execution = 1;
   sol_thread_ops.to_has_thread_control = tc_none;
-  sol_thread_ops.to_sections = 0;
-  sol_thread_ops.to_sections_end = 0;
+  sol_thread_ops.to_find_memory_regions = sol_find_memory_regions;
+  sol_thread_ops.to_make_corefile_notes = sol_make_note_section;
   sol_thread_ops.to_magic = OPS_MAGIC;
 }
 
-
 static void
-init_sol_core_ops ()
+init_sol_core_ops (void)
 {
   sol_core_ops.to_shortname = "solaris-core";
   sol_core_ops.to_longname = "Solaris core threads and pthread.";
@@ -1585,44 +1583,38 @@ init_sol_core_ops ()
   sol_core_ops.to_close = sol_core_close;
   sol_core_ops.to_attach = sol_thread_attach;
   sol_core_ops.to_detach = sol_core_detach;
-  /* sol_core_ops.to_resume  = 0; */
-  /* sol_core_ops.to_wait  = 0;  */
   sol_core_ops.to_fetch_registers = sol_thread_fetch_registers;
-  /* sol_core_ops.to_store_registers  = 0; */
-  /* sol_core_ops.to_prepare_to_store  = 0; */
-  sol_core_ops.to_xfer_memory = sol_thread_xfer_memory;
+  sol_core_ops.deprecated_xfer_memory = sol_thread_xfer_memory;
+  sol_core_ops.to_xfer_partial = sol_thread_xfer_partial;
   sol_core_ops.to_files_info = sol_core_files_info;
   sol_core_ops.to_insert_breakpoint = ignore;
   sol_core_ops.to_remove_breakpoint = ignore;
-  /* sol_core_ops.to_terminal_init  = 0; */
-  /* sol_core_ops.to_terminal_inferior  = 0; */
-  /* sol_core_ops.to_terminal_ours_for_output  = 0; */
-  /* sol_core_ops.to_terminal_ours  = 0; */
-  /* sol_core_ops.to_terminal_info  = 0; */
-  /* sol_core_ops.to_kill  = 0; */
-  /* sol_core_ops.to_load  = 0; */
-  /* sol_core_ops.to_lookup_symbol  = 0; */
   sol_core_ops.to_create_inferior = sol_thread_create_inferior;
   sol_core_ops.to_stratum = core_stratum;
-  sol_core_ops.to_has_all_memory = 0;
   sol_core_ops.to_has_memory = 1;
   sol_core_ops.to_has_stack = 1;
   sol_core_ops.to_has_registers = 1;
-  sol_core_ops.to_has_execution = 0;
   sol_core_ops.to_has_thread_control = tc_none;
-  sol_core_ops.to_sections = 0;
-  sol_core_ops.to_sections_end = 0;
+  sol_core_ops.to_thread_alive = sol_thread_alive;
+  sol_core_ops.to_pid_to_str = solaris_pid_to_str;
+  /* On Solaris/x86, when debugging a threaded core file from process
+     <n>, the following causes "info threads" to produce "procfs:
+     couldn't find pid <n> in procinfo list" where <n> is the pid of
+     the process that produced the core file.  Disable it for now. */
+#if 0
+  sol_core_ops.to_find_new_threads = sol_find_new_threads;
+#endif
   sol_core_ops.to_magic = OPS_MAGIC;
 }
 
-/* we suppress the call to add_target of core_ops in corelow because
-   if there are two targets in the stratum core_stratum, find_core_target
-   won't know which one to return.  see corelow.c for an additonal
-   comment on coreops_suppress_target. */
+/* We suppress the call to add_target of core_ops in corelow because
+   if there are two targets in the stratum core_stratum,
+   find_core_target won't know which one to return.  See corelow.c for
+   an additonal comment on coreops_suppress_target.  */
 int coreops_suppress_target = 1;
 
 void
-_initialize_sol_thread ()
+_initialize_sol_thread (void)
 {
   void *dlhandle;
 
@@ -1666,22 +1658,24 @@ _initialize_sol_thread ()
   procfs_suppress_run = 1;
 
   add_cmd ("sol-threads", class_maintenance, info_solthreads,
-	   "Show info on Solaris user threads.\n", &maintenanceinfolist);
+	   _("Show info on Solaris user threads."), &maintenanceinfolist);
 
   memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
   memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));
   add_target (&core_ops);
 
+  /* Hook into new_objfile notification.  */
+  observer_attach_new_objfile (sol_thread_new_objfile);
   return;
 
-die:
-
-  fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
+ die:
+  fprintf_unfiltered (gdb_stderr, "\
+[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
 
   if (dlhandle)
     dlclose (dlhandle);
 
-  /* allow the user to debug non-threaded core files */
+  /* Allow the user to debug non-threaded core files.  */
   add_target (&core_ops);
 
   return;