* gdb.base/help.exp: Allow Win32 child process.

[deliverable/binutils-gdb.git] / gdb / sol-thread.c

diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index e0568c21277cf8347e26fa6ea039152a68406803..1d379e9ec19020f7cb1c79683b3fab34bf0d2245 100644 (file)
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -1,21 +1,23 @@
 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.

-   Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+   Free Software Foundation, Inc.

 
 

-This file is part of GDB.
+   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
-(at your option) any later version.
+   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
+   (at your option) any later version.

 
 

-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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.  */
+   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.  */

 
 /* This module implements a sort of half target that sits between the
    machine-independent parts of GDB and the /proc interface (procfs.c) to
 
 /* This module implements a sort of half target that sits between the
    machine-independent parts of GDB and the /proc interface (procfs.c) to


@@ -53,169 +55,173 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "target.h"
 #include "inferior.h"
 #include <fcntl.h>
 #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 <dlfcn.h>
 #include "gdbcmd.h"

+#include "gdbcore.h"
+#include "regcache.h"
+#include "symfile.h"

 
 

-extern struct target_ops sol_thread_ops; /* Forward declaration */
-extern struct target_ops sol_core_ops; /* Forward declaration */
+extern struct target_ops sol_thread_ops;       /* Forward declaration */
+extern struct target_ops sol_core_ops; /* Forward declaration */

 
 /* place to store core_ops before we overwrite it */
 static struct target_ops orig_core_ops;
 
 
 /* place to store core_ops before we overwrite it */
 static struct target_ops orig_core_ops;
 

+struct target_ops sol_thread_ops;
+struct target_ops sol_core_ops;
+

 extern int procfs_suppress_run;
 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));
+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 (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
 
 /* 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
 
 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 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 ((int 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));
-
-#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))
+static char *td_err_string (td_err_e errcode);
+static char *td_state_string (td_thr_state_e statecode);
+static ptid_t thread_to_lwp (ptid_t thread_id, int default_lwp);
+static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
+static ptid_t lwp_to_thread (ptid_t lwp);
+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 lithread_db resolved by dlopen() */
 
 
 /* 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);
-\f
+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
+   LOCAL FUNCTION

 
 

-       td_err_string - Convert a thread_db error code to a string
+   td_err_string - Convert a thread_db error code to a string

 
 

-SYNOPSIS
+   SYNOPSIS

 
 

-       char * td_err_string (errcode)
+   char * td_err_string (errcode)

 
 

-DESCRIPTION
+   DESCRIPTION

 
 

-       Return the thread_db error string associated with errcode.  If errcode
-       is unknown, then return a message.
+   Return the thread_db error string associated with errcode.  If errcode
+   is unknown, then return a message.

 
  */
 
 static char *
 
  */
 
 static char *

-td_err_string (errcode)
-     td_err_e errcode;
+td_err_string (td_err_e errcode)

 {
   static struct string_map
 {
   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_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 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;
   static char buf[50];
   const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
   int i;
   static char buf[50];


@@ -223,7 +229,7 @@ td_err_string (errcode)
   for (i = 0; i < td_err_size; i++)
     if (td_err_table[i].num == errcode)
       return td_err_table[i].str;
   for (i = 0; i < td_err_size; i++)
     if (td_err_table[i].num == errcode)
       return td_err_table[i].str;

-                 
+

   sprintf (buf, "Unknown thread_db error code: %d", errcode);
 
   return buf;
   sprintf (buf, "Unknown thread_db error code: %d", errcode);
 
   return buf;


@@ -231,36 +237,36 @@ td_err_string (errcode)
 \f
 /*
 
 \f
 /*
 

-LOCAL FUNCTION
+   LOCAL FUNCTION

 
 

-       td_state_string - Convert a thread_db state code to a string
+   td_state_string - Convert a thread_db state code to a string

 
 

-SYNOPSIS
+   SYNOPSIS

 
 

-       char * td_state_string (statecode)
+   char * td_state_string (statecode)

 
 

-DESCRIPTION
+   DESCRIPTION

 
 

-       Return the thread_db state string associated with statecode.  If
-       statecode is unknown, then return a message.
+   Return the thread_db state string associated with statecode.  If
+   statecode is unknown, then return a message.

 
  */
 
 static char *
 
  */
 
 static char *

-td_state_string (statecode)
-     td_thr_state_e statecode;
+td_state_string (td_thr_state_e statecode)

 {
   static struct string_map
 {
   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_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"}
+  };

   const int td_thr_state_table_size = sizeof td_thr_state_table / sizeof (struct string_map);
   int i;
   static char buf[50];
   const int td_thr_state_table_size = sizeof td_thr_state_table / sizeof (struct string_map);
   int i;
   static char buf[50];


@@ -268,7 +274,7 @@ td_state_string (statecode)
   for (i = 0; i < td_thr_state_table_size; i++)
     if (td_thr_state_table[i].num == statecode)
       return td_thr_state_table[i].str;
   for (i = 0; i < td_thr_state_table_size; i++)
     if (td_thr_state_table[i].num == statecode)
       return td_thr_state_table[i].str;

-                 
+

   sprintf (buf, "Unknown thread_db state code: %d", statecode);
 
   return buf;
   sprintf (buf, "Unknown thread_db state code: %d", statecode);
 
   return buf;


@@ -276,56 +282,54 @@ td_state_string (statecode)
 \f
 /*
 
 \f
 /*
 

-LOCAL FUNCTION
+   LOCAL FUNCTION

 
 

-       thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
+   thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.

 
 

-SYNOPSIS
+   SYNOPSIS

 
 

-       int thread_to_lwp (thread_id, default_lwp)
+   tpid_t thread_to_lwp (thread_id, default_lwp)

 
 

-DESCRIPTION
+   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.
+   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.

 
 

-NOTES
+   NOTES

 
 

-       This function probably shouldn't call error()...
+   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))
 {
   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 */
 
   val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
   if (val == TD_NOTHR)
 
   /* 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));
 
   val = p_td_thr_get_info (&th, &ti);
   if (val == TD_NOTHR)
   else if (val != TD_OK)
     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));
 
   if (ti.ti_state != TD_THR_ACTIVE)
     {
       if (default_lwp != -1)
   else if (val != TD_OK)
     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;
+       return pid_to_ptid (default_lwp);

       error ("thread_to_lwp: thread state not active: %s",
             td_state_string (ti.ti_state));
     }
       error ("thread_to_lwp: thread state not active: %s",
             td_state_string (ti.ti_state));
     }


@@ -335,28 +339,27 @@ thread_to_lwp (thread_id, default_lwp)
 \f
 /*
 
 \f
 /*
 

-LOCAL FUNCTION
+   LOCAL FUNCTION

 
 

-       lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
+   lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.

 
 

-SYNOPSIS
+   SYNOPSIS

 
 

-       int lwp_to_thread (lwp_id)
+   int lwp_to_thread (lwp_id)

 
 

-DESCRIPTION
+   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.
+   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
+   NOTES

 
 

-       This function probably shouldn't call error()...
+   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_thrinfo_t ti;
   td_thrhandle_t th;


@@ -368,70 +371,30 @@ lwp_to_thread (lwp)
   /* It's an lwp.  Convert it to a thread id.  */
 
   if (!sol_thread_alive (lwp))
   /* It's an lwp.  Convert it to a thread id.  */
 
   if (!sol_thread_alive (lwp))

-    return -1;                 /* defunct lwp */
+    return pid_to_ptid (-1);   /* defunct lwp */

 
   val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
   if (val == TD_NOTHR)
 
   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));
 
   val = p_td_thr_validate (&th);
   if (val == TD_NOTHR)
   else if (val != TD_OK)
     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;                        /* libthread doesn't know about it;
+                                  just return lwp */

   else if (val != TD_OK)
     error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));
 
   val = p_td_thr_get_info (&th, &ti);
   if (val == TD_NOTHR)
   else if (val != TD_OK)
     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));
 
   return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
 }
 \f
   else if (val != TD_OK)
     error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
 
   return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
 }
 \f

-/*
-
-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, inferior_pid);
-}
-
-static void
-restore_inferior_pid (pid)
-     int pid;
-{
-  inferior_pid = pid;
-}
-\f

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


@@ -439,9 +402,7 @@ restore_inferior_pid (pid)
 
 /* ARGSUSED */
 static void
 
 /* 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);
 }
 {
   procfs_ops.to_open (arg, from_tty);
 }


@@ -450,23 +411,23 @@ sol_thread_open (arg, from_tty)
    and wait for the trace-trap that results from attaching.  */
 
 static void
    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);
 {
   procfs_ops.to_attach (args, from_tty);

+

   /* Must get symbols from solibs before libthread_db can run! */
   /* Must get symbols from solibs before libthread_db can run! */

-  SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0);
+  SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add);
+

   if (sol_thread_active)
     {
       printf_filtered ("sol-thread active.\n");
   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);
       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
       else

-       add_thread (inferior_pid);
+       add_thread (inferior_ptid);

     }
   /* XXX - might want to iterate over all the threads and register them. */
 }
     }
   /* XXX - might want to iterate over all the threads and register them. */
 }


@@ -480,10 +441,9 @@ sol_thread_attach (args, from_tty)
    started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
    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);
 }
   unpush_target (&sol_thread_ops);
   procfs_ops.to_detach (args, from_tty);
 }


@@ -494,32 +454,29 @@ sol_thread_detach (args, from_tty)
    for procfs.  */
 
 static void
    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;
 
 {
   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;
+      ptid_t save_ptid = ptid;

 
 

-      pid = thread_to_lwp (pid, -2);
-      if (pid == -2)           /* Inactive thread */
+      ptid = thread_to_lwp (ptid, -2);
+      if (PIDGET (ptid) == -2)         /* Inactive thread */

        error ("This version of Solaris can't start inactive threads.");
        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));
+      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);
 }
 
   do_cleanups (old_chain);
 }


@@ -527,46 +484,44 @@ sol_thread_resume (pid, step, signo)
 /* 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 PID from a thread id
    to a 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;
 
   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;
+      ptid_t save_ptid = ptid;

 
 

-      pid = thread_to_lwp (pid, -2);
-      if (pid == -2)           /* Inactive thread */
+      ptid = thread_to_lwp (ptid, -2);
+      if (PIDGET (ptid) == -2)         /* Inactive thread */

        error ("This version of Solaris can't start inactive threads.");
        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));
+      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 */
       rtnval = lwp_to_thread (rtnval);
 
   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
     {
       /* 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 */
       if (is_thread (rtnval)
 
       /* 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));
          && !in_thread_list (rtnval))
        {
          printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));


@@ -584,8 +539,7 @@ sol_thread_wait (pid, ourstatus)
 }
 
 static void
 }
 
 static void

-sol_thread_fetch_registers (regno)
-     int regno;
+sol_thread_fetch_registers (int regno)

 {
   thread_t thread;
   td_thrhandle_t thandle;
 {
   thread_t thread;
   td_thrhandle_t thandle;


@@ -597,8 +551,8 @@ sol_thread_fetch_registers (regno)
   caddr_t xregset;
 #endif
 
   caddr_t xregset;
 #endif
 

-  if (!is_thread (inferior_pid))
-    { /* LWP: pass the request on to procfs.c */
+  if (!is_thread (inferior_ptid))
+    {                          /* LWP: pass the request on to procfs.c */

       if (target_has_execution)
        procfs_ops.to_fetch_registers (regno);
       else
       if (target_has_execution)
        procfs_ops.to_fetch_registers (regno);
       else


@@ -606,9 +560,9 @@ sol_thread_fetch_registers (regno)
       return;
     }
 
       return;
     }
 

-  /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
+  /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */

 
 

-  thread = GET_THREAD (inferior_pid);
+  thread = GET_THREAD (inferior_ptid);

 
   if (thread == 0)
     error ("sol_thread_fetch_registers:  thread == 0");
 
   if (thread == 0)
     error ("sol_thread_fetch_registers:  thread == 0");


@@ -641,8 +595,8 @@ sol_thread_fetch_registers (regno)
    because the td routines call ps_lget* which affect the values stored in the
    registers array.  */
 
    because the td routines call ps_lget* which affect the values stored in the
    registers array.  */
 

-  supply_gregset (gregset);
-  supply_fpregset (&fpregset);
+  supply_gregset  ((gdb_gregset_t *)  &gregset);
+  supply_fpregset ((gdb_fpregset_t *) &fpregset);

 
 #if 0
 /* thread_db doesn't seem to handle this right */
 
 #if 0
 /* thread_db doesn't seem to handle this right */


@@ -663,28 +617,27 @@ sol_thread_fetch_registers (regno)
 }
 
 static void
 }
 
 static void

-sol_thread_store_registers (regno)
-     int regno;
+sol_thread_store_registers (int regno)

 {
   thread_t thread;
   td_thrhandle_t thandle;
   td_err_e val;
 {
   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
 
   prfpregset_t 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))
+    {                          /* LWP: pass the request on to procfs.c */

       procfs_ops.to_store_registers (regno);
       return;
     }
 
       procfs_ops.to_store_registers (regno);
       return;
     }
 

-  /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
+  /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */

 
 

-  thread = GET_THREAD (inferior_pid);
+  thread = GET_THREAD (inferior_ptid);

 
   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
   if (val != TD_OK)
 
   val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
   if (val != TD_OK)


@@ -694,10 +647,11 @@ sol_thread_store_registers (regno)
   if (regno != -1)
     {                          /* Not writing all the regs */
       /* save new register value */
   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);
+      char* old_value = (char*) alloca (REGISTER_SIZE);
+      memcpy (old_value, &deprecated_registers[REGISTER_BYTE (regno)],
+             REGISTER_SIZE);

 
 

-      val = p_td_thr_getgregs (&thandle, regset);
+      val = p_td_thr_getgregs (&thandle, gregset);

       if (val != TD_OK)
        error ("sol_thread_store_registers: td_thr_getgregs %s",
               td_err_string (val));
       if (val != TD_OK)
        error ("sol_thread_store_registers: td_thr_getgregs %s",
               td_err_string (val));


@@ -707,7 +661,8 @@ sol_thread_store_registers (regno)
               td_err_string (val));
 
       /* restore new register value */
               td_err_string (val));
 
       /* restore new register value */

-      memcpy(& registers[REGISTER_BYTE(regno)], old_value, REGISTER_SIZE);
+      memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value,
+             REGISTER_SIZE);

 
 #if 0
 /* thread_db doesn't seem to handle this right */
 
 #if 0
 /* thread_db doesn't seem to handle this right */


@@ -727,10 +682,10 @@ sol_thread_store_registers (regno)
 #endif
     }
 
 #endif
     }
 

-  fill_gregset (regset, regno);
-  fill_fpregset (&fpregset, regno);
+  fill_gregset  ((gdb_gregset_t *)  &gregset,  regno);
+  fill_fpregset ((gdb_fpregset_t *) &fpregset, regno);

 
 

-  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",
           td_err_string (val));
   if (val != TD_OK)
     error ("sol_thread_store_registers: td_thr_setgregs %s",
           td_err_string (val));


@@ -758,34 +713,38 @@ sol_thread_store_registers (regno)
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-sol_thread_prepare_to_store ()
+sol_thread_prepare_to_store (void)

 {
   procfs_ops.to_prepare_to_store ();
 }
 
 {
   procfs_ops.to_prepare_to_store ();
 }
 

+/* 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
 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, char *myaddr, int len, int dowrite,
+                       struct mem_attrib *attrib,
+                       struct target_ops *target)

 {
   int retval;
   struct cleanup *old_chain;
 
 {
   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.  */
+  if (is_thread (inferior_ptid) ||     /* A thread */
+      !target_thread_alive (inferior_ptid))    /* An lwp, but not alive */
+    inferior_ptid = procfs_first_available (); /* Find any live lwp.  */

   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
 
   if (target_has_execution)
   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
 
   if (target_has_execution)

-    retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
+    retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, 
+                                       dowrite, attrib, target);

   else
     retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
   else
     retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,

-                                          dowrite, target);
+                                          dowrite, attrib, target);

 
   do_cleanups (old_chain);
 
 
   do_cleanups (old_chain);
 


@@ -795,46 +754,42 @@ sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
 /* Print status information about what we're accessing.  */
 
 static void
 /* 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
 {
   procfs_ops.to_files_info (ignore);
 }
 
 static void

-sol_thread_kill_inferior ()
+sol_thread_kill_inferior (void)

 {
   procfs_ops.to_kill ();
 }
 
 static 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
 }
 
 /* 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)

 {
   procfs_ops.to_create_inferior (exec_file, allargs, env);
 
 {
   procfs_ops.to_create_inferior (exec_file, allargs, env);
 

-  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 */
+      main_ph.ptid = inferior_ptid;    /* Save for xfer_memory */

 
       push_target (&sol_thread_ops);
 
 
       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);

     }
 }
 
     }
 }
 


@@ -844,22 +799,27 @@ sol_thread_create_inferior (exec_file, allargs, env)
    those variables don't show up until the library gets mapped and the symbol
    table is read in.  */
 
    those variables don't show up until the library gets mapped and the symbol
    table is read in.  */
 

+/* This new_objfile event is now managed by a chained function pointer. 
+ * It is the callee's responsability to call the next client on the chain.
+ */
+
+/* Saved pointer to previous owner of the new_objfile event. */
+static void (*target_new_objfile_chain) (struct objfile *);
+

 void
 void

-sol_thread_new_objfile (objfile)
-     struct objfile *objfile;
+sol_thread_new_objfile (struct objfile *objfile)

 {
   td_err_e val;
 
   if (!objfile)
     {
       sol_thread_active = 0;
 {
   td_err_e val;
 
   if (!objfile)
     {
       sol_thread_active = 0;

-
-      return;
+      goto quit;

     }
 
   /* don't do anything if init failed to resolve the libthread_db library */
   if (!procfs_suppress_run)
     }
 
   /* don't do anything if init failed to resolve the libthread_db library */
   if (!procfs_suppress_run)

-    return;
+    goto quit;

 
   /* Now, initialize the thread debugging library.  This needs to be done after
      the shared libraries are located because it needs information from the
 
   /* Now, initialize the thread debugging library.  This needs to be done after
      the shared libraries are located because it needs information from the


@@ -867,21 +827,31 @@ sol_thread_new_objfile (objfile)
 
   val = p_td_init ();
   if (val != TD_OK)
 
   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));
+      goto quit;
+    }

 
   val = p_td_ta_new (&main_ph, &main_ta);
   if (val == TD_NOLIBTHREAD)
 
   val = p_td_ta_new (&main_ph, &main_ta);
   if (val == TD_NOLIBTHREAD)

-    return;
+    goto quit;

   else if (val != TD_OK)
   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));
+      goto quit;
+    }

 
   sol_thread_active = 1;
 
   sol_thread_active = 1;

+quit:
+  /* Call predecessor on chain, if any. */
+  if (target_new_objfile_chain)
+    target_new_objfile_chain (objfile);

 }
 
 /* Clean up after the inferior dies.  */
 
 static void
 }
 
 /* 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 ();
 {
   unpush_target (&sol_thread_ops);
   procfs_ops.to_mourn_inferior ();


@@ -890,54 +860,55 @@ sol_thread_mourn_inferior ()
 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
 
 static int
 /* 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;
 }
 
 /* 
 
 {
   return procfs_suppress_run;
 }
 
 /* 
 

-LOCAL FUNCTION
+   LOCAL FUNCTION

 
 

-       sol_thread_alive     - test thread for "aliveness"
+   sol_thread_alive     - test thread for "aliveness"

 
 

-SYNOPSIS
+   SYNOPSIS

 
 

-       static bool sol_thread_alive (int pid);
+   static bool sol_thread_alive (ptid_t ptid);

 
 

-DESCRIPTION
+   DESCRIPTION

 
 

-       returns true if thread still active in inferior.
+   returns true if thread still active in inferior.

 
  */
 
 static int
 
  */
 
 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))                /* non-kernel thread */

     {
       td_err_e val;
       td_thrhandle_t th;
     {
       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)
       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)
       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: return true */

     }
     }

-  else                 /* kernel thread (LWP): let procfs test it */
+  else
+    /* kernel thread (LWP): let procfs test it */

     {
       if (target_has_execution)
     {
       if (target_has_execution)

-       return procfs_ops.to_thread_alive (pid);
+       return procfs_ops.to_thread_alive (ptid);

       else
       else

-       return orig_core_ops.to_thread_alive (pid);
+       return orig_core_ops.to_thread_alive (ptid);

     }
 }
 
 static void
     }
 }
 
 static void

-sol_thread_stop ()
+sol_thread_stop (void)

 {
   procfs_ops.to_stop ();
 }
 {
   procfs_ops.to_stop ();
 }


@@ -948,11 +919,11 @@ sol_thread_stop ()
 /* 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
+   NEWER                        OLDER
+   struct ps_prochandle *       const struct ps_prochandle *
+   void*                        char*
+   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
 
    Which one you have depends on solaris version and what
    patches you've applied.  On the theory that there are


@@ -961,15 +932,17 @@ sol_thread_stop ()
    appropriate typedefs here. */
 
 #ifdef PROC_SERVICE_IS_OLD
    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 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 int gdb_ps_size_t;

+typedef paddr_t gdb_ps_addr_t;

 #else
 #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 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 size_t gdb_ps_size_t;

+typedef psaddr_t gdb_ps_addr_t;

 #endif
 
 
 #endif
 
 


@@ -978,33 +951,43 @@ typedef size_t gdb_ps_size_t;
    by the time we call anything in thread_db, these routines need to do
    nothing.  */
 
    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)
 {
   return PS_OK;
 }
 
 ps_err_e
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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,
 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;
 
 {
   struct minimal_symbol *ms;
 


@@ -1021,26 +1004,36 @@ ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
 /* Common routine for reading and writing memory.  */
 
 static ps_err_e
 /* 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;
 
           char *buf, int size)
 {
   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.  */
+  if (is_thread (inferior_ptid) ||     /* A thread */
+      !target_thread_alive (inferior_ptid))    /* An lwp, but not alive */
+    inferior_ptid = procfs_first_available (); /* Find any live lwp.  */

   /* Note: don't need to call switch_to_thread; we're just reading memory.  */
 
   /* 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;
 
   while (size > 0)
     {
       int cc;
 

+      /* FIXME: passing 0 as attrib argument.  */

       if (target_has_execution)
       if (target_has_execution)

-       cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
+       cc = procfs_ops.to_xfer_memory (addr, buf, size, 
+                                       dowrite, 0, &procfs_ops);

       else
       else

-       cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, &core_ops);
+       cc = orig_core_ops.to_xfer_memory (addr, buf, size, 
+                                          dowrite, 0, &core_ops);

 
       if (cc < 0)
        {
 
       if (cc < 0)
        {


@@ -1053,6 +1046,20 @@ rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
 
          return PS_ERR;
        }
 
          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;
     }
       size -= cc;
       buf += cc;
     }


@@ -1062,35 +1069,43 @@ rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
   return PS_OK;
 }
 
   return PS_OK;
 }
 

+/* Copies SIZE bytes from target process .data segment to debugger memory.  */
+

 ps_err_e
 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);
 }
 
           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_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)
 {
            gdb_ps_write_buf_t buf, gdb_ps_size_t size)
 {

-  return rw_common (1, ph, addr, (char*) buf, 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_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);
 }
 
           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_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)
 {
            gdb_ps_write_buf_t buf, gdb_ps_size_t size)
 {

-  return rw_common (1, ph, addr, (char*) buf, size);
+  return rw_common (1, ph, addr, (char *) buf, size);

 }
 
 }
 

-/* Get integer regs */
+/* Get integer regs for LWP */

 
 ps_err_e
 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 
 ps_err_e
 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,


@@ -1098,22 +1113,22 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 {
   struct cleanup *old_chain;
 
 {
   struct cleanup *old_chain;
 

-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
+
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));

 
 

-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-  

   if (target_has_execution)
     procfs_ops.to_fetch_registers (-1);
   else
     orig_core_ops.to_fetch_registers (-1);
   if (target_has_execution)
     procfs_ops.to_fetch_registers (-1);
   else
     orig_core_ops.to_fetch_registers (-1);

-  fill_gregset (gregset, -1);
+  fill_gregset ((gdb_gregset_t *) gregset, -1);

 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 
 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 

-/* Set integer regs */
+/* Set integer regs for LWP */

 
 ps_err_e
 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 
 ps_err_e
 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,


@@ -1121,11 +1136,11 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 {
   struct cleanup *old_chain;
 
 {
   struct cleanup *old_chain;
 

-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
+
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));

 
 

-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-  
-  supply_gregset (gregset);
+  supply_gregset ((gdb_gregset_t *) gregset);

   if (target_has_execution)
     procfs_ops.to_store_registers (-1);
   else
   if (target_has_execution)
     procfs_ops.to_store_registers (-1);
   else


@@ -1136,8 +1151,10 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   return PS_OK;
 }
 
   return PS_OK;
 }
 

+/* Log a message (sends to gdb_stderr).  */
+

 void
 void

-ps_plog (const char *fmt, ...)
+ps_plog (const char *fmt,...)

 {
   va_list args;
 
 {
   va_list args;
 


@@ -1220,42 +1237,42 @@ ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
   return PS_OK;
 }
 
   return PS_OK;
 }
 

-/* Get floating-point regs.  */
+/* Get floating-point regs for LWP */

 
 ps_err_e
 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 
 ps_err_e
 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,

-              prfpregset_t *fpregset)
+              prfpregset_t * fpregset)

 {
   struct cleanup *old_chain;
 
 {
   struct cleanup *old_chain;
 

-  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));

 
   if (target_has_execution)
     procfs_ops.to_fetch_registers (-1);
   else
     orig_core_ops.to_fetch_registers (-1);
 
   if (target_has_execution)
     procfs_ops.to_fetch_registers (-1);
   else
     orig_core_ops.to_fetch_registers (-1);

-  fill_fpregset (fpregset, -1);
+  fill_fpregset ((gdb_fpregset_t *) fpregset, -1);

 
   do_cleanups (old_chain);
 
   return PS_OK;
 }
 
 
   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,
 
 ps_err_e
 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,

-              const prfpregset_t *fpregset)
+              const prfpregset_t * fpregset)

 {
   struct cleanup *old_chain;
 
 {
   struct cleanup *old_chain;
 

-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();

 
 

-  inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-  
-  supply_fpregset (fpregset);
+  inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+
+  supply_fpregset ((gdb_fpregset_t *) fpregset);

   if (target_has_execution)
     procfs_ops.to_store_registers (-1);
   else
   if (target_has_execution)
     procfs_ops.to_store_registers (-1);
   else


@@ -1266,93 +1283,83 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   return PS_OK;
 }
 
   return PS_OK;
 }
 

-#ifdef TM_I386SOL2_H
+#ifdef PR_MODEL_LP64
+/* Identify process as 32-bit or 64-bit.
+   At the moment I'm using bfd to do this.
+   There might be a more solaris-specific (eg. 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;

 
 

-#include <sys/procfs.h>
-#include <sys/reg.h>
-#include <sys/sysi86.h>
+  return PS_OK;
+}
+#endif /* PR_MODEL_LP64 */

 
 

-static int nldt_allocated = 0;
-static struct ssd *ldt_bufp = NULL;
+#ifdef TM_I386SOL2_H
+
+/* Reads the local descriptor table of a LWP.  */

 
 ps_err_e
 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
            struct ssd *pldt)
 {
 
 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;
+  /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
+  extern struct ssd *procfs_find_LDT_entry (ptid_t);
+  struct ssd *ret;

 
 

-  /* 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;
-
-  /* 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;
     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 */
 \f
 /* Convert a pid to printable form. */
 
 char *
 #endif /* TM_I386SOL2_H */
 \f
 /* Convert a pid 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 */
   if (!procfs_suppress_run)
 {
   static char buf[100];
 
   /* 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
       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
   else

-    sprintf (buf, "process %d    ", PIDGET (pid));
+    sprintf (buf, "process %d    ", PIDGET (ptid));

 
   return buf;
 }
 
   return buf;
 }


@@ -1363,116 +1370,127 @@ solaris_pid_to_str (pid)
    kernel) thread. */
 
 static int
    kernel) thread. */
 
 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;
 {
   td_err_e retval;
   td_thrinfo_t ti;

-  int pid;
+  ptid_t ptid;

 
 

-  if ((retval = p_td_thr_get_info(th, &ti)) != TD_OK)
+  if ((retval = p_td_thr_get_info (th, &ti)) != TD_OK)

     {
       return -1;
     }
     {
       return -1;
     }

-  pid = BUILD_THREAD(ti.ti_tid, PIDGET(inferior_pid));
-  if (!in_thread_list(pid))
-    add_thread(pid);
+  ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
+  if (!in_thread_list (ptid))
+    add_thread (ptid);

 
   return 0;
 }
 
 
   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 */
   if (!procfs_suppress_run)
     return;
 
 {
   /* 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");
+      printf_filtered ("No process.\n");

       return;
     }
       return;
     }

-  p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *)0,
+  procfs_ops.to_find_new_threads ();   /* first find new kernel 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
                    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
 {
   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
 {
   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
 {
   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);
 }
 
 {
   orig_core_ops.to_files_info (t);
 }
 

-#ifdef MAINTENANCE_CMDS

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

-static int 
-info_cb (th, s)
-     const td_thrhandle_t *th;
-     void *s;
+static int
+info_cb (const td_thrhandle_t *th, void *s)

 {
   td_err_e ret;
   td_thrinfo_t ti;
 {
   td_err_e ret;
   td_thrinfo_t ti;

-  struct minimal_symbol *msym;

 
   if ((ret = p_td_thr_get_info (th, &ti)) == TD_OK)
     {
 
   if ((ret = p_td_thr_get_info (th, &ti)) == TD_OK)
     {

-      printf_filtered ("%s thread #%d, lwp %d, ", 
-                      ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ", 
+      printf_filtered ("%s thread #%d, lwp %d, ",
+                      ti.ti_type == TD_THR_SYSTEM ? "system" : "user  ",

                       ti.ti_tid, ti.ti_lid);
                       ti.ti_tid, ti.ti_lid);

-      switch (ti.ti_state) {
+      switch (ti.ti_state)
+       {

        default:
        default:

-       case TD_THR_UNKNOWN: printf_filtered ("<unknown state>");       break;
-       case TD_THR_STOPPED: printf_filtered ("(stopped)");     break;
-       case TD_THR_RUN:     printf_filtered ("(run)    ");     break;
-       case TD_THR_ACTIVE:  printf_filtered ("(active) ");     break;
-       case TD_THR_ZOMBIE:  printf_filtered ("(zombie) ");     break;
-       case TD_THR_SLEEP:   printf_filtered ("(asleep) ");     break;
-       case TD_THR_STOPPED_ASLEEP: 
-         printf_filtered ("(stopped asleep)");                 break;
-      }
+       case TD_THR_UNKNOWN:
+         printf_filtered ("<unknown state>");
+         break;
+       case TD_THR_STOPPED:
+         printf_filtered ("(stopped)");
+         break;
+       case TD_THR_RUN:
+         printf_filtered ("(run)    ");
+         break;
+       case TD_THR_ACTIVE:
+         printf_filtered ("(active) ");
+         break;
+       case TD_THR_ZOMBIE:
+         printf_filtered ("(zombie) ");
+         break;
+       case TD_THR_SLEEP:
+         printf_filtered ("(asleep) ");
+         break;
+       case TD_THR_STOPPED_ASLEEP:
+         printf_filtered ("(stopped asleep)");
+         break;
+       }

       /* Print thr_create start function: */
       if (ti.ti_startfunc != 0)
       /* 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 (ti.ti_state == TD_THR_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 */
       if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
 
       /* Wrap up line, if necessary */
       if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)


@@ -1481,51 +1499,49 @@ info_cb (th, s)
   else
     warning ("info sol-thread: failed to get info for thread.");
 
   else
     warning ("info sol-thread: failed to get info for thread.");
 

-  return 0;    
+  return 0;

 }
 
 /* List some state about each Solaris user thread in the inferior.  */
 
 static void
 }
 
 /* List some state about each Solaris user 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, 
+  p_td_ta_thr_iter (main_ta, info_cb, args,

                    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
                    TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 }
                    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
                    TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 }

-#endif /* MAINTENANCE_CMDS */

 
 static int
 
 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);
+}

 
 

-struct target_ops sol_thread_ops;
-struct target_ops sol_core_ops;
+static int
+ignore (CORE_ADDR addr, char *contents)
+{
+  return 0;
+}

 
 

-/* 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 ()
+static void
+init_sol_thread_ops (void)

 {
 {

-  void *dlhandle;
-
-  /* Initialize sol_thread_ops */

   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_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;
   sol_thread_ops.to_attach = sol_thread_attach;
   sol_thread_ops.to_detach = sol_thread_detach;
   sol_thread_ops.to_resume = sol_thread_resume;


@@ -1541,15 +1557,16 @@ _initialize_sol_thread ()
   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_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_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_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;
   sol_thread_ops.to_has_all_memory = 1;
   sol_thread_ops.to_stop = sol_thread_stop;
   sol_thread_ops.to_stratum = process_stratum;
   sol_thread_ops.to_has_all_memory = 1;


@@ -1558,47 +1575,56 @@ _initialize_sol_thread ()
   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_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;
   sol_thread_ops.to_magic = OPS_MAGIC;

+}
+
+
+static void
+init_sol_core_ops (void)
+{
+  sol_core_ops.to_shortname = "solaris-core";
+  sol_core_ops.to_longname = "Solaris core threads and pthread.";
+  sol_core_ops.to_doc = "Solaris threads and pthread support for core files.";
+  sol_core_ops.to_open = sol_core_open;
+  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_fetch_registers = sol_thread_fetch_registers;
+  sol_core_ops.to_xfer_memory = sol_thread_xfer_memory;
+  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_create_inferior = sol_thread_create_inferior;
+  sol_core_ops.to_stratum = core_stratum;
+  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_thread_control = tc_none;
+  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. */
+  /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
+  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. */
+int coreops_suppress_target = 1;

 
 

-  /* Initialize sol_core_ops */
-  sol_core_ops.to_shortname  = "solaris-core";
-  sol_core_ops.to_longname  = "Solaris core threads and pthread.";
-  sol_core_ops.to_doc  = "Solaris threads and pthread support for core files.";
-  sol_core_ops.to_open  = sol_core_open;
-  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.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_magic  = OPS_MAGIC;
+void
+_initialize_sol_thread (void)
+{
+  void *dlhandle;

 
 

+  init_sol_thread_ops ();
+  init_sol_core_ops ();

 
   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
   if (!dlhandle)
 
   dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
   if (!dlhandle)


@@ -1636,18 +1662,19 @@ _initialize_sol_thread ()
 
   procfs_suppress_run = 1;
 
 
   procfs_suppress_run = 1;
 

-#ifdef MAINTENANCE_CMDS
-  add_cmd ("sol-threads", class_maintenance, info_solthreads, 
-           "Show info on Solaris user threads.\n", &maintenanceinfolist);
-#endif /* MAINTENANCE_CMDS */
+  add_cmd ("sol-threads", class_maintenance, info_solthreads,
+          "Show info on Solaris user threads.\n", &maintenanceinfolist);

 
 

-  memcpy(&orig_core_ops, &core_ops, sizeof (struct target_ops));
-  memcpy(&core_ops, &sol_core_ops, sizeof (struct target_ops));
+  memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
+  memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));

   add_target (&core_ops);
 
   add_target (&core_ops);
 

+  /* Hook into new_objfile notification. */
+  target_new_objfile_chain = target_new_objfile_hook;
+  target_new_objfile_hook  = sol_thread_new_objfile;

   return;
 
   return;
 

- die:
+die:

 
   fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
 
 
   fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
 


@@ -1655,7 +1682,7 @@ _initialize_sol_thread ()
     dlclose (dlhandle);
 
   /* allow the user to debug non-threaded core files */
     dlclose (dlhandle);
 
   /* allow the user to debug non-threaded core files */

-  add_target(&core_ops);
+  add_target (&core_ops);

 
   return;
 }
 
   return;
 }